Grafiken in der Bibliothek DoEasy (Teil 100): Verbesserungen im Umgang mit erweiterten grafischen Standardobjekten

26 Mai 2022, 13:22
Artyom Trishkin
0
72

Inhalt


Konzept

Im Laufe der letzten Artikel habe ich die Funktionsweise für die Handhabung von zusammengesetzten grafischen Objekten entwickelt, die auf der Grundlage von erweiterten grafischen Standardobjekten erstellt wurden. Wir haben uns schrittweise auf die Schaffung dieser Funktionsweise Artikel für Artikel zubewegt. Manchmal war ich gezwungen, von einem Thema zum anderen zu wechseln: Zuerst erstellte ich Objekte auf der Basis der Klasse CCanvas und begann dann mit der Erstellung von grafischen Objekten, da die geplante Funktionalität für die Einführung von grafischen Objekten in alle Bibliotheksobjekte das Vorhandensein einer zumindest teilweise funktionierenden Funktionalität von grafischen Standardobjekten erforderte. Danach kehrte ich zu Formularobjekten auf der Basis von CCanvas zurück, da fortgeschrittene grafische Objekte die Verbesserung von Klassen auf der Basis des Canvas erforderten. Jetzt müssen wir wieder weitergehen, um die Entwicklung von Objekten auf Canvas fortzusetzen.

Daher werde ich im aktuellen Artikel offensichtliche Mängel bei der gleichzeitigen Handhabung von erweiterten (und Standard-) grafischen Objekten und Formularobjekten auf Canvas beseitigen sowie Fehler beheben, die während des im vorherigen Artikel durchgeführten Tests entdeckt wurden. Der Artikel schließt diesen Teil der Bibliotheksbeschreibung ab. Der nächste Artikel wird einen neuen Abschnitt einleiten, in dem ich mit der Entwicklung von grafischen Objekten auf der Leinwand beginnen werde, die Windows Forms in MS Visual Studio imitieren. Ich werde diese Objekte benötigen, um die Entwicklung von erweiterten grafischen Standardobjekten sowie von darauf basierenden zusammengesetzten Objekten fortzusetzen.


Verbesserung der Klassenbibliothek

Wenn das Chart grafische Objekte auf dem Canvas zur Erstellung von GUI-Elementen — Element, Gestalt, Fenster (noch nicht implementiert) oder andere ähnliche Steuerelemente — enthält, führt das Platzieren von grafischen Standardobjekten sowie anderen darauf basierenden Bibliotheksobjekten auf dem Diagramm (entweder manuell oder programmatisch) dazu, dass diese Objekte über den Steuerelementen gezeichnet werden, was unpraktisch ist. Daher müssen wir einen Mechanismus entwickeln, um neue grafische Objekte im Diagramm zu verfolgen und alle GUI-Elemente in den Vordergrund zu bringen. Um dies zu erreichen, können wir die Eigenschaft ZOrder eines grafischen Objekts verwenden (Priorität eines grafischen Objekts für den Empfang des Ereignisses beim Klicken auf ein Chart (CHARTEVENT_CLICK)).

Unten finden Sie die Hilfeinformationen:

Der Standardwert ist Null, wenn ein Objekt erstellt wird, aber die Priorität kann bei Bedarf erhöht werden. Beim Übereinanderlegen von Objekten wird nur das Objekt mit der höchsten Priorität das Ereignis CHARTEVENT_CLICK erhalten.

Aber ich werde diese Eigenschaft breiter einsetzen — der Wert dieser Eigenschaft gibt die Reihenfolge an, in der GUI-Elemente relativ zueinander sowie relativ zu anderen grafischen Objekten angeordnet sind.

In der Enumeration der Integer-Eigenschaften eines grafischen Elements auf der Leinwand in der Datei \MQL5\Include\DoEasy\Defines.mqh fügen wir eine neue Eigenschaft hinzu und erhöhen die Anzahl der Integer-Eigenschaften von 23 auf 24:

//+------------------------------------------------------------------+
//| Integer properties of the graphical element on the canvas        |
//+------------------------------------------------------------------+
enum ENUM_CANV_ELEMENT_PROP_INTEGER
  {
   CANV_ELEMENT_PROP_ID = 0,                          // Element ID
   CANV_ELEMENT_PROP_TYPE,                            // Graphical element type
   CANV_ELEMENT_PROP_BELONG,                          // Graphical element affiliation
   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,                           // Element width
   CANV_ELEMENT_PROP_HEIGHT,                          // Element height
   CANV_ELEMENT_PROP_RIGHT,                           // Element right border
   CANV_ELEMENT_PROP_BOTTOM,                          // Element bottom border
   CANV_ELEMENT_PROP_ACT_SHIFT_LEFT,                  // Active area offset from the left edge of the element
   CANV_ELEMENT_PROP_ACT_SHIFT_TOP,                   // Active area offset from the upper edge of the element
   CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT,                 // Active area offset from the right edge of the element
   CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM,                // Active area offset from the bottom edge of the element
   CANV_ELEMENT_PROP_MOVABLE,                         // Element moveability flag
   CANV_ELEMENT_PROP_ACTIVE,                          // Element activity flag
   CANV_ELEMENT_PROP_INTERACTION,                     // Flag of interaction with the outside environment
   CANV_ELEMENT_PROP_COORD_ACT_X,                     // X coordinate of the element active area
   CANV_ELEMENT_PROP_COORD_ACT_Y,                     // Y coordinate of the element active area
   CANV_ELEMENT_PROP_ACT_RIGHT,                       // Right border of the element active area
   CANV_ELEMENT_PROP_ACT_BOTTOM,                      // Bottom border of the element active area
   CANV_ELEMENT_PROP_ZORDER,                          // Priority of a graphical object for receiving the event of clicking on a chart
  };
#define CANV_ELEMENT_PROP_INTEGER_TOTAL (24)          // Total number of integer properties
#define CANV_ELEMENT_PROP_INTEGER_SKIP  (0)           // Number of integer properties not used in sorting
//+------------------------------------------------------------------+


Fügen wir die neue Eigenschaft zur Liste der möglichen Kriterien für die Sortierung von grafischen Elementen auf der Leinwand hinzu:

//+------------------------------------------------------------------+
//| 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 element ID
   SORT_BY_CANV_ELEMENT_TYPE,                         // Sort by graphical element type
   SORT_BY_CANV_ELEMENT_BELONG,                       // Sort by a graphical element affiliation
   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 element X coordinate on the chart
   SORT_BY_CANV_ELEMENT_COORD_Y,                      // Sort by the element Y coordinate on the chart
   SORT_BY_CANV_ELEMENT_WIDTH,                        // Sort by the element width
   SORT_BY_CANV_ELEMENT_HEIGHT,                       // Sort by the element height
   SORT_BY_CANV_ELEMENT_RIGHT,                        // Sort by the element right border
   SORT_BY_CANV_ELEMENT_BOTTOM,                       // Sort by the element bottom border
   SORT_BY_CANV_ELEMENT_ACT_SHIFT_LEFT,               // Sort by the active area offset from the left edge of the element
   SORT_BY_CANV_ELEMENT_ACT_SHIFT_TOP,                // Sort by the active area offset from the top edge of the element
   SORT_BY_CANV_ELEMENT_ACT_SHIFT_RIGHT,              // Sort by the active area offset from the right edge of the element
   SORT_BY_CANV_ELEMENT_ACT_SHIFT_BOTTOM,             // Sort by the active area offset from the bottom edge of the element
   SORT_BY_CANV_ELEMENT_MOVABLE,                      // Sort by the element moveability flag
   SORT_BY_CANV_ELEMENT_ACTIVE,                       // Sort by the element activity flag
   SORT_BY_CANV_ELEMENT_INTERACTION,                  // Sort by the flag of interaction with the outside environment
   SORT_BY_CANV_ELEMENT_COORD_ACT_X,                  // Sort by X coordinate of the element active area
   SORT_BY_CANV_ELEMENT_COORD_ACT_Y,                  // Sort by Y coordinate of the element active area
   SORT_BY_CANV_ELEMENT_ACT_RIGHT,                    // Sort by the right border of the element active area
   SORT_BY_CANV_ELEMENT_ACT_BOTTOM,                   // Sort by the bottom border of the element active area
   SORT_BY_CANV_ELEMENT_ZORDER,                       // Sort by the priority of a graphical object for receiving the event of clicking on a chart
//--- Sort by real properties

//--- Sort by string properties
   SORT_BY_CANV_ELEMENT_NAME_OBJ = FIRST_CANV_ELEMENT_STR_PROP,// Sort by an element object name
   SORT_BY_CANV_ELEMENT_NAME_RES,                     // Sort by the graphical resource name
  };
//+------------------------------------------------------------------+

Jetzt können wir grafische Elemente auf der Leinwand anhand dieser Eigenschaft auswählen und sortieren.


Alle grafischen Objekte in der Bibliothek sind vom Basisobjekt aller grafischen Objekte der Bibliothek abgeleitet — standardmäßige grafische Objekte und grafische Elemente auf der Leinwand. In der Datei der grafischen Basisobjektklasse \MQL5\Include\DoEasy\Objects\Graph\GBaseObj.mqh werden die Methoden zur Handhabung der Eigenschaft ZOrder virtuell gemacht:

//--- Set the "Disable displaying the name of a graphical object in the terminal object list" flag
   bool              SetFlagHidden(const bool flag,const bool only_prop)
                       {
                        ::ResetLastError();
                        if((!only_prop && ::ObjectSetInteger(this.m_chart_id,this.m_name,OBJPROP_SELECTABLE,flag)) || only_prop)
                          {
                           this.m_hidden=flag;
                           return true;
                          }
                        else
                           CMessage::ToLog(DFUN,::GetLastError(),true);
                        return false;
                       }
//--- Set the priority of a graphical object for receiving the event of clicking on a chart 
   virtual bool      SetZorder(const long value,const bool only_prop)
                       {
                        ::ResetLastError();
                        if((!only_prop && ::ObjectSetInteger(this.m_chart_id,this.m_name,OBJPROP_ZORDER,value)) || only_prop)
                          {
                           this.m_zorder=value;
                           return true;
                          }
                        else
                           CMessage::ToLog(DFUN,::GetLastError(),true);
                        return false;
                       }
//--- Set object visibility on all timeframes
   bool              SetVisible(const bool flag,const bool only_prop)   
                       {
                        long value=(flag ? OBJ_ALL_PERIODS : OBJ_NO_PERIODS);
                        ::ResetLastError();
                        if((!only_prop && ::ObjectSetInteger(this.m_chart_id,this.m_name,OBJPROP_TIMEFRAMES,value)) || only_prop)
                          {
                           this.m_visible=flag;
                           return true;
                          }
                        else
                           CMessage::ToLog(DFUN,::GetLastError(),true);
                        return false;
                       }
//--- Set visibility flags on timeframes specified as flags

...

//--- Return the values of class variables
   ENUM_GRAPH_ELEMENT_TYPE TypeGraphElement(void)        const { return this.m_type_element;       }
   ENUM_GRAPH_OBJ_BELONG   Belong(void)                  const { return this.m_belong;             }
   ENUM_GRAPH_OBJ_SPECIES  Species(void)                 const { return this.m_species;            }
   ENUM_OBJECT       TypeGraphObject(void)               const { return this.m_type_graph_obj;     }
   datetime          TimeCreate(void)                    const { return this.m_create_time;        }
   string            Name(void)                          const { return this.m_name;               }
   long              ChartID(void)                       const { return this.m_chart_id;           }
   long              ObjectID(void)                      const { return this.m_object_id;          }
   virtual long      Zorder(void)                        const { return this.m_zorder;             }
   int               SubWindow(void)                     const { return this.m_subwindow;          }
   int               ShiftY(void)                        const { return this.m_shift_y;            }
   int               VisibleOnTimeframes(void)           const { return this.m_timeframes_visible; }
   int               Digits(void)                        const { return this.m_digits;             }
   int               Group(void)                         const { return this.m_group;              }
   bool              IsBack(void)                        const { return this.m_back;               }
   bool              IsSelected(void)                    const { return this.m_selected;           }
   bool              IsSelectable(void)                  const { return this.m_selectable;         }
   bool              IsHidden(void)                      const { return this.m_hidden;             }
   bool              IsVisible(void)                     const { return this.m_visible;            }

//--- Return the graphical object type (ENUM_OBJECT) calculated from the object type (ENUM_OBJECT_DE_TYPE) passed to the method

Die gleichen Methoden sind in der Basisobjektklasse aller grafischen Bibliotheksobjekte vorhanden.
Die Methoden sind in ihnen ebenfalls virtuell.

In der Datei der abstrakten grafischen Standardobjektklasse \MQL5\Include\DoEasy\Objects\Graph\Standard\GStdGraphObj.mqh:

//--- Background object
   bool              Back(void)                    const { return (bool)this.GetProperty(GRAPH_OBJ_PROP_BACK,0);                          }
   bool              SetFlagBack(const bool flag,const bool only_prop)
                       {
                        if(!CGBaseObj::SetFlagBack(flag,only_prop))
                           return false;
                        this.SetProperty(GRAPH_OBJ_PROP_BACK,0,flag);
                        return true;
                       }
//--- Priority of a graphical object for receiving the event of clicking on a chart
   virtual long      Zorder(void)                  const { return this.GetProperty(GRAPH_OBJ_PROP_ZORDER,0);                              }
   virtual bool      SetZorder(const long value,const bool only_prop)
                       {
                        if(!CGBaseObj::SetZorder(value,only_prop))
                           return false;
                        this.SetProperty(GRAPH_OBJ_PROP_ZORDER,0,value);
                        return true;
                       }
//--- Disable displaying the name of a graphical object in the terminal object list
   bool              Hidden(void)                  const { return (bool)this.GetProperty(GRAPH_OBJ_PROP_HIDDEN,0);                        }
   bool              SetFlagHidden(const bool flag,const bool only_prop)
                       {
                        if(!CGBaseObj::SetFlagHidden(flag,only_prop))
                           return false;
                        this.SetProperty(GRAPH_OBJ_PROP_HIDDEN,0,flag);
                        return true;
                       }
//--- Object selection


In der Datei der grafischen Elementobjektklasse \MQL5\Include\DoEasy\Objects\Graph\GCnvElement.mqh fügen wir die gleichen virtuellen Methoden hinzu:

//--- (1) Show and (2) hide the element
   virtual void      Show(void)                                { CGBaseObj::SetVisible(true,false);                                    }
   virtual void      Hide(void)                                { CGBaseObj::SetVisible(false,false);                                   }
   
//--- Priority of a graphical object for receiving the event of clicking on a chart
   virtual long      Zorder(void)                        const { return this.GetProperty(CANV_ELEMENT_PROP_ZORDER);                    }
   virtual bool      SetZorder(const long value,const bool only_prop)
                       {
                        if(!CGBaseObj::SetZorder(value,only_prop))
                           return false;
                        this.SetProperty(CANV_ELEMENT_PROP_ZORDER,value);
                        return true;
                       }
//+------------------------------------------------------------------+
//| The methods of receiving raster data                             |
//+------------------------------------------------------------------+

Da die Objektklasse des grafischen Elements bereits über die Struktur der Objekteigenschaften zum Speichern und Wiederherstellen verfügt, sollten wir das Feld für die neue Integer-Eigenschaft hinzufügen:

//--- Create (1) the object structure and (2) the object from the structure
   virtual bool      ObjectToStruct(void);
   virtual void      StructToObject(void);
   
private:
   struct SData
     {
      //--- Object integer properties
      int            id;                                       // Element ID
      int            type;                                     // Graphical element type
      int            number;                                   // Element index in the list
      long           chart_id;                                 // Chart ID
      int            subwindow;                                // Chart subwindow index
      int            coord_x;                                  // Form's X coordinate on the chart
      int            coord_y;                                  // Form's Y coordinate on the chart
      int            width;                                    // Element width
      int            height;                                   // Element height
      int            edge_right;                               // Element right border
      int            edge_bottom;                              // Element bottom border
      int            act_shift_left;                           // Active area offset from the left edge of the element
      int            act_shift_top;                            // Active area offset from the top edge of the element
      int            act_shift_right;                          // Active area offset from the right edge of the element
      int            act_shift_bottom;                         // Active area offset from the bottom edge of the element
      uchar          opacity;                                  // Element opacity
      color          color_bg;                                 // Element background color
      bool           movable;                                  // Element moveability flag
      bool           active;                                   // Element activity flag
      bool           interaction;                              // Flag of interaction with the outside environment
      int            coord_act_x;                              // X coordinate of the element active area
      int            coord_act_y;                              // Y coordinate of the element active area
      int            coord_act_right;                          // Right border of the element active area
      int            coord_act_bottom;                         // Bottom border of the element active area
      long           zorder;                                   // Priority of a graphical object for receiving the event of clicking on a chart
      //--- Object real properties

      //--- Object string properties
      uchar          name_obj[64];                             // Graphical element object name
      uchar          name_res[64];                             // Graphical resource name
     };
   SData             m_struct_obj;                             // Object structure


In der Methode zur Erstellung der Objektstruktur fügen wir das Speichern einer neuen Objekteigenschaft hinzu:

//+------------------------------------------------------------------+
//| Create the object structure                                      |
//+------------------------------------------------------------------+
bool CGCnvElement::ObjectToStruct(void)
  {
//--- Save integer properties
   this.m_struct_obj.id=(int)this.GetProperty(CANV_ELEMENT_PROP_ID);                            // Element ID
   this.m_struct_obj.type=(int)this.GetProperty(CANV_ELEMENT_PROP_TYPE);                        // Graphical element type
   this.m_struct_obj.number=(int)this.GetProperty(CANV_ELEMENT_PROP_NUM);                       // Eleemnt ID in the list
   this.m_struct_obj.chart_id=this.GetProperty(CANV_ELEMENT_PROP_CHART_ID);                     // Chart ID
   this.m_struct_obj.subwindow=(int)this.GetProperty(CANV_ELEMENT_PROP_WND_NUM);                // Chart subwindow index
   this.m_struct_obj.coord_x=(int)this.GetProperty(CANV_ELEMENT_PROP_COORD_X);                  // Form's X coordinate on the chart
   this.m_struct_obj.coord_y=(int)this.GetProperty(CANV_ELEMENT_PROP_COORD_Y);                  // Form's Y coordinate on the chart
   this.m_struct_obj.width=(int)this.GetProperty(CANV_ELEMENT_PROP_WIDTH);                      // Element width
   this.m_struct_obj.height=(int)this.GetProperty(CANV_ELEMENT_PROP_HEIGHT);                    // Element height
   this.m_struct_obj.edge_right=(int)this.GetProperty(CANV_ELEMENT_PROP_RIGHT);                 // Element right edge
   this.m_struct_obj.edge_bottom=(int)this.GetProperty(CANV_ELEMENT_PROP_BOTTOM);               // Element bottom edge
   this.m_struct_obj.act_shift_left=(int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_LEFT);    // Active area offset from the left edge of the element
   this.m_struct_obj.act_shift_top=(int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_TOP);      // Active area offset from the top edge of the element
   this.m_struct_obj.act_shift_right=(int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT);  // Active area offset from the right edge of the element
   this.m_struct_obj.act_shift_bottom=(int)this.GetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM);// Active area offset from the bottom edge of the element
   this.m_struct_obj.movable=(bool)this.GetProperty(CANV_ELEMENT_PROP_MOVABLE);                 // Element moveability flag
   this.m_struct_obj.active=(bool)this.GetProperty(CANV_ELEMENT_PROP_ACTIVE);                   // Element activity flag
   this.m_struct_obj.interaction=(bool)this.GetProperty(CANV_ELEMENT_PROP_INTERACTION);         // Flag of interaction with the outside environment
   this.m_struct_obj.coord_act_x=(int)this.GetProperty(CANV_ELEMENT_PROP_COORD_ACT_X);          // X coordinate of the element active area
   this.m_struct_obj.coord_act_y=(int)this.GetProperty(CANV_ELEMENT_PROP_COORD_ACT_Y);          // Y coordinate of the element active area
   this.m_struct_obj.coord_act_right=(int)this.GetProperty(CANV_ELEMENT_PROP_ACT_RIGHT);        // Right border of the element active area
   this.m_struct_obj.coord_act_bottom=(int)this.GetProperty(CANV_ELEMENT_PROP_ACT_BOTTOM);      // Bottom border of the element active area
   this.m_struct_obj.color_bg=this.m_color_bg;                                                  // Element background color
   this.m_struct_obj.opacity=this.m_opacity;                                                    // Element opacity
   this.m_struct_obj.zorder=this.m_zorder;                                                      // Priority of a graphical object for receiving the on-chart mouse click event
//--- Save real properties

//--- Save string properties
   ::StringToCharArray(this.GetProperty(CANV_ELEMENT_PROP_NAME_OBJ),this.m_struct_obj.name_obj);// Graphical element object name
   ::StringToCharArray(this.GetProperty(CANV_ELEMENT_PROP_NAME_RES),this.m_struct_obj.name_res);// Graphical resource name
   //--- Save the structure to the uchar array
   ::ResetLastError();
   if(!::StructToCharArray(this.m_struct_obj,this.m_uchar_array))
     {
      CMessage::ToLog(DFUN,MSG_LIB_SYS_FAILED_SAVE_OBJ_STRUCT_TO_UARRAY,true);
      return false;
     }
   return true;
  }
//+------------------------------------------------------------------+

In der Methode der Wiederherstellung eines Objekts aus der Struktur fügen wir das Lesen der Eigenschaft zu einem Objekt hinzu:

//+------------------------------------------------------------------+
//| Create the object from the structure                             |
//+------------------------------------------------------------------+
void CGCnvElement::StructToObject(void)
  {
//--- Save integer properties
   this.SetProperty(CANV_ELEMENT_PROP_ID,this.m_struct_obj.id);                                 // Element ID
   this.SetProperty(CANV_ELEMENT_PROP_TYPE,this.m_struct_obj.type);                             // Graphical element type
   this.SetProperty(CANV_ELEMENT_PROP_NUM,this.m_struct_obj.number);                            // Element index in the list
   this.SetProperty(CANV_ELEMENT_PROP_CHART_ID,this.m_struct_obj.chart_id);                     // Chart ID
   this.SetProperty(CANV_ELEMENT_PROP_WND_NUM,this.m_struct_obj.subwindow);                     // Chart subwindow index
   this.SetProperty(CANV_ELEMENT_PROP_COORD_X,this.m_struct_obj.coord_x);                       // Form's X coordinate on the chart
   this.SetProperty(CANV_ELEMENT_PROP_COORD_Y,this.m_struct_obj.coord_y);                       // Form's Y coordinate on the chart
   this.SetProperty(CANV_ELEMENT_PROP_WIDTH,this.m_struct_obj.width);                           // Element width
   this.SetProperty(CANV_ELEMENT_PROP_HEIGHT,this.m_struct_obj.height);                         // Element height
   this.SetProperty(CANV_ELEMENT_PROP_RIGHT,this.m_struct_obj.edge_right);                      // Element right edge
   this.SetProperty(CANV_ELEMENT_PROP_BOTTOM,this.m_struct_obj.edge_bottom);                    // Element bottom edge
   this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_LEFT,this.m_struct_obj.act_shift_left);         // Active area offset from the left edge of the element
   this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_TOP,this.m_struct_obj.act_shift_top);           // Active area offset from the upper edge of the element
   this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_RIGHT,this.m_struct_obj.act_shift_right);       // Active area offset from the right edge of the element
   this.SetProperty(CANV_ELEMENT_PROP_ACT_SHIFT_BOTTOM,this.m_struct_obj.act_shift_bottom);     // Active area offset from the bottom edge of the element
   this.SetProperty(CANV_ELEMENT_PROP_MOVABLE,this.m_struct_obj.movable);                       // Element moveability flag
   this.SetProperty(CANV_ELEMENT_PROP_ACTIVE,this.m_struct_obj.active);                         // Element activity flag
   this.SetProperty(CANV_ELEMENT_PROP_INTERACTION,this.m_struct_obj.interaction);               // Flag of interaction with the outside environment
   this.SetProperty(CANV_ELEMENT_PROP_COORD_ACT_X,this.m_struct_obj.coord_act_x);               // X coordinate of the element active area
   this.SetProperty(CANV_ELEMENT_PROP_COORD_ACT_Y,this.m_struct_obj.coord_act_y);               // Y coordinate of the element active area
   this.SetProperty(CANV_ELEMENT_PROP_ACT_RIGHT,this.m_struct_obj.coord_act_right);             // Right border of the element active area
   this.SetProperty(CANV_ELEMENT_PROP_ACT_BOTTOM,this.m_struct_obj.coord_act_bottom);           // Bottom border of the element active area
   this.m_color_bg=this.m_struct_obj.color_bg;                                                  // Element background color
   this.m_opacity=this.m_struct_obj.opacity;                                                    // Element opacity
   this.m_zorder=this.m_struct_obj.zorder;                                                      // Priority of a graphical object for receiving the on-chart mouse click event
//--- Save real properties

//--- Save string properties
   this.SetProperty(CANV_ELEMENT_PROP_NAME_OBJ,::CharArrayToString(this.m_struct_obj.name_obj));// Graphical element object name
   this.SetProperty(CANV_ELEMENT_PROP_NAME_RES,::CharArrayToString(this.m_struct_obj.name_res));// Graphical resource name
  }
//+------------------------------------------------------------------+

Wir brauchen all dies, um das Objekt korrekt auf der Festplatte zu speichern und es in Zukunft beim Lesen und Schreiben von Bibliotheksobjekten in Dateien von der Festplatte wiederherzustellen. Dies wird notwendig sein, damit die Bibliothek beim Neustart des Terminals den Zustand des Programms und seiner Daten wiederherstellen kann, um die Arbeit normal fortzusetzen. Aber all dies wird erst später implementiert werden. In der Zwischenzeit bereiten wir lediglich die notwendige Funktionsweise vor.


Kehren wir zu der Datei der abstrakten grafischen Standardobjektklasse \MQL5\Include\DoEasy\Objects\Graph\Standard\GStdGraphObj.mqh zurück.

Da wir in Zukunft die minimalen und maximalen Koordinaten des gesamten Objekts kennen müssen, wenn wir aus den erweiterten grafischen Standardobjekten zusammengesetzte grafische Objekte erstellen, ist es jetzt an der Zeit, Methoden hinzuzufügen, die die Werte der minimalen und maximalen X- und Y-Koordinaten des grafischen Standardobjekts ermitteln und zurückgeben. Später werden wir in der Lage sein, die minimalen/maximalen Koordinaten des gesamten zusammengesetzten grafischen Objekts auf der Grundlage dieser Methoden zu ermitteln.

Wir deklarieren zwei neue Methoden im öffentlichen Teil der Klasse:

//--- Return (1) the list of dependent objects, (2) dependent graphical object by index and (3) the number of dependent objects
   CArrayObj        *GetListDependentObj(void)        { return &this.m_list;           }
   CGStdGraphObj    *GetDependentObj(const int index) { return this.m_list.At(index);  }
   int               GetNumDependentObj(void)         { return this.m_list.Total();    }
//--- Return the name of the dependent object by index
   string            NameDependent(const int index);
//--- Add the dependent graphical object to the list
   bool              AddDependentObj(CGStdGraphObj *obj);
//--- Change X and Y coordinates of the current and all dependent objects
   bool              ChangeCoordsExtendedObj(const int x,const int y,const int modifier,bool redraw=false);
//--- Set X and Y coordinates into the appropriate pivot points of a specified subordinate object
   bool              SetCoordsXYtoDependentObj(CGStdGraphObj *dependent_obj);

//--- Return (1) the minimum and (2) maximum XY screen coordinate of the specified pivot point
   bool              GetMinCoordXY(int &x,int &y);
   bool              GetMaxCoordXY(int &x,int &y);
   
//--- Return the pivot point data object
   CLinkedPivotPoint*GetLinkedPivotPoint(void)        { return &this.m_linked_pivots;  }

Schreiben wir ihre Implementierung außerhalb des Klassenkörpers.

Die Methode, die die minimale XY-Bildschirmkoordinate von allen Pivotpunkten zurückgibt:

//+------------------------------------------------------------------+
//| Return the minimum XY screen coordinate                          |
//| from all pivot points                                            |
//+------------------------------------------------------------------+
bool CGStdGraphObj::GetMinCoordXY(int &x,int &y)
  {
//--- Declare the variables storing the minimum time and maximum price
   datetime time_min=LONG_MAX;
   double   price_max=0;
//--- Depending on the object type
   switch(this.TypeGraphObject())
     {
      //--- Objects constructed based on screen coordinates
      case OBJ_LABEL             :
      case OBJ_BUTTON            :
      case OBJ_BITMAP_LABEL      :
      case OBJ_EDIT              :
      case OBJ_RECTANGLE_LABEL   :
      case OBJ_CHART             :
         //--- Write XY screen coordinates to x and y variables and return 'true'
         x=this.XDistance();
         y=this.YDistance();
         return true;
      
      //--- Objects constructed in time/price coordinates
      default                    :
         //--- In the loop by all pivot points
         for(int i=0;i<this.Pivots();i++)
           {
            //--- Define the minimum time
            if(this.Time(i)<time_min)
               time_min=this.Time(i);
            //--- Define the maximum price
            if(this.Price(i)>price_max)
               price_max=this.Price(i);
           }
         //--- Return the result of converting time/price coordinates into XY screen coordinates
         return(::ChartTimePriceToXY(this.ChartID(),this.SubWindow(),time_min,price_max,x,y) ? true : false);
     }
   return false;
  }
//+------------------------------------------------------------------+

Bei Objekten, die in Bildschirmkoordinaten konstruiert wurden, ist es nicht notwendig, nach der Maximum/Minimum-Koordinate zu suchen, da solche Objekte einen einzigen Chart-Ankerpunkt haben, der bereits in den Bildschirmkoordinaten enthalten ist — wir sollten sie einfach zurückgeben.
Umgekehrt müssen wir bei Objekten, die in Zeit-/Preiskoordinaten konstruiert wurden, diese Koordinaten über die Funktion ChartTimePriceToXY() ermitteln. Zunächst muss jedoch die minimale Zeitkoordinate aus allen Pivotpunkten des Objekts und die maximale Preiskoordinate aus denselben Pivotpunkten ermittelt werden. Warum suchen wir nach der maximalen Preiskoordinate, wenn wir die minimale Koordinate im Chart benötigen? Die Antwort ist einfach: Der Preis auf dem Chart steigt von unten nach oben, während die Koordinaten in Pixeln auf dem Chart von der linken oberen Ecke aus gezählt werden. Je höher also der Preis ist, desto kleiner ist der Wert der Pixelkoordinate für diesen Preispunkt.
In der Schleife durch alle Pivotpunkte finden wir die minimale Zeit und den maximalen Preis, die wir schließlich an die Funktion ChartTimePriceToXY() übergeben, um Koordinaten in Chart-Pixeln zu erhalten.

Die ähnliche Methode wird verwendet, um die maximale Bildschirm-XY-Koordinate von allen Pivot-Punkten zu erhalten:

//+------------------------------------------------------------------+
//| Return the maximum XY screen coordinate                          |
//| from all pivot points                                            |
//+------------------------------------------------------------------+
bool CGStdGraphObj::GetMaxCoordXY(int &x,int &y)
  {
//--- Declare the variables that store the maximum time and minimum price
   datetime time_max=0;
   double   price_min=DBL_MAX;
//--- Depending on the object type
   switch(this.TypeGraphObject())
     {
      //--- Objects constructed based on screen coordinates
      case OBJ_LABEL             :
      case OBJ_BUTTON            :
      case OBJ_BITMAP_LABEL      :
      case OBJ_EDIT              :
      case OBJ_RECTANGLE_LABEL   :
      case OBJ_CHART             :
         //--- Write XY screen coordinates to x and y variables and return 'true'
         x=this.XDistance();
         y=this.YDistance();
         return true;
      
      //--- Objects constructed in time/price coordinates
      default                    :
         //--- In the loop by all pivot points
         for(int i=0;i<this.Pivots();i++)
           {
            //--- Define the maximum time
            if(this.Time(i)>time_max)
               time_max=this.Time(i);
            //--- Define the maximum price
            if(this.Price(i)<price_min)
               price_min=this.Price(i);
           }
         //--- Return the result of converting time/price coordinates into XY screen coordinates
         return(::ChartTimePriceToXY(this.ChartID(),this.SubWindow(),time_max,price_min,x,y) ? true : false);
     }
   return false;
  }
//+------------------------------------------------------------------+

Die Methode ähnelt der vorherigen, nur dass wir hier nach der maximalen Zeit und dem minimalen Preis suchen.

Wie ich bereits erwähnt habe, werde ich diese Methoden später bei der Arbeit mit zusammengesetzten grafischen Objekten benötigen.


In der Klasse des erweiterten Standard-Toolkits für grafische Objekte \MQL5\Include\DoEasy\Objects\Graph\Extend\CGStdGraphObjExtToolkit.mqh muss die Methode, die die X- und Y-Koordinaten des angegebenen Drehpunkts des grafischen Objekts in Bildschirmkoordinaten zurückgibt, leicht angepasst werden. Der Grund dafür ist, dass wir die grafischen Objekte durch die "switch"-Operator-Fälle so verteilen müssen, dass jeder Fall grafische Objekte nach der Anzahl der Pivot-Punkte für Objekte enthält, die mit Zeit-/Preiskoordinaten konstruiert wurden. Verteilen wir sie also in der richtigen Reihenfolge:

//+------------------------------------------------------------------+
//| Return the X and Y coordinates of the specified pivot point      |
//| of the graphical object in screen coordinates                    |
//+------------------------------------------------------------------+
bool CGStdGraphObjExtToolkit::GetControlPointCoordXY(const int index,int &x,int &y)
  {
//--- Declare form objects, from which we are to receive their screen coordinates
   CFormControl *form0=NULL, *form1=NULL;
//--- Set X and Y to zero - these values will be received in case of a failure
   x=0;
   y=0;
//--- Depending on the graphical object type
   switch(this.m_base_type)
     {
      //--- Objects drawn using screen coordinates
      case OBJ_LABEL             :
      case OBJ_BUTTON            :
      case OBJ_BITMAP_LABEL      :
      case OBJ_EDIT              :
      case OBJ_RECTANGLE_LABEL   :
      case OBJ_CHART             :
        //--- Write object screen coordinates and return 'true'
        x=this.m_base_x;
        y=this.m_base_y;
        return true;
      
      //--- One pivot point (price only)
      case OBJ_HLINE             : break;
      
      //--- One pivot point (time only)
      case OBJ_VLINE             :
      case OBJ_EVENT             : break;
      
      //--- One reference point (time/price)
      case OBJ_TEXT              :
      case OBJ_BITMAP            : break;
      
      //--- Two pivot points and a central one
      //--- Lines
      case OBJ_TREND             :
      case OBJ_TRENDBYANGLE      :
      case OBJ_CYCLES            :
      case OBJ_ARROWED_LINE      :
      //--- Channels
      case OBJ_CHANNEL           :
      case OBJ_STDDEVCHANNEL     :
      case OBJ_REGRESSION        :
      //--- Gann
      case OBJ_GANNLINE          :
      case OBJ_GANNGRID          :
      //--- Fibo
      case OBJ_FIBO              :
      case OBJ_FIBOTIMES         :
      case OBJ_FIBOFAN           :
      case OBJ_FIBOARC           :
      case OBJ_FIBOCHANNEL       :
      case OBJ_EXPANSION         :
        //--- Calculate coordinates for forms on the line pivot points
        if(index<this.m_base_pivots)
           return(::ChartTimePriceToXY(this.m_base_chart_id,this.m_base_subwindow,this.m_base_time[index],this.m_base_price[index],x,y) ? true : false);
        //--- Calculate the coordinates for the central form located between the line pivot points
        else
          {
           form0=this.GetControlPointForm(0);
           form1=this.GetControlPointForm(1);
           if(form0==NULL || form1==NULL)
              return false;
           x=(form0.CoordX()+this.m_shift+form1.CoordX()+this.m_shift)/2;
           y=(form0.CoordY()+this.m_shift+form1.CoordY()+this.m_shift)/2;
           return true;
          }

      //--- Channels
      case OBJ_PITCHFORK         : break;
      
      //--- Gann
      case OBJ_GANNFAN           : break;
      
      //--- Elliott
      case OBJ_ELLIOTWAVE5       : break;
      case OBJ_ELLIOTWAVE3       : break;
      
      //--- Shapes
      case OBJ_RECTANGLE         : break;
      case OBJ_TRIANGLE          : break;
      case OBJ_ELLIPSE           : break;
      
      //--- Arrows
      case OBJ_ARROW_THUMB_UP    : break;
      case OBJ_ARROW_THUMB_DOWN  : break;
      case OBJ_ARROW_UP          : break;
      case OBJ_ARROW_DOWN        : break;
      case OBJ_ARROW_STOP        : break;
      case OBJ_ARROW_CHECK       : break;
      case OBJ_ARROW_LEFT_PRICE  : break;
      case OBJ_ARROW_RIGHT_PRICE : break;
      case OBJ_ARROW_BUY         : break;
      case OBJ_ARROW_SELL        : break;
      case OBJ_ARROW             : break;
      
      //---
      default                    : break;
     }
   return false;
  }
//+------------------------------------------------------------------+

Objekte, die anfänglich in Bildschirmkoordinaten gezeichnet werden, geben einfach die Bildschirmkoordinaten ihres Basisobjekts zurück (das Objekt, an das sie angehängt sind).

Objekte mit implementierter Rückgabe von Bildschirmkoordinaten haben zwei Drehpunkte. Die Bildschirmkoordinaten werden für alle Objekt-Drehpunkte und den zentralen Punkt berechnet.

Die restlichen Objekte, die noch nicht so funktionieren, werden einfach in ihre Gruppen eingeteilt (einige Objekte werden in Gruppen nach Typen und nicht nach der Anzahl der Pivotpunkte zusammengefasst, ich werde sie später implementieren).


Jetzt müssen wir sicherstellen, dass alle GUI-Steuerelemente im Chart immer über den grafischen Objekten bleiben, die neu zum Chart hinzugefügt werden. Außerdem müssen wir dafür sorgen, dass die GUI-Elemente in der gleichen Reihenfolge angeordnet werden, in der sie sich befanden, bevor ein grafisches Objekt zum Chart hinzugefügt wurde.

Um ein grafisches Objekt in den Vordergrund zu bringen, müssen wir es ausblenden und nacheinander wieder einblenden. Dies geschieht, indem man das Sichtbarkeitsflag für grafische Objekte zurücksetzt und dann einbaut. Um das Objekt auszublenden, müssen wir die ObjectSetInteger() Funktion verwenden, um das OBJ_NO_PERIODS Flag für die OBJPROP_TIMEFRAMES Eigenschaft zu setzen. Das OBJ_ALL_PERIODS-Flag wird verwendet, um das Objekt anzuzeigen. Wenn wir dies für alle GUI-Objekte in der Reihenfolge tun, in der sie sich in der Liste der grafischen Elemente befinden, verlieren wir die Reihenfolge ihrer Position auf dem Chart. Mit anderen Worten, die Objekte werden so angeordnet, dass das allererste in der Liste auf dem Chart ganz unten steht und das letzte ganz oben. Diese Objekte können aber auch in einer völlig anderen Reihenfolge angeordnet sein, die beim Neuzeichnen geändert wird. Hier wenden wir uns der neuen Eigenschaft zu, die wir heute hinzugefügt haben — ZOrder. Wir müssen die Liste der grafischen Objekte in aufsteigender Reihenfolge der ZOrder-Eigenschaft sortieren. Dann werden die Objekte in der richtigen Reihenfolge neu gezeichnet.

Öffnen Sie die Datei der Sammlungsklasse für grafische Elemente \MQL5\Include\DoEasy\Collections\GraphElementsCollection.mqh und nehmen wir darin alle notwendigen Verbesserungen vor.

Wir deklarieren drei neue Methoden im privaten Abschnitt der Klasse:

//--- Event handler
   void              OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam);

private:
//--- Move all objects on canvas to the foreground
   void              BringToTopAllCanvElm(void);
//--- (1) Return the maximum ZOrder of all CCanvas elements,
//--- (2) Set ZOrde to the specified element and adjust it in all the remaining elements
   long              GetZOrderMax(void);
   bool              SetZOrderMAX(CGCnvElement *obj);
//--- Handle the removal of extended graphical objects
   void              DeleteExtendedObj(CGStdGraphObj *obj);

Schreiben wir ihre Implementierung außerhalb des Klassenkörpers.

Die Methode verschiebt alle Objekte auf der Leinwand in den Vordergrund:

//+------------------------------------------------------------------+
//| Move all objects on canvas to the foreground                     |
//+------------------------------------------------------------------+
void CGraphElementsCollection::BringToTopAllCanvElm(void)
  {
//--- Create a new list, reset the flag of managing memory and sort by ZOrder
   CArrayObj *list=new CArrayObj();
   list.FreeMode(false);
   list.Sort(SORT_BY_CANV_ELEMENT_ZORDER);
//--- Declare the graphical element object
   CGCnvElement *obj=NULL;
//--- In the loop by the total number of all graphical elements,
   for(int i=0;i<this.m_list_all_canv_elm_obj.Total();i++)
     {
      //--- get the next object
      obj=this.m_list_all_canv_elm_obj.At(i);
      if(obj==NULL)
         continue;
      //--- and insert it to the list in the order of sorting by ZOrder
      list.InsertSort(obj);
     }
//--- In a loop by the created list sorted by ZOrder,
   for(int i=0;i<list.Total();i++)
     {
      //--- get the next object
      obj=list.At(i);
      if(obj==NULL)
         continue;
      //--- and move it to the foreground
      obj.BringToTop();
     }
//--- Remove the list sorted by 'new'
   delete list;
  }
//+------------------------------------------------------------------+

Was wir hier also sehen. Wir deklarieren das neue Listenobjekt CArrayObj und setzen sein Speicherverwaltungsflag zurück. Als Nächstes setzen wir die Eigenschaft des Sortierflags der Liste für ZOrder. Warum tun wir das? Um die CObject-Objekte nach einer beliebigen Eigenschaft sortieren zu können, müssen wir den Eigenschaftswert als Sortierkennzeichen setzen. In diesem Fall gibt die virtuelle Methode Compare(), die in allen von der Klasse CObject abgeleiteten Objekten implementiert ist, den Wert zurück, der sich aus dem Vergleich ähnlicher Eigenschaften (die als Sortiermodus festgelegte Eigenschaft) zweier Objekte ergibt, was für die Operation der Methode Sort() erforderlich ist.

Das Zurücksetzen des Speichermanagement-Flags ist erforderlich, damit wir schließlich Kopien von Objekten aus der Kollektionsliste in dem erstellten Array erhalten und nicht nur Zeiger auf die Sammlungsobjekte. Das ist wichtig, denn wenn wir es mit den Zeigern zu tun haben, dann wird jede Änderung an ihnen in der neuen Liste automatisch das Objekt in der Kollektionsliste ändern, da es sich um die Zeiger auf dasselbe Objekt der Kollektionsliste handelt, die sich in zwei Listen befinden. Ich erstelle eine unabhängige Listenkopie, deren Änderung sich nicht auf das Original auswirkt, um solche "Überraschungen" zu vermeiden. Nach Abschluss der Methode sollten wir die erstellte Liste löschen, um Speicherlecks zu vermeiden. Dies wird auch in der Hilfe der Standardbibliothek (FreeMode) erwähnt:

Das Setzen des Speichermanagement-Flags ist ein wichtiger Bestandteil bei der Verwendung der Klasse CArrayObj. Da die Array-Elemente Zeiger auf dynamische Objekte sind, ist es wichtig zu bestimmen, was mit ihnen geschehen soll, wenn sie aus dem Array entfernt werden.

Wenn das Flag gesetzt ist und ein Element aus dem Array entfernt wird, wird das Element automatisch durch den delete-Operator gelöscht. Wenn das Flag nicht gesetzt ist, wird davon ausgegangen, dass ein Zeiger auf das gelöschte Objekt noch irgendwo im Benutzerprogramm vorhanden ist und anschließend vom Programm freigegeben wird.

Wenn das Nutzerprogramm das Flag der Speicherverwaltung zurücksetzt, muss der Benutzer seine Verantwortung für die Entfernung des Arrays vor Beendigung des Programms verstehen. Andernfalls wird der vom neuen Operator für Elemente zugewiesene Speicher nicht freigegeben.

Bei großen Datenmengen kann dies sogar zu einem Absturz des Terminals führen. Wenn der Nutzer das Speicherverwaltungsflag nicht zurücksetzt, gibt es einen weiteren Fallstrick.

Wenn Zeigerelemente in einem Array irgendwo in den lokalen Variablen gespeichert sind, dann führt das Entfernen des Arrays zu einem kritischen Fehler und zum Absturz des Nutzerprogramms. Standardmäßig ist das Speicherverwaltungsflag gesetzt, d. h. die Klasse des Arrays ist für das Freigeben der Speicherelemente verantwortlich.

Als Nächstes durchlaufen wir in einer Schleife die Kollektionsliste der grafischen Elemente und fügen das jeweils nächste Objekt in der Sortierreihenfolge in die neue Liste ein.

Nach Abschluss der Schleife erhalten wir die neue Liste sortiert in aufsteigender Reihenfolge der ZOrder-Eigenschaften aller grafischen Elemente.
In der Schleife durch die Liste holen wir das nächste Element und bringen es in den Vordergrund. Jedes nachfolgende Element wird immer höher sein als das vorherige.
Wenn die Schleife beendet ist, entferne die neu erstellte Liste.

Die Methode gibt die maximale ZOrder aller CCanvas-Elemente zurück:

//+------------------------------------------------------------------+
//| Return the maximum ZOrder of all CCanvas elements                |
//+------------------------------------------------------------------+
long CGraphElementsCollection::GetZOrderMax(void)
  {
   this.m_list_all_canv_elm_obj.Sort(SORT_BY_CANV_ELEMENT_ZORDER);
   int index=CSelect::FindGraphCanvElementMax(this.GetListCanvElm(),CANV_ELEMENT_PROP_ZORDER);
   CGCnvElement *obj=this.m_list_all_canv_elm_obj.At(index);
   return(obj!=NULL ? obj.Zorder() : WRONG_VALUE);
  }
//+------------------------------------------------------------------+

Hier sortieren wir die Liste nach der Eigenschaft ZOrder und erhalten den Elementindex in der Liste mit dem maximalen Eigenschaftswert.
Wir holen uns den Zeiger auf das Element über den erhaltenen Index und geben die Eigenschaft ZOrder des Elements zurück.
Wenn das Element nicht empfangen wurde, gibt die Methode -1 zurück.

Wenn wir zum Beispiel drei GUI-Objekte haben, wäre es sinnvoll, drei ZOrder-Werte für sie zu haben. Alle Objekte haben zunächst einen ZOrder-Wert von Null — sie befinden sich alle ganz unten. Sobald wir ein Objekt erfassen, wird seine ZOrder um 1 erhöht. Aber zuerst sollten wir sehen, ob irgendein anderes Objekt einen ZOrder-Wert hat, der gleich oder größer als 1 ist, denn das letzte ausgewählte Objekt sollte höher als alle anderen sein und die maximal verfügbare ZOrder um 1 überschreiten. Natürlich können wir die maximale ZOrder ermitteln und sie einfach um 1 erhöhen. Aber das ist nicht die eleganteste Lösung. Stattdessen werde ich dafür sorgen, dass von den drei Objekten nur ZOrder-Werte im Bereich von 0 - 2 möglich sind.

Daher müssen wir für das letzte ausgewählte Objekt entweder die ZOrder um 1 erhöhen oder sie so hoch wie möglich lassen (um die Anzahl aller Objekte, die bei Null beginnen), während wir die ZOrder für die übrigen Objekte um 1 verringern. Wenn sich das Objekt ganz unten befindet und seine ZOrder bereits Null ist, wird sie nicht verringert. Die Änderung der ZOrder-Werte erfolgt also "on loop" entsprechend der Anzahl der GUI-Objekte.

Die Methode setzt ZOrder auf das angegebene Element und passt es in anderen Elementen an:

//+------------------------------------------------------------------+
//| Set ZOrde to the specified element                               |
//| and adjust it in other elements                                  |
//+------------------------------------------------------------------+
bool CGraphElementsCollection::SetZOrderMAX(CGCnvElement *obj)
  {
//--- Get the maximum ZOrder of all graphical elements
   long max=this.GetZOrderMax();
//--- If an invalid pointer to the object has been passed or the maximum ZOrder has not been received, return 'false'
   if(obj==NULL || max<0)
      return false;
//--- Declare the variable for storing the method result
   bool res=true;
//--- If the maximum ZOrder is zero, ZOrder is equal to 1,
//--- if the maximum ZOrder is less than (the total number of graphical elements)-1, ZOrder will exceed it by 1,
//--- otherwise, ZOrder will be equal to (the total number of graphical elements)-1
   long value=(max==0 ? 1 : max<this.m_list_all_canv_elm_obj.Total()-1 ? max+1 : this.m_list_all_canv_elm_obj.Total()-1);
//--- If failed to set ZOrder for an object passed to the method, return 'false'
   if(!obj.SetZorder(value,false))
      return false;
//--- Temporarily declare a form object for drawing a text for visually displaying its ZOrder
   CForm *form=obj;
//--- and draw a text specifying ZOrder on the form
   form.TextOnBG(0,TextByLanguage("Тест: ID ","Test. ID ")+(string)form.ID()+", ZOrder "+(string)form.Zorder(),form.Width()/2,form.Height()/2,FRAME_ANCHOR_CENTER,C'211,233,149',255,true,true);
//--- Sort the list of graphical elements by an element ID
   this.m_list_all_canv_elm_obj.Sort(SORT_BY_CANV_ELEMENT_ID);
//--- Get the list of graphical elements without an object whose ID is equal to the ID of the object passed to the method
   CArrayObj *list=CSelect::ByGraphCanvElementProperty(this.GetListCanvElm(),CANV_ELEMENT_PROP_ID,obj.ID(),NO_EQUAL);
//--- If failed to obtain the list and the list size exceeds one,
//--- which indicates the presence of other objects in it in addition to the one sorted by ID, return 'false'
   if(list==NULL && this.m_list_all_canv_elm_obj.Total()>1)
      return false;
//--- In the loop by the obtained list of remaining graphical element objects
   for(int i=0;i<list.Total();i++)
     {
      //--- get the next object
      CGCnvElement *elm=list.At(i);
      //--- If failed to get the object or if this is a control form for managing pivot points of an extended standard graphical object
      //--- or, if the object's ZOrder is zero, skip the object since there is no need in changing its ZOrder as it is the bottom one
      if(elm==NULL || elm.Type()==OBJECT_DE_TYPE_GFORM_CONTROL || elm.Zorder()==0)
         continue;
      //--- If failed to set the object's ZOrder to 1 less than it already is (decreasing ZOrder by 1), add 'false' to the 'res' value
      if(!elm.SetZorder(elm.Zorder()-1,false))
         res &=false;
      //--- Temporarily (for the test purpose), if the element is a form,
      if(elm.Type()==OBJECT_DE_TYPE_GFORM)
        {
         //--- assign the pointer to the element for the form and draw a text specifying ZOrder on the form 
         form=elm;
         form.TextOnBG(0,TextByLanguage("Тест: ID ","Test. ID ")+(string)form.ID()+", ZOrder "+(string)form.Zorder(),form.Width()/2,form.Height()/2,FRAME_ANCHOR_CENTER,C'211,233,149',255,true,true);
        }
     }
//--- Upon the loop completion, return the result set in 'res'
   return res;
  }
//+------------------------------------------------------------------+

Jeder Methodenstring ist mit Kommentaren versehen, um die Logik der Methode zu verdeutlichen. Zu Testzwecken wurde eine Textanzeige auf dem Formular mit einem Hinweis auf den ZOrder-Wert hinzugefügt, damit wir die Änderung der Eigenschaften jedes Formularobjekts während der Tests visuell verfolgen können.

Es gibt zwei Fälle, in denen wir GUI-Objekte über die neu erstellten grafischen Objekte verschieben müssen:

  1. Manuelles Hinzufügen eines grafischen Standardobjekts zu einem Chart,
  2. Programmgesteuertes Hinzufügen eines grafischen Objekts (ein Standard- oder ein erweitertes zusammengesetztes Objekt).

Diese Fälle werden in der Bibliothek unabhängig voneinander behandelt.
Daher müssen wir an verschiedenen Stellen einen Aufruf einer Methode hinzufügen, die GUI-Objekte auf eine höhere Ebene hebt.

Wenn wir ein grafisches Objekt programmatisch erstellen, können wir einen Aufruf zum Neuzeichnen von GUI-Objekten direkt in einer privaten Methode platzieren, die das erstellte grafische Standardobjekt zur Liste hinzufügt. Dies ist genau die Stelle, an der der Erfolg der Erstellung eines grafischen Objekts letztendlich bestimmt wird, und wir können den Aufruf einer Methode zum Verschieben aller GUI-Objekte in den Vordergrund genau an das Ende dieser Methode setzen:

//--- Add a newly created standard graphical object to the list
   bool              AddCreatedObjToList(const string source,const long chart_id,const string name,CGStdGraphObj *obj)
                       {

                        if(!this.m_list_all_graph_obj.Add(obj))
                          {
                           CMessage::ToLog(source,MSG_LIB_SYS_FAILED_OBJ_ADD_TO_LIST);
                           ::ObjectDelete(chart_id,name);
                           delete obj;
                           return false;
                          }
                        //--- Move all the forms above the created chart object and redraw the chart
                        this.BringToTopAllCanvElm();
                        ::ChartRedraw(chart_id);
                        return true;
                       }

Nach dem Aufruf der Methode müssen wir das Chart aktualisieren, damit die Änderungen sofort angezeigt werden.


Im Falle einer manuellen Deklaration von grafischen Objekten wird dieses Ereignis in der Methode zur Aktualisierung der Liste aller grafischen Objekte definiert.

In dem Code-Block, in dem das Hinzufügen eines neuen grafischen Objekts definiert ist, fügen wir den Aufruf der Methode hinzu, die GUI-Objekte in den Vordergrund bringt:

//+------------------------------------------------------------------+
//| Update the list of all graphical objects                         |
//+------------------------------------------------------------------+
void CGraphElementsCollection::Refresh(void)
  {
   this.RefreshForExtraObjects();
//--- Declare variables to search for charts
   long chart_id=0;
   int i=0;
//--- In the loop by all open charts in the terminal (no more than 100)
   while(i<CHARTS_MAX)
     {
      //--- Get the chart ID
      chart_id=::ChartNext(chart_id);
      if(chart_id<0)
         break;
      //--- Get the pointer to the object for managing graphical objects
      //--- and update the list of graphical objects by chart ID
      CChartObjectsControl *obj_ctrl=this.RefreshByChartID(chart_id);
      //--- If failed to get the pointer, move on to the next chart
      if(obj_ctrl==NULL)
         continue;
      //--- If the number of objects on the chart changes
      if(obj_ctrl.IsEvent())
        {
         //--- If a graphical object is added to the chart
         if(obj_ctrl.Delta()>0)
           {
            //--- Get the list of added graphical objects and move them to the collection list
            //--- (if failed to move the object to the collection, move on to the next object)
            if(!this.AddGraphObjToCollection(DFUN_ERR_LINE,obj_ctrl))
               continue;
            //--- Move all the forms above the created chart object and redraw the chart
            this.BringToTopAllCanvElm();
            ::ChartRedraw(obj_ctrl.ChartID());
           }
         //--- If the graphical object has been removed
         else if(obj_ctrl.Delta()<0)
           {
            int index=WRONG_VALUE;
            //--- In the loop by the number of removed graphical objects
            for(int j=0;j<-obj_ctrl.Delta();j++)
              {
               // Find an extra object in the list
               CGStdGraphObj *obj=this.FindMissingObj(chart_id,index);
               if(obj!=NULL)
                 {
                  //--- Get the removed object parameters
                  long   lparam=obj.ChartID();
                  string sparam=obj.Name();
                  double dparam=(double)obj.TimeCreate();
                  //--- If this is an extended graphical object
                  if(obj.TypeGraphElement()==GRAPH_ELEMENT_TYPE_STANDARD_EXTENDED)
                    {
                     this.DeleteExtendedObj(obj);
                    }
                  //--- Move the graphical object class object to the list of removed objects
                  //--- and send the event to the control program chart
                  if(this.MoveGraphObjToDeletedObjList(index))
                     ::EventChartCustom(this.m_chart_id_main,GRAPH_OBJ_EVENT_DELETE,lparam,dparam,sparam);
                 }
              }
           }
        }
      //--- Increase the loop index
      i++;
     }
  }
//+------------------------------------------------------------------+


Bei der Durchführung des Tests im vorigen Artikel habe ich festgestellt, dass die Koordinaten eines zusammengesetzten grafischen Objekts nicht immer korrekt durch die Grenzen des Charts begrenzt werden. Bei unterschiedlichen Positionen der Objektdrehpunkte kann das Objekt "deformiert" werden, wenn es einen Chart-Rand erreicht.
Den Grund habe ich gleich nach dem Test aufgedeckt:

... die Verschiebungen der Pivotpunkte werden relativ zum zentralen Punkt berechnet, d.h. ein Punkt hat eine positive Verschiebung, der zweite eine negative. Der Fehler bei der Berechnung der Begrenzung tritt auf, wenn man die Lage der Angelpunkte relativ zum zentralen Punkt ändert.

Wir beheben dies, indem wir die notwendigen Änderungen vornehmen. Wir werden sofort die Koordinaten des zentralen Punktes sowie die Verschiebungen von den Drehpunkten der grafischen Objekte zu ihrem zentralen Punkt berechnen. Bei der Berechnung der Begrenzungen durch die Chart-Größe sollten Sie den Wert für die Verschiebung ohne Vorzeichen verwenden. In diesem Fall hat das Vorzeichen der Verschiebung keinen Einfluss auf die Berechnung.

In der Ereignisbehandlung des Blocks für die Behandlung eines erweiterten grafischen Standardobjekts fügen wir eine neue Berechnung der Begrenzungen hinzu und zeigen die Debugging-Daten im Chart an:

                           //--- If the form is central for managing all pivot points of a graphical object
                           else
                             {
                              //--- Get screen coordinates of all object pivot points and write them to the m_data_pivot_point structure
                              if(this.GetPivotPointCoordsAll(ext,m_data_pivot_point))
                                {
                                 //--- In the loop by the number of object pivot points,
                                 for(int i=0;i<(int)this.m_data_pivot_point.Size();i++)
                                   {
                                    //--- limit the screen coordinates of the current pivot point so that they do not move beyond the chart borders
                                    //--- By X coordinate
                                    if(x+shift-::fabs(this.m_data_pivot_point[i].ShiftX)<0)
                                       x=-shift+::fabs(m_data_pivot_point[i].ShiftX);
                                    if(x+shift+::fabs(this.m_data_pivot_point[i].ShiftX)>chart_width)
                                       x=chart_width-shift-::fabs(this.m_data_pivot_point[i].ShiftX);
                                    //--- By Y coordinate
                                    if(y+shift-::fabs(this.m_data_pivot_point[i].ShiftY)<0)
                                       y=-shift+::fabs(this.m_data_pivot_point[i].ShiftY);
                                    if(y+shift+::fabs(this.m_data_pivot_point[i].ShiftY)>chart_height)
                                       y=chart_height-shift-::fabs(this.m_data_pivot_point[i].ShiftY);
                                    //--- set the calculated coordinates to the current object pivot point
                                    ext.ChangeCoordsExtendedObj(x+shift+this.m_data_pivot_point[i].ShiftX,y+shift+this.m_data_pivot_point[i].ShiftY,i);
                                   }
                                }
                                
                              //--- Display debugging comments on the chart
                              if(m_data_pivot_point.Size()>=2)
                                {
                                 int max_x,min_x,max_y,min_y;
                                 if(ext.GetMinCoordXY(min_x,min_y) && ext.GetMaxCoordXY(max_x,max_y))
                                    Comment
                                      (
                                       "MinX=",min_x,", MaxX=",max_x,"\n",
                                       "MaxY=",min_y,", MaxY=",max_y
                                      );
                                }
                                
                             }


Sobald wir auf das GUI-Objekt klicken, müssen wir es in den Vordergrund bringen und seine maximale ZOrder setzen.

In der Ereignisbehandlung des Cursor-Handling-Blocks innerhalb eines aktiven Bereichs der gedrückten Maustaste fügen wir den Code-Block zum Setzen einer maximalen ZOrder für das Objekt ein:

            //--- 'The cursor is inside the active area,  any mouse button is clicked' event handler
            if(mouse_state==MOUSE_FORM_STATE_INSIDE_ACTIVE_AREA_PRESSED && !move)
              {
               pressed_form=true;   // the flag of holding the mouse button on the form
               //--- If the left mouse button is pressed
               if(this.m_mouse.IsPressedButtonLeft())
                 {
                  //--- Set flags and form parameters
                  move=true;                                            // movement flag
                  form.SetInteraction(true);                            // flag of the form interaction with the environment
                  form.BringToTop();                                    // form on the background - above all others
                  form.SetOffsetX(this.m_mouse.CoordX()-form.CoordX()); // Cursor shift relative to the X coordinate
                  form.SetOffsetY(this.m_mouse.CoordY()-form.CoordY()); // Cursor shift relative to the Y coordinate
                  this.ResetAllInteractionExeptOne(form);               // Reset interaction flags for all forms except the current one
                  
                  //--- Get the maximum ZOrder
                  long zmax=this.GetZOrderMax();
                  //--- If the maximum ZOrder has been received and the form's ZOrder is less than the maximum one or the maximum ZOrder of all forms is equal to zero
                  if(zmax>WRONG_VALUE && (form.Zorder()<zmax || zmax==0))
                    {
                     //--- If the form is not a control point for managing an extended standard graphical object,
                     //--- set the form's ZOrder above all others
                     if(form.Type()!=OBJECT_DE_TYPE_GFORM_CONTROL)
                        this.SetZOrderMAX(form);
                    }
                 }
              }

Hier setze ich ZOrder für Formularobjekte, die keine erweiterten grafischen Standardobjektsteuerungen sind.

Die Behandlung der Klassenereignisse der grafischen Elementsammlung ist recht umfangreich. Es macht also keinen Sinn, den gesamten Code hier zu veröffentlichen. Sie finden alle Änderungen (siehe oben) in den angehängten Dateien.

Ändern wir die Berechnung der Verschiebung in der Methode, die die Bildschirmkoordinaten jedes Drehpunkts eines grafischen Objekts zurückgibt.
Jetzt berechnen wir sofort die Koordinaten des zentralen Drehpunktes (der zum Verschieben des Objekts verwendet wird) und berechnen die Verschiebungen auf der Grundlage dieses Punktes. Genauer gesagt werden wir die Verschiebungen von jedem Drehpunkt bis zum zentralen Punkt berechnen:

//+------------------------------------------------------------------+
//| Return screen coordinates                                        |
//| of each graphical object pivot point                             |
//+------------------------------------------------------------------+
bool CGraphElementsCollection::GetPivotPointCoordsAll(CGStdGraphObj *obj,SDataPivotPoint &array_pivots[])
  {
//--- Central point coordinates
   int xc=0, yc=0;
//--- If failed to increase the array of structures to match the number of pivot points,
//--- inform of that in the journal and return 'false'
   if(::ArrayResize(array_pivots,obj.Pivots())!=obj.Pivots())
     {
      CMessage::ToLog(DFUN,MSG_LIB_SYS_FAILED_ARRAY_RESIZE);
      return false;
     }
//--- In the loop by the number of graphical object pivot points
   for(int i=0;i<obj.Pivots();i++)
     {
      //--- Convert the object coordinates into screen ones. If failed, inform of that and return 'false'
      if(!::ChartTimePriceToXY(obj.ChartID(),obj.SubWindow(),obj.Time(i),obj.Price(i),array_pivots[i].X,array_pivots[i].Y))
        {
         CMessage::ToLog(DFUN,MSG_LIB_SYS_FAILED_CONV_GRAPH_OBJ_COORDS_TO_XY);
         return false;
        }
     }
//--- Depending on the graphical object type
   switch(obj.TypeGraphObject())
     {
      //--- One pivot point in screen coordinates
      case OBJ_LABEL             :
      case OBJ_BUTTON            :
      case OBJ_BITMAP_LABEL      :
      case OBJ_EDIT              :
      case OBJ_RECTANGLE_LABEL   :
      case OBJ_CHART             : break;
      
      //--- One pivot point (price only)
      case OBJ_HLINE             : break;
      
      //--- One pivot point (time only)
      case OBJ_VLINE             :
      case OBJ_EVENT             : break;
      
      //--- Two pivot points and a central one
      //--- Lines
      case OBJ_TREND             :
      case OBJ_TRENDBYANGLE      :
      case OBJ_CYCLES            :
      case OBJ_ARROWED_LINE      :
      //--- Channels
      case OBJ_CHANNEL           :
      case OBJ_STDDEVCHANNEL     :
      case OBJ_REGRESSION        :
      //--- Gann
      case OBJ_GANNLINE          :
      case OBJ_GANNGRID          :
      //--- Fibo
      case OBJ_FIBO              :
      case OBJ_FIBOTIMES         :
      case OBJ_FIBOFAN           :
      case OBJ_FIBOARC           :
      case OBJ_FIBOCHANNEL       :
      case OBJ_EXPANSION         :
        //--- Calculate the central point coordinates
        xc=(array_pivots[0].X+array_pivots[1].X)/2;
        yc=(array_pivots[0].Y+array_pivots[1].Y)/2;
        //--- Calculate the shifts of all pivot points from the central one and write them to the structure array
        array_pivots[0].ShiftX=array_pivots[0].X-xc;  // X shift from 0 to the central point
        array_pivots[1].ShiftX=array_pivots[1].X-xc;  // X shift from 1 to the central point
        array_pivots[0].ShiftY=array_pivots[0].Y-yc;  // Y shift from 0 to the central point
        array_pivots[1].ShiftY=array_pivots[1].Y-yc;  // Y shift from 1 to the central point
        return true;

      //--- Channels
      case OBJ_PITCHFORK         : break;
      //--- Gann
      case OBJ_GANNFAN           : break;
      //--- Elliott
      case OBJ_ELLIOTWAVE5       : break;
      case OBJ_ELLIOTWAVE3       : break;
      //--- Shapes
      case OBJ_RECTANGLE         : break;
      case OBJ_TRIANGLE          : break;
      case OBJ_ELLIPSE           : break;
      //--- Arrows
      case OBJ_ARROW_THUMB_UP    : break;
      case OBJ_ARROW_THUMB_DOWN  : break;
      case OBJ_ARROW_UP          : break;
      case OBJ_ARROW_DOWN        : break;
      case OBJ_ARROW_STOP        : break;
      case OBJ_ARROW_CHECK       : break;
      case OBJ_ARROW_LEFT_PRICE  : break;
      case OBJ_ARROW_RIGHT_PRICE : break;
      case OBJ_ARROW_BUY         : break;
      case OBJ_ARROW_SELL        : break;
      case OBJ_ARROW             : break;
      
      //--- Graphical objects with time/price coordinates
      case OBJ_TEXT              : break;
      case OBJ_BITMAP            : break;
      //---
      default: break;
     }
   return false;
  }
//+------------------------------------------------------------------+

Alle Verschiebungen und Begrenzungen sollten nun korrekt berechnet werden. Führen wir den Test durch, um das zu überprüfen.


Test

Um den Test durchzuführen, verwenden wir den EA aus dem vorherigen Artikel und speichern ihn in \MQL5\Experts\TestDoEasy\Part100\ als TestDoEasyPart100.mq5.

Da wir während des Tests den Wert der ZOrder-Eigenschaft auf jedem Formular sofort sehen wollen, fügen wir in OnInit() den Nullwert der Eigenschaft für das Formular (das Objekt ganz unten) ein und fügen die Anzeige der ID des Formularobjekts und seinen ZOrder-Eigenschaftswert hinzu:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Set EA global variables
   ArrayResize(array_clr,2);        // Array of gradient filling colors
   array_clr[0]=C'26,100,128';      // Original ≈Dark-azure color
   array_clr[1]=C'35,133,169';      // Lightened original color
//--- Create the array with the current symbol and set it to be used in the library
   string array[1]={Symbol()};
   engine.SetUsedSymbols(array);
   //--- Create the timeseries object for the current symbol and period, and show its description in the journal
   engine.SeriesCreate(Symbol(),Period());
   engine.GetTimeSeriesCollection().PrintShort(false); // Short descriptions
//--- Create form objects
   CForm *form=NULL;
   for(int i=0;i<FORMS_TOTAL;i++)
     {
      //--- When creating an object, pass all the required parameters to it
      form=new CForm("Form_0"+string(i+1),30,(form==NULL ? 100 : form.BottomEdge()+20),100,30);
      if(form==NULL)
         continue;
      //--- Set activity and moveability flags for the form
      form.SetActive(true);
      form.SetMovable(true);
      //--- Set the form ID and the index in the list of objects
      form.SetID(i);
      form.SetNumber(0);   // (0 - main form object) Auxiliary objects may be attached to the main one. The main object is able to manage them
      //--- Set the opacity of 200
      form.SetOpacity(245);
      //--- The form background color is set as the first color from the color array
      form.SetColorBackground(array_clr[0]);
      //--- Form outlining frame color
      form.SetColorFrame(clrDarkBlue);
      //--- Draw the shadow drawing flag
      form.SetShadow(false);
      //--- Calculate the shadow color as the chart background color converted to the monochrome one
      color clrS=form.ChangeColorSaturation(form.ColorBackground(),-100);
      //--- If the settings specify the usage of the chart background color, replace the monochrome color with 20 units
      //--- Otherwise, use the color specified in the settings for drawing the shadow
      color clr=(InpUseColorBG ? form.ChangeColorLightness(clrS,-20) : InpColorForm3);
      //--- Draw the form shadow with the right-downwards offset from the form by three pixels along all axes
      //--- Set the shadow opacity to 200, while the blur radius is equal to 4
      form.DrawShadow(3,3,clr,200,4);
      //--- Fill the form background with a vertical gradient
      form.Erase(array_clr,form.Opacity(),true);
      //--- Draw an outlining rectangle at the edges of the form
      form.DrawRectangle(0,0,form.Width()-1,form.Height()-1,form.ColorFrame(),form.Opacity());
      form.Done();
      
      //--- Set ZOrder to zero, display the text describing the gradient type and update the form
      //--- Text parameters: the text coordinates and the anchor point in the form center
      //--- Create a new text animation frame with the ID of 0 and display the text on the form
      form.SetZorder(0,false);
      form.TextOnBG(0,TextByLanguage("Тест: ID ","Test: ID ")+(string)form.ID()+", ZOrder "+(string)form.Zorder(),form.Width()/2,form.Height()/2,FRAME_ANCHOR_CENTER,C'211,233,149',255,true,true);
      //--- Add the form to the list
      if(!engine.GraphAddCanvElmToCollection(form))
         delete form;
     }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+


Kompilieren und starten wir den EA auf dem Chart:


Wie wir sehen können, ist der ZOrder-Wert jedes Formularobjekts unmittelbar nach der Erstellung gleich Null, aber grafische Objekte werden immer noch "unter ihnen" aufgebaut. Änderungen des ZOrder-Werts eines jeden Objekts werden "kreisförmig" durchgeführt — nicht mehr als die Anzahl der Formularobjekte auf dem Chart (von Null an gerechnet). Jedes konstruierte grafische Objekt erscheint immer "unter" den GUI-Objekten, und ihre relative Position bleibt unverändert, was bedeutet, dass sie in der Liste entsprechend den Werten ihrer ZOrder-Eigenschaft korrekt verteilt sind. Schließlich ist das zusammengesetzte grafische Objekt jetzt korrekt auf die Ränder des Bildschirms begrenzt und wird unabhängig von der Lage seiner Drehpunkte nicht verzerrt. Wie andere grafische Objekte wird es unterhalb der Formularobjekte gezeichnet.

Was kommt als Nächstes?

Der nächste Artikel wird einen großen Abschnitt über die Erstellung von GUI-Objekten im Stile von Windows Forms beginnen.
Das bedeutet aber nicht, dass erweiterte grafische Objekte und darauf basierende zusammengesetzte Objekte nicht weiterentwickelt werden. Wir brauchen einfach vollwertige Steuerelemente für ihre Weiterentwicklung. Im nächsten Abschnitt der Bibliothek werde ich die Entwicklung und Verfeinerung von erweiterten grafischen Objekten schrittweise fortsetzen.

Alle Dateien der aktuellen Bibliotheksversion, des Test-EA und des Chart-Event-Control-Indikators für MQL5 sind unten zum Testen und Herunterladen angehängt. Stellen Sie Ihre Fragen, Kommentare und Vorschläge bitte im Kommentarteil.

Zurück zum Inhalt

*Frühere Artikel dieser Serie:

Grafiken in der Bibliothek DoEasy (Teil 93): Vorbereiten der Funktionen zur Erstellung zusammengesetzter grafischer Objekte
Grafiken in der Bibliothek DoEasy (Teil 94): Bewegen und Löschen zusammengesetzter grafischer Objekte
Grafiken in der DoEasy-Bibliothek (Teil 95): Steuerelemente für zusammengesetzte grafische Objekte
Grafiken in der DoEasy-Bibliothek (Teil 96): Grafiken in Formularobjekten und Behandlung von Mausereignissen
Grafiken in der DoEasy-Bibliothek (Teil 97): Unabhängige Handhabung der Bewegung von Formularobjekten
Grafiken in der Bibliothek DoEasy (Teil 98): Verschieben von Angelpunkten erweiterter grafischer Standardobjekte
Grafiken in der DoEasy-Bibliothek (Teil 99): Verschieben eines erweiterten grafischen Objekts mit einem einzigen Steuerpunkt

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/10634

Beigefügte Dateien |
MQL5.zip (4371.63 KB)
Lernen Sie, wie man ein Handelssystem mit Hilfe von Parabolic SAR entwickelt Lernen Sie, wie man ein Handelssystem mit Hilfe von Parabolic SAR entwickelt
In diesem Artikel setzen wir unsere Serie darüber fort, wie man ein Handelssystem mit den beliebtesten Indikatoren entwickelt. In diesem Artikel lernen wir den Parabolic SAR Indikator im Detail kennen und erfahren, wie wir ein Handelssystem für den MetaTrader 5 mit Hilfe einiger einfacher Strategien entwickeln können.
Mehrere Indikatoren in einem Chart (Teil 06): Umwandlung des MetaTrader 5 in ein RAD-System (II) Mehrere Indikatoren in einem Chart (Teil 06): Umwandlung des MetaTrader 5 in ein RAD-System (II)
In meinem letzten Artikel habe ich Ihnen gezeigt, wie man einen Chart Trade mit MetaTrader 5 Objekten erstellt und so die Plattform in ein RAD-System verwandelt. Das System funktioniert sehr gut, und sicher haben viele der Leser über die Erstellung einer Bibliothek nachgedacht, die es ermöglichen würde, die Funktionsweise des vorgeschlagenen Systems zu erweitern. Auf dieser Grundlage wäre es möglich, einen intuitiveren Expert Advisor mit einer schöneren und einfacher zu bedienenden Oberfläche zu entwickeln.
Datenwissenschaft und maschinelles Lernen (Teil 03): Matrix-Regression Datenwissenschaft und maschinelles Lernen (Teil 03): Matrix-Regression
Diesmal werden unsere Modelle mit Hilfe von Matrizen erstellt, was uns eine gewisse Flexibilität ermöglicht, während wir gleichzeitig leistungsstarke Modelle erstellen können, die nicht nur mit fünf unabhängigen Variablen, sondern auch mit vielen Variablen umgehen können, solange wir innerhalb der Berechnungsgrenzen eines Computers bleiben.
Mehrere Indikatoren in einem Chart (Teil 05): Umwandlung des MetaTrader 5 in ein RAD-System (I) Mehrere Indikatoren in einem Chart (Teil 05): Umwandlung des MetaTrader 5 in ein RAD-System (I)
Es gibt viele Menschen, die keine Ahnung vom Programmieren haben, aber sehr kreativ sind und tolle Ideen haben. Der Mangel an Programmierkenntnissen hindert sie jedoch daran, diese Ideen umzusetzen. Schauen wir uns gemeinsam an, wie man einen Chart Trade mit der MetaTrader 5 Plattform selbst erstellt, als wäre es eine IDE (integrierte Entwicklungsumgebung).