Descargar MetaTrader 5

Guía práctica de MQL5: Controles de la subventana del indicador: Barra de desplazamiento

7 mayo 2014, 14:34
Anatoli Kazharski
0
476

Introducción

Vamos a continuar explorando los diversos controles y esta vez nos centraremos en la barra de desplazamiento. Al igual que en el artículo anterior "Guía práctica de MQL5: Controles de la subventana del indicador: Botones", trabajaremos en la subventana del indicador. Tome un momento para leer el artículo mencionado anteriormente, ya que proporciona una descripción detallada de la utilización de eventos en la función OnChartEvent(), asimismo, se verá este punto muy por encima en este artículo. Con fines ilustrativos, esta vez vamos a crear una barra de desplazamiento vertical para una larga lista de todas las propiedades de los instrumentos financieros que se puedan obtener mediante los recursos de MQL5.

En los artículos anteriores sobre programación MQL5 hemos utilizado el objeto gráfico OBJ_LABEL (etiqueta de texto) para crear las listas. En este artículo, vamos a utilizar un "canvas" o un lienzo para mostrar el texto. La conveniencia de este enfoque reside en que en lugar de un gran número de objetos OBJ_LABEL, solo se utilizará uno; OBJ_BITMAP_LABEL (etiqueta Bitmap). Puede dibujar todos los elementos de la interfaz en un lienzo, pero esta vez nos limitaremos al texto solo.

La barra de desplazamiento será muy simple. Por lo general, tiene botones en forma de flechas, pero no va a ser así en nuestro caso. La barra de desplazamiento solo estará compuesta del fondo y del cuadro de desplazamiento. El cuadro de desplazamiento cambiará de color al pasar el cursor por encima de él. También cambiará de color al hacer clic sobre él, sugiriendo al usuario que el cuadro de desplazamiento está activado y se puede arrastrar. Para la creación de los objetos de desplazamiento, usaremos los objetos gráficos del tipo OBJ_RECTANGLE_LABEL (etiqueta rectangular).

 

El desarrollo del indicador

Comencemos con la programación. Cree una plantilla del indicador, del mismo modo que se hizo en el artículo anterior. Como siempre, hay que declarar las variables y las matrices al principio. Para poder trabajar con el lienzo, incluimos la clase CCanvas de la librería estándar.

#define LIST_SIZE 71                // Number of strings in the list of financial instrument properties
//--- Include the class for working with the canvas
#include <Canvas\Canvas.mqh>
CCanvas canvas;
//+------------------------------------------------------------------+
//|   Global variables                                               |
//+------------------------------------------------------------------+
//--- Indicator subwindow properties
int               subwindow_number              =WRONG_VALUE;                    // Subwindow number
int               subwindow_height              =0;                              // Subwindow height
string            subwindow_shortname           ="TestScrollbar";                // Short name of the indicator
string            prefix                        =subwindow_shortname+"_";        // Prefix for objects
int               chart_width                   =0;                              // Chart width
int               chart_height                  =0;                              // Chart height
int               chart_y_offset                =0;                              // Distance from the chart top to the subwindow
//--- Canvas properties
string            canvas_name                   =prefix+"canvas";                // Canvas name
color             canvas_background_color       =C'20,20,20';                    // Canvas background color
ENUM_COLOR_FORMAT color_format                  =COLOR_FORMAT_XRGB_NOALPHA;      // Alpha channel component is ignored
//--- List properties
int               list_height                   =0;                              // List height
int               text_height                   =0;                              // Text height
int               font_size                     =15;                             // Font size
string            font_name                     ="Calibri";                      // Font
double            line_size                     =100/LIST_SIZE;                  // Size of a single string on the list, expressed as percentage
//--- Scrollbar properties: scroll box
string            scrollbar_thumb_name          =prefix+"scrollbar_thumb";       // Scroll box object name
int               scrollbar_thumb_x1            =0;                              // x1 coordinate
int               scrollbar_thumb_y1            =0;                              // y1 coordinate
int               scrollbar_thumb_x2            =0;                              // x2 coordinate
int               scrollbar_thumb_y2            =0;                              // y2 coordinate
double            scrollbar_thumb_y_percent     =0.0;                            // Y-coordinate expressed as percentage
int               scrollbar_thumb_width         =9;                              // Width
int               scrollbar_thumb_height        =0;                              // Height
bool              scrollbar_thumb_clicked       =false;                          // State (whether or not the scroll box is clicked)
color             scrollbar_thumb_color         =clrSilver;                      // Scroll box color
color             scrollbar_thumb_color_on_hover=clrDimGray;                     // Scroll box color when the cursor hovers over it
color             scrollbar_thumb_color_on_click=clrSlateGray;                   // Scroll box color when clicked
//--- Scrollbar properties: background
string            scrollbar_background_name     =prefix+"scrollbar_background";  // Background object name
int               scrollbar_background_width    =9;                              // Background width
color             scrollbar_background_color    =C'50,50,50';                    // Background color
//--- Scrollbar properties: other
int               scrollbar_fix_point           =0;                              // Y-coordinate of the fix point upon clicking
int               scrollbar_fix_point_y_offest  =0;                              // Distance along the Y-axis from the scrollbar top to the fix point
//--- Mouse button state (pressed/released)
bool              mouse_button_state=false;
//--- Arrays for financial instrument properties
color             symbol_property_colors[];                                      // Colors of values
string            symbol_property_values[];                                      // Values
//--- Financial instrument property names
string symbol_propety_names[LIST_SIZE]=
  {
   "Number of deals in the current session",
   "Total number of Buy orders at the moment",
   "Total number of Sell orders at the moment",
   "Volume of the last deal",
   "Maximum daily volume",
   "Minimum daily volume",
   "Time of the last quote",
   "Number of decimal places",
   "Spread in points",
   "Floating spread indication",
   "Maximum number of requests displayed in the Depth of Market",
   "Contract price calculation mode",
   "Order execution type",
   "Trading start date for an instrument (usually used for futures)",
   "Trading end date for an instrument (usually used for futures)",
   "Minimum distance in points from the current closing price for the purpose of setting Stop orders",
   "Freeze distance for trading operations (in points)",
   "Deal execution mode",
   "Swap calculation model",
   "Day of the week when triple swap is charged",
   "Flags of allowed order expiration modes",
   "Flags of allowed order filling modes",
//---
   "Bid - best price at which an instrument can be sold",
   "Maximum Bid of the day",
   "Minimum Bid of the day",
   "Ask - best price at which an instrument can be bought",
   "Maximum Ask of the day",
   "Minimum Ask of the day",
   "Last - last deal price",
   "Maximum Last of the day",
   "Minimum Last of the day",
   "Point value",
   "Calculated tick value for a winning position",
   "Calculated tick value for a losing position",
   "Minimum price change",
   "Trade contract size",
   "Minimum volume for deal execution",
   "Maximum volume for deal execution",
   "Minimum step of volume change for deal execution",
   "Maximum allowable total volume of an open position and pending orders in the same direction",
   "Long swap value",
   "Short swap value",
   "Initial margin - amount in the margin currency required for opening a position (1 lot)",
   "Maintenance margin for an instrument",
   "Margin requirement applicable to long positions",
   "Margin requirement applicable to short positions",
   "Margin requirement applicable to Limit orders",
   "Margin requirement applicable to Stop orders",
   "Margin requirement applicable to Stop Limit orders",
   "Total volume of deals in the current session",
   "Total turnover in the current session",
   "Total volume of open positions",
   "Total volume of buy orders at the moment",
   "Total volume of sell orders at the moment",
   "Open price of the session",
   "Close price of the session",
   "Average weighted price of the session",
   "Settlement price of the current session",
   "Minimum allowable price value for the session",
   "Maximum allowable price value for the session",
//---
   "Base currency of an instrument",
   "Profit currency",
   "Margin currency",
   "Current quote source",
   "String description of a symbol",
   "Name of a trading symbol in the international system of securities identification numbers (ISIN)",
   "Location in the symbol tree",
//---
   "Current number of bars for a symbol on a selected time frame",
   "The very first date for a symbol on a selected time frame",
   "The very first date in the history for a symbol on a selected time frame",
   "Symbol data synchronized"
  };

En primer lugar, vamos a escribir todas las funciones necesarias para la visualización de la lista de propiedades en el lienzo. Justo después de esto, procederemos a la creación de la barra de desplazamiento.

Para crear el lienzo, escribimos la función AddCanvas() y usamos la segunda variante del método CreateBitmapLabel() de la clase CCanvas:

//+------------------------------------------------------------------+
//| Adding canvas                                                    |
//+------------------------------------------------------------------+
void AddCanvas()
  {
//--- If there is no canvas, add it
   if(ObjectFind(0,canvas_name)<0)
      canvas.CreateBitmapLabel(0,subwindow_number,canvas_name,0,0,chart_width,subwindow_height,color_format);
  }

Necesitaremos también un método para cambiar el tamaño del lienzo con el fin de ajustarlo al tamaño de la subventana del indicador. Para ello, vamos a escribir la función ResizeCanvas() que utiliza el método Resize() en la clase CCanvas:

//+------------------------------------------------------------------+
//| Resizing canvas                                                  |
//+------------------------------------------------------------------+
void ResizeCanvas()
  {
//--- If the canvas has already been added to the indicator subwindow, set the new size
   if(ObjectFind(0,canvas_name)==subwindow_number)
      canvas.Resize(chart_width,subwindow_height);
//--- If there is no canvas, add it
   else
      canvas.CreateBitmapLabel(0,subwindow_number,canvas_name,0,0,chart_width,subwindow_height,color_format);
  }

Para eliminar el lienzo, usamos el método Destroy():

//+------------------------------------------------------------------+
//| Deleting canvas                                                  |
//+------------------------------------------------------------------+
void DeleteCanvas()
  {
   if(ObjectFind(0,canvas_name)>0)
      canvas.Destroy();
  }

En este artículo, también vamos a utilizar otros métodos de la clase CCanvas, como FontSet() para establecer las fuentes, TextHeight() para determinar la altura del texto, TextOut() para representar el texto en el lienzo, Erase() para limpiar el lienzo y Update() para volver a dibujar. Más adelante, veremos en qué parte del programa se usan estos métodos.

Durante la inicialización en la función OnInit(), tenemos que preparar el terreno para el funcionamiento del programa. En el siguiente código se muestra lo que hay que hacer. Los comentarios proporcionados en cada cadena le ayudarán a comprender mejor el funcionamiento. Se utilizan los métodos FontSet() y TextHeight() de la clase CCanvas solamente en esta parte del programa.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Enable tracking of mouse events
   ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,true);
//--- Set the short name
   IndicatorSetString(INDICATOR_SHORTNAME,subwindow_shortname);
//--- Set sizes of arrays of symbol properties and their colors
   ArrayResize(symbol_property_colors,LIST_SIZE);
   ArrayResize(symbol_property_values,LIST_SIZE);
//--- Set subwindow properties
   SetSubwindowProperties();
//--- Set the font for displaying on the canvas
   canvas.FontSet(font_name,font_size,FW_NORMAL);
//--- Save the text size (height) for calculations
   text_height=canvas.TextHeight("A")-1;
//--- Calculate the height of the entire list
   list_height=text_height*LIST_SIZE;
//--- Add the canvas to the chart
   AddCanvas();
//--- Display the list of symbol properties
   ShowSymbolInfo();
//--- Refresh the chart
   ChartRedraw();
//--- Everything completed successfully
   return(INIT_SUCCEEDED);
  }

Se ha tomado la función SetSubwindowProperties() del artículo anterior tal cual: asigna el número de la subventana del indicador y su tamaño a las variables globales. Pasemos directamente a la función ShowSymbolInfo():

//+------------------------------------------------------------------+
//| Displaying current symbol information                            |
//+------------------------------------------------------------------+
void ShowSymbolInfo(double current_thumb_position=0.0)
  {
   int    list_lines       =0;   // Counter of strings displayed in the canvas
   double thumb_position   =0.0; // Position of the scroll box expressed as percentage for determining the first displayed string
   int    y_distance       =0;   // For determining the coordinate of the next string in the list
   int    line_number      =0;   // Number of the string starting from which the list will be displayed
//--- Determine the string starting from which the list will be displayed
   for(int i=0; i<LIST_SIZE; i++)
     {
      //--- Count strings until you reach the one starting from which the list will be displayed
      if(thumb_position>=current_thumb_position)
         break;
      //---
      thumb_position+=line_size;
      line_number++;
     }
//--- Initialize list arrays from the specified string
   InitializePropertyArrays(line_number);
//--- Clear the canvas
   canvas.Erase(canvas_background_color);
//--- Show the list on the canvas
   for(int i=line_number; i<LIST_SIZE; i++)
     {
      //--- Property name
      canvas.TextOut(655,y_distance,symbol_propety_names[i]+" :",ColorToARGB(clrWhite),TA_RIGHT|TA_TOP);
      //--- Property value
      canvas.TextOut(665,y_distance,symbol_property_values[i],ColorToARGB(symbol_property_colors[i]),TA_LEFT|TA_TOP);
      //--- Calculate the coordinate for the next string
      y_distance+=text_height;
      //--- Count the number of displayed strings
      list_lines++;
      //--- If you go beyond the subwindow boundaries, terminate the loop
      if(list_lines*text_height>subwindow_height)
         break;
     }
//--- Refresh the canvas
   canvas.Update();
  }

La función ShowSymbolInfo() tiene un parámetro, current_thumb_position, que por defecto es igual a cero (en caso de que tenga que usar el valor por defecto, no hace falta enviar el valor a la función). Este parámetro determina el inicio de la cadena a partir de la cual hay que mostrar la lista. El valor cero significa que hay que mostrar la lista desde el principio.

Al principio, determinamos el número de la cadena a partir de la cual se debe mostrar la lista. Después, se inicializan las matrices de valores y colores (cadena resaltada del código anterior) en la función InitializePropertyArrays(). Se lleva a cabo la inicialización a partir de la cadena determinada en el bucle anterior. Después de borrar el lienzo mediante el método Erase(); en la práctica, todo el lienzo se llena con el color especificado. En el último bucle, se representa el texto en el lienzo con el método TextOut(). Al final, se actualiza el lienzo mediante el método Update().

A continuación, se proporciona el código de la función CreateSymbolBalanceReport():

//+-----------------------------------------------------------------------+
//| Initializing arrays of values and their colors for the current symbol |
//+-----------------------------------------------------------------------+
void InitializePropertyArrays(int line_number)
  {
   int lines_count=0;
//---
   for(int i=line_number; i<LIST_SIZE; i++)
     {
      //--- Determine the value and color of the symbol property
      symbol_property_values[i]=GetStringSymbolInfoByIndex(i);
      symbol_property_colors[i]=GetColorSymbolInfoByIndex(i);
      //--- Increase the counter
      lines_count++;
      //--- If the number of strings exceeds the subwindow height, exit
      if(lines_count*text_height>subwindow_height)
         break;
     }
  }

El código anterior sugiere que los valores de las propiedades del símbolo y sus colores se determinan mediante dos funciones que operan siguiendo unos principios similares, GetStringSymbolInfoByIndex() y GetColorSymbolInfoByIndex().

La función GetStringSymbolInfoByIndex() es sencilla, pero muy voluminosa debido al gran número de propiedades. Además, con el fin de obtener algunas propiedades, necesitamos funciones adicionales (cadenas resaltadas del siguiente código).

//+------------------------------------------------------------------+
//| Returning the string value of the symbol property by index       |
//+------------------------------------------------------------------+
string GetStringSymbolInfoByIndex(int index)
  {
   string str           ="-";
   long   l_check_value =0;
   double d_check_value =0.0;
   string s_check_value ="";
//---
   switch(index)
     {
      case 0  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_SESSION_DEALS);
         str=(l_check_value==0) ? "-" : IntegerToString(l_check_value);                                  break;
      case 1  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_SESSION_BUY_ORDERS);
         str=(l_check_value==0) ? "-" : IntegerToString(l_check_value);                                  break;
      case 2  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_SESSION_SELL_ORDERS);
         str=(l_check_value==0) ? "-" : IntegerToString(l_check_value);                                  break;
      case 3  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_VOLUME);
         str=(l_check_value==0) ? "-" : IntegerToString(l_check_value);                                  break;
      case 4  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_VOLUMEHIGH);
         str=(l_check_value==0) ? "-" : IntegerToString(l_check_value);                                  break;
      case 5  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_VOLUMELOW);
         str=(l_check_value==0) ? "-" : IntegerToString(l_check_value);                                  break;
      case 6  :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_TIME);
         str=(l_check_value==0) ? "-" : TimeToString(l_check_value);                                     break;
      case 7  : str=IntegerToString(SymbolInfoInteger(_Symbol,SYMBOL_DIGITS));                           break;
      case 8  : str=IntegerToString(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD));                           break;
      case 9  : str=(!SymbolInfoInteger(_Symbol,SYMBOL_SPREAD_FLOAT)) ? "false" : "true";                break;
      case 10 :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_TICKS_BOOKDEPTH);
         str=(l_check_value==0) ? "-" : DoubleToString(l_check_value,_Digits);                           break;
      case 11 : str=TradeCalcModeToString(SymbolInfoInteger(_Symbol,SYMBOL_TRADE_CALC_MODE));            break;
      case 12 : str=TradeModeToString(SymbolInfoInteger(_Symbol,SYMBOL_TRADE_MODE));                     break;
      case 13 :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_START_TIME);
         str=(l_check_value==0) ? "-" : TimeToString(l_check_value);                                     break;
      case 14 :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_EXPIRATION_TIME);
         str=(l_check_value==0) ? "-" : TimeToString(l_check_value);                                     break;
      case 15 :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
         str=(l_check_value==0) ? "false" : IntegerToString(l_check_value);                              break;
      case 16 :
         l_check_value=SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL);
         str=(l_check_value==0) ? "false" : IntegerToString(l_check_value);                              break;
      case 17 : str=TradeExeModeToString(SymbolInfoInteger(_Symbol,SYMBOL_TRADE_EXEMODE));               break;
      case 18 : str=SwapModeToString(SymbolInfoInteger(_Symbol,SYMBOL_SWAP_MODE));                       break;
      case 19 : str=WeekdayToString(SymbolInfoInteger(_Symbol,SYMBOL_SWAP_ROLLOVER3DAYS));               break;
      case 20 : str=ExpirationModeToString();                                                            break;
      case 21 : str=FillingModeToString();                                                               break;
      //---
      case 22 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_BID);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 23 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_BIDHIGH);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 24 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_BIDLOW);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 25 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 26 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_ASKHIGH);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 27 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_ASKLOW);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 28 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_LAST);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 29 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_LASTHIGH);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 30 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_LASTLOW);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,_Digits);                           break;
      case 31 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_POINT),_Digits);                      break;
      case 32 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE_PROFIT),2);          break;
      case 33 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE_LOSS),2);            break;
      case 34 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_SIZE),_Digits);            break;
      case 35 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_TRADE_CONTRACT_SIZE),2);              break;
      case 36 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN),2);                       break;
      case 37 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX),2);                       break;
      case 38 : str=DoubleToString(SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP),2);                      break;
      case 39 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_LIMIT);
         str=(d_check_value==0) ? "Unlimited" : DoubleToString(d_check_value,2);                         break;
      case 40 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SWAP_LONG);
         str=(d_check_value==0) ? "false" : DoubleToString(d_check_value,2);                             break;
      case 41 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SWAP_SHORT);
         str=(d_check_value==0) ? "false" : DoubleToString(d_check_value,2);                             break;
      case 42 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_INITIAL);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 43 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_MAINTENANCE);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 44 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_LONG);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 45 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_SHORT);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 46 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_LIMIT);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 47 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_STOP);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 48 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_MARGIN_STOPLIMIT);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 49 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_VOLUME);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 50 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_TURNOVER);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 51 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_INTEREST);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 52 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_BUY_ORDERS_VOLUME);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 53 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_SELL_ORDERS_VOLUME);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 54 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_OPEN);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 55 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_CLOSE);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 56 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_AW);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 57 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_PRICE_SETTLEMENT);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 58 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_PRICE_LIMIT_MIN);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
      case 59 :
         d_check_value=SymbolInfoDouble(_Symbol,SYMBOL_SESSION_PRICE_LIMIT_MAX);
         str=(d_check_value==0) ? "-" : DoubleToString(d_check_value,2);                                 break;
         //---
      case 60 : str=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_BASE);                                      break;
      case 61 : str=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT);                                    break;
      case 62 : str=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_MARGIN);                                    break;
      case 63 :
         s_check_value=SymbolInfoString(_Symbol,SYMBOL_BANK);
         str=(s_check_value!="") ? s_check_value : "-";                                                  break;
      case 64 : str=SymbolInfoString(_Symbol,SYMBOL_DESCRIPTION);                                        break;
      case 65 :
         s_check_value=SymbolInfoString(_Symbol,SYMBOL_ISIN);
         str=(s_check_value!="") ? s_check_value : "-";                                                  break;
      case 66 : str=SymbolInfoString(_Symbol,SYMBOL_PATH);                                               break;
      //---
      case 67 : str=IntegerToString(SeriesInfoInteger(_Symbol,_Period,SERIES_BARS_COUNT));               break;
      case 68 : str=TimeToString((datetime)SeriesInfoInteger(_Symbol,_Period,SERIES_FIRSTDATE));         break;
      case 69 : str=TimeToString((datetime)SeriesInfoInteger(_Symbol,_Period,SERIES_SERVER_FIRSTDATE));  break;
      case 70 : str=(!(bool)SeriesInfoInteger(_Symbol,_Period,SERIES_SYNCHRONIZED)) ? "false" : "true";  break;
     }
//---
   return(str);
  }

Las funciones resaltadas del código anterior: TradeCalcModeToString(), TradeModeToString(), TradeExeModeToString(), SwapModeToString() y WeekdayToString(), simplemente devuelven la representación de la cadena de propiedades en función del valor enviado.

//+------------------------------------------------------------------+
//| Returning string representation of the margin calculation        |
//| method for an instrument                                         |
//+------------------------------------------------------------------+
string TradeCalcModeToString(long mode)
  {
   string str="?";
//---
   switch((ENUM_SYMBOL_CALC_MODE)mode)
     {
      case SYMBOL_CALC_MODE_FOREX               :
         str="Forex mode";          break;
      case SYMBOL_CALC_MODE_FUTURES             :
         str="Futures mode";        break;
      case SYMBOL_CALC_MODE_CFD                 :
         str="CFD mode";            break;
      case SYMBOL_CALC_MODE_CFDINDEX            :
         str="CFD index mode";      break;
      case SYMBOL_CALC_MODE_CFDLEVERAGE         :
         str="CFD Leverage mode";   break;
      case SYMBOL_CALC_MODE_EXCH_STOCKS         :
         str="Exchange mode";       break;
      case SYMBOL_CALC_MODE_EXCH_FUTURES        :
         str="Futures mode";        break;
      case SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS  :
         str="FORTS Futures mode";  break;
     }
//---
   return(str);
  }
//+------------------------------------------------------------------+
//| Returning string representation of the trade mode                |
//+------------------------------------------------------------------+
string TradeModeToString(long mode)
  {
   string str="-";
//---
   switch((ENUM_SYMBOL_TRADE_MODE)mode)
     {
      case SYMBOL_TRADE_MODE_DISABLED  :
         str="Trade is disabled for a given symbol";               break;
      case SYMBOL_TRADE_MODE_LONGONLY  :
         str="Only long positions are allowed";                    break;
      case SYMBOL_TRADE_MODE_SHORTONLY :
         str="Only short positions are allowed";                   break;
      case SYMBOL_TRADE_MODE_CLOSEONLY :
         str="Only position closing operations are allowed";       break;
      case SYMBOL_TRADE_MODE_FULL      :
         str="No trade restrictions";                              break;
     }
//---
   return(str);
  }
//+------------------------------------------------------------------+
//| Returning string representation of the deal execution mode       |
//+------------------------------------------------------------------+
string TradeExeModeToString(long mode)
  {
   string str="-";
//---
   switch((ENUM_SYMBOL_TRADE_EXECUTION)mode)
     {
      case SYMBOL_TRADE_EXECUTION_REQUEST  :
         str="Request execution";         break;
      case SYMBOL_TRADE_EXECUTION_INSTANT  :
         str="Instant execution";         break;
      case SYMBOL_TRADE_EXECUTION_MARKET   :
         str="Market execution";          break;
      case SYMBOL_TRADE_EXECUTION_EXCHANGE :
         str="Exchange execution";        break;
     }
//---
   return(str);
  }
//+------------------------------------------------------------------+
//| Returning string representation of the swap calculation model    |
//+------------------------------------------------------------------+
string SwapModeToString(long mode)
  {
   string str="-";
//---
   switch((ENUM_SYMBOL_SWAP_MODE)mode)
     {
      case SYMBOL_SWAP_MODE_DISABLED         :
         str="No swaps";                                                             break;
      case SYMBOL_SWAP_MODE_POINTS           :
         str="Swaps calculated in points";                                           break;
      case SYMBOL_SWAP_MODE_CURRENCY_SYMBOL  :
         str="Swaps calculated in base currency of the symbol";                      break;
      case SYMBOL_SWAP_MODE_CURRENCY_MARGIN  :
         str="Swaps calculated in margin currency of the symbol";                    break;
      case SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT :
         str="Swaps calculated in the client's deposit currency";                    break;
      case SYMBOL_SWAP_MODE_INTEREST_CURRENT :
         str="Swaps expressed as a percent per annum of the instrument price";       break;
      case SYMBOL_SWAP_MODE_INTEREST_OPEN    :
         str="Swaps expressed as a percent per annum of the position opening price"; break;
      case SYMBOL_SWAP_MODE_REOPEN_CURRENT   :
         str="Swaps based on position reopening (close price +/-)";                  break;
      case SYMBOL_SWAP_MODE_REOPEN_BID       :
         str="Swaps based on position reopening (bid price +/-)";                    break;
     }
//---
   return(str);
  }
//+------------------------------------------------------------------+
//| Returning string representation of the day of the week           |
//+------------------------------------------------------------------+
string WeekdayToString(long day)
  {
   string str="-";
//---
   switch((ENUM_DAY_OF_WEEK)day)
     {
      case SUNDAY    :
         str="Sunday";            break;
      case MONDAY    :
         str="Monday";            break;
      case TUESDAY   :
         str="Tuesday";           break;
      case WEDNESDAY :
         str="Wednesday";         break;
      case THURSDAY  :
         str="Thursday";          break;
      case FRIDAY    :
         str="Friday";            break;
      case SATURDAY  :
         str="Saturday";          break;
     }
//---
   return(str);
  }

En las funciones GetStringExpirationMode() y GetStringFillingMode(), se genera la representación de la cadena en función del vencimiento de la orden y los modos de rellenado de volumen disponibles para el símbolo actual.

//+------------------------------------------------------------------+
//| Returning string representation of the order expiration modes    |
//+------------------------------------------------------------------+
string ExpirationModeToString()
  {
   string str="";    // For string generation
//--- Variables for checking the modes
   bool   gtc           =false; // The order is valid for an unlimited time until explicitly canceled
   bool   day           =false; // The order is valid until the end of the day
   bool   specified     =false; // The expiration time is specified in the order
   bool   specified_day =false; // The expiration date is specified in the order
//--- Check the modes
   gtc           =IsExpirationTypeAllowed(_Symbol,SYMBOL_EXPIRATION_GTC);
   day           =IsExpirationTypeAllowed(_Symbol,SYMBOL_EXPIRATION_DAY);
   specified     =IsExpirationTypeAllowed(_Symbol,SYMBOL_EXPIRATION_SPECIFIED);
   specified_day =IsExpirationTypeAllowed(_Symbol,SYMBOL_EXPIRATION_SPECIFIED_DAY);
//--- Generate a string of the modes available
   if(gtc)
     {
      StringAdd(str,"GTC");
      if(day || specified || specified_day)
         StringAdd(str," / ");
     }
//---
   if(day)
     {
      StringAdd(str,"Day");
      if(specified || specified_day)
         StringAdd(str," / ");
     }
//---
   if(specified)
     {
      StringAdd(str,"Specified");
      if(specified_day)
         StringAdd(str," / ");
     }
//---
   if(specified_day)
      StringAdd(str,"Specified Day");
//---
   return(str);
  }
//+------------------------------------------------------------------+
//| Returning string representation of the volume filling modes      |
//+------------------------------------------------------------------+
string FillingModeToString()
  {
//--- Variable for string generation
   string str="";

//--- Variables for checking the modes:

//    "Fill or Kill"   -  if the required order volume cannot be filled at the specified price,
//                      the order is canceled and the deal is not executed
   bool   fok=false;

//    "Immediate or Cancel" -  if the deal volume can only be partially filled at the price specified in the order, 
//                      the deal is executed to the extent of the volume available. The remaining volume of the order is canceled 
//                      and the new order is not placed
   bool   ioc=false;

//    "Return"       -  The deal is executed to the extent of the volume available at the price specified in the order.
//                      A new order is placed for the remaining volume at the same price
   bool   return_remainder=false;

//--- Check the modes
   fok   =IsFillingTypeAllowed(_Symbol,SYMBOL_FILLING_FOK);
   ioc   =IsFillingTypeAllowed(_Symbol,SYMBOL_FILLING_IOC);
//--- For "Market execution" and "Exchange execution" modes
   ENUM_SYMBOL_TRADE_EXECUTION symbol_trade_exemode=(ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_EXEMODE);
   return_remainder=(symbol_trade_exemode==SYMBOL_TRADE_EXECUTION_MARKET || 
                     symbol_trade_exemode==SYMBOL_TRADE_EXECUTION_EXCHANGE) ? true : false;
//--- Generate a string of the modes available
   if(fok)
     {
      StringAdd(str,"Fill or Kill");
      if(ioc || return_remainder)
         StringAdd(str," / ");
     }
//---
   if(ioc)
     {
      StringAdd(str,"Immediate or Cancel");
      if(return_remainder)
         StringAdd(str," / ");
     }
//---
   if(return_remainder)
      StringAdd(str,"Return");
//---
   return(str);
  }

Puesto que hay que comprobar la disponibilidad de cada modo por separado, por comodidad, usamos las funciones adicionales IsExpirationTypeAllowed() y IsFillingTypeAllowed(), proporcionadas en los ejemplos de la documentación:

//+------------------------------------------------------------------+
//| Checking if a given expiration mode is allowed                   |
//+------------------------------------------------------------------+
bool IsExpirationTypeAllowed(string symbol, int exp_type)
  {
//--- Get the value of the property describing the allowable expiration modes
   int expiration=(int)SymbolInfoInteger(symbol,SYMBOL_EXPIRATION_MODE);
//--- Return true if the exp_type mode is allowed
   return((expiration&exp_type)==exp_type);
  }
//+------------------------------------------------------------------+
//| Checking if a given filling mode is allowed                      |
//+------------------------------------------------------------------+
bool IsFillingTypeAllowed(string symbol, int fill_type)
  {
//--- Get the value of the property describing the filling mode
   int filling=(int)SymbolInfoInteger(symbol,SYMBOL_FILLING_MODE);
//--- Return true if the fill_type mode is allowed
   return((filling&fill_type)==fill_type);
  }

Así, hemos repasado los valores de la cadena de propiedades del símbolo. Echemos un vistazo a la función GetColorSymbolInfoByIndex(). El código de esta función es mucho más sencillo por el hecho de que no todas las propiedades dependen del valor que se muestra en pantalla:

//+------------------------------------------------------------------+
//| Returning the symbol property color by index                     |
//+------------------------------------------------------------------+
color GetColorSymbolInfoByIndex(int index)
  {
   double check_value =0.0;
   color  clr         =clrWhiteSmoke;
//---
   switch(index)
     {
      case 6  :
         clr=(SymbolInfoInteger(_Symbol,SYMBOL_TIME)>0) ? clrCornflowerBlue : clrWhiteSmoke;                      break;
         //---
      case 9  : clr=(SymbolInfoInteger(_Symbol,SYMBOL_SPREAD_FLOAT)>0) ? clrGold : clrRed;                        break;
      //---
      case 13 :
         clr=(SymbolInfoInteger(_Symbol,SYMBOL_START_TIME)>0) ? clrCornflowerBlue : clrWhiteSmoke;                break;
      case 14 :
         clr=(SymbolInfoInteger(_Symbol,SYMBOL_EXPIRATION_TIME)>0) ? clrCornflowerBlue : clrWhiteSmoke;           break;
         //---
      case 15 : clr=(SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL)>0) ? clrWhiteSmoke : clrRed;             break;
      case 16 : clr=(SymbolInfoInteger(_Symbol,SYMBOL_TRADE_FREEZE_LEVEL)>0) ? clrWhiteSmoke : clrRed;            break;
      //---
      case 20 : clr=clrGold;                                                                                      break;
      case 21 : clr=clrGold;                                                                                      break;
      //---
      case 39 : clr=(SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_LIMIT)>0) ? clrWhiteSmoke : clrGold;                  break;
      case 40 : clr=(SymbolInfoDouble(_Symbol,SYMBOL_SWAP_LONG)>0) ? clrLime : clrRed;                            break;
      case 41 : clr=(SymbolInfoDouble(_Symbol,SYMBOL_SWAP_SHORT)>0) ? clrLime : clrRed;                           break;
      //---
      case 60 : clr=clrGold;                                                                                      break;
      case 61 : clr=clrGold;                                                                                      break;
      case 62 : clr=clrGold;                                                                                      break;
      //---
      case 68 :
         clr=(SeriesInfoInteger(_Symbol,_Period,SERIES_FIRSTDATE)>0) ? clrCornflowerBlue : clrWhiteSmoke;         break;
      case 69 :
         clr=(SeriesInfoInteger(_Symbol,_Period,SERIES_SERVER_FIRSTDATE)>0) ? clrCornflowerBlue : clrWhiteSmoke;  break;
      case 70 : clr=(!(bool)SeriesInfoInteger(_Symbol,_Period,SERIES_SYNCHRONIZED)) ? clrRed : clrGold;           break;
     }
//---
   return(clr);
  }

Si ahora compilamos el indicador y lo añadimos al gráfico, podremos ver la lista de las propiedades del símbolo en la subventana, como se muestra en la siguiente captura de pantalla:

Fig. 1. Indicador cargado en el gráfico sin la barra de desplazamiento

Fig. 1. Indicador cargado en el gráfico sin la barra de desplazamiento

¡Y todo esto es un solo objeto!

Además, vamos a escribir funciones para trabajar con la barra de desplazamiento vertical. Como ya se ha mencionado al principio del artículo, la barra de desplazamiento se ha creado usando dos objetos gráficos OBJ_RECTANGLE_LABEL (etiqueta rectangular). Uno de ellos será el fondo y el otro será el cuadro de desplazamiento. La barra de desplazamiento se encuentra a la derecha de la subventana del indicador.

CreateRectangleLable(); la función para crear una etiqueta rectangular:

//+------------------------------------------------------------------+
//| Creating a rectangle                                             |
//+------------------------------------------------------------------+
void CreateRectangleLable(long              chart_id,          // chart id
                          int               sub_window,        // window number
                          string            object_name,       // object name
                          int               x_distance,        // X-coordinate
                          int               y_distance,        // Y-coordinate
                          int               x_size,            // width
                          int               y_size,            // height
                          ENUM_BASE_CORNER  corner,            // chart corner
                          color             border_color,      // border color
                          color             background_color,  // background color
                          bool              selectable,        // cannot select the object if FALSE
                          bool              is_on_background)  // background position
  {
//--- If the object has been created successfully
   if(ObjectCreate(chart_id,object_name,OBJ_RECTANGLE_LABEL,sub_window,0,0))
     {
      // set its properties
      ObjectSetInteger(chart_id,object_name,OBJPROP_XDISTANCE,x_distance);
      ObjectSetInteger(chart_id,object_name,OBJPROP_YDISTANCE,y_distance);
      ObjectSetInteger(chart_id,object_name,OBJPROP_XSIZE,x_size);
      ObjectSetInteger(chart_id,object_name,OBJPROP_YSIZE,y_size);
      ObjectSetInteger(chart_id,object_name,OBJPROP_BORDER_TYPE,BORDER_FLAT);    // set the flat border style
      ObjectSetInteger(chart_id,object_name,OBJPROP_COLOR,border_color);
      ObjectSetInteger(chart_id,object_name,OBJPROP_CORNER,corner);
      ObjectSetInteger(chart_id,object_name,OBJPROP_BGCOLOR,background_color);
      ObjectSetInteger(chart_id,object_name,OBJPROP_SELECTABLE,selectable);
      ObjectSetInteger(chart_id,object_name,OBJPROP_BACK,is_on_background);      // it will be used as a background if true
      ObjectSetString(chart_id,object_name,OBJPROP_TOOLTIP,"\n");                // no tooltip if "\n"
     }
  }

Vamos a escribir las funciones para crear y modificar los tamaños del cuadro de desplazamiento y el fondo de la barra de desplazamiento: AdjustScrollbarThumb() y AdjustScrollbarBackground():

//+------------------------------------------------------------------+
//| Adding scroll box or adjusting its size                          |
//+------------------------------------------------------------------+
void AdjustScrollbarThumb()
  {
//--- Calculate the scroll box size relative to the subwindow height
   CalculateScrollbarThumbHeight();
//--- If the scroll box is already available in the chart, adjust its properties
   if(ObjectFind(0,scrollbar_thumb_name)>0)
     {
      //--- Set the height and X-coordinate
      ObjectSetInteger(0,scrollbar_thumb_name,OBJPROP_YSIZE,scrollbar_thumb_height);
      ObjectSetInteger(0,scrollbar_thumb_name,OBJPROP_XDISTANCE,chart_width-scrollbar_thumb_width);
      //--- Adjust the scroll box position along the Y-axis if you go below the subwindow bottom boundary
      if(scrollbar_thumb_y1+scrollbar_thumb_height>subwindow_height)
         ObjectSetInteger(0,scrollbar_thumb_name,OBJPROP_YDISTANCE,subwindow_height-scrollbar_thumb_height);
     }
//--- Create the scroll box if it does not exist
   else
     {
      CreateRectangleLable(0,subwindow_number,scrollbar_thumb_name,
                           chart_width-scrollbar_thumb_width,0,scrollbar_thumb_width,scrollbar_thumb_height,
                           CORNER_LEFT_UPPER,clrSilver,clrSilver,false,false);
     }
  }
//+------------------------------------------------------------------+
//| Adding the scrollbar background or adjusting its size            |
//+------------------------------------------------------------------+
void AdjustScrollbarBackground()
  {
//--- If the scrollbar background is already available in the chart, adjust its properties
   if(ObjectFind(0,scrollbar_background_name)>0)
     {
      //--- Set the background size
      ObjectSetInteger(0,scrollbar_background_name,OBJPROP_YDISTANCE,0);
      ObjectSetInteger(0,scrollbar_background_name,OBJPROP_XDISTANCE,chart_width-scrollbar_background_width);
      ObjectSetInteger(0,scrollbar_background_name,OBJPROP_YSIZE,subwindow_height);
     }
//--- If there is no background, create it
   else
     {
      CreateRectangleLable(0,subwindow_number,scrollbar_background_name,
                           chart_width-scrollbar_background_width,0,scrollbar_background_width,subwindow_height,
                           CORNER_LEFT_UPPER,scrollbar_background_color,scrollbar_background_color,false,false);
     }
  }

La altura del cuadro de desplazamiento se calcula desde el principio de la función AdjustScrollbarThumb(), en la cadena resaltada:

//+------------------------------------------------------------------+
//| Calculating the scroll box size relative to the subwindow height |
//+------------------------------------------------------------------+
void CalculateScrollbarThumbHeight()
  {
//--- If the subwindow height is greater than the list size, save the subwindow size
   if(subwindow_height>=list_height)
      scrollbar_thumb_height=subwindow_height-1;
//--- Otherwise calculate the scroll box size
   else
     {
      double height_temp=0.0;
      //--- Calculate the scroll box size relative to the subwindow height
      height_temp=subwindow_height-(((double)subwindow_height/100)*(100-((double)subwindow_height/list_height)*100));
      //--- Set the minimum size at 25% of the subwindow height
      if(height_temp/subwindow_height<0.25)
         height_temp=subwindow_height/4;
      //--- Save to the global variable
      scrollbar_thumb_height=(int)height_temp;
     }
  }

Recuerde eliminar los objetos gráficos:

//+------------------------------------------------------------------+
//| Deleting the scrollbar                                           |
//+------------------------------------------------------------------+
void DeleteScrollbar()
  {
   DeleteObjectByName(scrollbar_thumb_name);
   DeleteObjectByName(scrollbar_background_name);
  }
//+------------------------------------------------------------------+
//| Deleting the object by name                                      |
//+------------------------------------------------------------------+
void DeleteObjectByName(string object_name)
  {
//--- If such object exists
   if(ObjectFind(0,object_name)>=0)
     {
      //--- If an error occurred when deleting, print the relevant message
      if(!ObjectDelete(0,object_name))
         Print("Error ("+IntegerToString(GetLastError())+") when deleting the object!");
     }
  }

Pasemos ahora a la parte más interesante: tenemos que escribir las funciones que permiten arrastrar el cuadro de desplazamiento, haciendo que se mueva la lista. También tenemos que implementar el cambio de color del cuadro de desplazamiento cuando se mueva el cursor encima de su área o se hace un clic encima de él para indicar que el control ha pasado al cuadro de desplazamiento y que ahora se puede arrastrar este último. Para ello, el color del cuadro de desplazamiento seguirá cambiando al hacer clic.

La anchura del cuadro de desplazamiento es bastante estrecha, de modo que al moverlo hacia arriba o abajo se puede producir un cambio de lado del cursor. Para solucionar este problema, vamos a pasar el control al cuadro de desplazamiento mientras se presiona el botón izquierdo del ratón.

Los códigos de las funciones descritas anteriormente son los siguientes:

//+------------------------------------------------------------------+
//| Setting the scroll box color                                     |
//+------------------------------------------------------------------+
void SetScrollbarThumbColor(color thumb_color)
  {
   ObjectSetInteger(0,scrollbar_thumb_name,OBJPROP_COLOR,thumb_color);
   ObjectSetInteger(0,scrollbar_thumb_name,OBJPROP_BGCOLOR,thumb_color);
  }
//+------------------------------------------------------------------+
//| Setting the scroll box boundaries                                |
//+------------------------------------------------------------------+
void SetScrollbarThumbBoundaries()
  {
   scrollbar_thumb_x1=(int)ObjectGetInteger(0,scrollbar_thumb_name,OBJPROP_XDISTANCE);
   scrollbar_thumb_y1=(int)ObjectGetInteger(0,scrollbar_thumb_name,OBJPROP_YDISTANCE);
   scrollbar_thumb_x2=scrollbar_thumb_x1+scrollbar_thumb_width;
   scrollbar_thumb_y2=scrollbar_thumb_y1+scrollbar_thumb_height;
  }
//+------------------------------------------------------------------+
//| Changing the color of the scroll box when the cursor hovers over |
//+------------------------------------------------------------------+
void ChangeScrollbarThumbColorOnHover(int x,int y)
  {
//--- If the cursor is within the scroll box area, make the color darker
   if(x>scrollbar_thumb_x1 && x<scrollbar_thumb_x2 && y>scrollbar_thumb_y1 && y<scrollbar_thumb_x2)
      SetScrollbarThumbColor(scrollbar_thumb_color_on_hover);
//--- If the cursor is outside the scroll box boundaries
   else
     {
      //--- If the mouse button is released, set the standard scroll box color
      if(!mouse_button_state)
         SetScrollbarThumbColor(scrollbar_thumb_color);
     }
  }
//+------------------------------------------------------------------+
//| Determining the scroll box state                                 |
//+------------------------------------------------------------------+
void SetScrollbarThumbState(int x,int y)
  {
//--- If the mouse cursor is within the scroll box boundaries
   if(x>scrollbar_thumb_x1 && x<scrollbar_thumb_x2 && y>scrollbar_thumb_y1 && y<scrollbar_thumb_x2)
     {
      //--- If the mouse button is pressed, save it
      if(mouse_button_state)
         scrollbar_thumb_clicked=true;
     }
//--- If the cursor is outside the scroll box boundaries
   else
     {
      //--- If the mouse button is released, disable the scroll box control
      if(!mouse_button_state)
         ZeroScrollbarThumbVariables();
     }
  }
//+------------------------------------------------------------------+
//| Zeroing out variables related to scroll box movement             |
//+------------------------------------------------------------------+
void ZeroScrollbarThumbVariables()
  {
   scrollbar_thumb_clicked       =false;
   scrollbar_fix_point           =0;
   scrollbar_fix_point_y_offest  =0;
  }

No son todas las funciones necesarias para que se mueva el cuadro de desplazamiento. De hecho, la movilidad del cuadro de desplazamiento está basada en eventos. En otras palabras, se dispara una determinada acción si se pulsa el botón del ratón estando el cursor en la zona supervisada del gráfico, seguido por un desplazamiento del cursor acorde al número especificado de píxeles y con el botón del ratón todavía pulsado. En nuestro caso, este sería el cambio en la posición del cuadro de desplazamiento y, en consecuencia, la lista de las propiedades del símbolo. Es bastante sencillo.

A continuación puede ver las funciones MoveThumb(), UpdateListAndScrollbarThumb() y ThumbYCoordinateToPercent() que se usan para implementar las acciones mencionadas anteriormente:

//+------------------------------------------------------------------+
//| Moving the scroll box vertically to the specified coordinate     |
//+------------------------------------------------------------------+
void MoveThumb(int y)
  {
   int  threshold   =1; // Threshold in pixels for recalculation
   int  new_y_point =0; // New Y-coordinate
//--- If the mouse button is pressed
   if(mouse_button_state)
     {
      //--- Set the clicked scroll box color
      SetScrollbarThumbColor(scrollbar_thumb_color_on_click);
      //--- Save the current Y-coordinate of the cursor
      if(scrollbar_fix_point==0)
         scrollbar_fix_point=y;
      //--- Save the distance from the scroll box top to the cursor
      if(scrollbar_fix_point_y_offest==0)
         scrollbar_fix_point_y_offest=scrollbar_thumb_y1-scrollbar_fix_point;
     }
//--- If you scrolled down below the threshold value, while keeping the button pressed
   if(y-scrollbar_fix_point>=threshold)
     {
      //--- If you are still within the subwindow boundaries
      if(scrollbar_thumb_y1+scrollbar_thumb_height+threshold<subwindow_height)
         new_y_point=y+scrollbar_fix_point_y_offest;
      else
        {
         scrollbar_fix_point_y_offest=0;
         new_y_point=int(subwindow_height-scrollbar_thumb_height)-1;
        }
      //--- Refresh the list and the scroll box
      UpdateListAndScrollbarThumb(new_y_point);
      return;
     }
//--- If you scrolled up above the threshold value, while keeping the button pressed
   if(y-scrollbar_fix_point<=-(threshold))
     {
      //--- If you are still within the subwindow boundaries
      if(y-fabs(scrollbar_fix_point_y_offest)>=0)
         new_y_point=y-fabs(scrollbar_fix_point_y_offest);
      else
        {
         new_y_point=0;
         scrollbar_fix_point_y_offest=0;
        }
      //--- Refresh the list and the scroll box
      UpdateListAndScrollbarThumb(new_y_point);
      return;
     }
  }
//+------------------------------------------------------------------+
//| Refreshing the list and the scroll box position                  |
//+------------------------------------------------------------------+
void UpdateListAndScrollbarThumb(int new_point)
  {
//--- Set the new Y-coordinate for the scroll box
   ObjectSetInteger(0,scrollbar_thumb_name,OBJPROP_YDISTANCE,new_point);
//--- Refresh the list of the symbol properties relative to the current scroll box position
   ShowSymbolInfo(ThumbYCoordinateToPercent(new_point));
//--- Zero out the fix point
   scrollbar_fix_point=0;
  }
//+------------------------------------------------------------------+
//| Converting the Y-coordinate of the scroll box to percentage      |
//+------------------------------------------------------------------+
double ThumbYCoordinateToPercent(long y)
  {
   if(subwindow_height<=0)
      subwindow_height=1;
//---
   return(((double)y/subwindow_height)*100);
  }

Ahora, hay que colocar todas las funciones en un orden determinado para que funcione el programa tal y como se había concebido inicialmente. En la función OnChartEvent(), tenemos que controlar los eventos que ayudan al usuario a interactuar con la subventana del indicador, así como la lista y la barra de desplazamiento que se encuentran en la subventana:

//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- Track mouse clicks on the chart
   if(id==CHARTEVENT_CLICK)
     {
      //--- Zero out variables related to the scroll box movement
      ZeroScrollbarThumbVariables();
      //--- Refresh the chart
      ChartRedraw();
      return;
     }
//--- Track the cursor movement and the state of the left mouse button
   if(id==CHARTEVENT_MOUSE_MOVE)
     {
      int      x      =(int)lparam; // X-coordinate
      int      y      =(int)dparam; // Y-coordinate
      int      window =WRONG_VALUE; // Number of the window where the cursor is located
      datetime time   =NULL;        // Time corresponding to the X-coordinate
      double   price  =0.0;         // Price corresponding to the Y-coordinate
 
      //--- Set subwindow properties
      SetSubwindowProperties();
      //--- Check and save the state of the mouse button
      CheckMouseButtonState(sparam);
      //--- Get the position of the cursor
      if(ChartXYToTimePrice(0,x,y,window,time,price))
        {
         //--- If the cursor is within the subwindow boundaries
         if(window==subwindow_number)
           {
            //--- Disable scrolling of the price chart
            ChartSetInteger(0,CHART_MOUSE_SCROLL,false);
            //--- Recalculate the Y coordinate relative to the indicator subwindow
            ChartYToSubwindowY(y);
            //--- Determine the scroll box boundaries
            SetScrollbarThumbBoundaries();
            //--- Change the scroll box color when the cursor moves over it
            ChangeScrollbarThumbColorOnHover(x,y);
            //--- Determine the scroll box state
            SetScrollbarThumbState(x,y);
            //--- If the control is passed to the scroll box, drag it and refresh the list
            if(scrollbar_thumb_clicked)
               MoveThumb(y);
           }
         //--- If the cursor is outside the subwindow boundaries
         else
           {
            //--- Enable scrolling of the price chart
            ChartSetInteger(0,CHART_MOUSE_SCROLL,true);
            //--- If the mouse button is released, set the standard scroll box color
            if(!scrollbar_thumb_clicked)
               SetScrollbarThumbColor(scrollbar_thumb_color);
           }
        }
      //--- If the position of the cursor could not be determined
      else
        {
         //--- If the control has not been passed to the scroll box, set the standard scroll box color
         if(!scrollbar_thumb_clicked)
            SetScrollbarThumbColor(scrollbar_thumb_color);
        }
      //--- Refresh the chart
      ChartRedraw();
      return;
     }
//--- Track the change of properties and size of the chart
   if(id==CHARTEVENT_CHART_CHANGE)
     {
      //--- Set subwindow properties
      SetSubwindowProperties();
      //--- Get the Y-coordinate of the scroll box
      scrollbar_thumb_y1=(int)ObjectGetInteger(0,scrollbar_thumb_name,OBJPROP_YDISTANCE);
      //--- If the subwindow size is zero, exit
      if(subwindow_height<=0)
         return;
      //--- Set the new canvas size
      ResizeCanvas();
      //--- Refresh the scrollbar background
      AdjustScrollbarBackground();
      //--- Refresh the scroll box
      AdjustScrollbarThumb();
      //--- Refresh the data on the canvas
      ShowSymbolInfo(ThumbYCoordinateToPercent(scrollbar_thumb_y1));
      //---
      return;
     }
  }

Las funciones resaltadas en el código anterior son adicionales. Puede entender su finalidad fácilmente a partir de los comentarios proporcionados.

//+-------------------------------------------------------------------+
//| Checking the mouse button state                                   |
//+-------------------------------------------------------------------+
void CheckMouseButtonState(string state)
  {
//--- Left mouse button is pressed
   if(state=="1")
      mouse_button_state=true;
//--- Left mouse button is released
   if(state=="0")
     {
      //--- Zero out variables
      ZeroScrollbarThumbVariables();
      mouse_button_state=false;
     }
  }
//+-------------------------------------------------------------------+
//| Recalculating the Y-coordinate relative to the indicator subwindow|
//+-------------------------------------------------------------------+
void ChartYToSubwindowY(int &y)
  {
//--- Get the distance from the chart top to the indicator subwindow
   chart_y_offset=(int)ChartGetInteger(0,CHART_WINDOW_YDISTANCE,subwindow_number);
//--- Recalculate the Y-coordinate relative to the indicator subwindow
   y-=chart_y_offset;
  }

Al igual que el lienzo, hay que añadir la barra de desplazamiento a la subventana del indicador durante la inicialización.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Enable tracking of mouse events
   ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,true);
//--- Set the short name
   IndicatorSetString(INDICATOR_SHORTNAME,subwindow_shortname);
//--- Set sizes of arrays of symbol properties and their colors
   ArrayResize(symbol_property_colors,LIST_SIZE);
   ArrayResize(symbol_property_values,LIST_SIZE);
//--- Set subwindow properties
   SetSubwindowProperties();
//--- Set the font for displaying on the canvas
   canvas.FontSet(font_name,font_size,FW_NORMAL);
//--- Save the text size (height) for calculations
   text_height=canvas.TextHeight("A")-1;
//--- Calculate the height of the entire list
   list_height=text_height*LIST_SIZE;
//--- Add the canvas to the chart
   AddCanvas();
//--- Add the scrollbar: background and scroll box
   AdjustScrollbarBackground();
   AdjustScrollbarThumb();
//--- Display the list of symbol properties
   ShowSymbolInfo();
//--- Refresh the chart
   ChartRedraw();
//--- Everything completed successfully
   return(INIT_SUCCEEDED);
  }

No se olvide de "limpiar" en la función OnDeinit(). Dependiendo del motivo de la desinicialización, se puede configurar el programa con mayor precisión.

//+------------------------------------------------------------------+
//| Deinitialization                                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(reason==REASON_REMOVE      || // If the indicator has been removed from the chart or
      reason==REASON_CHARTCHANGE || // the symbol or time frame has been modified or
      reason==REASON_RECOMPILE   || // the program has been recompiled or
      reason==REASON_CHARTCLOSE  || // the chart has been closed or
      reason==REASON_CLOSE)         // the terminal has been closed
     {
      //--- Delete the scrollbar
      DeleteScrollbar();
      //--- Delete the canvas
      DeleteCanvas();
      //--- Enable scrolling of the price chart
      ChartSetInteger(0,CHART_MOUSE_SCROLL,true);
      //--- Disable cursor tracking
      ChartSetInteger(0,CHART_EVENT_MOUSE_MOVE,false);
      //--- Refresh the chart
      ChartRedraw();
     }
  }

Y por último, para permitir que se actualicen algunas propiedades del símbolo en el modo de tiempo real, tenemos que añadir un par de cadenas de código a la función OnCalculate():

Ya está todo listo. El código fuente está adjunto al artículo para que lo pueda utilizar en MetaEditor 5 y está disponible para su descarga. En el siguiente vídeo, se muestra el funcionamiento de las funciones incluidas en este artículo.

 

Conclusión

Ya hemos terminado con el tema del control de la barra de desplazamiento. En el artículo se mostró cómo se puede realizar una barra de desplazamiento a partir de objetos gráficos independientes que se encuentran en un lienzo (canvas). En alguno de los próximos artículos, trataremos de implementar toda la funcionalidad mediante los métodos de esta clase.

Traducción del ruso hecha por MetaQuotes Software Corp.
Artículo original: https://www.mql5.com/ru/articles/751

Archivos adjuntos |
testscrollbar.mq5 (57.23 KB)
Guía práctica de MQL5: Controles de la subventana del indicador: Botones Guía práctica de MQL5: Controles de la subventana del indicador: Botones

En este artículo, vamos a ver un ejemplo del desarrollo de una interfaz de usuario con controles mediante botones. Para transmitir la idea de interactividad al usuario, los botones cambiarán de color cuando se pasa el cursor por encima de ellos. Cuando el cursor está encima de un botón, el color de este último será ligeramente oscurecido, haciéndose notablemente más oscuro cuando se pulsa el botón. Además, vamos a añadir tooltips (información sobre herramientas) a cada botón, creando así una interfaz intuitiva.

Guía práctica de MQL5: Supervisar múltiples períodos de tiempo en una sola ventana Guía práctica de MQL5: Supervisar múltiples períodos de tiempo en una sola ventana

MetaTrader 5 ofrece 21 períodos de tiempo para el análisis. Puede aprovechar los objetos gráficos especiales que puede colocar en el gráfico existente y establecer el símbolo, el período de tiempo y otras propiedades. En este artículo se va a proporcionar una información detallada acerca de estos objetos gráficos: crearemos un indicador con controles (botones) que nos permitirán establecer múltiples objetos gráficos en una subventana al mismo tiempo. Además, se encajarán los objetos gráficos con precisión en la subventana y se ajustarán automáticamente al modificar el tamaño del gráfico principal o el de la ventana del terminal.

Guía práctica de MQL5: Desarrollo de un indicador de volatilidad multisímbolo en MQL5 Guía práctica de MQL5: Desarrollo de un indicador de volatilidad multisímbolo en MQL5

En este artículo, trataremos el desarrollo de un indicador de volatilidad multisímbolo. El desarrollo de los indicadores multisímbolo puede presentar algunas dificultades para los desarrolladores novatos de MQL5 que este artículo ayudará a aclarar. Los temas importantes que aparecerán a lo largo del desarrollo de un indicador multisímbolo tendrán que ver con la sincronización de otros símbolos respecto al símbolo actual, la falta de algunos datos de los indicadores y la identificación del principio de las barras "true" (verdaderas) en un periodo de tiempo determinado. Se tendrán en cuenta de cerca todas estas cuestiones en este artículo.

Creación de un Asesor Experto multisistema y multidivisa Creación de un Asesor Experto multisistema y multidivisa

El artículo constituye una introducción a una estructura para un Asesor Experto que opera con múltiples símbolos y utiliza varios sistemas de trading simultáneamente. Si ya identificó los parámetros de entrada óptimos para todos sus Asesores Expertos y consiguió buenos resultados de la prueba para cada uno de ellos separadamente, pregúntese qué resultados conseguiría si probara todos los Asesores Expertos simultáneamente, con todas sus estrategias en conjunto.