Download MetaTrader 5

Graphical Interfaces II: the Separation Line and Context Menu Elements (Chapter 2)

11 March 2016, 13:46
Anatoli Kazharski
0
6 019

Contents  

 

Introduction

The first article Graphical Interfaces I: Preparation of the Library Structure (Chapter 1) considers in detail what this library is for. A full list of the links to the articles is at the end of each chapter of the series. There you can also find and download a complete version of the library at the current stage of development. The files must be located in the same directories as in the archive.  

In the previous chapter, we wrote a class for creating a menu item. This is used both as an independent control and as a part of a context and main menu. In this article, we will describe the creation of the separation line element, which also can be used not only as an independent interface element but as a part of many other elements too. After that, we will have everything required for the development of the context menu class, which will also be discussed in this article in detail. Added to that, we will introduce all necessary additions to the class, which is the base for storing pointers to all the elements of the graphical interface of the application.



Developing the Class for Creating a Separation Line

In a context menu, besides different types of menu items, we can often see one more interface element - a separation line. This element can be encountered not only in context menus. For instance, the status bar of the MetaTrader trading terminal and the MetaEditor code editor have vertical separation lines. That is why we will create a separate class for this object so it can be used in any other control or even used as a separate element of the graphical interface.

To give an illusion of volume, a separation line must consist of at least two parts. If one line is lighter than the background and the other one is darker, this will create a visual effect of a groove on the surface. There are two ways of creating a separation line: (1) from two primitive objects of the CRectLabel type, which are already present in the Objects.mqh file or (2) create an object of the OBJ_BITMAP_LABEL type and use it as a canvas for drawing. Let us use the second option. The standard library suggests the CCanvas class for drawing. This class already contains all necessary methods for drawing simple geometrical figures, which significantly simplifies the implementation of the intended design and will save us a lot of time. 

The CCanvas class has to be embedded in a way so it can be used in a similar way to those primitive objects, which are already present in the Objects.mqh file. This can be easily achieved by making the CCanvas class derived from the CChartObjectBmpLabel class. A little change has to be introduced in the code of the CCanvas class so there are no errors or warnings later when the program is compiled. This is because in both the CCanvas class and the CChartObject class, which is the base class for the CChartObjectBmpLabel class, there is the m_chart_id field (variable). As a result, the compiler will give a warning that a variable with such a name already exists:

Fig. 1. Warning from the compiler that a variable with such a name already exists.

Fig. 1. Warning from the compiler

 

In practice, such a warning will not cause any critical errors and compilation will take place in spite of this. It is recommended, however, to avoid such situations because its potential impact on the work of the program is unknown. Let us assume this as a rule and follow it. Besides, the changes in the Canvas.mqh file will have to be introduced anyway because the CCanvas class has to be derived from the CChartObjectBmpLabel class. This way we can easily get rid of the persisting warning. We will simply remove the m_chart_id variable from the CCanvas class. Introducing changes in the classes of the standard library, it must be noted that at the next terminal update the files of the standard library can also be updated and the changes will get nullified. Therefore, as we cannot achieve our goal without making changes in the CCanvas class, create its copy and place it in the directory where the files of our library are located.

Create the Canvas folder in the #Include folder. Create a copy of the file containing the СCanvas class and rename it to CustomCanvas.mqh and name the class CCustomCanvas. Include the ChartObjectsBmpControls.mqh file of the standard library in the CustomCanvas.mqh file and make the CCustomCanvas class a derived one from the CChartObjectBmpLabel class. Then remove the m_chart_id variable from the body of the CCustomCanvas class and from the constructor.

//+------------------------------------------------------------------+
//|                                                 CustomCanvas.mqh |
//|                   Copyright 2009-2013, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#include <Files\FileBin.mqh>
#include <Controls\Rect.mqh>
#include <ChartObjects\ChartObjectsBmpControls.mqh>

//...

//+------------------------------------------------------------------+
//| Class CCustomCanvas                                              |
//| Usage: class for working with a dynamic resource                 |
//+------------------------------------------------------------------+
class CCustomCanvas : public CChartObjectBmpLabel
  {
//...

Now, include the CustomCanvas.mqh file in the Objects.mqh file:

//+------------------------------------------------------------------+
//|                                                      Objects.mqh |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#include "Enums.mqh"
#include "Defines.mqh"
#include "..\Canvas\CustomCanvas.mqh"
#include <ChartObjects\ChartObjectsBmpControls.mqh>
#include <ChartObjects\ChartObjectsTxtControls.mqh>

Then, let us create the CRectCanvas class, which has to be a derived class from the CCustomCanvas class. The CRectCanvas class will be similar to all other classes, which are in the Objects.mqh file. Their contents were considered in the previous article. Now, it can be used for drawing any other interface elements, which will be a part of the library under development. 

We have everything ready for the development of the CSeparateLine class, which is intended for the creation of a separation line. Create the SeparateLine.mqh file in the Controls folder. Include the Element.mqh and Window.mqh files in it. Then, follow the following sequence of steps:

1) create the CSeparateLine class;

2) in this class, declare a pointer to the form to which the element is going to be attached and create a method for storing a pointer in it;

3) create an instance of the CRectCanvas class;

4) declare and implement standard visual methods for all elements that can be used to manage the element.

//+------------------------------------------------------------------+
//|                                                 SeparateLine.mqh |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#include "Element.mqh"
#include "Window.mqh"
//+------------------------------------------------------------------+
//| Class for creating a separation line                             |
//+------------------------------------------------------------------+
class CSeparateLine : public CElement
  {
private:
   //--- Pointer to the form to which the element is attached
   CWindow          *m_wnd;
   //--- Object for creating a separation line
   CRectCanvas       m_canvas;
   //---
public:
                     CSeparateLine(void);
                    ~CSeparateLine(void);
   //--- Stores the pointer to the passed form
   void              WindowPointer(CWindow &object) { m_wnd=::GetPointer(object); }
   //---
public:
   //--- Chart event handler
   virtual void      OnEvent(const int id,const long &lparam,const double &dparam,const string &sparam);
   //--- Moving the element
   virtual void      Moving(const int x,const int y);
   //--- (1) Show, (2) hide, (3) reset, (4) delete
   virtual void      Show(void);
   virtual void      Hide(void);
   virtual void      Reset(void);
   virtual void      Delete(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSeparateLine::CSeparateLine(void)
  {
//--- Store the name of the element class in the base class  
   CElement::ClassName(CLASS_NAME);
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSeparateLine::~CSeparateLine(void)
  {
  }
//+------------------------------------------------------------------+

To set up the appearance of the separation line, let us create three methods. These methods will be used for setting:

  • The type of the separation line: (1) horizontal, (2) vertical.
  • The color of the dark part.
  • The color of the light part.

The enumeration, which will be used for specifying the type, has to be added to the Enums.mqh file:

//+------------------------------------------------------------------+
//| Enumeration of the separation line types                         |
//+------------------------------------------------------------------+
enum ENUM_TYPE_SEP_LINE
  {
   H_SEP_LINE =0,
   V_SEP_LINE =1
  };

Now, we can add the corresponding variables and methods to the CSeparateLine class and carry out the initialization by default values in the constructor:

class CSeparateLine : public CElement
  {
private:
   //--- Properties
   ENUM_TYPE_SEP_LINE m_type_sep_line;   
   color             m_dark_color;
   color             m_light_color;
   //---
public:
   //--- (1) Line type, (2) line colors
   void              TypeSepLine(const ENUM_TYPE_SEP_LINE type) { m_type_sep_line=type; }
   void              DarkColor(const color clr)                 { m_dark_color=clr;     }
   void              LightColor(const color clr)                { m_light_color=clr;    }
   //---
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSeparateLine::CSeparateLine(void) : m_type_sep_line(H_SEP_LINE),
                                     m_dark_color(clrBlack),
                                     m_light_color(clrDimGray)
  {
  }

We only have to add the methods for creating the element and the method, in which a separation line will be drawn on the canvas. The following parameters must be passed to the public method for creating the element CreateSeparateLine(), which will be called in the custom application:

  • chart identifier;
  • number of the chart window;
  • number of the line index. This is necessary for the cases when several separation lines have to be created in a loop either in a context menu or other interface elements. In this case, the only element identifier is not sufficient for creating a unique name of the graphical object;
  • coordinates;
  • size.

class CSeparateLine : public CElement
  {
public:
   //--- Creating a separation line
   bool              CreateSeparateLine(const long chart_id,const int subwin,const int index,
                                        const int x,const int y,const int x_size,const int y_size);
   //---
private:
   //--- Creates the canvas for drawing a separation line
   bool              CreateSepLine(void);
   //--- Drawing a separation line
   void              DrawSeparateLine(void);
   //---
  };

The code of the CreateSeparateLine() method does not differ from other similar methods in principle (for instance, in the CMenuItem class), that is why we will next consider the code of the CreateSepLine() method. 

Similar to all other methods of this type, the name of the graphical object is set at the beginning. Then the graphical object (canvas) is created on which we will draw. It should be noted that for the creation of the object of the OBJ_BITMAP_LABEL type, the CreateBitmapLabel() method is used, which belongs to the CCustomCanvas class. In this class, when objects are created, attaching the object to the chart is not provided as in the CChartObjectBmpLabel class, where the CChartObject::Attach() method of the base class is used straight after creation of the object. We ourselves must manage this. As the CCustomCanvas class was derived from the CChartObjectBmpLabel class, we can access the CChartObject::Attach() method from its base class. If the object is not attached to the chart, it will be impossible to manage.

After the object was created, attached to the chart and the properties have been set up, a separation line can be drawn on our custom canvas using the DrawSeparateLine() method. This is shown in the code below. Then the object pointer is stored in the array of the CElement base class.

//+------------------------------------------------------------------+
//| Creates the canvas for drawing a separation line                 |
//+------------------------------------------------------------------+
bool CSeparateLine::CreateSepLine(void)
  {
//--- Forming the object name  
   string name=CElement::ProgramName()+"_separate_line_"+(string)CElement::Index()+"__"+(string)CElement::Id();
//--- Creating an object
   if(!m_canvas.CreateBitmapLabel(m_chart_id,m_subwin,name,m_x,m_y,m_x_size,m_y_size,COLOR_FORMAT_ARGB_NORMALIZE))
      return(false);
//--- Attaching to the chart
   if(!m_canvas.Attach(m_chart_id,name,m_subwin,1))
      return(false);
//--- Properties
   m_canvas.Background(false);
//--- Margins from the edge point
   m_canvas.XGap(m_x-m_wnd.X());
   m_canvas.YGap(m_y-m_wnd.Y());
//--- Draw a separation line
   DrawSeparateLine();
//--- Add to array
   CElement::AddToArray(m_canvas);
   return(true);
  }

The code of the DrawSeparateLine() method is simple. At first, get the size of the canvas. Then clear the canvas by using the CCustomCanvas::Erase() method. Then, depending on whether a horizontal or vertical line has to be drawn, the program will move to the corresponding code block. As an example, we will describe building a horizontal line. At first, coordinates for two points of the line are defined and then the first line is drawn in the upper part of the canvas. Coordinates for the second line are defined in the lower part of the canvas. If the height of the canvas is set to be two pixels, then the lines will be located very close to each other. You can arrange a margin between the upper and the lower lines by setting the height of the canvas greater than two pixels. To display the changes, the canvas must be refreshed at the very end of the method using the CCustomCanvas::Update() method.

//+------------------------------------------------------------------+
//|  Draws a separation line                                         |
//+------------------------------------------------------------------+
void CSeparateLine::DrawSeparateLine(void)
  {
//--- Coordinates for the lines
   int x1=0,x2=0,y1=0,y2=0;
//--- Canvas size
   int   x_size =m_canvas.X_Size()-1;
   int   y_size =m_canvas.Y_Size()-1;
//--- Clear canvas
   m_canvas.Erase(::ColorToARGB(clrNONE,0));
//--- If the line is horizontal
   if(m_type_sep_line==H_SEP_LINE)
     {
      //--- The dark line above
      x1=0;
      y1=0;
      x2=x_size;
      y2=0;
      //---
      m_canvas.Line(x1,y1,x2,y2,::ColorToARGB(m_dark_color));
      //--- The light line below
      x1=0;
      x2=x_size;
      y1=y_size;
      y2=y_size;
      //---
      m_canvas.Line(x1,y1,x2,y2,::ColorToARGB(m_light_color));
     }
//--- If the line is vertical
   else
     {
      //--- The dark line on the left
      x1=0;
      x2=0;
      y1=0;
      y2=y_size;
      //---
      m_canvas.Line(x1,y1,x2,y2,::ColorToARGB(m_dark_color));
      //--- The light line on the right
      x1=x_size;
      y1=0;
      x2=x_size;
      y2=y_size;
      //---
      m_canvas.Line(x1,y1,x2,y2,::ColorToARGB(m_light_color));
     }
//--- Refreshing canvas
   m_canvas.Update();
  }

 



Test of Attaching a Separation Line

Now, we can test how this works. In the previous article, we attached a menu item to the form. Following the same principle, a separation line can be attached as a separate interface element. 

I will briefly remind you about the process of attaching an element to the form.

  • If the element class is not in the base yet, its file has to be included in the WndContainer.mqh file.
  • As the custom class of the application (in our case this is CProgram) must be derived from CWndContainer -> CWndEvents, then the creation of the element class instance and the method for it will become available after including the element file.
  • Then, call the method for creating the element in the method where the graphical interface of the program is created.

If everything is done correctly, then after the program compilation and loading it on to the chart, the result should be as follows:

Fig. 2. Test of the separation line element.

Fig. 2. Test of the separation line element.


The development of the CSeparateLine class is finished, and we have everything ready to start implementing the class for creating a context menu.

 


Developing the Class for Creating a Context Menu

Previously, in the process of the library development, three interface elements were created: (1) a form for controls (CWindow), (2) the menu item control (CMenuItem) and (3) the separation line element (CSeparateLine). Each of them belongs to a simple type of element, as they are composed only of primitive objects. A context menu is classed as a complex (compound) type of control. It will be composed not only of primitive objects but also of other elements. The base class for those elements is CElement

Create the ContextMenu.mqh file in the Controls folder in the directory of our library. In this file include the files that will be used for creating the context menu:

//+------------------------------------------------------------------+
//|                                                  ContextMenu.mqh |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#include "Element.mqh"
#include "Window.mqh"
#include "MenuItem.mqh"
#include "SeparateLine.mqh"

Then, create the CContextMenu class with the standard set of virtual methods for all library elements, the form pointer and the method for storing it. We need an object of the OBJ_RECTANGLE_LABEL type as the element background. That is why to create this object, we are going to use the CRectLabel class from the Object.mqhfile. The CMenuItem class for menu items was created in the previous article. As a context menu usually contains more than one CMenuItem class and the number of these classes is not known initially, then a dynamic array of the instances of this class has to be declared. The same applies to the separation lines (CSeparateLine) of a context menu.

//+------------------------------------------------------------------+
//| Class for creating a context menu                                |
//+------------------------------------------------------------------+
class CContextMenu : public CElement
  {
private:
   //--- Pointer to the form to which the element is attached
   CWindow          *m_wnd;
   //--- Objects for creating a menu item
   CRectLabel        m_area;
   CMenuItem         m_items[];
   CSeparateLine     m_sep_line[];
   //---
public:
                     CContextMenu(void);
                    ~CContextMenu(void);
   //--- Stores the pointer to the passed form
   void              WindowPointer(CWindow &object) { m_wnd=::GetPointer(object); }

   //--- Chart event handler
   virtual void      OnEvent(const int id,const long &lparam,const double &dparam,const string &sparam);
   //--- Timer
   virtual void      OnEventTimer(void);
   //--- Moving the element
   virtual void      Moving(const int x,const int y);
   //--- (1) Show, (2) hide, (3) reset, (4) delete
   virtual void      Show(void);
   virtual void      Hide(void);
   virtual void      Reset(void);
   virtual void      Delete(void);
   //--- (1) Setting, (2) resetting of priorities for left clicking
   virtual void      SetZorders(void);
   virtual void      ResetZorders(void);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CContextMenu::CContextMenu(void)
  {
//--- Store the name of the element class in the base class
   CElement::ClassName(CLASS_NAME);
//--- Context menu is a drop-down element
   CElement::m_is_dropdown=true;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CContextMenu::~CContextMenu(void)
  {
  }
//+------------------------------------------------------------------+

To set up the appearance of the context menu, corresponding fields and methods are required:

class CContextMenu : public CElement
  {
private:
   //--- Background properties
   int               m_area_zorder;
   color             m_area_color;
   color             m_area_border_color;
   color             m_area_color_hover;
   color             m_area_color_array[];
   //--- Properties of menu items
   int               m_item_y_size;
   color             m_item_back_color;
   color             m_item_border_color;
   color             m_item_back_color_hover;
   color             m_item_back_color_hover_off;
   color             m_label_color;
   color             m_label_color_hover;
   string            m_right_arrow_file_on;
   string            m_right_arrow_file_off;
   //--- Separation line properties
   color             m_sepline_dark_color;
   color             m_sepline_light_color;
   //---
public:
   //--- Number of menu items
   int               ItemsTotal(void)                         const { return(::ArraySize(m_items));         }
   //--- Methods for setting up the appearance of the context menu:
   //    Color of the context menu background
   void              MenuBackColor(const color clr)                 { m_area_color=clr;                     }
   void              MenuBorderColor(const color clr)               { m_area_border_color=clr;              }
   //--- (1) Height, (2) background color and (3) color of the menu item frame 
   void              ItemYSize(const int y_size)                    { m_item_y_size=y_size;                 }
   void              ItemBackColor(const color clr)                 { m_item_back_color=clr;                }
   void              ItemBorderColor(const color clr)               { m_item_border_color=clr;              }
   //--- Background color of (1) the available and (2) the blocked menu item when hovering the mouse cursor over it
   void              ItemBackColorHover(const color clr)            { m_item_back_color_hover=clr;          }
   void              ItemBackColorHoverOff(const color clr)         { m_item_back_color_hover_off=clr;      }
   //--- (1) Standard and (2) in-focus text color 
   void              LabelColor(const color clr)                    { m_label_color=clr;                    }
   void              LabelColorHover(const color clr)               { m_label_color_hover=clr;              }
   //--- Defining an icon for indicating the presence of a context menu in the item
   void              RightArrowFileOn(const string file_path)       { m_right_arrow_file_on=file_path;      }
   void              RightArrowFileOff(const string file_path)      { m_right_arrow_file_off=file_path;     }
   //--- (1) Dark and (2) light color of the separation line
   void              SeparateLineDarkColor(const color clr)         { m_sepline_dark_color=clr;             }
   void              SeparateLineLightColor(const color clr)        { m_sepline_light_color=clr;            }
   //---
  };

The menu item and its context menu must be connected, otherwise it will be impossible to manage those elements correctly. To be precise, the context menu and its items must have access to the menu item to which it is attached, that is to the previous node. This means that both the CContextMenu class and the CMenuItem class must have a pointer of the CMenuItem type and methods to store and get this pointer. This pointer will also be used for checking the sequence of creating the graphical interface of the program for correctness. This will be shown later, when the methods for creating a context menu are considered. 

Adding the pointer and methods for storing it and getting it in the CContextMenu class:

class CContextMenu : public CElement
  {
private:
   //--- Pointer to the previous node
   CMenuItem        *m_prev_node;
   //---
public:
   //--- Getting and storing the pointer to the previous node
   CMenuItem        *PrevNodePointer(void)                    const { return(m_prev_node);                  }
   void              PrevNodePointer(CMenuItem &object)             { m_prev_node=::GetPointer(object);     }
   //---
  };

Same must be added to the CMenuItem class:

class CMenuItem : public CElement
  {
private:
   //--- Pointer to the previous node
   CMenuItem        *m_prev_node;
   //---
public:
   //--- Getting and storing the pointer to the previous node
   CMenuItem        *PrevNodePointer(void)                    const { return(m_prev_node);                  }
   void              PrevNodePointer(CMenuItem &object)             { m_prev_node=::GetPointer(object);     }
   //---
  };

The graphical interface will be built in the custom class of the application (CProgram). When creating a context menu, we will require a method to specify the intended number of items in a context menu and unique values of some parameters not common for all the items. Let us write the CContextMenu::AddItem() method, which will accept as parameters: (1) the menu item text, (2) a path to the icon for the label of the available item, (3) a path to the icon for the blocked item and (4) the menu item type. Arrays to store passed values will also be required. The size of these arrays will be increased by one element each time when the CContextMenu::AddItem() method is called.

class CContextMenu : public CElement
  {
private:
   //--- Arrays of the menu item properties:
   //    (1) Text, (2) label of the available item, (3) label of the blocked item
   string            m_label_text[];
   string            m_path_bmp_on[];
   string            m_path_bmp_off[];
   //---
public:
   //--- Adds a menu item with specified properties before the creation of a context menu
   void              AddItem(const string text,const string path_bmp_on,const string path_bmp_off,const ENUM_TYPE_MENU_ITEM type);
   //---
  };
//+------------------------------------------------------------------+
//| Adds a menu item                                                 |
//+------------------------------------------------------------------+
void CContextMenu::AddItem(const string text,const string path_bmp_on,const string path_bmp_off,const ENUM_TYPE_MENU_ITEM type)
  {
//--- Increase the size of the arrays by one element
   int array_size=::ArraySize(m_items);
   ::ArrayResize(m_items,array_size+1);
   ::ArrayResize(m_label_text,array_size+1);
   ::ArrayResize(m_path_bmp_on,array_size+1);
   ::ArrayResize(m_path_bmp_off,array_size+1);
//--- Store the values of passed parameters
   m_label_text[array_size]   =text;
   m_path_bmp_on[array_size]  =path_bmp_on;
   m_path_bmp_off[array_size] =path_bmp_off;
//--- Setting the type of the menu item
   m_items[array_size].TypeMenuItem(type);
  }

To add a separation line in a context menu, we will need an array to store the index number of the menu item after which this line is to be set. The index number of the menu item will be passed to the CContextMenu::AddSeparateLine() method. The code is shown below.

class CContextMenu : public CElement
  {
private:
   //--- Array of index numbers of menu items after which a separation line is to be set
   int               m_sep_line_index[];
   //---
public:
   //--- Adds a separation line after the specified item before the creation of a context menu
   void              AddSeparateLine(const int item_index);
   //---
  };
//+------------------------------------------------------------------+
//| Adds a separation line                                           |
//+------------------------------------------------------------------+
void CContextMenu::AddSeparateLine(const int item_index)
  {
//--- Increase the size of the arrays by one element
   int array_size=::ArraySize(m_sep_line);
   ::ArrayResize(m_sep_line,array_size+1);
   ::ArrayResize(m_sep_line_index,array_size+1);
//--- Store the index number
   m_sep_line_index[array_size]=item_index;
  }

We will need methods which will allow us to get the following, having specified the index of the menu item: (1) the pointer to the menu item, (2) description (displayed text) and (3) the type. In every method, before returning the value of the property, at first a check for exceeding the array size is carried out and then the index is adjusted. It is implemented so that if the passed index is greater that the array size, then the last item will be called and if the index is less than zero, then the first item will be called. 

class CContextMenu : public CElement
  {
public:
   //--- Returns the item pointer from the context menu
   CMenuItem        *ItemPointerByIndex(const int index);
   //--- Returns description (displayed text)
   string            DescriptionByIndex(const int index);
   //--- Returns the menu item type
   ENUM_TYPE_MENU_ITEM TypeMenuItemByIndex(const int index);
   //---
  };
//+------------------------------------------------------------------+
//| Returns the menu item pointer by the index                       |
//+------------------------------------------------------------------+
CMenuItem *CContextMenu::ItemPointerByIndex(const int index)
  {
   int array_size=::ArraySize(m_items);
//--- If there is no item in the context menu, report
   if(array_size<1)
     {
      ::Print(__FUNCTION__," > This method is to be called, "
              "if the context menu has at least one item!");
     }
//--- Adjustment in case the range has been exceeded
   int i=(index>=array_size)? array_size-1 :(index<0)? 0 : index;
//--- Return the pointer
   return(::GetPointer(m_items[i]));
  }
//+------------------------------------------------------------------+
//| Returns the item name by the index                               |
//+------------------------------------------------------------------+
string CContextMenu::DescriptionByIndex(const int index)
  {
   int array_size=::ArraySize(m_items);
//--- If there is no item in the context menu, report
   if(array_size<1)
     {
      ::Print(__FUNCTION__," > This method is to be called, "
              "if the context menu has at least one item!");
     }
//--- Adjustment in case the range has been exceeded
   int i=(index>=array_size)? array_size-1 :(index<0)? 0 : index;
//--- Return the item description
   return(m_items[i].LabelText());
  }
//+------------------------------------------------------------------+
//| Returns the item type by the index                               |
//+------------------------------------------------------------------+
ENUM_TYPE_MENU_ITEM CContextMenu::TypeMenuItemByIndex(const int index)
  {
   int array_size=::ArraySize(m_items);
//--- If there is no item in the context menu, report
   if(array_size<1)
     {
      ::Print(__FUNCTION__," > This method is to be called, "
              "if the context menu has at least one item!");
     }
//--- Adjustment in case the range has been exceeded
   int i=(index>=array_size)? array_size-1 :(index<0)? 0 : index;
//--- Return the item type
   return(m_items[i].TypeMenuItem());
  }

One context menu may have several groups of radio items. To avoid confusion when identifying what item was clicked on, every radio item must have its own group identifier and the index in relation to the list of this group. The schematic below shows that besides general indices and the identifier of the context menu element, a radio item has its own distinguishing characteristics. 

Fig. 3. Schematic of identifiers and indices of different groups in a context menu.

Fig. 3. Schematic of identifiers and indices of different groups in a context menu.

 

When forming a context menu, the type of the menu item has to be identified before the menu is attached to the chart. In case this is a radio item, the group it belongs to has to be specified. In other words, we need a method that will allow us to determine the identifier of each radio item. The default identifiers of radio items will be equal to zero. If we leave them like this, a context menu will have only one group of radio items no matter how many we add. There will be situations when it is required to establish the identifier of the radio item and which of them is currently highlighted. There also must be a possibility to switch radio items. 

In addition to that, methods for working with checkboxes will be required. They will allow to find out the state of a checkbox and change its state if necessary. The declaration and implementation of these methods is in the code below.

class CContextMenu : public CElement
  {
public:
   //--- (1) Getting and (2) setting the checkbox state
   bool              CheckBoxStateByIndex(const int index);
   void              CheckBoxStateByIndex(const int index,const bool state);
   //--- (1) Returns and (2) sets the id of the radio item by the index
   int               RadioItemIdByIndex(const int index);
   void              RadioItemIdByIndex(const int item_index,const int radio_id);
   //--- (1) Returns selected radio item, (2) switches the radio item
   int               SelectedRadioItem(const int radio_id);
   void              SelectedRadioItem(const int radio_index,const int radio_id);
   //---
  };
//+------------------------------------------------------------------+
//| Returns the checkbox state by the index                          |
//+------------------------------------------------------------------+
bool CContextMenu::CheckBoxStateByIndex(const int index)
  {
   int array_size=::ArraySize(m_items);
//--- If there is no item in the context menu, report
   if(array_size<1)
     {
      ::Print(__FUNCTION__," > This method is to be called, "
              "if the context menu has at least one item!");
     }
//--- Adjustment in case the range has been exceeded
   int i=(index>=array_size)? array_size-1 :(index<0)? 0 : index;
//--- Return the item state
   return(m_items[i].CheckBoxState());
  }
//+------------------------------------------------------------------+
//| Sets the checkbox state by the index                             |
//+------------------------------------------------------------------+
void CContextMenu::CheckBoxStateByIndex(const int index,const bool state)
  {
//--- Check for exceeding the range
   int size=::ArraySize(m_items);
   if(size<1 || index<0 || index>=size)
      return;
//--- Set the state
   m_items[index].CheckBoxState(state);
  }
//+------------------------------------------------------------------+
//| Returns the radio item id by the index                           |
//+------------------------------------------------------------------+
int CContextMenu::RadioItemIdByIndex(const int index)
  {
   int array_size=::ArraySize(m_items);
//--- If there is no item in the context menu, report
   if(array_size<1)
     {
      ::Print(__FUNCTION__," > This method is to be called, "
              "if the context menu has at least one item!");
     }
//--- Adjustment in case the range has been exceeded
   int i=(index>=array_size)? array_size-1 :(index<0)? 0 : index;
//--- Return the identifier
   return(m_items[i].RadioButtonID());
  }
//+------------------------------------------------------------------+
//| Sets the radio item id by the index                              |
//+------------------------------------------------------------------+
void CContextMenu::RadioItemIdByIndex(const int index,const int id)
  {
//--- Check for exceeding the range
   int array_size=::ArraySize(m_items);
   if(array_size<1 || index<0 || index>=array_size)
      return;
//--- Set the identifier
   m_items[index].RadioButtonID(id);
  }
//+------------------------------------------------------------------+
//| Returns the radio item index by the id                           |
//+------------------------------------------------------------------+
int CContextMenu::SelectedRadioItem(const int radio_id)
  {
//--- Radio item counter
   int count_radio_id=0;
//--- Iterate over the list of context menu items
   int items_total=ItemsTotal();
   for(int i=0; i<items_total; i++)
     {
      //--- Move to the following if this is not a radio item
      if(m_items[i].TypeMenuItem()!=MI_RADIOBUTTON)
         continue;
      //--- If identifiers match
      if(m_items[i].RadioButtonID()==radio_id)
        {
         //--- If this is an active radio item, leave the loop
         if(m_items[i].RadioButtonState())
            break;
         //--- Increase the counter of radio items
         count_radio_id++;
        }
     }
//--- Return the index
   return(count_radio_id);
  }
//+------------------------------------------------------------------+
//| Switches the radio item by the index and id                      |
//+------------------------------------------------------------------+
void CContextMenu::SelectedRadioItem(const int radio_index,const int radio_id)
  {
//--- Radio item counter
   int count_radio_id=0;
//--- Iterate over the list of context menu items
   int items_total=ItemsTotal();
   for(int i=0; i<items_total; i++)
     {
      //--- Move to the following if this is not a radio item
      if(m_items[i].TypeMenuItem()!=MI_RADIOBUTTON)
         continue;
      //--- If identifiers match
      if(m_items[i].RadioButtonID()==radio_id)
        {
         //--- Switch the radio item
         if(count_radio_id==radio_index)
            m_items[i].RadioButtonState(true);
         else
            m_items[i].RadioButtonState(false);
         //--- Increase the counter of radio items
         count_radio_id++;
        }
     }
  }

Everything is ready for creating methods for attaching a context menu to the chart. The attachment will have three stages:

  • Creating the context menu background.
  • Creating menu items.
  • Creating separation lines.

Every stage requires a private method. Later, they will be called in the common public method. Declare them in the class body:

class CContextMenu : public CElement
  {
public:
   //--- Methods for creating a context menu
   bool              CreateContextMenu(const long chart_id,const int window,const int x=0,const int y=0);
   //---
private:
   bool              CreateArea(void);
   bool              CreateItems(void);
   bool              CreateSeparateLine(const int line_number,const int x,const int y);
   //---
  };

The height of the context menu background depends on the number of items and separation lines. That is why there is no point in setting this value in the application class as this value will be replaced in the CContextMenu::CreateArea() method which is designed for setting the context menu background. The height for the separation line area will be equal to nine pixels and, therefore, the number of lines must be multiplied by this value to calculate the area they occupy.

//+------------------------------------------------------------------+
//| Creates the common area of the context menu                      |
//+------------------------------------------------------------------+
bool CContextMenu::CreateArea(void)
  {
//--- Forming the object name
   string name=CElement::ProgramName()+"_contextmenu_bg_"+(string)CElement::Id();
//--- Calculation of the context menu height depends on the number of menu items and separation lines
   int items_total =ItemsTotal();
   int sep_y_size  =::ArraySize(m_sep_line)*9;
   m_y_size        =(m_item_y_size*items_total+2)+sep_y_size-(items_total-1);
//--- Set up the context menu background
   if(!m_area.Create(m_chart_id,name,m_subwin,m_x,m_y,m_x_size,m_y_size))
      return(false);
//--- Set properties
   m_area.BackColor(m_area_color);
   m_area.Color(m_area_border_color);
   m_area.BorderType(BORDER_FLAT);
   m_area.Corner(m_corner);
   m_area.Selectable(false);
   m_area.Z_Order(m_area_zorder);
   m_area.Tooltip("\n");
//--- Margins from the edge point
   m_area.XGap(m_x-m_wnd.X());
   m_area.YGap(m_y-m_wnd.Y());
//--- Размеры фона
   m_area.XSize(m_x_size);
   m_area.YSize(m_y_size);
//--- Set the object pointer
   CElement::AddToArray(m_area);
   return(true);
  }

Separation lines will be set by the CContextMenu::CreateSeparateLine() method. The line number and coordinates are to be passed to this method as parameters:

//+------------------------------------------------------------------+
//| Creates a separation line                                        |
//+------------------------------------------------------------------+
bool CContextMenu::CreateSeparateLine(const int line_number,const int x,const int y)
  {
//--- Store the form pointer
   m_sep_line[line_number].WindowPointer(m_wnd);
//--- Set properties
   m_sep_line[line_number].TypeSepLine(H_SEP_LINE);
   m_sep_line[line_number].DarkColor(m_sepline_dark_color);
   m_sep_line[line_number].LightColor(m_sepline_light_color);
//--- Creating a separation line
   if(!m_sep_line[line_number].CreateSeparateLine(m_chart_id,m_subwin,line_number,x,y,m_x_size-10,2))
      return(false);
//--- Set the object pointer
   CElement::AddToArray(m_sep_line[line_number].Object(0));
   return(true);
  }

The CContextMenu::CreateSeparateLine() method will be called in the CContextMenu::CreateItems() method for setting menu items. Coordinates and the sequence of setting these element will be defined in one loop. Earlier, we have considered the m_sep_line_index[] array. The index numbers of the menu items after which a separation line is to be set will be stored in this array when a context menu is formed. Comparing the number of the current iteration of the loop and index numbers of the menu items in the m_sep_line_index[] array can identify after which point the separation line is to be set. 

It is also necessary to store the pointer to the previous node before setting each item in the context menu. The code of the CContextMenu::CreateItems() method with detailed comments is presented below.

//+------------------------------------------------------------------+
//| Creates a list of menu items                                     |
//+------------------------------------------------------------------+
bool CContextMenu::CreateItems(void)
  {
   int s =0;     // For identification of the location of separation lines
   int x =m_x+1; // X coordinate
   int y =m_y+1; // Y coordinate. Will be calculated in a loop for each menu item.
//--- Number of separation lines
   int sep_lines_total=::ArraySize(m_sep_line_index);
//---
   int items_total=ItemsTotal();
   for(int i=0; i<items_total; i++)
     {
      //--- Calculation of the Y coordinate
      y=(i>0)? y+m_item_y_size-1 : y;
      //--- Store the form pointer
      m_items[i].WindowPointer(m_wnd);
      //--- Add the pointer to the previous node
      m_items[i].PrevNodePointer(m_prev_node);
      //--- Set properties
      m_items[i].XSize(m_x_size-2);
      m_items[i].YSize(m_item_y_size);
      m_items[i].IconFileOn(m_path_bmp_on[i]);
      m_items[i].IconFileOff(m_path_bmp_off[i]);
      m_items[i].AreaBackColor(m_area_color);
      m_items[i].AreaBackColorOff(m_item_back_color_hover_off);
      m_items[i].AreaBorderColor(m_area_color);
      m_items[i].LabelColor(m_label_color);
      m_items[i].LabelColorHover(m_label_color_hover);
      m_items[i].RightArrowFileOn(m_right_arrow_file_on);
      m_items[i].RightArrowFileOff(m_right_arrow_file_off);
      m_items[i].IsDropdown(m_is_dropdown);
      //--- Margins from the edge point of the panel
      m_items[i].XGap(x-m_wnd.X());
      m_items[i].YGap(y-m_wnd.Y());
      //--- Creating a menu item
      if(!m_items[i].CreateMenuItem(m_chart_id,m_subwin,i,m_label_text[i],x,y))
         return(false);
      //--- Move to the next one if all separation lines are set up
      if(s>=sep_lines_total)
         continue;
      //--- If all indices match, then a separation line can be set up after this item
      if(i==m_sep_line_index[s])
        {
         //--- Coordinates
         int l_x=x+5;
         y=y+m_item_y_size+2;
         //--- Setting up a separation line
         if(!CreateSeparateLine(s,l_x,y))
            return(false);
         //--- Adjustment of the Y coordinate for the following item
         y=y-m_item_y_size+7;
         //--- Increase the counter for separation lines
         s++;
        }
     }
   return(true);
  }

Then, the CContextMenu::CreateContextMenu() method for external use has to be implemented. At this stage, let us consider an option where a context menu must be attached to an item of the external menu or to an independent lone menu item. That means that before creating a context menu, it has to be passed a pointer to the previous node as was said earlier. Besides, the check for the presence of the form pointer, a check for the presence of the pointer to the previous node must be carried out. For the library user, this will be an additional reference point eliminating a possibility of incorrect graphical interface formation. 

A context menu is usually hidden after creation as it is designed to be brought up by either clicking on another control or clicking on the working area. The Hide() method is designed for hiding objects in each element. There is a similar method in the CContextMenu class. At first objects of a context menu - background and a separation line are hidden by it. Then all menu items are hidden in a loop. At the same time, their own CMenuItem::Hide() methods are called for menu items. Separation lines could also be hidden in a similar way because this element has its own CSeparateLine::Hide() method. However, as this is only a design element, consisting of only one graphical object and is not designed for the interactions with the user, it was added to the common array of the context menu objects at the moment of creation and will be hidden in a corresponding loop.

//+------------------------------------------------------------------+
//| Hides the context menu                                           |
//+------------------------------------------------------------------+
void CContextMenu::Hide(void)
  {
//--- Leave, if the element is hidden
   if(!CElement::m_is_visible)
      return;
//--- Hide the objects of the context menu
   for(int i=0; i<ObjectsElementTotal(); i++)
      Object(i).Timeframes(OBJ_NO_PERIODS);
//--- Hide menu items
   int items_total=ItemsTotal();
   for(int i=0; i<items_total; i++)
      m_items[i].Hide();
//--- Zero the focus
   CElement::MouseFocus(false);
//--- Assign the status of a hidden control
   CElement::m_is_visible=false;
  }

All the methods for managing a context menu will be structured in a similar way and we will not consider their code here. You can see the code in the files attached to this article. We will only discuss the code of the CContextMenu::Delete() method for removing the element. Here, besides removing all graphical objects, all arrays that were used for the formation of a context menu are emptied. If this is not done, then every time when a symbol or a timeframe is changed, the list of menu items will be increased. At the stage of testing, you can try to experiment with this by just commenting on those lines.

//+------------------------------------------------------------------+
//| Deletion                                                         |
//+------------------------------------------------------------------+
void CContextMenu::Delete(void)
  {
//--- Removing objects  
   m_area.Delete();
   int items_total=ItemsTotal();
   for(int i=0; i<items_total; i++)
      m_items[i].Delete();
//--- Removing separation lines
   int sep_total=::ArraySize(m_sep_line);
   for(int i=0; i<sep_total; i++)
      m_sep_line[i].Delete();
//--- Emptying the control arrays
   ::ArrayFree(m_items);
   ::ArrayFree(m_sep_line);
   ::ArrayFree(m_sep_line_index);
   ::ArrayFree(m_label_text);
   ::ArrayFree(m_path_bmp_on);
   ::ArrayFree(m_path_bmp_off);
//--- Emptying the array of the objects
   CElement::FreeObjectsArray();
  }

Getting back to the method for creating a context menu, it must be mentioned that coordinates will be set in relation to the previous node. Let us arrange so that the library user can set custom coordinates if the necessity arises. Default coordinates will be set to zero in the CContextMenu::CreateContextMenu() method for creating a context menu. Coordinates will be calculated from the previous node automatically only unless at least one coordinate is specified. If both coordinates are specified, then an automatic calculation will be canceled.

For those context menus which are open from other context menus, their coordinates will be automatically calculated from the right part of the item to which the the menu is attached. For those context menus attached to the menu items of the main menu, coordinate calculation will be carried out from the lower part of the items. To manage this system, one more field and method for the CContextMenu class are required. Let us add a new enumeration to the Enums.mqh file:

//+------------------------------------------------------------------+
//| Enumeration of the menu attachment sides                            |
//+------------------------------------------------------------------+
enum ENUM_FIX_CONTEXT_MENU
  {
   FIX_RIGHT  =0,
   FIX_BOTTOM =1
  };

A corresponding field and the method for setting the coordinate calculation mode must be added to the class of the context menu. By default, the coordinates will be calculated from the right part of the item.

class CContextMenu : public CElement
  {
private:
   //--- Attachment side of the context menu
   ENUM_FIX_CONTEXT_MENU m_fix_side;
   //---
public:
   //--- Setting the context menu attachment mode
   void              FixSide(const ENUM_FIX_CONTEXT_MENU side)      { m_fix_side=side;                      }
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CContextMenu::CContextMenu(void) : m_fix_side(FIX_RIGHT)
  {
  }

Below is the code of the CContextMenu::CreateContextMenu() method. Creating an element is possible only if there is a pointer to it. Properties of this node will be available only after a corresponding check discussed earlier has been completed and this will allow to calculate relative coordinates automatically. Hiding a context menu in the code must be located after its creation.

//+------------------------------------------------------------------+
//| Creates a context menu                                           |
//+------------------------------------------------------------------+
bool CContextMenu::CreateContextMenu(const long chart_id,const int subwin,const int x=0,const int y=0)
  {
//--- Leave, if there is no form pointer
   if(::CheckPointer(m_wnd)==POINTER_INVALID)
     {
      ::Print(__FUNCTION__," > Before creating a context menu it has to be passed  "
              "a window object using the WindowPointer(CWindow &object).");
      return(false);
     }
//--- Leave, if there is no pointer to the previous node 
   if(::CheckPointer(m_prev_node)==POINTER_INVALID)
     {
      ::Print(__FUNCTION__," > Before creating a context menu it has to be passed "
              "the pointer to the previous node using the CContextMenu::PrevNodePointer(CMenuItem &object) method.");
      return(false);
     }
//--- Initialization of variables
   m_id       =m_wnd.LastId()+1;
   m_chart_id =chart_id;
   m_subwin   =subwin;
//--- If coordinates are not specified
   if(x==0 || y==0)
     {
      m_x =(m_fix_side==FIX_RIGHT)? m_prev_node.X2()-3 : m_prev_node.X()+1;
      m_y =(m_fix_side==FIX_RIGHT)? m_prev_node.Y()-1  : m_prev_node.Y2()-1;
     }
//--- If coordinates are specified
   else
     {
      m_x =x;
      m_y =y;
     } 
//--- Margins from the edge point
   CElement::XGap(m_x-m_wnd.X());
   CElement::YGap(m_y-m_wnd.Y());
//--- Creating the context menu
   if(!CreateArea())
      return(false);
   if(!CreateItems())
      return(false);
//--- Hide element
   Hide();
   return(true);
  }

A check for presence of the previous node pointer with a condition has to be added to the CMenuItem class of the CreateMenuItem() method. Absence of a pointer will mean that an independent menu item is implied. This means that this item is not a part of a context menu. Such items can be either items of a simple type (MI_SIMPLE) or items containing a context menu (MI_HAS_CONTEXT_MENU). It might be difficult to understand this right now but it will become clear when we look at examples at the end of this article.

Place this code to the CMenuItem::CreateMenuItem() method after checking for presence of the form pointer as shown below.

//--- If there is no pointer to the previous node, then
//    an independent menu item is implied, that is the one that is not a part of the context menu
   if(::CheckPointer(m_prev_node)==POINTER_INVALID)
     {
      //--- Leave, if the set type does not match
      if(m_type_menu_item!=MI_SIMPLE && m_type_menu_item!=MI_HAS_CONTEXT_MENU)
        {
         ::Print(__FUNCTION__," > The type of the independent menu item can be only MI_SIMPLE or MI_HAS_CONTEXT_MENU,",
                 "that is only with a context menu.\n",
                 __FUNCTION__," > The type of the menu item can be set using the CMenuItem::TypeMenuItem() method");
         return(false);
        }
     }



Test of Attaching a Context Menu

Attaching a context menu to the chart can be tested right now. Include the ContextMenu.mqh file with the CContextMenu class of the menu to the library as shown below.

//+------------------------------------------------------------------+
//|                                                 WndContainer.mqh |
//|                        Copyright 2015, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#include "Window.mqh"
#include "MenuItem.mqh"
#include "ContextMenu.mqh"
#include "SeparateLine.mqh"

Create an instance of the CContextMenu class in the custom class of the CProgram application and declare the method for creating a context menu. Margins from the edge point of the form do not have to be specified as they will be calculated in relation to the menu item to which they are attached.

class CProgram : public CWndEvents
  {
private:
   //--- Menu item and context menu
   CMenuItem         m_menu_item1;
   CContextMenu      m_mi1_contextmenu1;
   //---
private:
#define MENU_ITEM1_GAP_X (6)
#define MENU_ITEM1_GAP_Y (25)
   bool              CreateMenuItem1(const string item_text);
   bool              CreateMI1ContextMenu1(void);
  };

Now, let us form the context menu. It will have five items: three simple ones (MI_SIMPLE) and two items of the checkbox type (MI_CHECKBOX). Include the resources with icons for their labels for simple items outside of the method body. The icon will be colored for the available item and colorless for the blocked one. You can download them by the links at the end of this article. Then, at the very beginning of the method, store the pointers to the form and the previous node in the context menu. Without these actions, the graphical interface will not be created and the program will be removed from the chart. Then follow the arrays with (1) the item description (displayed text), with the icons of (2) the available and (3) blocked states (4) and item types. After that, we need to specify common properties of all items and then add them to the class of the context menu in a loop using the CContextMenu::AddItem() method. Add a separation line after the second item (index 1). After all these actions have been completed, the context menu can be attached to the chart. At the very end of the method, add the element pointer to the base. Below is the code of the method.

//+------------------------------------------------------------------+
//| Creates a context menu                                           |
//+------------------------------------------------------------------+
#resource "\\Images\\Controls\\coins.bmp"
#resource "\\Images\\Controls\\coins_colorless.bmp"
#resource "\\Images\\Controls\\line_chart.bmp"
#resource "\\Images\\Controls\\line_chart_colorless.bmp"
#resource "\\Images\\Controls\\safe.bmp"
#resource "\\Images\\Controls\\safe_colorless.bmp"
//---
bool CProgram::CreateMI1ContextMenu1(void)
  {
//--- Five items in the context menu
#define CONTEXTMENU_ITEMS1 5
//--- Store the window pointer
   m_mi1_contextmenu1.WindowPointer(m_window);
//--- Store the pointer to the previous node
   m_mi1_contextmenu1.PrevNodePointer(m_menu_item1);
//--- Array of item names
   string items_text[CONTEXTMENU_ITEMS1]=
     {
      "ContextMenu 1 Item 1",
      "ContextMenu 1 Item 2",
      "ContextMenu 1 Item 3",
      "ContextMenu 1 Item 4",
      "ContextMenu 1 Item 5"
     };
//--- Label array for the available mode
   string items_bmp_on[CONTEXTMENU_ITEMS1]=
     {
      "Images\\Controls\\coins.bmp",
      "Images\\Controls\\line_chart.bmp",
      "Images\\Controls\\safe.bmp",
      "",""
     };
//--- Label array for the blocked mode
   string items_bmp_off[CONTEXTMENU_ITEMS1]=
     {
      "Images\\Controls\\coins_colorless.bmp",
      "Images\\Controls\\line_chart_colorless.bmp",
      "Images\\Controls\\safe_colorless.bmp",
      "",""
     };
//--- Array of item types
   ENUM_TYPE_MENU_ITEM items_type[CONTEXTMENU_ITEMS1]=
     {
      MI_SIMPLE,
      MI_SIMPLE,
      MI_SIMPLE,
      MI_CHECKBOX,
      MI_CHECKBOX
     };
//--- Set up properties before creation
   m_mi1_contextmenu1.XSize(160);
   m_mi1_contextmenu1.ItemYSize(24);
   m_mi1_contextmenu1.AreaBackColor(C'240,240,240');
   m_mi1_contextmenu1.AreaBorderColor(clrSilver);
   m_mi1_contextmenu1.ItemBackColorHover(C'240,240,240');
   m_mi1_contextmenu1.ItemBackColorHoverOff(clrLightGray);
   m_mi1_contextmenu1.ItemBorderColor(C'240,240,240');
   m_mi1_contextmenu1.LabelColor(clrBlack);
   m_mi1_contextmenu1.LabelColorHover(clrWhite);
   m_mi1_contextmenu1.RightArrowFileOff("Images\\EasyAndFastGUI\\Controls\\RightTransp_black.bmp");
   m_mi1_contextmenu1.SeparateLineDarkColor(C'160,160,160');
   m_mi1_contextmenu1.SeparateLineLightColor(clrWhite);
//--- Add items to the context menu
   for(int i=0; i<CONTEXTMENU_ITEMS1; i++)
      m_mi1_contextmenu1.AddItem(items_text[i],items_bmp_on[i],items_bmp_off[i],items_type[i]);
//--- Separation line after the second item
   m_mi1_contextmenu1.AddSeparateLine(1);
//--- Create the context menu
   if(!m_mi1_contextmenu1.CreateContextMenu(m_chart_id,m_subwin))
      return(false);
//--- Add the control pointer to the base
   CWndContainer::AddToElementsArray(0,m_mi1_contextmenu1);
   return(true);
  }

Now, add the call of the method for creating a context menu to the main method for creating the graphical interface. Although the context menu is to be hidden at the set up, it will be shown in this test. The code below shows what lines have to be added to the CProgram::CreateTradePanel() method.

//+------------------------------------------------------------------+
//| Creates a trading panel                                          |
//+------------------------------------------------------------------+
bool CProgram::CreateTradePanel(void)
  {
//--- Creating a form for controls
   if(!CreateWindow("EXPERT PANEL"))
      return(false);
//--- Creating controls:
//    Menu item
   if(!CreateMenuItem1("Menu item"))
      return(false);
   if(!CreateMI1ContextMenu1())
      return(false);
//--- Separation line
   if(!CreateSepLine())
      return(false);
//--- Show the context menu
   m_mi1_contextmenu1.Show();
//--- Redrawing of the chart
   m_chart.Redraw();
   return(true);
  }

Compile the files and load the program on to the chart. The result should be as in the screenshot below

Fig. 4. Test of the context menu element.

Fig. 4. Test of the context menu element.


At this stage, when the mouse cursor is hovering over the items of the context menu, they will not change their color. This functionality can be created in the CContextMenu class of the context menu or you can use a ready-made one in the CMenuItem class of the menu item. After the context menu has been attached to the chart, its pointer is added to the base. However, the pointers to each menu item stay unavailable for use in the CWndEvents class for event handling in the current implementation of adding pointers to the common array for elements. For each complex (compound) control, which consists of several elements, we will create in the CWndContainer class a method in which the pointers to these elements can be obtained. For that, we implemented the ItemPointerByIndex() method in the CContextMenu class, using which we can get the pointer to the menu item by specifying its index.

 


Further Development of the Class for Storing the Pointers to All Elements

Let us implement the AddContextMenuElements() method in the CWndContainer class for work with the context menu element. The form index and the element object are to be passed to it as parameters. At the beginning of the method, a check will be carried out if the passed element is a context menu. If it is, then a pointer to the context menu (CContextMenu) is required to get access to its methods. How can this be done if the object that is being passed belongs to the base class (CElement)? For that, it is sufficient to declare a pointer with the CContextMenu type and assign the pointer to the passed object to it. In the code below it is highlighted in yellow. This way, there is an access to the items of the context menu. Then, they are added in a loop to the common array of elements of their form. At the end of each iteration, menu items are passed to the CWndContainer::AddToObjectsArray() method for storing pointers to the objects constituting them in the object array of the CChartObject type.

//+------------------------------------------------------------------+
//| Class for storing all interface objects                          |
//+------------------------------------------------------------------+
class CWndContainer
  {
protected:
   //--- Stores pointers to the context menu elements in the base
   bool              AddContextMenuElements(const int window_index,CElement &object);
  };
//+------------------------------------------------------------------+
//| Stores pointers to the context menu elements in the base         |
//+------------------------------------------------------------------+
bool CWndContainer::AddContextMenuElements(const int window_index,CElement &object)
  {
//--- Leave, if this is not a context menu
   if(object.ClassName()!="CContextMenu")
      return(false);
//--- Get the context menu pointers
   CContextMenu *cm=::GetPointer(object);
//--- Store the pointers to its objects in the base
   int items_total=cm.ItemsTotal();
   for(int i=0; i<items_total; i++)
     {
      //--- Increasing the element array
      int size=::ArraySize(m_wnd[window_index].m_elements);
      ::ArrayResize(m_wnd[window_index].m_elements,size+1);
      //--- Getting the menu item pointers
      CMenuItem *mi=cm.ItemPointerByIndex(i);
      //--- Store the pointer in the array
      m_wnd[window_index].m_elements[size]=mi;
      //--- Add pointers to all the objects of a menu item to the common array
      AddToObjectsArray(window_index,mi);
     }
//---
   return(true);
  }

This will be called in the CWndContainer::AddToElementsArray() method straight after increasing the element counter. For the sake of saving space in the article, we show only a shortened version of the code. The full version can be found in the files attached to this article.

//+------------------------------------------------------------------+
//| Adds a pointer to the element array                              |
//+------------------------------------------------------------------+
void CWndContainer::AddToElementsArray(const int window_index,CElement &object)
  {
//--- If the base does not contain forms for controls
//--- If the request is for a non-existent form
//--- Add to the common array of elements
//--- Add element objects to the common array of objects
//--- Store the id of the last element in all forms
//--- Increase the counter of element identifiers

//--- Stores the pointers to the context menu objects in the base
   if(AddContextMenuElements(window_index,object))
      return;
  }

The code of the CWndContainer::AddToElementsArray() method will be enriched in the same way with other similar methods for complex (compound) elements.

If we compile all the files and load the program on to the chart, the items of the context menu will change their appearance when the mouse cursor is hovering over them.

Fig. 5. Test of the context menu items.

Fig. 5. Test of the context menu items.


Development of the class for creating a context menu is completed. The next step is to set up its event handler and the event handler of menu items. We will deal with this in the next article.

 


Conclusion

Our library already contains three classes for creating such elements as:

  • a menu item;
  • a separation line;
  • a context menu.

In the next article, we will set up event handlers of the library in the main class and in the classes of controls created earlier.

You can find and download archives with the library files at the current stage of development, icons and files of the programs (the EA, indicators and the script) considered in this article for testing in the Metatrader 4 and Metatrader 5 terminals. If you have questions on using the material presented in those files, you can refer to the detailed description of the library development in one of the articles from the list below or ask your question in the comments of this article. 

List of the articles (chapters) of the second part:

Translated from Russian by MetaQuotes Software Corp.
Original article: https://www.mql5.com/ru/articles/2202

Attached files |
Step on New Rails: Custom Indicators in MQL5 Step on New Rails: Custom Indicators in MQL5

I will not list all of the new possibilities and features of the new terminal and language. They are numerous, and some novelties are worth the discussion in a separate article. Also there is no code here, written with object-oriented programming, it is a too serous topic to be simply mentioned in a context as additional advantages for developers. In this article we will consider the indicators, their structure, drawing, types and their programming details, as compared to MQL4. I hope that this article will be useful both for beginners and experienced developers, maybe some of them will find something new.

Here Comes the New MetaTrader 5 and MQL5 Here Comes the New MetaTrader 5 and MQL5

This is just a brief review of MetaTrader 5. I can't describe all the system's new features for such a short time period - the testing started on 2009.09.09. This is a symbolical date, and I am sure it will be a lucky number. A few days have passed since I got the beta version of the MetaTrader 5 terminal and MQL5. I haven't managed to try all its features, but I am already impressed.

False trigger protection for Trading Robot False trigger protection for Trading Robot

Profitability of trading systems is defined not only by logic and precision of analyzing the financial instrument dynamics, but also by the quality of the performance algorithm of this logic. False trigger is typical for low quality performance of the main logic of a trading robot. Ways of solving the specified problem are considered in this article.

Using text files for storing input parameters of Expert Advisors, indicators and scripts Using text files for storing input parameters of Expert Advisors, indicators and scripts

The article describes the application of text files for storing dynamic objects, arrays and other variables used as properties of Expert Advisors, indicators and scripts. The files serve as a convenient addition to the functionality of standard tools offered by MQL languages.