Operations with Charts

In his or her practical work, a trader usually opens in a symbol window several subwindows that display indicators. There are no limitations on placing indicators, they can be attached in any sequence. The amount of subwindos in a symbol window is not limited either. Each subwindow has its number. The main window containing a price chart is always available, its number being 0. Each indicator subwindow has a number, as well. The subwindows are numbered in a simple sequence - they are numbered by their displaying in the symbol window from top to bottom: the indicator subwindow closest to the main window has number 1, the next lower one has number 2, the next one has number 3, etc.

Fig. 140. Subwindow locations in the symbol window.

The amount of subwindows can be easily calculated using the following function:

int WindowsTotal()

The function returns the amount of indicator subwindows located in the chart, including the main chart window. The largest number (of the lowest subwindow) is always 1 less than the total amount of subwindows (including the main window numbered as 0) in the symbol window. If, in the situation shown in Fig. 140, we call for execution the function WindowsTotal() from any application, the returned value will be equal to 3, while the largest number (of the lowest subwindow) is 2.

The numbering sequence described above is kept, if a new indicator subwindow is added to or an existing subwindow is deleted from the symbol window. If you add a new subwindow, it will be displayed below all other subwindows and its number is 1 more than that of the last window above it. If you delete a subwindow from the symbol window, all subwindows below it will be automatically renumbered - the number of each of them will be decreased by 1.

In MQL4, it is possible to create graphical objects (and change their properties) in any of the existing subwindows. For this purpose, in the function ObjectCreate() the parameter 'window' is provided, according to which an object is created in the given subwindow of the symbol window. The current number of the subwindow can be calculated using the following function:

int WindowFind(string name)

The function returns the number of the chart subwindow that contains the indicator named as 'name', if it has been found. Otherwise, it returns -1. The function will also return -1, if a custom indicator searches for itself during initialization init().

Parameters:

name - short name of the indicator.

The amount of subwindows in a symbol window can change at any moment, if the user deletes an indicator. This is why the algorithm of an application that supports monitoring of graphical objects must continuously track the numbers of windows, in which the indicators are displayed.

Problem 34. Using graphical objects, display the messages informing about data received from two indicators. If the corresponding indicator is attached to the symbol window, display the graphical object in the indicator window. Otherwise, display it in the main window.

To solve the problem, let's choose indicators RSI and Momentum. The general algorithm of building an Expert Advisor comes down to this. In the function init(), you can specify texts to be displayed on the screen according to the indicator readings, i.e., make the calculations to be executed only once in the program. In the function start(), you should calculate the indicator readings, detect the availability of necessary subwindows and their numbers, and then, according to the situation, display one or another message in one or another subwindow. At the execution of the function deinit(), it is necessary to delete all graphical objects created during the work of your program. Below is the EA named charts.mq4 that controls graphical objects in the subwindows of a symbol window.

//-----------------------------------------------------------------------------------
// charts.mq4
// The code should be used for educational purpose only.
//------------------------------------------------------------------------------ 1 --
int   Win_Mom_old=0,                          // Old number of subwindow Moment.
      Win_RSI_old=0;                          // Old number of subwindow RSI
color Color[5];                               // Declaration of the color array
string Text[5];                               // Declaration of the string array
//------------------------------------------------------------------------------ 2 --
int init()                                    // Special function init()
  {   
   Win_RSI_old=0;                             // Technical moment
   Win_Mom_old=0;                             // Technical moment
 
   Text[0]= "RSI(14) is below 30. Buy";       // Texts for situations RSI
   Text[1]= "RSI(14) is above 70. Sell";      // Texts for situations RSI
   Text[2]= "RSI(14) is between 30 and 70";   // Texts for situations RSI
   Text[3]= "Momentum(14) is growing";        // Texts for situations Momentum
   Text[4]= "Momentum(14) is sinking";        // Texts for situations Momentum
   Color[0]= DeepSkyBlue;                     // Object color for ..
   Color[1]= LightPink;                       // .. different situations ..
   Color[2]= Orange;                          // .. of the indicator RSI
   Color[3]= Color[0];                        // The same colors for Momentum
   Color[4]= Color[1];                        // The same colors for Momentum
 
   Create_RSI(0);                             // Creation of the first object
   Create_Mom(0);                             // Creation of the second object
   Main();                                    // Call to user-defined function
   return;                                    // Exit init()
  }
//------------------------------------------------------------------------------ 3 --
int start()                                   // Special function 'start'
  {
   Main();                                    // Call to the user-defined function
   return;                                    // Exit start()
  }
//------------------------------------------------------------------------------ 4 --
int deinit()                                  // Special function deinit()
  {
   ObjectDelete("Obj_RSI");                   // Deletion of the object
   ObjectDelete("Obj_Mom");                   // Deletion of the object
   return;                                    // Exit deinit()
  }
//------------------------------------------------------------------------------ 5 --
int Main()                                    // User-defined function
  {
   int                                        // Integer variables
   Win_RSI_new=0,                             // New number of the subwindow RSI
   Win_Mom_new=0,                             // New number of the subwindow Moment.
   Ind_RSI, Ind_Mom;                          // Indexes for situations
   double                                     // Real variables
   RSI,                                       // Value of RSI on bar 0
   Mom_0, Mom_1;                              // Value of Mom. on bars 0 and 1
//------------------------------------------------------------------------------ 6 --
   RSI=iRSI(NULL,0,14,PRICE_CLOSE,0);         // RSI(14) on zero bar
   Ind_RSI=2;                                 // RSI between levels 30 and 70
   if(RSI < 30)Ind_RSI=0;                     // RSI at the bottom. To buy
   if(RSI > 70)Ind_RSI=1;                     // RSI on the top. To sell     
//------------------------------------------------------------------------------ 7 --
   Win_RSI_new=WindowFind("RSI(14)");         // Window number of indicator RSI
   if(Win_RSI_new==-1) Win_RSI_new=0;         // If there is no ind., then the main window
   if(Win_RSI_new!=Win_RSI_old)               // Deleted or placed ..
     {                                        // .. window of indicator RSI
      ObjectDelete("Obj_RSI");                // Deletion of the object
      Create_RSI(Win_RSI_new);                // Create an object in the desired window
      Win_RSI_old=Win_RSI_new;                // Remember this window
     }                                        // Change the textual description:
   ObjectSetText("Obj_RSI",Text[Ind_RSI],10,"Arial",Color[Ind_RSI]);
//------------------------------------------------------------------------------ 8 --
   Mom_0=iMomentum(NULL,0,14,PRICE_CLOSE,0);  // Value on zero bar
   Mom_1=iMomentum(NULL,0,14,PRICE_CLOSE,1);  // Value on the preceding bar 
   if(Mom_0 >=Mom_1)Ind_Mom=3;                // Indicator line goes up
   if(Mom_0 < Mom_1)Ind_Mom=4;                // Indicator line goes down
//------------------------------------------------------------------------------ 9 --
   Win_Mom_new=WindowFind("Momentum(14)");    // Window number of indicator Momen
   if(Win_Mom_new==-1) Win_Mom_new=0;         // If there is no ind., then the main window
   if(Win_Mom_new!=Win_Mom_old)               // Deleted or placed ..
     {                                        // .. the window of Momentum indicator
      ObjectDelete("Obj_Mom");                // Deletion of the object
      Create_Mom(Win_Mom_new);                // Create an object in the desired window
      Win_Mom_old=Win_Mom_new;                // Remember this window
     }                                        // Change the textual description:
   ObjectSetText("Obj_Mom",Text[Ind_Mom],10,"Arial",Color[Ind_Mom]);
//----------------------------------------------------------------------------- 10 --
   WindowRedraw();                            // Redrawing the image 
   return;                                    // Exit the user-defined function
  }
//----------------------------------------------------------------------------- 11 --
int Create_RSI(int Win)                       // User-defined function
  {                                           // ..of creation of an object
   ObjectCreate("Obj_RSI",OBJ_LABEL, Win, 0,0); // Creation of an object
   ObjectSet("Obj_RSI", OBJPROP_CORNER, 0);     // Anchoring to an angle
   ObjectSet("Obj_RSI", OBJPROP_XDISTANCE, 3);  // Coordinate X
   if (Win==0)
      ObjectSet("Obj_RSI",OBJPROP_YDISTANCE,20);// Coordinate Y
   else
      ObjectSet("Obj_RSI",OBJPROP_YDISTANCE,15);// Coordinate Y
   return;                                      // Exit the user-defined function
  }
//----------------------------------------------------------------------------- 12 --
int Create_Mom(int Win)                         // User-defined function
  {                                             // ..creating an object
   ObjectCreate("Obj_Mom",OBJ_LABEL, Win, 0,0); // Creation of an object
   ObjectSet("Obj_Mom", OBJPROP_CORNER, 0);     // Anchoring to an angle
   ObjectSet("Obj_Mom", OBJPROP_XDISTANCE, 3);  // Coordinate X
   if (Win==0)
      ObjectSet("Obj_Mom",OBJPROP_YDISTANCE, 5);// Coordinate Y
   else
      ObjectSet("Obj_Mom",OBJPROP_YDISTANCE,15);// Coordinate Y
   return;                                      // Exit the user-defined function
  }
//----------------------------------------------------------------------------- 13 --

Prior to considering the code above, we should explain the specifics of the program operation. A graphical object once created (in this case, one displaying a text) is supposed to be present in the screen continuously. Its textual description is supposed to characterize the situation. The content of the textual description must be changed at the execution of the function start(), at every tick. At the same time, when switching between timeframes for the window, to which the EA is attached, the program goes through the following stages: deinit(), init(), (awaiting a tick), and start(). If the object is first time created during the execution of start(), then, every time when switching to another timeframe, a certain period of time will lapse before the object appears, the time period being equal to that of awaiting the next tick. This is very inconvenient, particularly, when timeframes are often switched between.

In a properly built program, the necessary messages are displayed on the screen at the moment of attaching the program to the symbol window or at the moment of timeframe switching (i.e., before a new tick incomes). For this purpose, as a rule, it is necessary to perform all actions to be performed at every tick at the launching of the special function start() at the stage of the execution of the special function init(). In order not to repeat the same program code in different special functions, the code can be organized as a separate function. For this purpose, the EA contains the user-defined function Main(). It is called to be executed once at the stage of initialization (block 2-3) and at every tick during the further work of the EA (block 3-4).

In the program (block 11-13), there are two more user-defined functions - Create_RSI() and Create_Mom() intended for creation and modification of the object properties. At the execution of the function init(), the necessary objects are created using these functions. The call to the function Main() results in giving necessary properties to the objects (the objects with the desired description of the desired color are displayed in the desired window).

Let's consider the function Main() (block 5-11) in more details. In block 6-7, the readings of the indicator RSI are calculated. Depending on whether the end of the indicator line is above 70, below 30, or within the range between these indexes, one or another value will be assigned to the variable Ind_RSI. Then this value is used as an index of arrays Color[] and Text[] (in block 7-8) to change the properties of the graphical object of the name "Obj_RSI".

Block 7-8. The number of RSI window is calculated in the line:

   Win_RSI_new = WindowFind("RSI(14)");// Window number of indicator RSI

The string value RSI(14) is used as the transferred parameter. This is the short name of the indicator, the number of which should be detected. In this case, the entire sequence of characters in the given line, including parentheses and digits, composes the name. It must be noted that, in general case, there can be several indicators of the same type in the symbol window, for example, RSI(14), RSI(21) and RSI(34). Each subwindow displaying these indicators has its own number. This is why technical indicators are developed in such a way that each of them forms its short name according to the preset values of adjustable parameters. The short name of each technical indicator coincides with that shown in the upper left corner of its subwindow (the short name of a custom indicator may be created by the programmer using the function IndicatorShortName()).

If the searched indicator is not placed in the symbol window, the variable Win_RSI_new (the number of the subwindow, in which this object must be displayed at the current moment) will take the value of -1, i.e., non-existing window. In this case, the program implies displaying of the graphical object in the main chart window, the number of which is always 0:

   if(Win_RSI_new == -1) Win_RSI_new=0;// If there is no ind., then the main window

During his or her operations, the user may place a missing indicator or delete an existing one. In order to find out about what actions should be performed, the program uses global variables Win_RSI_old and Win_Mom_old. The value of each variable is the number of the subwindow, in which the object has previously been created. If the values of the variables Win_RSI_new and Win_RSI_old don't coincide, this means that the indicator window is either added (it didn't exist before) or deleted (it was available on the previous tick). In both cases, the previously created object must be deleted, and a new one must be created in the desired window:

      ObjectDelete("Obj_RSI");         // Deletion of the object
      Create_RSI(Win_RSI_new);         // Create an object in the desired window

After the object has been created in the window numbered as Win_RSI_new, the value equal to the number of this window is assigned to the variable Win_RSI_old, i.e., the program remembers the number of window, in which the graphical object was created:

      Win_RSI_old = Win_RSI_new;       // Remember this window

If the values of the variables Win_RSI_new and Win_RSI_old coincide, it means that it is sufficient to assign a textual description to the object (that is now placed in the necessary window). It must also be done, in case of creating a new object:

      ObjectSetText("Obj_RSI",Text[Ind_RSI],10,"Arial",Color[Ind_RSI]);

Similar calculations are made for the other subwindow, that of indicator Momentum (blocks 8 - 10). At the end of the function Main(), all available graphical objects are redrawn as a result of the execution of WindowRedraw().

It's easy to see that programmed control over graphical objects in subwindows implies using global variables (you can also use 'static'). In such cases, when coding a program, you should pay a special attention to what values can be taken by global variables in different situations and what this can result in. In the program considered above, global variables are zeroized in the function init():

   Win_RSI_old = 0;                    // Technical moment
   Win_Mom_old = 0;                    // Technical moment

These lines are included into the program due to the fact that global variables lose their values, only if the user has stopped the execution of the application program in the symbol window. However, if the user has adjusted external variables or switched the timeframe, the program undergoes deinitialization and the consequent initialization, the values of global variables being saved.

Let's consider the operations of the program that doesn't contain these lines. Suppose, both indicators with the subwindow numbers 1 and 2, respectively, have been placed in the symbol window by the moment when the user switches the timeframe. In the considered example, when deinitializing the program, the graphical objects are deleted. At the execution of the special function init(), the objects are created in zero window. Then, at the execution of the function Main(), in blocks 7-8 and 9-10, the program compares the obtained number of the window, in which the objects must be placed, and the number of the window, in which the objects were at the preceding tick. In fact, the object has already been placed in zero window, but the values of global variables will say for other result: their numbers will be 1 and 2. As a result, the graphical objects will remain in the main window, until the user deletes and reattaches the corresponding indicators. As to prevent these undesirable developments, the program implies nulling of global variables at the execution of the function init(). Thus, the values of these variables are made correspond with the situation.

As a result of the execution of EA charts.mq4, the following combinations of windows and graphical objects displayed can appear:

Fig. 141. Displaying graphical objects in the subwindows of a symbol window.

If there are both indicators in the symbol window, the corresponding graphical objects will be shown in their subwindows. If no one of these indicators is placed, then both objects will be created by the program in the main window. Adding or deletion of either indicator, the name of which is processed in the program, will result in moving of the corresponding graphical object into the necessary window. Adding or deletion of other indicators from the symbol window will not entail any consequences.

It must be noted separately that the alternative of deleting a graphical object by the user is not considered in this program. A program used in your practical trading must contain the analysis of such situation with the subsequent restoring of the object (see the solution of Problem 33).

Functions Used in Operations with Charts

For the detailed description of these and other functions, please refer to Documentation at MQL4.community, MetaQuotes Ltd. website or to "Help" section in MetaEditor.