Grafiken in der Bibliothek DoEasy (Teil 74): Das grafisches Basiselement, das von der Klasse CCanvas unterstützt wird
Artyom Trishkin | 29 Juni, 2021
Inhalt
- Konzept
- Verbesserung der Klassenbibliothek
- Das Basisobjekt aller grafischen Objekte der Bibliothek, die auf Canvas basieren
- Test
- Was kommt als Nächstes?
Konzept
Im vorigen Artikel habe ich mit der Arbeit an dem großen Bibliotheksbereich für den Umgang mit Grafiken begonnen. Nämlich habe ich mit der Entwicklung des Form-Objekts begonnen, das das Hauptobjekt aller grafischen Objekte der Bibliothek sein soll basierend auf der CCanvas-Standardbibliothek-Klasse. Ich testete auch einige Mechanismen und traf Vorbereitungen für die weitere Entwicklung. Eine sorgfältige Analyse zeigte jedoch, dass das gewählte Konzept vom Konzept der Konstruktion von Bibliotheksobjekten abweicht und das Formularobjekt viel komplexer ist als das Basisobjekt.
Ich werde das Konzept des "Elements" für das grafische Basisobjekt auf der Leinwand einführen. Dieses Konzept soll für den Aufbau der übrigen grafischen Objekte verwendet werden. Zum Beispiel ist das Formularobjekt auch ein minimal ausreichendes Objekt zum Zeichnen von grafischen Konstruktionen in einem Programm, aber es kann bereits ein eigenständiges Objekt für die Gestaltung sein. Es hat bereits die Fähigkeit, den Objektrahmen, verschiedene Formen und einen Text zu zeichnen. Im Gegensatz dazu dient das Element-Objekt als Basis für die Erstellung aller abgeleiteten Objekte in der Hierarchie der Bibliothek "graphical", z. B.:
- Das grafische Basisobjekt ist abgeleitet von CObject. Es enthält die Eigenschaften, die grafischen Objekten eigen sind, die im Terminal erstellt werden können;
- Elementobjekt auf der Leinwand (canvas) hat die Eigenschaften des Objekts, das auf dem Leinwandobjekt basiert;
- Formularobjekt verfügt über zusätzliche Eigenschaften und Funktionen zur Gestaltung des Erscheinungsbildes des Elementobjekts;
- Fensterobjekt ist ein zusammengesetztes Objekt, das auf Element- und Formularobjekten basiert;
- usw.
Auf der Grundlage des neuen Konzepts werde ich die Basisklasse der grafischen Objekte der Bibliothek CGBaseObj überarbeiten und ein neues Objekt "Grafisches Element" erstellen, das das gesamte Konzept des Aufbaus der grundlegenden Bibliotheksobjekte vollständig wiederholt. Später wird uns ein solcher Ansatz erlauben, schnell nach den notwendigen grafischen Objekten zu suchen, sowie sie zu sortieren und ihr Verhalten und Rendering zu verwalten.
Verbesserung der Klassenbibliothek
Fügen wir in MQL5\Include\DoEasy\Data.mqh den neuen Indices der Mitteilungen hinzu:
MSG_LIB_SYS_FAILED_CREATE_STORAGE_FOLDER, // Failed to create folder for storing files. Error: MSG_LIB_SYS_FAILED_ADD_ACC_OBJ_TO_LIST, // Error. Failed to add current account object to collection list MSG_LIB_SYS_FAILED_CREATE_CURR_ACC_OBJ, // Error. Failed to create account object with current account data MSG_LIB_SYS_FAILED_OPEN_FILE_FOR_WRITE, // Could not open file for writing MSG_LIB_SYS_INPUT_ERROR_NO_SYMBOL, // Input error: no symbol MSG_LIB_SYS_FAILED_CREATE_SYM_OBJ, // Failed to create symbol object MSG_LIB_SYS_FAILED_ADD_SYM_OBJ, // Failed to add symbol MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ, // Failed to create the graphical element object
und die Texte, die den neu hinzugefügten Indices entsprechen:
{"Не удалось создать папку хранения файлов. Ошибка: ","Could not create file storage folder. Error: "},
{"Ошибка. Не удалось добавить текущий объект-аккаунт в список-коллекцию","Error. Failed to add current account object to collection list"},
{"Ошибка. Не удалось создать объект-аккаунт с данными текущего счёта","Error. Failed to create account object with current account data"},
{"Не удалось открыть для записи файл ","Could not open file for writing: "},
{"Ошибка входных данных: нет символа ","Input error: no "},
{"Не удалось создать объект-символ ","Failed to create symbol object "},
{"Не удалось добавить символ ","Failed to add "},
{"Не удалось создать объект-графический элемент ","Failed to create graphic element object "},
Für das neue Objekt des "Grafischen Elements" in \MQL5\Include\DoEasy\Defines.mqh fügen wir seinen Typ zur Enumerationsliste der grafischen Objekttypen hinzu, ebenso wie seine ganzzahligen und Text- Eigenschaften:
//+------------------------------------------------------------------+ //| The list of graphical element types | //+------------------------------------------------------------------+ enum ENUM_GRAPH_ELEMENT_TYPE { GRAPH_ELEMENT_TYPE_ELEMENT, // Element GRAPH_ELEMENT_TYPE_FORM, // Form GRAPH_ELEMENT_TYPE_WINDOW, // Window }; //+------------------------------------------------------------------+ //| Integer properties of the graphical element on the canvas | //+------------------------------------------------------------------+ enum ENUM_CANV_ELEMENT_PROP_INTEGER { CANV_ELEMENT_PROP_ID = 0, // Form ID CANV_ELEMENT_PROP_TYPE, // Graphical element type CANV_ELEMENT_PROP_NUM, // Element index in the list CANV_ELEMENT_PROP_CHART_ID, // Chart ID CANV_ELEMENT_PROP_WND_NUM, // Chart subwindow index CANV_ELEMENT_PROP_COORD_X, // Form's X coordinate on the chart CANV_ELEMENT_PROP_COORD_Y, // Form's Y coordinate on the chart CANV_ELEMENT_PROP_WIDTH, // Form width CANV_ELEMENT_PROP_HEIGHT, // Form height CANV_ELEMENT_PROP_RIGHT, // Form right border CANV_ELEMENT_PROP_BOTTOM, // Form bottom border CANV_ELEMENT_PROP_ACT_SHIFT_LEFT, // Active area offset from the left edge of the form CANV_ELEMENT_PROP_ACT_SHIFT_TOP, // Active area offset from the top edge of the form CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT, // Active area offset from the right edge of the form CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM, // Active area offset from the bottom edge of the form CANV_ELEMENT_PROP_OPACITY, // Form opacity CANV_ELEMENT_PROP_COLOR_BG, // Form background color CANV_ELEMENT_PROP_MOVABLE, // Form moveability flag CANV_ELEMENT_PROP_ACTIVE, // Form activity flag CANV_ELEMENT_PROP_COORD_ACT_X, // X coordinate of the form's active area CANV_ELEMENT_PROP_COORD_ACT_Y, // Y coordinate of the form's active area CANV_ELEMENT_PROP_ACT_RIGHT, // Right border of the form's active area CANV_ELEMENT_PROP_ACT_BOTTOM, // Bottom border of the form's active area }; #define CANV_ELEMENT_PROP_INTEGER_TOTAL (23) // Total number of integer properties #define CANV_ELEMENT_PROP_INTEGER_SKIP (0) // Number of integer properties not used in sorting //+------------------------------------------------------------------+ //| Real properties of the graphical element on the canvas | //+------------------------------------------------------------------+ enum ENUM_CANV_ELEMENT_PROP_DOUBLE { CANV_ELEMENT_PROP_DUMMY = CANV_ELEMENT_PROP_INTEGER_TOTAL, // DBL stub }; #define CANV_ELEMENT_PROP_DOUBLE_TOTAL (1) // Total number of real properties #define CANV_ELEMENT_PROP_DOUBLE_SKIP (1) // Number of real properties not used in sorting //+------------------------------------------------------------------+ //| String properties of the graphical element on the canvas | //+------------------------------------------------------------------+ enum ENUM_CANV_ELEMENT_PROP_STRING { CANV_ELEMENT_PROP_NAME_OBJ = (CANV_ELEMENT_PROP_INTEGER_TOTAL+CANV_ELEMENT_PROP_DOUBLE_TOTAL), // Form object name CANV_ELEMENT_PROP_NAME_RES, // Graphical resource name }; #define CANV_ELEMENT_PROP_STRING_TOTAL (2) // Total number of string properties //+------------------------------------------------------------------+
Da die leinwandbasierten Objekte noch keine echten Eigenschaften haben, während das Konzept der Konstruktion von Bibliotheksobjekten deren Vorhandensein voraussetzt, habe ich die echte Eigenschaft stub als einzige echte Eigenschaft hinzugefügt.
Um die Objekte der grafischen Elemente nach Eigenschaften zu sortieren, wird die Enumeration mit den möglichen Sortierkriterien hinzugefügt:
//+------------------------------------------------------------------+ //| Possible sorting criteria of graphical elements on the canvas | //+------------------------------------------------------------------+ #define FIRST_CANV_ELEMENT_DBL_PROP (CANV_ELEMENT_PROP_INTEGER_TOTAL-CANV_ELEMENT_PROP_INTEGER_SKIP) #define FIRST_CANV_ELEMENT_STR_PROP (CANV_ELEMENT_PROP_INTEGER_TOTAL-CANV_ELEMENT_PROP_INTEGER_SKIP+CANV_ELEMENT_PROP_DOUBLE_TOTAL-CANV_ELEMENT_PROP_DOUBLE_SKIP) enum ENUM_SORT_CANV_ELEMENT_MODE { //--- Sort by integer properties SORT_BY_CANV_ELEMENT_ID = 0, // Sort by form ID SORT_BY_CANV_ELEMENT_TYPE, // Sort by graphical element type SORT_BY_CANV_ELEMENT_NUM, // Sort by form index in the list SORT_BY_CANV_ELEMENT_CHART_ID, // Sort by chart ID SORT_BY_CANV_ELEMENT_WND_NUM, // Sort by chart window index SORT_BY_CANV_ELEMENT_COORD_X, // Sort by the form X coordinate on the chart SORT_BY_CANV_ELEMENT_COORD_Y, // Sort by the form Y coordinate on the chart SORT_BY_CANV_ELEMENT_WIDTH, // Sort by the form width SORT_BY_CANV_ELEMENT_HEIGHT, // Sort by the form height SORT_BY_CANV_ELEMENT_RIGHT, // Sort by the form right border SORT_BY_CANV_ELEMENT_BOTTOM, // Sort by the form bottom border SORT_BY_CANV_ELEMENT_ACT_SHIFT_LEFT, // Sort by the active area offset from the left edge of the form SORT_BY_CANV_ELEMENT_ACT_SHIFT_TOP, // Sort by the active area offset from the top edge of the form SORT_BY_CANV_ELEMENT_ACT_SHIFT_RIGHT, // Sort by the active area offset from the right edge of the form SORT_BY_CANV_ELEMENT_ACT_SHIFT_BOTTOM, // Sort by the active area offset from the bottom edge of the form SORT_BY_CANV_ELEMENT_OPACITY, // Sort by the form opacity SORT_BY_CANV_ELEMENT_COLOR_BG, // Sort by the form background color SORT_BY_CANV_ELEMENT_MOVABLE, // Sort by the form moveability flag SORT_BY_CANV_ELEMENT_ACTIVE, // Sort by the form activity flag SORT_BY_CANV_ELEMENT_COORD_ACT_X, // Sort by X coordinate of the form active area SORT_BY_CANV_ELEMENT_COORD_ACT_Y, // Sort by Y coordinate of the form active area SORT_BY_CANV_ELEMENT_ACT_RIGHT, // Sort by the right border of the form active area SORT_BY_CANV_ELEMENT_ACT_BOTTOM, // Sort by the bottom border of the form active area //--- Sort by real properties //--- Sort by string properties SORT_BY_CANV_ELEMENT_NAME_OBJ = FIRST_CANV_ELEMENT_STR_PROP,// Sort by the form object name SORT_BY_CANV_ELEMENT_NAME_RES, // Sort by the graphical resource name }; //+------------------------------------------------------------------+
Alle diese Enumerationen wurden im ersten Artikel beschrieben und vielfach berücksichtigt, so dass ich hier nicht näher darauf eingehen werde.
Bevor wir das Objekt "Grafisches Element" erstellen, überarbeiten wir die Basisobjektklasse aller grafischen Objekte der Bibliothek in MQL5\Include\DoEasy\Objects\Graph\GBaseObj.mqh.
Das Objekt soll alle allgemeinen Eigenschaften beliebiger grafischer Objekte speichern, wie z. B. den erstellten Objekttyp, die Diagramm-ID und den Index des Unterfensters, in dem das grafische Objekt, sein Name und das Namenspräfix festgelegt sind. Alle grafischen Objekte der Bibliothek sollten von der Klasse abgeleitet werden.
Es ist bequemer, diese Klasse komplett neu zu erstellen, als die bestehende Klasse zu reparieren. Entfernen wir daher einfach alles aus der Datei und fügen die notwendigen Dinge hinzu:
//+------------------------------------------------------------------+ //| GBaseObj.mqh | //| Copyright 2021, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2021, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "..\..\Services\DELib.mqh" #include <Graphics\Graphic.mqh> //+------------------------------------------------------------------+ //| Class of the base object of the library graphical objects | //+------------------------------------------------------------------+ class CGBaseObj : public CObject { private: int m_type; // Object type protected: string m_name_prefix; // Object name prefix string m_name; // Object name long m_chart_id; // Chart ID int m_subwindow; // Subwindow index int m_shift_y; // Subwindow Y coordinate shift public: //--- Return the values of class variables string Name(void) const { return this.m_name; } long ChartID(void) const { return this.m_chart_id; } int SubWindow(void) const { return this.m_subwindow; } //--- The virtual method returning the object type virtual int Type(void) const { return this.m_type; } //--- Constructor/destructor CGBaseObj(); ~CGBaseObj(); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CGBaseObj::CGBaseObj() : m_shift_y(0), m_type(0), m_name_prefix(::MQLInfoString(MQL_PROGRAM_NAME)+"_") { } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CGBaseObj::~CGBaseObj() { } //+------------------------------------------------------------------+
Die Datei der Bibliotheksdienstfunktionen und die Klassendatei der Standardbibliothek CGraphic werden sofort in die Datei eingebunden. Die Klassendatei CCanvas ist bereits in CGraphic eingebunden. Gleichzeitig verfügt die Klasse CGraphic über eine Vielzahl von Methoden zum Zeichnen verschiedener Grafiken. Diese werden wir auch in Zukunft benötigen.
Die Klasse wird von der Basisklasse der Standardbibliothek abgeleitet und erlaubt es uns, grafische Elemente als Objekte der Klasse CObject zu erzeugen und die Listen der grafischen Objekte der Bibliothek so zu speichern, wie ich bereits alle unsere Objekte in den entsprechenden Collections speichere.
Die private Variable m_type soll den Objekttyp aus der Enumeration ENUM_GRAPH_ELEMENT_TYPE speichern, die ich oben besprochen habe.
Standardmäßig ist der Objekttyp gleich Null und wird von der virtuellen Methode Type() der Basisklasse der Standardbibliothek zurückgegeben:
//--- method of identifying the object virtual int Type(void) const { return(0); }
Hier habe ich diese Methode ebenfalls umdefiniert, so dass sie die Variable m_type in Abhängigkeit von der Zeit des erzeugten grafischen Objekts zurückgibt.
Geschützte (protected) Klassenvariablen:
- m_name_prefix — hier werde ich ein Namenspräfix von Objekten zur Identifizierung von grafischen Objekten durch ihre Zugehörigkeit zum Programm speichern. Dementsprechend werde ich hier den Namen des Programms basierend auf der Bibliothek speichern.
- m_name speichert einen grafischen Objektnamen. Der vollständige Objektname wird durch die Addition von Präfix und Name gebildet. Bei der Erstellung von Objekten müssen wir also nur einen eindeutigen Namen für ein neu erstelltes Objekt angeben, während die Objektklasse "Grafisches Element" den Namen selbständig um ein Präfix ergänzt. Das Präfix ermöglicht die Identifizierung des Objekts mit dem Programm, das es erstellt hat.
- m_chart_id — hier wird eine ID des Diagramms festgelegt, auf dem das grafische Objekt erstellt werden soll.
- m_subwindow — Unterfenster des Charts, auf dem das grafische Objekt erstellt wird.
- m_shift_y — Offset der Y-Koordinate eines Objekts, das in einem Diagramm-Unterfenster erstellt wird.
Öffentliche Methoden geben einfach die Werte der entsprechenden Klassenvariablen zurück:
public: //--- Return the values of class variables string Name(void) const { return this.m_name; } long ChartID(void) const { return this.m_chart_id; } int SubWindow(void) const { return this.m_subwindow; } //--- The virtual method returning the object type virtual int Type(void) const { return this.m_type; }
In der Initialisierungsliste des Klassenkonstruktors setzen wir den Y-Koordinatenoffset, den Objekttyp (die Voreinstellung ist 0) und den Namenspräfix, bestehend aus dem Programmnamen und einem Unterstrich:
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CGBaseObj::CGBaseObj() : m_shift_y(0), m_type(0), m_name_prefix(::MQLInfoString(MQL_PROGRAM_NAME)+"_") { } //+------------------------------------------------------------------+
Das Basisobjekt aller grafischen Objekte der Bibliothek, die auf Canvas basieren
Beginnen wir mit der Entwicklung der Objektklasse "Grafisches Element" auf Basis der Klasse CCanvas.
Wir erstellen in \MQL5\Include\DoEasy\Objects\Graph\ die neue Datei GCnvElement.mqh der Klasse CGCnvElement.
Wir binden die Datei des grafischen Basisobjekts der Bibliothek von dem die Klasse geerbt werden soll in die Klassendatei ein:
//+------------------------------------------------------------------+ //| GCnvElement.mqh | //| Copyright 2021, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2021, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" #property strict // Necessary for mql4 //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include "GBaseObj.mqh" //+------------------------------------------------------------------+ //| Class of the base object of the library graphical objects | //+------------------------------------------------------------------+ class CGCnvElement : public CGBaseObj { }
Im geschützten Bereich der Klasse deklarieren wir die Objekte der Klassen CCanvas und CPause sowie zwei Methoden, die die Position der angegebenen Koordinaten relativ zum Element und dessen aktiven Bereich zurückgeben:
protected: CCanvas m_canvas; // CCanvas class object CPause m_pause; // Pause class object //--- Return the cursor position relative to the (1) entire element and (2) the element's active area bool CursorInsideElement(const int x,const int y); bool CursorInsideActiveArea(const int x,const int y); private:
Im privaten Abschnitt der Klasse deklarieren wir die Arrays zur Speicherung der Objekteigenschaften und schreiben zwei Methoden, die reale Indizes der angegebenen Eigenschaften in den entsprechenden Arrays zurückgeben:
private: long m_long_prop[ORDER_PROP_INTEGER_TOTAL]; // Integer properties double m_double_prop[ORDER_PROP_DOUBLE_TOTAL]; // Real properties string m_string_prop[ORDER_PROP_STRING_TOTAL]; // String properties //--- Return the index of the array the order's (1) double and (2) string properties are located at int IndexProp(ENUM_CANV_ELEMENT_PROP_DOUBLE property) const { return(int)property-CANV_ELEMENT_PROP_INTEGER_TOTAL; } int IndexProp(ENUM_CANV_ELEMENT_PROP_STRING property) const { return(int)property-CANV_ELEMENT_PROP_INTEGER_TOTAL-CANV_ELEMENT_PROP_DOUBLE_TOTAL; } public:
Der öffentliche Teil der Klasse enthält die Standardmethoden der Bibliotheksklassen-Objekte zum Setzen der Eigenschaften in die Arrays und zum Zurückgeben der Eigenschaften aus den Arrays, die Methoden zum Zurückgeben der Flags des Objekts, das die angegebene Eigenschaft unterstützt, und die Methoden zum Vergleichen zweier Objekte:
public: //--- Set object's (1) integer, (2) real and (3) string properties void SetProperty(ENUM_CANV_ELEMENT_PROP_INTEGER property,long value) { this.m_long_prop[property]=value; } void SetProperty(ENUM_CANV_ELEMENT_PROP_DOUBLE property,double value) { this.m_double_prop[this.IndexProp(property)]=value; } void SetProperty(ENUM_CANV_ELEMENT_PROP_STRING property,string value) { this.m_string_prop[this.IndexProp(property)]=value; } //--- Return object’s (1) integer, (2) real and (3) string property from the properties array long GetProperty(ENUM_CANV_ELEMENT_PROP_INTEGER property) const { return this.m_long_prop[property]; } double GetProperty(ENUM_CANV_ELEMENT_PROP_DOUBLE property) const { return this.m_double_prop[this.IndexProp(property)]; } string GetProperty(ENUM_CANV_ELEMENT_PROP_STRING property) const { return this.m_string_prop[this.IndexProp(property)]; } //--- Return the flag of the object supporting this property virtual bool SupportProperty(ENUM_CANV_ELEMENT_PROP_INTEGER property) { return true; } virtual bool SupportProperty(ENUM_CANV_ELEMENT_PROP_DOUBLE property) { return true; } virtual bool SupportProperty(ENUM_CANV_ELEMENT_PROP_STRING property) { return true; } //--- Compare CGCnvElement objects with each other by all possible properties (for sorting the lists by a specified object property) virtual int Compare(const CObject *node,const int mode=0) const; //--- Compare CGCnvElement objects with each other by all properties (to search equal objects) bool IsEqual(CGCnvElement* compared_obj) const; //--- Creates the control
Alle diese Methoden sind Standard für Bibliotheksobjekte. Ich habe sie im ersten Artikel besprochen.
Der öffentliche Teil der Klasse enthält die Methode zum Erzeugen des Objekts "Grafisches Element" auf der Leinwand, die Methode, die den Zeiger auf das erzeugte Leinwandobjekt zurückgibt, die Methode zum Einstellen der Aktualisierungsfrequenz der Leinwand, die Methode zum Verschieben der Leinwand auf dem Diagramm und die Methoden für einen vereinfachten Zugriff auf die Objekteigenschaften:
//--- Creates the control bool Create(const long chart_id, const int wnd_num, const string name, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool redraw=false); //--- Return the pointer to a canvas object CCanvas *CanvasObj(void) { return &this.m_canvas; } //--- Set the canvas update frequency void SetFrequency(const ulong value) { this.m_pause.SetWaitingMSC(value); } //--- Update the coordinates (shift the canvas) bool Move(const int x,const int y,const bool redraw=false); //--- Constructors/Destructor CGCnvElement(const ENUM_GRAPH_ELEMENT_TYPE element_type, const int element_id, const int element_num, const long chart_id, const int wnd_num, const string name, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable=true, const bool activity=true, const bool redraw=false); CGCnvElement(){;} ~CGCnvElement(); //+------------------------------------------------------------------+ //| Methods of simplified access to object properties | //+------------------------------------------------------------------+ //--- Set the (1) X, (2) Y coordinates, (3) element width and (4) height, bool SetCoordX(const int coord_x); bool SetCoordY(const int coord_y); bool SetWidth(const int width); bool SetHeight(const int height); //--- Set the shift of the (1) left, (2) top, (3) right, (4) bottom edge of the active area relative to the element, //--- (5) all shifts of the active area edges relative to the element and (6) the element opacity void SetActiveAreaLeftShift(const int value) { this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_LEFT,fabs(value)); } void SetActiveAreaRightShift(const int value) { this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT,fabs(value)); } void SetActiveAreaTopShift(const int value) { this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_TOP,fabs(value)); } void SetActiveAreaBottomShift(const int value) { this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM,fabs(value)); } void SetActiveAreaShift(const int left_shift,const int bottom_shift,const int right_shift,const int top_shift); void SetOpacity(const uchar value,const bool redraw=false); //--- Return the shift (1) of the left, (2) right, (3) top and (4) bottom edge of the element active area int ActiveAreaLeftShift(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_LEFT); } int ActiveAreaRightShift(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT); } int ActiveAreaTopShift(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_TOP); } int ActiveAreaBottomShift(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM); } //--- Return the coordinate (1) of the left, (2) right, (3) top and (4) bottom edge of the element active area int ActiveAreaLeft(void) const { return int(this.CoordX()+this.ActiveAreaLeftShift()); } int ActiveAreaRight(void) const { return int(this.RightEdge()-this.ActiveAreaRightShift()); } int ActiveAreaTop(void) const { return int(this.CoordY()+this.ActiveAreaTopShift()); } int ActiveAreaBottom(void) const { return int(this.BottomEdge()-this.ActiveAreaBottomShift()); } //--- Return (1) the opacity, coordinate (2) of the right and (3) bottom element edge uchar Opacity(void) const { return (uchar)this.GetProperty(CANV_ELEMENT_PROP_OPACITY); } int RightEdge(void) const { return this.CoordX()+this.m_canvas.Width(); } int BottomEdge(void) const { return this.CoordY()+this.m_canvas.Height(); } //--- Return the (1) X, (2) Y coordinates, (3) element width and (4) height, int CoordX(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_COORD_X); } int CoordY(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_COORD_Y); } int Width(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_WIDTH); } int Height(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_HEIGHT); } //--- Return the element (1) moveability and (2) activity flag bool Movable(void) const { return (bool)this.GetProperty(CANV_ELEMENT_PROP_MOVABLE); } bool Active(void) const { return (bool)this.GetProperty(CANV_ELEMENT_PROP_ACTIVE); } //--- Return (1) the object name, (2) the graphical resource name, (3) the chart ID and (4) the chart subwindow index string NameObj(void) const { return this.GetProperty(CANV_ELEMENT_PROP_NAME_OBJ); } string NameRes(void) const { return this.GetProperty(CANV_ELEMENT_PROP_NAME_RES); } long ChartID(void) const { return this.GetProperty(CANV_ELEMENT_PROP_CHART_ID); } int WindowNum(void) const { return (int)this.GetProperty(CANV_ELEMENT_PROP_WND_NUM); } }; //+------------------------------------------------------------------+
Schauen wir uns die Implementierung der deklarierten Methoden im Detail an.
Der parametrische Konstruktor der Klasse:
//+------------------------------------------------------------------+ //| Parametric constructor | //+------------------------------------------------------------------+ CGCnvElement::CGCnvElement(const ENUM_GRAPH_ELEMENT_TYPE element_type, const int element_id, const int element_num, const long chart_id, const int wnd_num, const string name, const int x, const int y, const int w, const int h, const color colour, const uchar opacity, const bool movable=true, const bool activity=true, const bool redraw=false) { this.m_name=this.m_name_prefix+name; this.m_chart_id=chart_id; this.m_subwindow=wnd_num; if(this.Create(chart_id,wnd_num,this.m_name,x,y,w,h,colour,opacity,redraw)) { this.SetProperty(CANV_ELEMENT_PROP_NAME_RES,this.m_canvas.ResourceName()); // Graphical resource name this.SetProperty(CANV_ELEMENT_PROP_CHART_ID,CGBaseObj::ChartID()); // Chart ID this.SetProperty(CANV_ELEMENT_PROP_WND_NUM,CGBaseObj::SubWindow()); // Chart subwindow index this.SetProperty(CANV_ELEMENT_PROP_NAME_OBJ,CGBaseObj::Name()); // Element object name this.SetProperty(CANV_ELEMENT_PROP_TYPE,element_type); // Graphical element type this.SetProperty(CANV_ELEMENT_PROP_ID,element_id); // Element ID this.SetProperty(CANV_ELEMENT_PROP_NUM,element_num); // Element index in the list this.SetProperty(CANV_ELEMENT_PROP_COORD_X,x); // Element's X coordinate on the chart this.SetProperty(CANV_ELEMENT_PROP_COORD_Y,y); // Element's Y coordinate on the chart this.SetProperty(CANV_ELEMENT_PROP_WIDTH,w); // Element width this.SetProperty(CANV_ELEMENT_PROP_HEIGHT,h); // Element height this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_LEFT,0); // Active area offset from the left edge of the element this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_TOP,0); // Active area offset from the upper edge of the element this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT,0); // Active area offset from the right edge of the element this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM,0); // Active area offset from the bottom edge of the element this.SetProperty(CANV_ELEMENT_PROP_OPACITY,opacity); // Element opacity this.SetProperty(CANV_ELEMENT_PROP_COLOR_BG,colour); // Element color this.SetProperty(CANV_ELEMENT_PROP_MOVABLE,movable); // Element moveability flag this.SetProperty(CANV_ELEMENT_PROP_ACTIVE,activity); // Element activity flag this.SetProperty(CANV_ELEMENT_PROP_RIGHT,this.RightEdge()); // Element right border this.SetProperty(CANV_ELEMENT_PROP_BOTTOM,this.BottomEdge()); // Element bottom border this.SetProperty(CANV_ELEMENT_PROP_COORD_ACT_X,this.ActiveAreaLeft()); // X coordinate of the element active area this.SetProperty(CANV_ELEMENT_PROP_COORD_ACT_Y,this.ActiveAreaTop()); // Y coordinate of the element active area this.SetProperty(CANV_ELEMENT_PROP_ACT_RIGHT,this.ActiveAreaRight()); // Right border of the element active area this.SetProperty(CANV_ELEMENT_PROP_ACT_BOTTOM,this.ActiveAreaBottom()); // Bottom border of the element active area } else { ::Print(CMessage::Text(MSG_LIB_SYS_FAILED_CREATE_ELM_OBJ),this.m_name); } } //+------------------------------------------------------------------+
Hier wird zunächst ein Objektname erzeugt, der sich aus dem in der Elternklasse erzeugten Objektnamenspräfix und dem in den Konstruktorparametern übergebenen Namen zusammensetzt. Der eindeutige Objektname sieht also aus wie "Präfix_Objekt_Name".
Als Nächstes setzen wir die Chart-ID und den Index des Subfensters, die in den Parametern übergeben wurden, auf die Variablen der Elternklasse.
Anschließend wird die Methode zum Erzeugen des grafischen Objekts auf der Leinwand aufgerufen. Wenn das Objekt erfolgreich erstellt wurde, werden alle Daten in die Eigenschaften des Elementobjekts geschrieben. Wenn die Erstellung des grafischen Objekts der Klasse CCanvas fehlgeschlagen ist, steht das im Journal. Der Name mit dem Präfix wird bereits erstellt worden sein und die ID des Charts wird zusammen mit seinem Unterfenster gesetzt worden sein. Wir können also versuchen, das Objekt der Klasse CCanvas erneut durch einen erneuten Aufruf der Methode Create() zu erzeugen. Standardmäßig wird bei der Erstellung eines Objekts der Offset der aktiven Fläche von jeder Seite auf Null gesetzt, d. h. die aktive Fläche des Objekts entspricht der Größe des erstellten grafischen Elements. Nach der Erstellung kann die Größe und Position des aktiven Bereichs jederzeit mit den unten betrachteten entsprechenden Methoden geändert werden.
Im Destruktor der Klasse, zerstören wir das erstellte Objekt der Klasse CCanvas:
//+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CGCnvElement::~CGCnvElement() { this.m_canvas.Destroy(); } //+------------------------------------------------------------------+
Die Methode vergleicht die grafischen Elementobjekte anhand einer bestimmten Eigenschaft:
//+----------------------------------------------------------------------+ //|Compare CGCnvElement objects with each other by the specified property| //+----------------------------------------------------------------------+ int CGCnvElement::Compare(const CObject *node,const int mode=0) const { const CGCnvElement *obj_compared=node; //--- compare integer properties of two objects if(mode<CANV_ELEMENT_PROP_INTEGER_TOTAL) { long value_compared=obj_compared.GetProperty((ENUM_CANV_ELEMENT_PROP_INTEGER)mode); long value_current=this.GetProperty((ENUM_CANV_ELEMENT_PROP_INTEGER)mode); return(value_current>value_compared ? 1 : value_current<value_compared ? -1 : 0); } //--- compare real properties of two objects else if(mode<CANV_ELEMENT_PROP_DOUBLE_TOTAL+CANV_ELEMENT_PROP_INTEGER_TOTAL) { double value_compared=obj_compared.GetProperty((ENUM_CANV_ELEMENT_PROP_DOUBLE)mode); double value_current=this.GetProperty((ENUM_CANV_ELEMENT_PROP_DOUBLE)mode); return(value_current>value_compared ? 1 : value_current<value_compared ? -1 : 0); } //--- compare string properties of two objects else if(mode<ORDER_PROP_DOUBLE_TOTAL+ORDER_PROP_INTEGER_TOTAL+ORDER_PROP_STRING_TOTAL) { string value_compared=obj_compared.GetProperty((ENUM_CANV_ELEMENT_PROP_STRING)mode); string value_current=this.GetProperty((ENUM_CANV_ELEMENT_PROP_STRING)mode); return(value_current>value_compared ? 1 : value_current<value_compared ? -1 : 0); } return 0; } //+------------------------------------------------------------------+
Die Methode ist Standard für alle Bibliotheksobjekte. Sie wurde bereits früher betrachtet. Kurz gesagt, die Methode empfängt das Objekt, dessen angegebener Parameter mit dem entsprechenden Parameter des aktuellen Objekts verglichen werden soll. Abhängig von dem übergebenen Parameter wird ein ähnlicher geholt und das Ergebnis des Vergleichs der Parameter zweier Objekte zurückgegeben (1, -1 und 0 für 'mehr', 'weniger' und 'gleich', entsprechend).
Die Methode vergleicht die grafischen Elementobjekte anhand aller Eigenschaften:
//+------------------------------------------------------------------+ //| Compare CGCnvElement objects with each other by all properties | //+------------------------------------------------------------------+ bool CGCnvElement::IsEqual(CGCnvElement *compared_obj) const { int beg=0, end=CANV_ELEMENT_PROP_INTEGER_TOTAL; for(int i=beg; i<end; i++) { ENUM_CANV_ELEMENT_PROP_INTEGER prop=(ENUM_CANV_ELEMENT_PROP_INTEGER)i; if(this.GetProperty(prop)!=compared_obj.GetProperty(prop)) return false; } beg=end; end+=CANV_ELEMENT_PROP_DOUBLE_TOTAL; for(int i=beg; i<end; i++) { ENUM_CANV_ELEMENT_PROP_DOUBLE prop=(ENUM_CANV_ELEMENT_PROP_DOUBLE)i; if(this.GetProperty(prop)!=compared_obj.GetProperty(prop)) return false; } beg=end; end+=CANV_ELEMENT_PROP_STRING_TOTAL; for(int i=beg; i<end; i++) { ENUM_CANV_ELEMENT_PROP_STRING prop=(ENUM_CANV_ELEMENT_PROP_STRING)i; if(this.GetProperty(prop)!=compared_obj.GetProperty(prop)) return false; } return true; } //+------------------------------------------------------------------+
Die Methode ist ebenfalls Standard für alle Bibliotheksobjekte. Kurz gesagt, die Methode erhält das Objekt, dessen Parameter mit denen des aktuellen Objekts verglichen werden sollen. In drei Schleifen durch alle Objekteigenschaften, vergleichen wir jede neue Eigenschaft von zwei Objekten. Gibt es ungleiche Eigenschaften, gibt die Methode false zurück — die verglichenen Objekte sind nicht gleich. Nach Abschluss von drei Schleifen wird true zurückgegeben — alle Eigenschaften der beiden verglichenen Objekte sind gleich.
Die Methode erzeugt das grafische Elementobjekt:
//+------------------------------------------------------------------+ //| Create the graphical element object | //+------------------------------------------------------------------+ bool CGCnvElement::Create(const long chart_id, // Chart ID const int wnd_num, // Chart subwindow const string name, // Element name const int x, // X coordinate const int y, // Y coordinate const int w, // Width const int h, // Height const color colour, // Background color const uchar opacity, // Opacity const bool redraw=false) // Flag indicating the need to redraw { if(this.m_canvas.CreateBitmapLabel(chart_id,wnd_num,name,x,y,w,h,COLOR_FORMAT_ARGB_NORMALIZE)) { this.m_canvas.Erase(::ColorToARGB(colour,opacity)); this.m_canvas.Update(redraw); this.m_shift_y=(int)::ChartGetInteger(chart_id,CHART_WINDOW_YDISTANCE,wnd_num); return true; } return false; } //+------------------------------------------------------------------+
Die Methode erhält alle für die Konstruktion notwendigen Parameter, und es wird das zweite Formular der Methode CreateBitmapLabel() der Klasse CCanvas aufgerufen. Ist die an das Chart-Objekt gebundene grafische Ressource erfolgreich erstellt, wird das grafische Element mit Farbe ausgefüllt und die Methode Update() aufgerufen, um die implementierten Änderungen auf dem Bildschirm darzustellen. Die Methode erhält das Flag zum Neuzeichnen des Bildschirms. Wenn wir ein zusammengesetztes Objekt aktualisieren, das aus mehreren grafischen Elementen besteht, sollte das Chart neu gezeichnet werden, nachdem wir Änderungen in allen Elementen des zusammengesetzten Objekts vorgenommen haben, um zu vermeiden, dass das Chart mehrfach aktualisiert wird, nachdem jedes Element geändert wurde. Als Nächstes erhält die abgeleitete Klassenvariable m_shift den Offset der Y-Koordinate für das Teilfenster und es wird true zurückgegeben. Wenn kein CCanvas-Klassenobjekt erzeugt wird, wird false zurückgegeben.
Die Methode, die die Cursorposition relativ zum Element zurückgibt:
//+------------------------------------------------------------------+ //| Return the cursor position relative to the element | //+------------------------------------------------------------------+ bool CGCnvElement::CursorInsideElement(const int x,const int y) { return(x>=this.CoordX() && x<=this.RightEdge() && y>=this.CoordY() && y<=this.BottomEdge()); } //+------------------------------------------------------------------+
Die Methode erhält die ganzzahligen Koordinaten der X- und Y-Cursor-Koordinaten und die Position der übergebenen Koordinaten relativ zu den Elementabmessungen — true wird nur zurückgegeben, wenn sich der Cursor innerhalb des Elements befindet.
Die Methode, die die Position des Cursors relativ zum aktiven Bereich des Elements zurückgibt:
//+------------------------------------------------------------------+ //| Return the cursor position relative to the element active area | //+------------------------------------------------------------------+ bool CGCnvElement::CursorInsideActiveArea(const int x,const int y) { return(x>=this.ActiveAreaLeft() && x<=this.ActiveAreaRight() && y>=this.ActiveAreaTop() && y<=this.ActiveAreaBottom()); } //+------------------------------------------------------------------+
Die Logik der Methode ist ähnlich wie bei der vorherigen Methode. Aber die Position der Cursor-Koordinaten wird relativ zu den Grenzen des aktiven Bereichs des Elements zurückgegeben — true wird nur zurückgegeben, wenn der Cursor innerhalb des aktiven Bereichs ist.
Die Methode aktualisiert die Elementkoordinaten:
//+------------------------------------------------------------------+ //| Update the coordinate elements | //+------------------------------------------------------------------+ bool CGCnvElement::Move(const int x,const int y,const bool redraw=false) { //--- Leave if the element is not movable or inactive if(!this.Movable()) return false; //--- If failed to set new values into graphical object properties, return 'false' if(!this.SetCoordX(x) || !this.SetCoordY(y)) return false; //--- If the update flag is activated, redraw the chart. if(redraw) ::ChartRedraw(this.ChartID()); //--- Return 'true' return true; } //+------------------------------------------------------------------+
Die Methode erhält die neuen Koordinaten der linken oberen Ecke des grafischen Elements, auf dem es platziert werden soll, sowie das Flag für das Neuzeichnen des Chart. Als Nächstes wird das Flag für die Verschiebbarkeit des Objekts geprüft und verlassen, wenn das Objekt nicht verschiebbar ist. Wenn es nicht gelingt, die neuen Koordinaten des Objekts mit den unten betrachteten Methoden zu setzen, Rückgabe von false. Als Nächstes aktualisieren wir das Chart, wenn das Flag zum Neuzeichnen des Charts gesetzt ist. Es wird als Ergebnis true zurückgegeben.
Die Methode setzt die neue X-Koordinate:
//+------------------------------------------------------------------+ //| Set the new X coordinate | //+------------------------------------------------------------------+ bool CGCnvElement::SetCoordX(const int coord_x) { int x=(int)::ObjectGetInteger(this.ChartID(),this.NameObj(),OBJPROP_XDISTANCE); if(coord_x==x) { if(coord_x==GetProperty(CANV_ELEMENT_PROP_COORD_X)) return true; this.SetProperty(CANV_ELEMENT_PROP_COORD_X,coord_x); return true; } if(::ObjectSetInteger(this.ChartID(),this.NameObj(),OBJPROP_XDISTANCE,coord_x)) { this.SetProperty(CANV_ELEMENT_PROP_COORD_X,coord_x); return true; } return false; } //+------------------------------------------------------------------+
Die Methode erhält den gewünschten X-Koordinatenwert. Als Nächstes holen wir uns diese Koordinate aus dem Objekt. Wenn die übergebene Koordinate gleich der des Objekts ist, sollte das Objekt nicht verschoben werden. Wir müssen aber prüfen, ob in den Objekteigenschaften der gleiche Wert eingestellt ist. Wenn die Werte übereinstimmen, wird true zurückgegeben, andernfalls wird der übergebene neue Koordinatenwert auf die Objekteigenschaft gesetzt und true zurückgegeben.
Wenn die übergebenen und die Objektkoordinaten nicht übereinstimmen, setzen wir die neue Koordinate des Objekts. Wenn das Setzen erfolgreich ist, schreiben wir den Wert in die Objekteigenschaft und geben true zurück. In allen anderen Fällen geben wir false zurück.
Die Methode, die die neue Y-Koordinate setzt:
//+------------------------------------------------------------------+ //| Set the new Y coordinate | //+------------------------------------------------------------------+ bool CGCnvElement::SetCoordY(const int coord_y) { int y=(int)::ObjectGetInteger(this.ChartID(),this.NameObj(),OBJPROP_YDISTANCE); if(coord_y==y) { if(coord_y==GetProperty(CANV_ELEMENT_PROP_COORD_Y)) return true; this.SetProperty(CANV_ELEMENT_PROP_COORD_Y,coord_y); return true; } if(::ObjectSetInteger(this.ChartID(),this.NameObj(),OBJPROP_YDISTANCE,coord_y)) { this.SetProperty(CANV_ELEMENT_PROP_COORD_Y,coord_y); return true; } return false; } //+------------------------------------------------------------------+
Die Logik der Methode ist ähnlich wie die oben betrachtete Einstellung der X-Koordinate.
Die Methode setzt die neue Objektbreite:
//+------------------------------------------------------------------+ //| Set the new width | //+------------------------------------------------------------------+ bool CGCnvElement::SetWidth(const int width) { return this.m_canvas.Resize(width,this.m_canvas.Height()); } //+------------------------------------------------------------------+
Die Methode empfängt die neue Breite des Objekts und das Ergebnis des Aufrufs der Methode Resize() zur Größenänderung der grafischen Ressource.
Die Methode Resize() übergibt die neue Breite und die aktuelle Höhe des Objekts.
Die Methode setzt die neue Höhe des Objekts:
//+------------------------------------------------------------------+ //| Set the new height | //+------------------------------------------------------------------+ bool CGCnvElement::SetHeight(const int height) { return this.m_canvas.Resize(this.m_canvas.Width(),height); } //+------------------------------------------------------------------+
Die Methode erhält die neue Höhe des Objekts und das Ergebnis des Aufrufs der Methode Resize() zur Größenänderung der grafischen Ressource.
Die Methode Resize() übergibt die aktuelle Breite und die neue Höhe des Objekts.
Vergessen wir nicht, dass beim Ändern der Größe der Ressource das zuvor auf dem Canvas gezeichnete Bild überschrieben wird.
Daher werden diese Methoden später noch verfeinert.
Die Methode setzt alle Verschiebungen der aktiven Fläche relativ zum Element:
//+------------------------------------------------------------------+ //| Set all shifts of the active area relative to the element | //+------------------------------------------------------------------+ void CGCnvElement::SetActiveAreaShift(const int left_shift,const int bottom_shift,const int right_shift,const int top_shift) { this.SetActiveAreaLeftShift(left_shift); this.SetActiveAreaBottomShift(bottom_shift); this.SetActiveAreaRightShift(right_shift); this.SetActiveAreaTopShift(top_shift); } //+------------------------------------------------------------------+
Die Methode erhält alle Werte der notwendigen Verschiebungen nach innen von den Kanten des Objekts "Grafisches Element". Alle vier Verschiebungen werden nacheinander durch Aufruf der entsprechenden Methoden gesetzt.
Die Methode setzt die Deckkraft des Elements:
//+------------------------------------------------------------------+ //| Set the element opacity | //+------------------------------------------------------------------+ void CGCnvElement::SetOpacity(const uchar value,const bool redraw=false) { this.m_canvas.TransparentLevelSet(value); this.SetProperty(CANV_ELEMENT_PROP_OPACITY,value); this.m_canvas.Update(redraw); } //+------------------------------------------------------------------+
Die Methode erhält den gewünschten Opazitätswert des Objekts (0 — komplett transparent, 255 — komplett undurchsichtig) und das Neuzeichnen-Flag des Charts.
Als Nächstes rufen wir die Methode TransparentLevelSet() der Klasse CCanvas auf, schreiben den neuen Eigenschaftswert in die Objekteigenschaften und aktualisieren das Objekt mit dem übergebenen Redrawing-Flag.
Das Objekt "Grafisches Element" ist fertig. Nun brauchen wir noch die Möglichkeit, diese Objekte in den Listen, in denen sie gespeichert werden sollen, zu sortieren. Dazu benötigen wir die Klasse CSelect, in der wir die Methoden zum Sortieren und Suchen aller Bibliotheksobjekte einstellen.
Wir öffnen \MQL5\Include\DoEasy\Services\Select.mqh und fügen die Einbindung der Klassendatei des Objekts "Grafisches Element" hinzu, sowie das Festlegen der Methoden zum Sortieren und Suchen von Objekten des "Grafischen Elements" anhand ihrer Eigenschaften am Ende des Klassenkörpers:
//+------------------------------------------------------------------+ //| Select.mqh | //| Copyright 2020, MetaQuotes Software Corp. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2020, MetaQuotes Software Corp." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //+------------------------------------------------------------------+ //| Include files | //+------------------------------------------------------------------+ #include <Arrays\ArrayObj.mqh> #include "..\Objects\Orders\Order.mqh" #include "..\Objects\Events\Event.mqh" #include "..\Objects\Accounts\Account.mqh" #include "..\Objects\Symbols\Symbol.mqh" #include "..\Objects\PendRequest\PendRequest.mqh" #include "..\Objects\Series\SeriesDE.mqh" #include "..\Objects\Indicators\Buffer.mqh" #include "..\Objects\Indicators\IndicatorDE.mqh" #include "..\Objects\Indicators\DataInd.mqh" #include "..\Objects\Ticks\DataTick.mqh" #include "..\Objects\Book\MarketBookOrd.mqh" #include "..\Objects\MQLSignalBase\MQLSignal.mqh" #include "..\Objects\Chart\ChartObj.mqh" #include "..\Objects\Graph\GCnvElement.mqh" //+------------------------------------------------------------------+
...
//+--------------------------------------------------------------------------+ //| The methods of working with data of the graphical elements on the canvas | //+--------------------------------------------------------------------------+ //--- Return the list of objects with one of (1) integer, (2) real and (3) string properties meeting a specified criterion static CArrayObj *ByGraphCanvElementProperty(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_INTEGER property,long value,ENUM_COMPARER_TYPE mode); static CArrayObj *ByGraphCanvElementProperty(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_DOUBLE property,double value,ENUM_COMPARER_TYPE mode); static CArrayObj *ByGraphCanvElementProperty(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_STRING property,string value,ENUM_COMPARER_TYPE mode); //--- Return the chart index with the maximum value of the (1) integer, (2) real and (3) string properties static int FindGraphCanvElementMax(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_INTEGER property); static int FindGraphCanvElementMax(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_DOUBLE property); static int FindGraphCanvElementMax(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_STRING property); //--- Return the chart index with the minimum value of the (1) integer, (2) real and (3) string properties static int FindGraphCanvElementMin(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_INTEGER property); static int FindGraphCanvElementMin(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_DOUBLE property); static int FindGraphCanvElementMin(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_STRING property); //--- }; //+------------------------------------------------------------------+
Am Ende der Codedatei fügen wir die Implementierung der neu deklarierten Methoden hinzu:
//+------------------------------------------------------------------+ //+---------------------------------------------------------------------------+ //| The methods of working with data of the graphical elements on the canvas | //+---------------------------------------------------------------------------+ //+------------------------------------------------------------------+ //| Return the list of objects with one integer | //| property meeting the specified criterion | //+------------------------------------------------------------------+ CArrayObj *CSelect::ByGraphCanvElementProperty(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_INTEGER property,long value,ENUM_COMPARER_TYPE mode) { if(list_source==NULL) return NULL; CArrayObj *list=new CArrayObj(); if(list==NULL) return NULL; list.FreeMode(false); ListStorage.Add(list); int total=list_source.Total(); for(int i=0; i<total; i++) { CGCnvElement *obj=list_source.At(i); if(!obj.SupportProperty(property)) continue; long obj_prop=obj.GetProperty(property); if(CompareValues(obj_prop,value,mode)) list.Add(obj); } return list; } //+------------------------------------------------------------------+ //| Return the list of objects with one real | //| property meeting the specified criterion | //+------------------------------------------------------------------+ CArrayObj *CSelect::ByGraphCanvElementProperty(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_DOUBLE property,double value,ENUM_COMPARER_TYPE mode) { if(list_source==NULL) return NULL; CArrayObj *list=new CArrayObj(); if(list==NULL) return NULL; list.FreeMode(false); ListStorage.Add(list); for(int i=0; i<list_source.Total(); i++) { CGCnvElement *obj=list_source.At(i); if(!obj.SupportProperty(property)) continue; double obj_prop=obj.GetProperty(property); if(CompareValues(obj_prop,value,mode)) list.Add(obj); } return list; } //+------------------------------------------------------------------+ //| Return the list of objects with one string | //| property meeting the specified criterion | //+------------------------------------------------------------------+ CArrayObj *CSelect::ByGraphCanvElementProperty(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_STRING property,string value,ENUM_COMPARER_TYPE mode) { if(list_source==NULL) return NULL; CArrayObj *list=new CArrayObj(); if(list==NULL) return NULL; list.FreeMode(false); ListStorage.Add(list); for(int i=0; i<list_source.Total(); i++) { CGCnvElement *obj=list_source.At(i); if(!obj.SupportProperty(property)) continue; string obj_prop=obj.GetProperty(property); if(CompareValues(obj_prop,value,mode)) list.Add(obj); } return list; } //+------------------------------------------------------------------+ //| Return the object index in the list | //| with the maximum integer property value | //+------------------------------------------------------------------+ int CSelect::FindGraphCanvElementMax(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_INTEGER property) { if(list_source==NULL) return WRONG_VALUE; int index=0; CGCnvElement *max_obj=NULL; int total=list_source.Total(); if(total==0) return WRONG_VALUE; for(int i=1; i<total; i++) { CGCnvElement *obj=list_source.At(i); long obj1_prop=obj.GetProperty(property); max_obj=list_source.At(index); long obj2_prop=max_obj.GetProperty(property); if(CompareValues(obj1_prop,obj2_prop,MORE)) index=i; } return index; } //+------------------------------------------------------------------+ //| Return the object index in the list | //| with the maximum real property value | //+------------------------------------------------------------------+ int CSelect::FindGraphCanvElementMax(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_DOUBLE property) { if(list_source==NULL) return WRONG_VALUE; int index=0; CGCnvElement *max_obj=NULL; int total=list_source.Total(); if(total==0) return WRONG_VALUE; for(int i=1; i<total; i++) { CGCnvElement *obj=list_source.At(i); double obj1_prop=obj.GetProperty(property); max_obj=list_source.At(index); double obj2_prop=max_obj.GetProperty(property); if(CompareValues(obj1_prop,obj2_prop,MORE)) index=i; } return index; } //+------------------------------------------------------------------+ //| Return the object index in the list | //| with the maximum string property value | //+------------------------------------------------------------------+ int CSelect::FindGraphCanvElementMax(CArrayObj *list_source,ENUM_CANV_ELEMENT_PROP_STRING property) { if(list_source==NULL) return WRONG_VALUE; int index=0; CGCnvElement *max_obj=NULL; int total=list_source.Total(); if(total==0) return WRONG_VALUE; for(int i=1; i<total; i++) { CGCnvElement *obj=list_source.At(i); string obj1_prop=obj.GetProperty(property); max_obj=list_source.At(index); string obj2_prop=max_obj.GetProperty(property); if(CompareValues(obj1_prop,obj2_prop,MORE)) index=i; } return index; } //+------------------------------------------------------------------+ //| Return the object index in the list | //| with the minimum integer property value | //+------------------------------------------------------------------+ int CSelect::FindGraphCanvElementMin(CArrayObj* list_source,ENUM_CANV_ELEMENT_PROP_INTEGER property) { int index=0; CGCnvElement *min_obj=NULL; int total=list_source.Total(); if(total==0) return WRONG_VALUE; for(int i=1; i<total; i++) { CGCnvElement *obj=list_source.At(i); long obj1_prop=obj.GetProperty(property); min_obj=list_source.At(index); long obj2_prop=min_obj.GetProperty(property); if(CompareValues(obj1_prop,obj2_prop,LESS)) index=i; } return index; } //+------------------------------------------------------------------+ //| Return the object index in the list | //| with the minimum real property value | //+------------------------------------------------------------------+ int CSelect::FindGraphCanvElementMin(CArrayObj* list_source,ENUM_CANV_ELEMENT_PROP_DOUBLE property) { int index=0; CGCnvElement *min_obj=NULL; int total=list_source.Total(); if(total== 0) return WRONG_VALUE; for(int i=1; i<total; i++) { CGCnvElement *obj=list_source.At(i); double obj1_prop=obj.GetProperty(property); min_obj=list_source.At(index); double obj2_prop=min_obj.GetProperty(property); if(CompareValues(obj1_prop,obj2_prop,LESS)) index=i; } return index; } //+------------------------------------------------------------------+ //| Return the object index in the list | //| with the minimum string property value | //+------------------------------------------------------------------+ int CSelect::FindGraphCanvElementMin(CArrayObj* list_source,ENUM_CANV_ELEMENT_PROP_STRING property) { int index=0; CGCnvElement *min_obj=NULL; int total=list_source.Total(); if(total==0) return WRONG_VALUE; for(int i=1; i<total; i++) { CGCnvElement *obj=list_source.At(i); string obj1_prop=obj.GetProperty(property); min_obj=list_source.At(index); string obj2_prop=min_obj.GetProperty(property); if(CompareValues(obj1_prop,obj2_prop,LESS)) index=i; } return index; } //+------------------------------------------------------------------+
Die Methoden sind im dritten Artikel beschrieben, in dem wir die Erstellung der Klasse CSelect besprochen haben.
Lassen Sie uns die Ergebnisse testen.
Test
Um den Test durchzuführen, verwenden wir den EA aus dem vorherigen Artikel und speichern ihn in \MQL5\Experts\TestDoEasy\Part74\ als TestDoEasyPart74.mq5.
Wir binden die Datei mit der Klasse des dynamischen Arrays von Zeigern auf die Instanzen der Klasse CObject und deren Ableitungen, der Standardbibliothek, CSelect und CGCnvElement Bibliotheksklassendateien ein, geben die Anzahl der erzeugten "grafischen Element"-Objekte an und deklarieren die Liste zum Speichern der erzeugten grafischen Elemente:
//+------------------------------------------------------------------+ //| TestDoEasyPart74.mq5 | //| Copyright 2021, MetaQuotes Ltd. | //| https://mql5.com/en/users/artmedia70 | //+------------------------------------------------------------------+ #property copyright "Copyright 2021, MetaQuotes Ltd." #property link "https://mql5.com/en/users/artmedia70" #property version "1.00" //--- includes #include <Arrays\ArrayObj.mqh> #include <DoEasy\Services\Select.mqh> #include <DoEasy\Objects\Graph\GCnvElement.mqh> //--- defines #define FORMS_TOTAL (2) //--- input parameters sinput bool InpMovable = true; // Movable flag //--- global variables CArrayObj list_elements; //+------------------------------------------------------------------+
In OnInit() des EA erzeugen wir neue Grafikelement-Objekte, indem wir alle notwendigen Parameter an den Klassenkonstruktor übergeben:
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- Set the permissions to send cursor movement and mouse scroll events ChartSetInteger(ChartID(),CHART_EVENT_MOUSE_MOVE,true); ChartSetInteger(ChartID(),CHART_EVENT_MOUSE_WHEEL,true); //--- Set EA global variables //--- Create the specified number of graphical elements on the canvas int total=FORMS_TOTAL; for(int i=0;i<total;i++) { //--- When creating an object, pass all the required parameters to it CGCnvElement *element=new CGCnvElement(GRAPH_ELEMENT_TYPE_ELEMENT,i,0,ChartID(),0,"Element_0"+(string)(i+1),300,40+(i*80),100,70,clrSilver,200,InpMovable,true,true); if(element==NULL) continue; //--- Add objects to the list if(!list_elements.Add(element)) { delete element; continue; } } //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+
Dann löschen wir in OnDeinit() alle Kommentare auf dem Chart:
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- destroy timer EventKillTimer(); Comment(""); } //+------------------------------------------------------------------+
In OnChartEvent() erfassen wir den Klick auf das Objekt, holen uns das Element-Objekt mit dem Namen, der dem Namen des angeklickten Objekts entspricht, das im Parameter des sparam eingetragen ist, und erhöhen dessen Deckkraftstufe um 5. Die Meldung mit dem Namen des behandelten Objekts und der Deckkraftstufe im Chart-Kommentar wird angezeigt an:
//+------------------------------------------------------------------+ //| ChartEvent function | //+------------------------------------------------------------------+ void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam) { //--- If clicking on an object if(id==CHARTEVENT_OBJECT_CLICK) { //--- In the new list, get the element object with the name corresponding to the sparam string parameter value of the OnChartEvent() handler CArrayObj *obj_list=CSelect::ByGraphCanvElementProperty(GetPointer(list_elements),CANV_ELEMENT_PROP_NAME_OBJ,sparam,EQUAL); if(obj_list!=NULL && obj_list.Total()>0) { //--- Get the pointer to the object in the list CGCnvElement *obj=obj_list.At(0); //--- and set the new opacity level for it uchar opasity=obj.Opacity(); if((opasity+5)>255) opasity=0; else opasity+=5; //--- Set the new opacity to the object and display the object name and opacity level in the journal obj.SetOpacity(opasity); Comment(DFUN,"Object name: ",obj.NameObj(),", opasity=",opasity); } } } //+------------------------------------------------------------------+
Kompilieren Sie den EA und starten Sie ihn auf dem Chart. Wenn Sie auf ein beliebiges Objekt "Grafisches Element" klicken, wird dessen Deckkraft bis zu 255 erhöht, bei Erreichen des Maximalwertes (255) wird sie von 0 auf 255 erhöht, während der Name des angeklickten Objekts und dessen Deckkraftstufe im Chart-Kommentar angezeigt werden:
Was kommt als Nächstes?
Im nächsten Artikel werde ich die Entwicklung des Objekts "Grafisches Element" fortsetzen und damit beginnen, Methoden für die Anzeige von grafischen Primitiven und Text darauf hinzuzufügen.
Alle Dateien der aktuellen Version der Bibliothek sind unten zusammen mit der Test-EA-Datei für MQL5 zum Testen und Herunterladen angehängt.
Ihre Fragen und Vorschläge schreiben Sie bitte in den Kommentarteil.
*Frühere Artikel dieser Serie:
Grafiken in der Bibliothek DoEasy (Teil 73): Das Formularobjekt eines grafischen Elements