Das Erstellen von grafischen Panels ist mit MQL5 einfach geworden
443
0
Einführung
MQL5 bietet Entwicklern eine Menge hilfreicher Tools, die verwendet werden können, um den Prozess der Kodierung zu erleichtern und die Dinge effektiv zu erledigen und dabei Zeit und Mühe zu sparen. Ein Beispiel für diese hilfreichen Werkzeuge ist, dass wir viele Bibliotheken oder Klassen in MQL5 haben, die verwendet werden können, um viele Anwendungen zu programmieren, ohne den Code dieser Anwendungen von Grund auf neu zu erstellen. Aus diesen Bibliotheken oder Klassen, z. B. Panels und Dialogs. In diesem Artikel erfahren wir, wie wir diese Klassen verwenden können und eine Anwendung mit ihnen zu erstellen, werden wir auch nach der Klärung, wie nützlich mit mql5 Klassen kann hilfreich sein, wenn die Schaffung MetaTrader5 Software, wie wir zwei verschiedene Methoden, um die gleiche Anwendung zu erstellen präsentieren lernen.
Darüber hinaus kann es ein guter praktischer Inhalt sein, um Ihre Programmierfähigkeiten als Anfänger zu verbessern, indem Sie die Anwendung von Grund auf neu erstellen, um Ihre Programmierlogikfähigkeiten zu verbessern, indem Sie vorgefertigte Dinge mit Ihrem eigenen Code kodieren. Es kann auch als einfacher Leitfaden verwendet werden, um etwas zu schaffen, das Sie vor Ablenkungen während des Handels bewahrt, wenn Sie ein Händler sind. Wenn Sie ein Anfänger in der Entwicklung von mql5 sind, kann es als hilfreicher Leitfaden verwendet werden, um zu lernen, wie Sie grafische Panels im MetaTrader 5 Terminal erstellen können. In diesem einfachen Leitfaden werden wir versuchen, die Dinge zu vereinfachen, damit Sie in der Lage sind, ein einfaches grafisches Panel zu erstellen oder mehr und mehr in dieses Thema einzutauchen, um als Entwickler oder sogar als Händler komplexe Panels zu erstellen.
Wir werden versuchen, die Themen anhand der folgenden Punkte zu behandeln:
- Grafische Panel-Identifikation
- Die Klassen Panels und Dialoge
- Einfache Anwendung des grafischen Panels
- Schlussfolgerung
Ich empfehle, dass Sie Wissen über das Thema der objektorientierten Programmierung in MQL5 haben, weil es helfen wird, das Thema dieses Artikels zu verstehen. Wenn Sie das tun wollen, können Sie meinen Artikel über „Verstehen der MQL5 Objektorientierte Programmierung (OOP)“ lesen.
Grafische Panel-Identifikation
In diesem Teil werden wir herausfinden, was das grafische Panel bedeutet und wie es für uns in der Handelsbranche nützlich sein kann. Bei dem Panel kann es sich einfach um eine grafische Oberfläche mit hilfreichen Funktionen oder Informationen handeln, wie z. B. ein Panel, das zum Eröffnen und Verwalten von Handelsgeschäften verwendet werden kann, das Informationen über das Konto oder den Handelstag liefert usw. Diese Panels können sehr nützlich sein, da es spart Zeit, wenn die Sache zu tun oder kann verwendet werden, um zu bekommen, was Sie brauchen, ohne es in seiner normalen Art und Weise, und dies kann uns mehr auf den Handel und die Marktanalyse während des Handels zu konzentrieren.
Dementsprechend können wir erstellen oder haben ein nutzerdefiniertes Panel in Abhängigkeit von den Objekten auf diese Panels und Aufgaben oder die Art der Interaktion zwischen dem Nutzer und diesem Panel, können wir einige dieser Objekte die gleichen wie die folgenden zu erwähnen:
- Zahlen,
- Zeichen,
- Formen,
- Farben,
- Knöpfe,
- usw.
Wenn Sie fragen, wie wir diese Art von Panels selbst entwickeln oder codieren können, kann ich Ihnen antworten, dass es zwei Methoden gibt, um diese Tafeln zu erstellen und zu entwickeln. Die erste Methode ist die harte Methode, da wir alles von Grund auf neu kodieren, und diese Methode nimmt viel Zeit und Mühe in Anspruch, aber wenn Sie ein Entwickler sind, müssen Sie in der Lage sein und verstehen, wie man das macht, da dies Ihre Kodierfähigkeiten verbessern wird, selbst wenn Sie es nicht als Methode in Ihrer Arbeit verwenden werden, aber zumindest in der Lage sein werden, diese Aufgabe zu verstehen und selbst zu erledigen. Die andere Methode ist die einfachste und reibungsloseste, da Sie vorgefertigte Klassen oder Bibliotheken verwenden, um Ihre Arbeit schnell und effektiv zu erledigen, ohne viel Zeit und Mühe zu verschwenden. Im weiteren Verlauf dieses Artikels werden wir mehr über die Klassen erfahren, die zur Erstellung dieser Panels verwendet werden können. Darüber hinaus werden wir eine einfache Anwendung mit den beiden genannten Methoden erstellen, um zu entscheiden und zu bestätigen, dass die Verwendung von Klassen eine wertvolle Angelegenheit ist.
Die Klassen Panels und Dialoge
In diesem Teil werden wir uns mit den Klassen beschäftigen, die uns helfen können, das grafische Panel einfach zu erstellen. Wir werden uns auf die Klassen Panels und Dialogs beziehen und Sie können die MQL5-Referenz für weitere Informationen lesen, da wir uns in diesem Artikel nur auf einige von ihnen beziehen werden.
Wenn wir nun die Klassen für die Erstellung von Kontrollfeldern und Dialogen identifizieren, können wir sagen, dass es sich um eine Bibliothek handelt, die vorgefertigten Code für die Erstellung oder Entwicklung von interaktiven Feldern oder Anwendungen einschließlich Indikatoren und Expertenberatern enthält. Es befindet sich im Ordner „Terminal Data“ im Ordner „Controls“ im Ordner „Include“. Es gibt Hilfs-, Basis-, einfache und komplexe Klassen, die für verschiedene Operationen verwendet werden können. Beispiele für diese Klassen:
| Klasse | Dateiname, einzubinden mit #include (Ordner „Controls“) | Beschreibung |
|---|---|---|
| CLabel | Label.mqh | Es ist eine einfache Steuerklasse zur Erstellung einfacher, nicht editierbarer Textbeschriftungen |
| CButton | Button.mqh | Es ist eine einfache Steuerklasse zur Erstellung einfacher Schaltflächen |
| CEdit | Edit.mqh | Es ist eine einfache Steuerklasse, die es dem Nutzer ermöglicht, einen Text einzugeben |
| CPanel | Panel.mqh | Es ist eine einfache Steuerklasse, um Steuerelemente mit anderen ähnlichen Funktionen in einer Gruppe zu kombinieren |
| CCheckBox | CheckBox.mqh | Es ist eine komplexe Steuerklasse, die ein Kontrollkästchen anzeigt und es dem Nutzer ermöglicht, zu wählen, ob es wahr oder falsch ist |
| CSpinEdit | SpinEdit.mqh | Es ist eine komplexe Steuerklasse, die die Bearbeitung eines Integer-Wertes durch ein Inkrement- und Dekrementfeld ermöglicht |
| CDialog | Dialog.mqh | Es ist eine komplexe Steuerklasse zur Kombination von Steuerelementen mit anderen verschiedenen Funktionen in einer Gruppe |
Wie wir durch die erwähnten Klassen und andere sehen können, können wir sie verwenden, um viele Aufgaben zu erledigen, die viel Zeit und Mühe kosten, wenn wir versuchen würden, sie durch den normalen Code oder ohne die Verwendung von Klassen zu erledigen, und wir können die gleiche Ansicht auf andere Klassen ausweiten, die helfen können, andere Aufgaben außer Panels zu erledigen. Wenn wir den Unterschied anhand eines einfachen Beispiels oder einer Anwendung sehen wollen, werden wir dies im nächsten Teil tun.
Einfache grafische Panel-Anwendung
In diesem Teil werden wir lernen, wie man ein einfaches Handels-Panel erstellt, mit dem man Kauf- und Verkaufsaufträge nach der Festlegung der Losgröße eröffnen kann. Wir werden dieses Panel mit zwei Methoden erstellen. Die erste Methode besteht darin, unseren eigenen Code ohne Klassen zu erstellen, und die zweite Methode verwendet Klassen verwenden, um so den Vergleich zu ermöglichen, inwieweit die Verwendung von Klassen uns helfen wird, unser Ziel reibungslos und einfach zu erreichen, und um von der Erstellung des Panels durch unseren eigenen Code zu lernen, ohne Klassen zu verwenden, da dies unsere Programmierlogik und Programmierfähigkeiten verbessern wird.
Ein grafisches Panel ohne Klassen
Die folgenden Schritte zur Erstellung eines einfachen Auftragspanels zum Öffnen von Kauf- und Verkaufsaufträgen nach der Festlegung der Losgröße ohne Verwendung von Klassen mit Ausnahme der Klasse „Trade“, da wir uns in diesem Artikel auf die Erstellung von Panels konzentrieren:
Verwendung von #include, um die Datei Trade einzubinden und ein Objekt mit dem Namen trade zu erstellen, das für das Erstellen und Absenden von Aufträgen verwendet wird
#include <Trade\Trade.mqh>
CTrade trade;
Wir erstellen eine boolesche Funktion zum Eröffnen von Handelsgeschäften, um den Auftragstyp (ENUM_ORDER_TYPE) und die Losgröße (double) des Handelsgeschäfts festzulegen. Dies sind die Parameter dieser Funktion, die wir erstellen werden, und der Hauptteil der Funktion ist wie folgt:
- Erstellen einer Preisvariablen vom Typ double.
- Festlegen einer Bedingung, um den Preistyp (Kauf- oder Verkaufskurs) auf der Grundlage des Auftragstyps mit Hilfe der if-Bedingung zu bestimmen:
- Wenn es sich bei der Auftragsart um einen Kauf handelt, ist der Preis, der für die Eröffnung des Auftrags verwendet wird, der Briefkurs (ask).
- Handelt es sich bei der Auftragsart um einen Verkauf, entspricht der Preis dem Geldkurs (bid).
- Das Ergebnis ist die Eröffnung der Position mit dem aktuellen Symbol, der Auftragsart, der Losgröße, dem Preistyp, einem Nullwert für Stop-Loss und Take-Profit und einem leeren Kommentar.
bool openTrade(ENUM_ORDER_TYPE type, double vol) { double price; if(type==ORDER_TYPE_BUY) { price=SymbolInfoDouble(Symbol(),SYMBOL_ASK); } else price=SymbolInfoDouble(Symbol(),SYMBOL_BID); return trade.PositionOpen(Symbol(),type,vol,price,0,0,""); }
Festlegung der Position des Panels durch Auswahl der oberen linken Ecke nach Erstellung der „const“ Variablen vom Typ ENUM_BASE_CORNER panelLoc:
const ENUM_BASE_CORNER panelLoc=CORNER_LEFT_UPPER;
Festlegen des x- und y-Abstandes mit den „const“ Variablen x und y:
const int xMargin=20; const int yMargin=20;
Einstellen des Abstandes zwischen den Elementen für x und y nach dem Erstellen einer weiteren „const“ ganzzahligen Variablen:
const int xSpace=10; const int ySpace=10;
Festlegen der Größe von Elementen, die Schaltflächen und Text, mit den vier, ganzzahligen „const“ Variablen btnWidth für die Breite der Schaltflächen, btnHeight für die Höhe der Schaltflächen, txtWidth für die Breite des Textes und txtHeight für die Höhe des Textes:
const int btnWidth=50; const int btnHeight=20; const int txtWidth=(btnWidth*2)+xSpace; const int txtHeight=20;
Festlegen der Positionen von Text und Schaltflächen: Text x, Text y, die Schaltflächen x und y für Kaufen und die Schaltflächen x und y für Verkaufen. Wir deklarieren die Variablen und weisen ihnen Werte zu:
const int txtX=3; const int txtY=yMargin+txtHeight; const int buyX=3; const int buyY=txtY+ySpace+btnHeight; const int sellX=buyX+xSpace+btnWidth; const int sellY=txtY+ySpace+btnHeight;
Zuweisung des Namens für die Elemente Text, Schaltfläche „Kaufen“ und Schaltfläche „Verkaufen“ nach der Erstellung von const-String-Variablen für diese Elemente:
const string txtName="txttVol"; const string buyName="buyBtn"; const string sellName="sellBtn";
Erstellen der Variablen für die Losgröße mit einem Anfangswert:
double lotSize=0.01;
In OnInit() rufen wir die Funktion createPanel() auf, die wir später erstellen werden:
createPanel();
In OnDeinit() löschen wir die Objekte mit Hilfe ihrer Namen:
ObjectDelete(0,txtName); ObjectDelete(0,buyName); ObjectDelete(0,sellName);
Im globalen Bereich erstellen wir die Funktion, die die Interaktion mit dem Panel ermöglicht, indem wir die folgenden Schritte ausführen:
Die Funktion OnChartEven und ihre Parameter sind:
- const int id: für die Ereignis-ID
- const long &lparam: für den Parameter vom Typ long event
- const double &dparam: für den Parameter vom Typ double event
- const string &sparam: für den Parameter vom Typ string event
Einstellung der Bedingungen für die Interaktion mit den Objekten Text (Losgröße), Kauf- und Verkaufsschaltfläche:
//+------------------------------------------------------------------+ //| Interaction function | //+------------------------------------------------------------------+ void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { //--- If the event id is equal to the end of text editing in the panel and the string type event is equal to the text name if(id==CHARTEVENT_OBJECT_ENDEDIT && sparam==txtName) { //--- lotTxt string variable will be equal to the returned property value by using the ObjectGetString function string lotTxt=ObjectGetString(0, txtName, OBJPROP_TEXT); //--- call setLot function that we will create later with the lotTxt value setLot(lotTxt); //Setting the property value by using the ObjectSetString ObjectSetString(0, txtName, OBJPROP_TEXT, string(lotSize)); //--- Use return return; } //--- If the event id is equal to the object click to check if we click the buy button else if(id==CHARTEVENT_OBJECT_CLICK) { //We will check if the string param is equal to buyname if(sparam==buyName) { //--- Setting the value of the property by using the ObjectSetInteger ObjectSetInteger(0, buyName, OBJPROP_STATE, false); //Calling the created openTrade to open a buy order. openTrade(ORDER_TYPE_BUY, lotSize); //--- Use return return; } //--- If the event id is equal to the object click to check if we click the sell button //--- We will check if the string param is equal to sellname else if(sparam==sellName) { //--- Setting the value of the property by using the ObjectSetInteger ObjectSetInteger(0, sellName, OBJPROP_STATE, false); //Calling the created openTrade to open a sell order openTrade(ORDER_TYPE_SELL, lotSize); //--- Use return return; } } }
Erstellen der Funktion void createPanel, die wir zuvor in OnInit() durch die folgenden Schritte aufgerufen haben:
- Objekte von txtName, buyName und sellName löschen
- Aufruf der Funktion EditCreate.
- Aufruf der Funktion ButtonCreate für die Kaufschaltfläche.
- Aufruf der Funktion ButtonCreate für die Verkaufsschaltfläche.
//+------------------------------------------------------------------+ //|createPanel function | //+------------------------------------------------------------------+ void createPanel() { //--- Delete objects of txtName, buyName, and sellName ObjectDelete(0, txtName); ObjectDelete(0, buyName); ObjectDelete(0, sellName); //--- calling the EditCreate function EditCreate( // Parameters: 0, // const long (chart_ID): to specify the chart's ID, we will use (0). txtName, // const string (name): to specify the button name, we will use (txtName) 0, // const int (sub_window): to specify the subwindow index, we will use (0) for the main window txtX, // const int (x): to specify the X coordinate, we will use (txtX) txtY, // const int (y): to specify the Y coordinate, we will use (txtY) txtWidth, // const int (width):to specify the button width, we will use (txtWidth) txtHeight, // const int (height): to specify the button height, we will use (txtHeight) string(lotSize), // const string (text): to specify the text, we will use (lotSize) "Arial", // const string (font): to specify the font, we will use "Arial" 10, // const int (font_size): to specify the font size, we will use (10) ALIGN_LEFT, // const ENUM_ALIGN_MODE (align_mode): to specify the position of text, we will use (ALIGN_LEFT) false, // const bool (read_only=false): to specify the ability to edit, we will be (false) panelLoc, // const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function clrBlack, // const color (clr): to specify the text color, we will specify clrBlack clrWhite, // const color (back_clr): to specify the background color, we will specify clrWhite clrBlack, // const color (border_clr): to specify the border color, we will specify clrBlack false, // const bool (back=false): in the background, we will set false false, // const bool (selection=false): highlight to move, we will set false false, // const bool (hidden): hidden in the object list, we will set false 0); // const long (z_order=0): priority for a mouse click, we will use (0) //--- calling the ButtonCreate function for the buy ButtonCreate( // Parameters: 0, // const long (chart_ID): to specify the chart's ID, we will use (0) buyName, // const string (name): to specify the button name, we will use (buyName) for the buy button 0, // const int (sub_window): to specify the subwindow index, we will use (0) for the main window buyX, // const int (x): to specify the X coordinate, we will use (buyX) for buy buyY, // const int (y): to specify the Y coordinate, we will use (buyY) for buy btnWidth, // const int (width): to specify the button width, we will use (btnWidth) for buy btnHeight, // const int (height): to specify the button height, we will use (btnHeight) for buy panelLoc, // const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function for buy button "Buy", // const string (text): to specify the text, we will use ("Buy") for the buy button "Arial", // const string (font): to specify the font, we will use "Arial" 10, // const int (font_size): to specify the font size, we will use (10) clrBlack, // const color (clr): to specify the text color, we will specify clrBlack clrGreen, // const color (back_clr): to specify the background color, we will specify clrGreen for the buy button clrBlack, // const color (border_clr): to specify the border color, we will specify clrBlack false, // const bool (state): to specify if the object is pressed or released, we will specify false false, // const bool (back=false): in the background, we will set false false, // const bool (selection=false): highlight to move, we will set false false, // const bool (hidden): hidden in the object list, we will set false 0); // const long (z_order=0): priority for mouse click, we will use (0) for buy button //--- calling the ButtonCreate function for the sell ButtonCreate( //Parameters: 0, //const long (chart_ID): to specify the chart's ID, we will use (0) sellName, //const string (name): to specify the button name, we will use (sellName) for the sell button 0, //const int (sub_window): to specify the subwindow index, we will use (0) for the main window sellX, //const int (x): to specify the X coordinate, we will use (sellX) for sell sellY, //const int (y): to specify the Y coordinate, we will use (sellY) btnWidth, //const int (width): to specify the button width, we will use (btnWidth) for sell btnHeight, //const int (height): to specify the button height, we will use (btnHeight) for sell panelLoc, //const ENUM_BASE_CORNER (corner): to specify the chart corner for anchoring, we will call panelLoc function for sell button "Sell", //const string (text): to specify the text, we will use ("Sell") for the sell button "Arial", //const string (font): to specify the font, we will use "Arial" 10, //const int (font_size): to specify the font size, we will use (10) clrBlack, //const color (clr): to specify the text color, we will specify clrBlack clrRed, //const color (back_clr): to specify the background color, we will specify clrRed for the sell button clrBlack, //const color (border_clr): to specify the border color, we will specify clrBlack false, //const bool (state): to specify if the object is pressed or released, we will specify false false, //const bool (back=false): in the background, we will set false false, //const bool (selection=false): highlight to move, we will set false false, //const bool (hidden): hidden in the object list, we will set false 0); //const long (z_order=0): priority for mouse click, we will use (0) for sell button }
Erstellen der Funktion void setLot mit dem einem Parameter lotTxt, der für lotSize verwendet wird. Der Hauptteil der Funktion ist wie folgt:
- Erstellung der Double-Variable newLot und Zuweisung an lotTxt nach der Konvertierung der Zeichenkette in einen double-Wert mit Hilfe der Funktion StringToDouble.
- Wenn die Variable newLot kleiner als 0 ist, müssen wir die Meldung „Invalid Volume Specified“ ausgeben und mit return die Funktion verlassen.
- Rückgabe des Wertes newLot, der mit lotSize übereinstimmt:
void setLot(string lotTxt) { double newLot=StringToDouble(lotTxt); if(newLot<0) { Print("Invaid Volume Specified"); return; } lotSize=newLot; }
Erstellen der Funktion EditCreate durch die folgenden Schritte:
//+------------------------------------------------------------------+ //|EditCreate function | //+------------------------------------------------------------------+ bool EditCreate(const long chart_ID=0, const string name="Edit", const int sub_window=0, const int x=0, const int y=0, const int width=50, const int height=18, const string text="Text", const string font="Arial", const int font_size=10, const ENUM_ALIGN_MODE align=ALIGN_CENTER, const bool read_only=false, const ENUM_BASE_CORNER corner=CORNER_LEFT_UPPER, const color clr=clrBlack, const color back_clr=clrWhite, const color border_clr=clrNONE, const bool back=false, const bool selection=false, const bool hidden=true, const long z_order=0) { //--- Reset the error value by using ResetLastError() ResetLastError(); //--- Create an edit field if(!ObjectCreate(chart_ID, name, OBJ_EDIT, sub_window, 0, 0)) { Print(__FUNCTION__, ": failed to create \"Edit\" object! Error code = ", GetLastError()); return(false); } //--- Setting the object coordinates x and y by using the ObjectSetInteger ObjectSetInteger(chart_ID, name, OBJPROP_XDISTANCE, x); ObjectSetInteger(chart_ID, name, OBJPROP_YDISTANCE, y); //--- Setting the object size by using the ObjectSetInteger function also ObjectSetInteger(chart_ID, name, OBJPROP_XSIZE, width); ObjectSetInteger(chart_ID, name, OBJPROP_YSIZE, height); //--- Setting the text by using ObjectSetString function ObjectSetString(chart_ID, name, OBJPROP_TEXT, text); //--- Setting the text font by using the ObjectSetString function also ObjectSetString(chart_ID, name, OBJPROP_FONT, font); //--- Setting the font size by using the ObjectSetInteger function ObjectSetInteger(chart_ID, name, OBJPROP_FONTSIZE, font_size); //--- Setting the type of text alignment in the object ObjectSetInteger(chart_ID, name, OBJPROP_ALIGN, align); //--- Setting the ability to edit, enable if it is (true) or cancel (false) if you need a read-only mode ObjectSetInteger(chart_ID, name, OBJPROP_READONLY, read_only); //--- Setting the chart's corner, relative to which object coordinates are defined to set the location of the object. ObjectSetInteger(chart_ID, name, OBJPROP_CORNER, corner); //--- Setting the text color ObjectSetInteger(chart_ID, name, OBJPROP_COLOR, clr); //--- Setting the background color ObjectSetInteger(chart_ID, name, OBJPROP_BGCOLOR, back_clr); //--- Setting the border color of the object ObjectSetInteger(chart_ID, name, OBJPROP_BORDER_COLOR, border_clr); //--- Displaying in the foreground by (false) or in the background by (true) ObjectSetInteger(chart_ID, name, OBJPROP_BACK, back); //--- Setting (true) to enable or (false) to disable the mode of moving the label by mouse ObjectSetInteger(chart_ID, name, OBJPROP_SELECTABLE, selection); ObjectSetInteger(chart_ID, name, OBJPROP_SELECTED, selection); //--- Setting (true) if you need hiding or (false) if you need the display of graphical object name in the object list ObjectSetInteger(chart_ID, name, OBJPROP_HIDDEN, hidden); //--- Setting the priority for receiving the event of a mouse click in the chart ObjectSetInteger(chart_ID, name, OBJPROP_ZORDER, z_order); //--- Returning (true) if successful execution return(true); }
Die Erstellung der Funktion ButtonCreate erfolgt durch die gleichen Parameter wie bei der Funktion EditCreate, nur mit einem kleinen Unterschied:
bool ButtonCreate(const long chart_ID=0, const string name="Button", const int sub_window=0, const int x=0, const int y=0, const int width=50, const int height=18, const ENUM_BASE_CORNER corner=CORNER_LEFT_UPPER, const string text="Button", const string font="Arial", const int font_size=10, const color clr=clrBlack, const color back_clr=C'236,233,216', const color border_clr=clrNONE, const bool state=false, const bool back=false, const bool selection=false, const bool hidden=true, const long z_order=0) { ResetLastError(); if(!ObjectCreate(chart_ID,name,OBJ_BUTTON,sub_window,0,0)) { Print(__FUNCTION__, ": failed to create the button! Error code = ",GetLastError()); return(false); } ObjectSetInteger(chart_ID,name,OBJPROP_XDISTANCE,x); ObjectSetInteger(chart_ID,name,OBJPROP_YDISTANCE,y); ObjectSetInteger(chart_ID,name,OBJPROP_XSIZE,width); ObjectSetInteger(chart_ID,name,OBJPROP_YSIZE,height); ObjectSetInteger(chart_ID,name,OBJPROP_CORNER,corner); ObjectSetString(chart_ID,name,OBJPROP_TEXT,text); ObjectSetString(chart_ID,name,OBJPROP_FONT,font); ObjectSetInteger(chart_ID,name,OBJPROP_FONTSIZE,font_size); ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr); ObjectSetInteger(chart_ID,name,OBJPROP_BGCOLOR,back_clr); ObjectSetInteger(chart_ID,name,OBJPROP_BORDER_COLOR,border_clr); ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back); ObjectSetInteger(chart_ID,name,OBJPROP_STATE,state); ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection); ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection); ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden); ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order); return(true); }
Nach dem Kompilieren und Ausführen des Codes erscheint das Panel wie folgt:
Wie in der vorherigen Abbildung zu sehen ist, befindet sich in der linken oberen Ecke ein Feld, in dem die Losgröße und die beiden Schaltflächen Kaufen und Verkaufen angezeigt werden. Wir können die benötigte Losgröße angeben und einen Auftrag erteilen, indem wir auf Kaufen oder Verkaufen drücken, je nachdem, welchen Typ wir benötigen. Dies ist die erste Methode, die wir sagten, wir werden dieses Panel ohne die Verwendung von Klassen von Panels oder Dialoge zu erstellen und wie wir finden, diese Methode nimmt viele Zeilen Code, jetzt müssen wir das gleiche Panel mit Panels und Dialoge Klassen zu bewerten und zu überprüfen, die Komplexität oder langen Code durch den Vergleich dieser beiden Methoden.
Ein grafisches Panel mit Klassen
Hier ist die zweite Methode zur Erstellung desselben Panels unter Verwendung der benötigten Klassen und der folgenden Schritte.
Include-Dateien oder Klassen, die wir benötigen, um ihre Komponenten in unserem Programm zu verwenden, sind Dialog, Button, Edit und Trade. Dies kann, wie wir wissen, mit der Direktiven #include erreicht werden:
#include <Controls\Dialog.mqh> #include <Controls\Button.mqh> #include <Controls\Edit.mqh> #include <Trade\Trade.mqh>
Unter Verwendung der Präprozessor-Direktiven #define zur Zuweisung von mnemonischen Namen an Konstanten, sind diese gleich wie die folgenden:
- PANEL_NAME "Order Panel"
- PANEL_WIDTH 116
- PANEL_HIEIGHT 100
- ROW_HEIGHT 20
- BUY_BTN_NAME "Buy BTN"
- SELL_BTN_NAME "Sell BTN"
- CLOSE_BTN_NAME "Close BTN"
- EDIT_NAME "Lot Size"
#define PANEL_NAME "Order Panel" #define PANEL_WIDTH 116 #define PANEL_HIEIGHT 100 #define ROW_HEIGHT 20 #define BUY_BTN_NAME "Buy BTN" #define SELL_BTN_NAME "Sell BTN" #define CLOSE_BTN_NAME "Close BTN" #define EDIT_NAME "Lot Size"
Erstellen von Objekten aus Klassen wie im Folgenden beschrieben:
CAppDialog panel; CButton buyBtn; CButton sellBtn; CButton closeBtn; CEdit lotSize; CTrade trade;
In OnInit() müssen wir unser Panel-Objekt erstellen, indem wir unser erstelltes Objekt panel.Create verwenden und seine Parameter sind:
- const long chart, verwenden wir 0, um das Panel im Hauptchart anzuzeigen.
- const string name, wir verwenden PANEL_NAME
- const int subwin, wir werden 0 verwenden
- const int x1, wir verwenden 10
- const int y1, wir verwenden 20
- const int x2, wir verwenden 10+PANEL_WIDTH+8
- const int y2, wir verwenden 20+PANEL_HIEIGHT
panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT);
Wir erstellen und konfigurieren die Schaltflächen zum Kaufen und Verkaufen wie in den folgenden Schritten beschrieben:
- Erstellen der Objekte mit object.Create.
- Einstellen der Breite der Kauf- und Verkaufsobjekte mit Hilfe von object.Width
- Einstellen der Höhe der Kauf- und Verkaufsobjekte mit Hilfe der Funktion object.Height.
- Einstellen der Hintergrundfarbe der Objekte durch Verwendung von object.ColorBackground.
- Festlegen der Texte der Objekte mit Hilfe von object.Text.
- Einstellen der Schriftart der Objekte mit object.Font.
- Einstellen der Schriftgröße der Objekte durch Verwendung von object.FontSize.
- Einstellen der Farbe der Objekte durch Verwendung der Funktion object.Color.
- Einstellen des farbigen Rahmens der Objekte mit Hilfe des Befehls object.ColorBorder.
- Platzieren des Objekts oder der Objekte auf dem Panel.
- Dann starten wir das Panel:
int OnInit() { //buy button panel.Create(0,PANEL_NAME,0,10,20,10+PANEL_WIDTH+8,20+PANEL_HIEIGHT); buyBtn.Create(0,BUY_BTN_NAME,0,3,40,0,0); buyBtn.Width(50); buyBtn.Height(ROW_HEIGHT); buyBtn.ColorBackground(clrGreen); buyBtn.Text("Buy"); buyBtn.Font("Arial"); buyBtn.FontSize(10); buyBtn.Color(clrBlack); buyBtn.ColorBorder(clrBlack); panel.Add(buyBtn); //sell button sellBtn.Create(0,SELL_BTN_NAME,0,63,40,0,0); sellBtn.Width(50); sellBtn.Height(ROW_HEIGHT); sellBtn.ColorBackground(clrRed); sellBtn.Text("Sell"); sellBtn.Font("Arial"); sellBtn.FontSize(10); sellBtn.Color(clrBlack); sellBtn.ColorBorder(clrBlack); panel.Add(sellBtn); //lotSize lotSize.Create(0,EDIT_NAME,0,4,10,0,0); lotSize.Width(108); lotSize.Height(ROW_HEIGHT); lotSize.Text("0.01"); lotSize.Font("Arial"); lotSize.FontSize(10); lotSize.ColorBackground(clrWhite); lotSize.Color(clrBlack); lotSize.ColorBorder(clrBlack); panel.Add(lotSize); //run the panel panel.Run(); return(INIT_SUCCEEDED); }
In OnDeinit(const int reason) verwenden wir Destroy wie folgt zur Deinitialisierung:
void OnDeinit(const int reason) { panel.Destroy(); }
Wir aktivieren die Interaktion mit dem Panel, indem Sie die Funktion OnChartEvent verwenden und die Bedingungen für das Verhalten der Kauf- und Verkaufsschaltflächen wie folgt festlegen:
- Erstellen der Funktion OnChartEvent,
- den Körper der Funktion:
- Verwendung von object.ChartEvent mit den Parametern id für das Ereignis, lparam für den Long-Typ des Ereignisses, dparam für den Double-Typ und sparam für den String-Typ.
- Prüfen, ob die ID gleich dem Klick auf dm Chart ist.
- Prüfen, ob sparam gleich buyBtn oder sellBtn als Namen ist.
- Erstellen einer Double-Variablen für die Losgröße und Übergabe die Funktion StringToDouble(Losgrößenwert).
- Eröffnen wir einen Kauf- oder Verkaufsauftrag je nach Art des Ereignisses unter Verwendung des Loswerts.
void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { panel.ChartEvent(id,lparam,dparam,sparam); if(id==CHARTEVENT_OBJECT_CLICK) { if(sparam==buyBtn.Name()) { double lot=StringToDouble(lotSize.Text()); trade.Buy(lot); } else if(sparam==sellBtn.Name()) { double lot=StringToDouble(lotSize.Text()); trade.Sell(lot); } } }
Nach dem Kompilieren des Codes und dem Ausführen der ausführbaren Datei können wir feststellen, dass das Panel auf dem Chart verankert ist, wie in der folgenden Abbildung dargestellt:
Wie im vorigen Bild zu sehen ist, befindet sich in der oberen linken Ecke das Panel mit den Feld für die Losgröße, und den Tasten für Kauf- und Verkauf. Die Losgröße und den jeweiligen Auftragstyp können wir wählen.
Nachdem wir das Erstellen des gleichen Panel mit zwei verschiedenen Methoden entwickelt haben, können wir feststellen, dass wir das Panel mit Hilfe von Klassen einfacher und reibungsloser erstellt haben als ohne Klassen. Also, Klassen sind sehr hilfreich und lassen Sie uns Code leicht und sparen eine Menge Zeit, aber mein Rat für Sie, wenn Sie die Entwickler, dass Sie versuchen zu lernen und zu verstehen, wie man fertige Dinge wie diese Klassen oder integrierte Funktionen in jeder Programmiersprache zu schaffen, da dies ein sehr guter Weg, um Ihre Codierung und Programmierung Fähigkeiten und Logik zu verbessern und wenn Sie Code können Sie Klassen, wie es wird Ihnen helfen, glatter und einfacher zusätzlich zu Ihrer Zeit sparen, um wiederholte Aufgaben zu tun.
Es ist gut, hier zu erwähnen, nachdem wir gelernt haben, wie wir diese Art von Panel erstellen können, dass dies eine einfache Anwendung ist, wie wir gesagt haben, und Sie können es mehr und mehr entwickeln, indem Sie mehr Funktionen verwenden, die durch sie getan werden können. Denn das Panel kann so einfach sein wie das, was wir erwähnt haben, oder sehr komplex und mit mehr Werkzeugen und Funktionen ausgestattet sein. Hier geht es darum, zu verstehen, wie diese Klassen zu verwenden sind, nachdem ihre Bedeutung und ihr Wert ermittelt wurden.
Schlussfolgerung
Am Ende dieses Artikels können wir feststellen, dass die Verwendung von Klassen ist eine wertvolle und hilfreiche Sache im Allgemeinen und speziell bei der Erstellung von Panels, die in der MetaTrader 5, die nützlich sein kann für Händler, wie es hilft ihnen in einer Menge von Dingen, die es ihnen ermöglichen, sich auf den Handel selbst und den Markt, ohne eine Menge von wesentlichen Aufgaben weit von der Verwendung dieser Panels. Wir lernten auch, was Panels sind und Beispiele für ihre Typen, lernten Panels und Dialogklassen kennen, die zur einfachen Erstellung dieser Panels verwendet werden können, und bestätigten, wie nützlich diese Klassen sein können, indem wir ein einfaches Panel als Anwendung mit zwei verschiedenen Methoden durch normalen Code erstellten, ohne die Panels und Dialogklassen zu verwenden, und indem wir sie verwendeten, um zu sehen, wie viel Zeit und Mühe verbraucht werden kann, wenn man keine Klassen verwendet.
Ich hoffe, dass dieser Artikel für Sie nützlich ist und Sie die darin enthaltenen Informationen leicht verstehen und umsetzen können. Ich hoffe auch, dass Sie mehr Einblicke darüber, wie können Sie entwickeln mehr erwähnt Anwendungen oder wie können Sie entwickeln und tauchen Sie tief, um mehr nützliche Panels, die nützlich sein können für Ihren Handel oder wenn Sie ein Anfänger mql5 Entwickler sind, ich hoffe, dass Sie etwas Neues gelernt und bekam mehr Einblicke darüber, wie Sie durch dieses wichtige Thema, das mit Klassen ist.
Wenn Sie mehr über Klassen und Objekte verstehen und lernen wollen, empfehle ich Ihnen, meinen früheren Artikel „Verstehen der MQL5 Objektorientierte Programmierung (OOP)“ lesen, der Ihnen helfen kann, dieses Thema zu meistern. Wenn Sie mehr darüber erfahren möchten, wie man Handelssysteme mit den beliebtesten technischen Indikatoren erstellt, können Sie meine früheren Artikel in meinem Abschnitt „Veröffentlichungen“ lesen, und ich hoffe, dass sie Ihnen nützlich sind.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/12903
Mean Reversion, eine einfache Handelsstrategie
Verstehen der MQL5 Objektorientierte Programmierung (OOP)
Entwicklung eines Wiedergabesystems — Marktsimulation (Teil 04): Anpassung der Einstellungen (II)
Handelsstrategie auf der Grundlage des verbesserten Indikators zur Erkennung des Kerzenmusters von Doji
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.