Operar con noticias de manera sencilla (Parte 3): Realizando operaciones

Introducción

Anteriormente, creamos un Asesor Experto para almacenar datos económicos en nuestra base de datos del calendario de noticias. También desarrollamos muchas clases para sentar las bases para que nuestro experto pueda desempeñarse adecuadamente. En este artículo, ampliaremos estas clases en nuestro proyecto para finalmente alcanzar nuestro objetivo de operar a partir de datos económicos. Nuestro próximo objetivo será la rentabilidad que abordaremos en los próximos artículos. Para este artículo, agregaremos una nueva vista a nuestra base de datos para mostrar todos los eventos únicos del Calendario económico MQL5 para proporcionar información sobre los diferentes eventos. También agregaremos nuevas entradas al experto para filtrar datos económicos al operar para brindar flexibilidad. Puedes consultar el artículo anterior de la serie "Operar con noticias de manera sencilla", donde creamos una clase de gestión de riesgos para administrar el riesgo en el trading y más información útil si aún no lo ha hecho. 

¿Qué puedes esperar?

Gráficos mejorados que son concisos, modernos y adaptables al gráfico actual. La imagen a continuación es una representación de estos gráficos en modo claro.

Secciones: 1, 2, 3, 4, 5, 6, 7, 8 y 9 se mostrarán automáticamente cada vez que el experto esté en un gráfico.

Secciones: 10, (11, 12, 13, 14 y 15 son un grupo) y 16 son opcionales y se actualizarán con cada nueva vela de 1 minuto (esto es para mejorar el rendimiento durante las pruebas retrospectivas).

Sección

• 10: Muestra la fecha y la hora del terminal. El texto de la hora se mostrará en rojo cuando ocurra un evento noticioso mientras el gráfico esté en modo claro.
• 11: Muestra la fecha y hora del evento de noticias actual/próximo. El texto se mostrará en rojo cuando la fecha y la hora sean iguales a la hora del terminal.
• 12: Muestra el nombre del evento de noticias. El color del texto cambiará dependiendo de la importancia del evento, por ejemplo, la importancia alta se muestra en rojo.
• 13: Muestra el nombre del país del evento. El color del texto cambiará según la importancia del evento y el modo de color del gráfico, por ejemplo, el modo claro.
• 14: Muestra el nombre de la moneda del evento de noticias. El color del texto variará.
• 15: Muestra la importancia del evento. El color del texto variará.
• 16: Muestra el spread para el símbolo actual y la calificación que se calcula con 2 semanas de datos de spread de velas de 1 minuto y se clasifica en grupos de excelente, bueno, normal, malo y terrible con diferentes colores para cada categoría con variación para modo oscuro y modo claro.

La imagen a continuación es una representación de cómo se implementa el modo oscuro.

Sección

• 17: Muestra la hora del evento de todos los eventos que ocurrirán o han ocurrido en el día terminal actual. 

Entradas de DISPLAY (PANTALLA)

• CHART COLOUR MODE: El propósito de esta opción es cambiar entre el modo oscuro o claro.
• DISPLAY NEWS INFO: El propósito de esta opción es mostrar o no mostrar las secciones (11, 12, 13, 14 y 15) en el gráfico.
• DISPLAY EVENT OBJ: El propósito de esta opción es mostrar o no mostrar la sección 17 en el gráfico.
• DISPLAY SPREAD RATING: El propósito de esta opción es mostrar o no mostrar la sección 16 en el gráfico.
• DISPLAY DATE: El propósito de esta opción es mostrar o no mostrar la sección 10 en el gráfico.

Entradas del DST SCHEDULE (HORARIO DST)

• SELECT DST OPTION: El propósito de esta opción es permitir al usuario/comerciante seleccionar su horario DST personalizado o permitir al experto seleccionar automáticamente el horario DST recomendado para configurar correctamente los tiempos de los eventos al realizar pruebas retrospectivas en el probador de estrategias.
• SELECT CUSTOM DST: El propósito de esta opción es permitir al usuario/operador configurar manualmente el horario DST.

Entradas de RISK MANAGEMENT (GESTIÓN DE RIESGOS)

• SELECT RISK OPTION: El propósito de esta opción es permitir al usuario/operador seleccionar diferentes perfiles de Gestión de Riesgo, por ejemplo, TAMAÑO MÍNIMO DEL LOTE, TAMAÑO MÁXIMO DEL LOTE, etc.
• RISK FLOOR: El objetivo de esta opción es fijar un riesgo mínimo para todos los perfiles de riesgo. Por ejemplo, si no hay suficiente dinero para un tamaño de lote de 1 lote, pero hay suficiente dinero para el tamaño de lote mínimo de 0,01 lote, entonces 0,01 se utilizará para abrir la operación en lugar de no abrir ninguna operación porque no había suficiente dinero. Se trata sólo de una red de seguridad por si los perfiles de riesgo no estuvieran configurados adecuadamente.
• MAX-RISK: El propósito de esta opción es abrir una operación con el porcentaje de margen libre en la cuenta si no hubiera suficiente dinero para abrir una operación normal. Esta opción solo está operativa cuando RISK FLOOR está configurado en MAX-RISK.
• RISK CEILING: El propósito de esta opción es establecer un tope/límite de tamaño de lote cuando la cuenta es lo suficientemente grande como para abrir el lote máximo para un símbolo específico. El tope/límite varía de MAX LOTSIZE que significa que el máximo tamaño de lote posible es el establecido por el símbolo específico, mientras que MAX LOTSIZE (x2) abrirá dos operaciones con el máximo tamaño de lote dependiendo de si el límite de volumen lo permite.
• PERCENTAGE OF [BALANCE | FREE-MARGIN]: El objetivo de esta opción es arriesgar un determinado porcentaje del Saldo o Margen Libre disponible.
• AMOUNT PER [BALANCE | FREE-MARGIN]: Por ejemplo, si [BALANCE | FREE-MARGIN] se establece en 1000 y CADA CANTIDAD se establece en 10, esto significa que por cada 1000 en valor de divisa de Saldo o Margen Libre se arriesgan 10 valores de divisa por cada operación. Entonces, si su saldo/margen libre es de 1000 USD, entonces arriesgue 10 USD en cada operación.
• LOTSIZE PER [BALANCE | FREE-MARGIN]: Por ejemplo, si [BALANCE | FREE-MARGIN] se establece en 1000 y CADA LOTE (VOLUMEN) se establece en 0,1, esto significa que por cada 1000 en valor de divisa de Saldo o Margen Libre se arriesga 0,1 en tamaño de lote para cada operación. Así, si su saldo/margen libre es de 1000 USD, entonces arriesgue 0,1 por cada operación.
• CUSTOM LOTSIZE: El objetivo de esta opción es arriesgar un tamaño de lote predeterminado por cada operación abierta.
• PERCENTAGE OF MAX-RISK: El propósito de esta opción es arriesgar un porcentaje del volumen de riesgo máximo para un símbolo con el margen libre disponible de la cuenta. Por ejemplo, si el volumen de riesgo máximo para AUDUSD con un margen libre de la cuenta de 10.000 USD es de 100 lotes, si establecemos el PORCENTAJE DE RIESGO MÁXIMO en 25%, el tamaño de lote utilizado será el 25% de 100 lotes, lo que equivale a 25 lotes.

Entradas en NEWS SETTINGS (CONFIGURACIÓN DE NOTICIAS)

News Settings consta de varias opciones de entrada, a saber:

1. CALENDAR IMPORTANCE (IMPORTANCIA DEL CALENDARIO)
2. EVENT FREQUENCY (FRECUENCIA DE EVENTOS)
3. EVENT SECTOR (SECTOR DE EVENTOS)
4. EVENT TYPE (TIPO DE EVENTO)
5. EVENT CURRENCY (MONEDA DEL EVENTO)

Estas opciones se muestran en la imagen de abajo.

• CALENDAR IMPORTANCE: El propósito de esta opción es filtrar los datos de noticias a una Importancia de noticias especificada.

• EVENT FREQUENCY: El objetivo de esta opción es filtrar los datos de las noticias en función de su frecuencia de aparición.

• EVENT SECTOR: El objetivo de esta opción es filtrar los datos de las noticias en función del sector.

• EVENT TYPE: El objetivo de esta opción es filtrar los datos de noticias de su tipo, por ejemplo, EVENT se utiliza normalmente para discursos y reuniones, mientras que INDICATOR es para tipos de interés, datos de empleo, etc. y HOLIDAY es para años de noticias y otras fiestas diversas.

• EVENT CURRENCY: El objetivo de esta opción es filtrar los datos de las noticias en función de las opciones de divisa seleccionadas. SYMBOL CURRENCIES tendrá en cuenta todas las divisas de SYMBOL MARGIN, SYMBOL BASE y SYMBOL PROFIT.

Entradas de TRADE SETTINGS (CONFIGURACIÓN DE COMERCIO)

• STOPLOSS[0=NONE]: El propósito de esta opción es establecer un stop loss fijo para todas las operaciones. Cuando el stop loss se establece en cero, todas las operaciones no tendrán un valor de stop loss.
• TAKEPROFIT[0=NONE]: El propósito de esta opción es establecer un take profit fijo para todas las operaciones. Cuando take profit se establece en cero, todas las operaciones no tendrán un valor de take profit.
• PRE-ENTRY SEC: El propósito de esta opción es permitir al usuario/operador configurar el número de segundos antes de que se abra una operación antes de la hora del evento. Por lo tanto, si PRE-ENTRY SEC se establece en 5, esto significa que 5 segundos antes de que ocurra el evento es el período de tiempo para que las operaciones se abran antes de la hora del evento. Ejemplo: Si la hora del evento es las 15:00 p. m., se permitirán transacciones desde 5 segundos antes del evento entre las 14:59:45 y las 14:59:59.
• TRADING DAY OF WEEK: El objetivo de esta opción es filtrar cualquier día laborable de la semana, por ejemplo, lunes, martes, etc. 

Ahora nos sumergiremos en el código que hará que nuestro experto sea funcional.

Clase de propiedades de símbolos

Se agregaron cambios realizados desde la Parte 2:

• Declaración de enumeración para la clasificación de spreads

//Enumeration for Spread rating
enum SpreadRating
  {
   SpreadRating_Terrible,//Terrible
   SpreadRating_Bad,//Bad
   SpreadRating_Normal,//Normal
   SpreadRating_Good,//Good
   SpreadRating_Excellent//Excellent
  };

• Declaración de variable booleana para configurar el modo de color del gráfico

bool isLightMode;//Variable to configure Chart color mode

• Declaración de función booleana para recuperar el valor flotante

bool              SpreadFloat(string SYMBOL=NULL);//Retrieve Spread Float

//+------------------------------------------------------------------+
//|Retrieve Spread Float                                             |
//+------------------------------------------------------------------+
bool CSymbolProperties::SpreadFloat(string SYMBOL=NULL)
  {
   if(SetSymbolName(SYMBOL))//Set Symbol
     {
      return CSymbol.SpreadFloat();
     }
   Print("Unable to retrieve Symbol's Spread Float");
   return false;//Retrieve false when failed.
  }

• Declaración de la función de calificación de spread para recuperar la calificación de spread

SpreadRating      SpreadValue(string SYMBOL=NULL);//Retrieve Spread Rating

Esta función debe devolver un valor de enumeración de SpreadRating.

//+------------------------------------------------------------------+
//|Retrieve Spread Rating                                            |
//+------------------------------------------------------------------+
SpreadRating CSymbolProperties::SpreadValue(string SYMBOL=NULL)
  {
   if(SetSymbolName(SYMBOL))//Set Symbol
     {
      if(SpreadFloat(SYMBOL))//Check if Symbol has a floating Spread
        {

         //Declarations
         vector Spreads;
         int SpreadArray[],SpreadAvg=0,SpreadMax=0,SpreadMin=0,
                           SpreadUpper=0,SpreadLower=0,SpreadAvgUpper=0,
                           SpreadAvgLower=0,SpreadMidUpper=0,SpreadMidLower=0;

         //Get Spread data from CopySpread built-in function for 2 weeks using M1 timeframe.
         if(CopySpread(GetSymbolName(),PERIOD_M1,iTime(GetSymbolName(),PERIOD_W1,2),
                       iTime(GetSymbolName(),PERIOD_M1,0),SpreadArray)==-1)
           {
            Print("Error trying to retrieve spread values");
            return SpreadRating_Normal;//Retrieve default value when failed.
           }
         else
           {
            Spreads.Assign(SpreadArray);//Assign spread array into Spreads vector variable

            SpreadMax = int(Spreads.Max());//Assign max spread
            SpreadMin = int(Spreads.Min());//Assign min spread
            SpreadAvg = int(Spreads.Median());//Assign average spread

            //Divide Spread into sectors based of different averages.
            SpreadMidUpper = int((SpreadAvg+SpreadMax)/2);
            SpreadMidLower = int((SpreadAvg+SpreadMin)/2);
            SpreadAvgUpper = int((SpreadAvg+SpreadMidUpper)/2);
            SpreadAvgLower = int((SpreadAvg+SpreadMidLower)/2);
            SpreadUpper = int((SpreadMidUpper+SpreadMax)/2);
            SpreadLower = int((SpreadMidLower+SpreadMin)/2);

            int Spread = Spread(SYMBOL);//Assign Symbol's Spread

            if(Spread<SpreadLower||Spread==SpreadMin)//Excellent
              {
               return SpreadRating_Excellent;
              }
            else
               if(Spread>=SpreadLower&&Spread<SpreadAvgLower)//Good
                 {
                  return SpreadRating_Good;
                 }
               else
                  if(Spread>=SpreadAvgLower&&Spread<=SpreadAvgUpper)//Normal
                    {
                     return SpreadRating_Normal;
                    }
                  else
                     if(Spread>SpreadAvgUpper&&Spread<=SpreadUpper)//Bad
                       {
                        return SpreadRating_Bad;
                       }
                     else//Terrible
                       {
                        return SpreadRating_Terrible;
                       }
           }
        }
      else
        {
         return SpreadRating_Normal;//Retrieve default value when spread is fixed.
        }
     }
   Print("Unable to retrieve Symbol's Spread Rating");
   return SpreadRating_Normal;//Retrieve default value when failed.
  }

Primero configuramos el símbolo, luego verificamos si el símbolo tiene un spread flotante antes de realizar cálculos simples para calificar el spread en función de sus promedios. Si la configuración del símbolo falló o el símbolo no tiene un spread flotante, devolvemos SpreadRating_Normal como valor predeterminado.

   if(SetSymbolName(SYMBOL))//Set Symbol
     {
      if(SpreadFloat(SYMBOL))//Check if Symbol has a floating Spread
        {

Si configuramos correctamente el símbolo y este tiene un spread flotante, entonces declararemos una variable vectorial Spreads y variables int para almacenar valores de spread. Después de declarar nuestras variables, utilizaremos la función CopySpread para almacenar los valores de spread en nuestra variable SpreadArray desde la vela de 1 minuto que comienza hace 2 semanas hasta el tiempo de la vela de 1 minuto actual. Si la función CopySpread falla por algún motivo, devolveremos SpreadRating_Normal como valor predeterminado.

 //Declarations
         vector Spreads;
         int SpreadArray[],SpreadAvg=0,SpreadMax=0,SpreadMin=0,
                           SpreadUpper=0,SpreadLower=0,SpreadAvgUpper=0,
                           SpreadAvgLower=0,SpreadMidUpper=0,SpreadMidLower=0;

         //Get Spread data from CopySpread built-in function for 2 weeks using M1 timeframe.
         if(CopySpread(GetSymbolName(),PERIOD_M1,iTime(GetSymbolName(),PERIOD_W1,2),
                       iTime(GetSymbolName(),PERIOD_M1,0),SpreadArray)==-1)
           {
            Print("Error trying to retrieve spread values");
            return SpreadRating_Normal;//Retrieve default value when failed.
           }

Una vez que CopySpread sea exitoso, asignaremos al vector Spreads los valores enteros de nuestro SpreadArray. Luego necesitamos obtener información básica de estos valores de la matriz, como el spread máximo a lo largo del período de 2 semanas, así como el spread mínimo y el spread promedio; almacenaremos estos valores en SpreadMax, SpreadMin y SpreadAvg según corresponda. Ahora queremos obtener promedios diferentes de estos tres valores anteriores.

Para la variable SpreadMidUpper queremos el promedio entre SpreadAvg y SpreadMax, para la variable SpreadMidLower queremos el promedio entre SpreadAvg y SpreadMin, para la variable SpreadAvgUpper queremos el promedio entre SpreadAvg y SpreadMidUpper, para la variable SpreadAvgLower queremos el promedio entre SpreadAvg y SpreadMidLower, para la variable SpreadUpper queremos el promedio entre SpreadMidUpper y SpreadMax, para la variable SpreadLower queremos el promedio entre SpreadMidLower y SpreadMin. También necesitaremos el spread del símbolo actual para comparar y clasificar el spread.

Spreads.Assign(SpreadArray);//Assign spread array into Spreads vector variable

            SpreadMax = int(Spreads.Max());//Assign max spread
            SpreadMin = int(Spreads.Min());//Assign min spread
            SpreadAvg = int(Spreads.Median());//Assign average spread

            //Divide Spread into sectors based of different averages.
            SpreadMidUpper = int((SpreadAvg+SpreadMax)/2);
            SpreadMidLower = int((SpreadAvg+SpreadMin)/2);
            SpreadAvgUpper = int((SpreadAvg+SpreadMidUpper)/2);
            SpreadAvgLower = int((SpreadAvg+SpreadMidLower)/2);
            SpreadUpper = int((SpreadMidUpper+SpreadMax)/2);
            SpreadLower = int((SpreadMidLower+SpreadMin)/2);

            int Spread = Spread(SYMBOL);//Assign Symbol's Spread

Contamos con 5 clasificaciones de spread, a saber:

• Excellent: cuando el spread actual es menor que la variable SpreadLower o igual a SpreadMin.
• Good: Cuando el spread actual es mayor o igual que la variable SpreadLower y el spread actual es menor que la variable SpreadAvgLower.
• Normal: Cuando el spread actual es menor o igual que la variable SpreadAvgLower y el spread actual es menor o igual que la variable SpreadAvgUpper.
• Bad: Cuando el spread actual es mayor que SpreadAvgUpper y el spread actual es menor o igual que la variable SpreadUpper.
• Terrible: Cuando el diferencial actual es superior a la variable SpreadUpper.

            if(Spread<SpreadLower||Spread==SpreadMin)//Excellent
              {
               return SpreadRating_Excellent;
              }
            else
               if(Spread>=SpreadLower&&Spread<SpreadAvgLower)//Good
                 {
                  return SpreadRating_Good;
                 }
               else
                  if(Spread>=SpreadAvgLower&&Spread<=SpreadAvgUpper)//Normal
                    {
                     return SpreadRating_Normal;
                    }
                  else
                     if(Spread>SpreadAvgUpper&&Spread<=SpreadUpper)//Bad
                       {
                        return SpreadRating_Bad;
                       }
                     else//Terrible
                       {
                        return SpreadRating_Terrible;
                       }

• Declaración de función para recuperar el color de la dispersión en función de su clasificación.

color             SpreadColor(string SYMBOL=NULL);//Retrieve Spread Color

Para obtener el color de dispersión para cada valor de enumeración de dispersión, consideraremos el uso de una sentencia switch ya que los valores de enumeración son constantes. Los colores para cada clasificación son los que se muestran:

• Excellent: si está en modo claro, entonces clrBlue

 De lo contrario, clrLightCyan

• Good: si está en modo claro, entonces clrCornflowerBlue

De lo contrario clrLightGreen

• Normal: si está en modo claro, entonces clrBlack

 De lo contrario clrWheat

• Bad: clrOrange
• Terrible: clrRed
• Default: si está en modo claro, entonces clrBlack, de lo contrario, clrWheat

//+------------------------------------------------------------------+
//|Retrieve Spread Color                                             |
//+------------------------------------------------------------------+
color CSymbolProperties::SpreadColor(string SYMBOL=NULL)
  {
   switch(SpreadValue(SYMBOL))//Get Spread Rating value
     {
      case SpreadRating_Excellent://Excellent Spread
         return (isLightMode)?clrBlue:clrLightCyan;
         break;
      case SpreadRating_Good://Good Spread
         return (isLightMode)?clrCornflowerBlue:clrLightGreen;
         break;
      case SpreadRating_Normal://Normal Spread
         return (isLightMode)?clrBlack:clrWheat;
         break;
      case SpreadRating_Bad://Bad Spread
         return clrOrange;
         break;
      case SpreadRating_Terrible://Terrible Spread
         return clrRed;
         break;
      default://failed to be identified
         return (isLightMode)?clrBlack:clrWheat;//Retrieve default color when failed.
         break;
     }
  }

• Declaración de función de cadena (string) para recuperar la descripción del spread.

string            SpreadDesc(string SYMBOL=NULL);//Retrieve Spread Description

//+------------------------------------------------------------------+
//|Retrieve Spread Description                                       |
//+------------------------------------------------------------------+
string CSymbolProperties::SpreadDesc(string SYMBOL=NULL)
  {
   switch(SpreadValue(SYMBOL))//Get Spread Rating value
     {
      case SpreadRating_Excellent://Excellent Spread
         return "Excellent";
         break;
      case SpreadRating_Good://Good Spread
         return "Good";
         break;
      case SpreadRating_Normal://Normal Spread
         return "Normal";
         break;
      case SpreadRating_Bad://Bad Spread
         return "Bad";
         break;
      case SpreadRating_Terrible://Terrible Spread
         return "Terrible";
         break;
      default://failed to be identified
         return "Unknown";//Retrieve default value when failed.
         break;
     }
  }

• Declaración de función de cadena (string) para recuperar la descripción del símbolo.

string            Description(string SYMBOL=NULL);//Retrieve Symbol's Description

//+------------------------------------------------------------------+
//|Retrieve Symbol's Description                                     |
//+------------------------------------------------------------------+
string CSymbolProperties::Description(string SYMBOL=NULL)
  {
   if(SetSymbolName(SYMBOL))//Set Symbol
     {
      return CSymbol.Description();
     }
   Print("Unable to retrieve Symbol's Description");
   return "";//Retrieve an empty string when failed.
  }

Clase de propiedades de gráfico

Esta clase ha sido reestructurada a partir de la Parte 2. La clase de propiedades del gráfico ahora heredará de la clases de gráficos incluidas en MQL5. La estructura ChartProp almacenará todas las propiedades del gráfico en las que introduciremos cambios. Nuestra función pública ChartRefresh llamará a nuestra función ChartGet que inicializará las propiedades del gráfico, y luego llamaremos a la función ChartSet que configurará el gráfico con nuestros valores de propiedad de gráfico de ChartGet.

#include "SymbolProperties.mqh"
#include <Charts/Chart.mqh>
CSymbolProperties CSymbol;//Symbol Properties object
//+------------------------------------------------------------------+
//|ChartProperties class                                             |
//+------------------------------------------------------------------+
class CChartProperties : public CChart
  {
private:
//Structure for chart properties
   struct ChartProp
     {
      ENUM_CHART_MODE mode;//Chart Mode
      color          clrBackground;//Chart Background Color
      color          clrForeground;//Chart Foreground Color
      color          clrLineLast;//Chart Line Color
      color          clrCandleBear;//Chart Bear Candle Color
      color          clrBarDown;//Chart Down Candle Color
      color          clrCandleBull;//Chart Bull Candle Color
      color          clrBarUp;//Chart Up Candle Color
      color          clrLineAsk;//Chart Ask Color
      color          clrLineBid;//Chart Bid Color
      color          clrChartLine;//Chart Line Color
      color          clrStopLevels;//Chart Stop Level Color
      color          clrVolumes;//Chart Volumes Color
      bool           Foreground;//Chart Foreground Visibility
      bool           ShowLineAsk;//Chart Ask Line Visibility
      bool           ShowLineBid;//Chart Bid Line Visibility
      bool           ShowPeriodSep;//Chart Period Separator Visibility
      bool           ShowOHLC;//Chart Open-High-Low-Close Visibility
      bool           ShowGrid;//Chart Grid Visibility
      ENUM_CHART_VOLUME_MODE ShowVolumes;//Chart Volumes Visibility
      bool           AutoScroll;//Chart Auto Scroll Option
      bool           Shift;//Chart Shift Option
      double         ShiftSize;//Chart Shift Size
      bool           ShowObjectDescr;//Chart Object Descriptions
      ulong          CHART_SHOW_TRADE_LEVELS;//Chart Trade Levels Visibility
      ulong          CHART_SHOW_ONE_CLICK;//Chart One Click Trading Visibility
      ulong          CHART_SHOW_TICKER;//Chart Ticker Visibility
      ulong          CHART_DRAG_TRADE_LEVELS;//Chart Drag Trade levels
      ENUM_CHART_POSITION Navigate;//Chart Navigate
     };
   ChartProp         DefaultChart,MyChart;//Used to store chart properties
   void              ChartSet(ChartProp &Prop);//Apply Chart format
   void              ChartGet();//Assign Chart property values
public:
                     CChartProperties();//Constructor
                    ~CChartProperties(void);//Destructor
                     //Configure the chart
   void              ChartRefresh() {ChartGet();ChartSet(MyChart);}
   string            GetChartPeriodName();//Retrieve Period name
  };

En el constructor asignamos a la variable heredada m_chart_id el ID del gráfico actual.

//+------------------------------------------------------------------+
//|Constructor                                                       |
//+------------------------------------------------------------------+
CChartProperties::CChartProperties()
  {
   m_chart_id=ChartID();//Set chart id
   ChartGet();//Get chart values
   ChartSet(MyChart);//customize chart
  }

Para la función ChartGet asignamos valores a nuestras variables DefaultChart y MyChart, donde DefaultChart almacenará las propiedades del gráfico actual antes de modificar el gráfico y donde MyChart almacenará nuestros valores personalizados.

//+------------------------------------------------------------------+
//|Assign Chart property values                                      |
//+------------------------------------------------------------------+
void CChartProperties::ChartGet()
  {
   DefaultChart.mode = Mode();//assign chart mode
   MyChart.mode = CHART_CANDLES;//assign custom chart mode
   DefaultChart.clrBackground = ColorBackground();//assign Background color
   MyChart.clrBackground = (isLightMode)?clrWhite:clrBlack;//assign custom Background color
   DefaultChart.clrForeground = ColorForeground();//assign foreground color
   MyChart.clrForeground = (isLightMode)?clrBlack:clrWhite;//assign custom foreground color
   DefaultChart.clrLineLast = ColorLineLast();//assign Chart Line Color
   MyChart.clrLineLast = clrWhite;//assign custom Chart Line Color
   DefaultChart.clrCandleBear = ColorCandleBear();//assign Chart Bear Candle Color
   MyChart.clrCandleBear = clrBlack;//assign custom Chart Bear Candle Color
   DefaultChart.clrBarDown = ColorBarDown();//assign Chart Down Candle Color
   MyChart.clrBarDown = (isLightMode)?clrBlack:CSymbol.Background();//assign custom Chart Down Candle Color
   DefaultChart.clrCandleBull = ColorCandleBull();//assign Chart Bull Candle Color
   MyChart.clrCandleBull = CSymbol.Background();//assign custom Chart Bull Candle Color
   DefaultChart.clrBarUp = ColorBarUp();//assign Chart Up Candle Color
   MyChart.clrBarUp = (isLightMode)?clrBlack:CSymbol.Background();//assign custom Chart Up Candle Color
   DefaultChart.clrLineAsk = ColorLineAsk();//assign Chart Ask Color 
   MyChart.clrLineAsk = (isLightMode)?clrBlack:clrWhite;//assign custom Chart Ask Color
   DefaultChart.clrLineBid = ColorLineBid();//assign Chart Bid Color
   MyChart.clrLineBid = (isLightMode)?clrBlack:CSymbol.Background();//assign custom Chart Bid Color
   DefaultChart.clrChartLine = ColorChartLine();//assign Chart Line Color
   MyChart.clrChartLine = (isLightMode)?clrBlack:clrWhite;//assign custom Chart Line Color
   DefaultChart.clrStopLevels = ColorStopLevels();//assign Chart Stop Level Color
   MyChart.clrStopLevels = clrRed;//assign custom Chart Stop Level Color
   DefaultChart.clrVolumes = ColorVolumes();//assign Chart Volumes Color
   MyChart.clrVolumes = clrGreen;//assign custom Chart Volumes Color
   DefaultChart.Foreground = Foreground();//assign Chart Foreground Visibility
   MyChart.Foreground = false;//assign custom Chart Foreground Visibility
   DefaultChart.ShowLineAsk = ShowLineAsk();//assign Chart Ask Line Visibility
   MyChart.ShowLineAsk = true;//assign custom Chart Ask Line Visibility
   DefaultChart.ShowLineBid = ShowLineBid();//assign Chart Bid Line Visibility
   MyChart.ShowLineBid = true;//assign custom Chart Bid Line Visibility
   DefaultChart.ShowPeriodSep = ShowPeriodSep();//assign Chart Period Separator Visibility
   MyChart.ShowPeriodSep = true;//assign custom Chart Period Separator Visibility
   DefaultChart.ShowOHLC = ShowOHLC();//assign Chart Open-High-Low-Close Visibility
   MyChart.ShowOHLC = false;//assign custom Chart Open-High-Low-Close Visibility
   DefaultChart.ShowGrid = ShowGrid();//assign Chart Grid Visibility
   MyChart.ShowGrid = false;//assign custom Chart Grid Visibility
   DefaultChart.ShowVolumes = ShowVolumes();//assign Chart Volumes Visibility
   MyChart.ShowVolumes = CHART_VOLUME_HIDE;//assign custom Chart Volumes Visibility
   DefaultChart.AutoScroll = AutoScroll();//assign Chart Auto Scroll Option
   MyChart.AutoScroll = true;//assign custom Chart Auto Scroll Option
   DefaultChart.Shift = Shift();//assign Chart Shift Option
   MyChart.Shift = true;//assign custom Chart Shift Option
   DefaultChart.ShiftSize = ShiftSize();//assign Chart Shift Size
   MyChart.ShiftSize = 15;//assign custom Chart Shift Size
   DefaultChart.ShowObjectDescr = ShowObjectDescr();//assign Chart Object Descriptions
   MyChart.ShowObjectDescr = false;//assign custom Chart Object Descriptions
   DefaultChart.Navigate = CHART_END;//assign Chart Navigate
   MyChart.Navigate = CHART_END;//assign custom Chart Navigate
   //---assign Chart Trade Levels Visibility
   DefaultChart.CHART_SHOW_TRADE_LEVELS = ChartGetInteger(ChartId(),CHART_SHOW_TRADE_LEVELS);
   //---assign custom Chart Trade Levels Visibility
   MyChart.CHART_SHOW_TRADE_LEVELS = ulong(true);
   //---assign Chart One Click Trading Visibility
   DefaultChart.CHART_SHOW_ONE_CLICK = ChartGetInteger(ChartId(),CHART_SHOW_ONE_CLICK);
   //---assign custom Chart One Click Trading Visibility
   MyChart.CHART_SHOW_ONE_CLICK = ulong(false);
   //---assign Chart Ticker Visibility
   DefaultChart.CHART_SHOW_TICKER = ChartGetInteger(ChartId(),CHART_SHOW_TICKER);
   //---assign custom Chart Ticker Visibility
   MyChart.CHART_SHOW_TICKER = ulong(false);
   //---assign Chart Drag Trade levels
   DefaultChart.CHART_DRAG_TRADE_LEVELS = ChartGetInteger(ChartId(),CHART_DRAG_TRADE_LEVELS);
   //---assign custom Chart Drag Trade levels
   MyChart.CHART_DRAG_TRADE_LEVELS = ulong(false);
  }

Nuestra función ChartSet tomará nuestra estructura ChartProp como argumento para configurar el gráfico actual.

//+------------------------------------------------------------------+
//|Apply Chart format                                                |
//+------------------------------------------------------------------+
void CChartProperties::ChartSet(ChartProp &Prop)
  {
   Mode(Prop.mode);//Set Chart Candle Mode
   ColorBackground(Prop.clrBackground);//Set Chart Background Color
   ColorForeground(Prop.clrForeground);//Set Chart Foreground Color
   ColorLineLast(Prop.clrLineLast);//Set Chart Line Color
   ColorCandleBear(Prop.clrCandleBear);//Set Chart Bear Candle Color
   ColorBarDown(Prop.clrBarDown);//Set Chart Down Candle Color
   ColorCandleBull(Prop.clrCandleBull);//Set Chart Bull Candle Color
   ColorBarUp(Prop.clrBarUp);//Set Chart Up Candle Color
   ColorLineAsk(Prop.clrLineAsk);//Set Chart Ask Color
   ColorLineBid(Prop.clrLineBid);//Set Chart Bid Color
   ColorChartLine(Prop.clrChartLine);//Set Chart Line Color
   ColorStopLevels(Prop.clrStopLevels);//Set Chart Stop Level Color
   ColorVolumes(Prop.clrVolumes);//Set Chart Volumes Color
   Foreground(Prop.Foreground);//Set if Chart is in Foreground Visibility
   ShowLineAsk(Prop.ShowLineAsk);//Set Chart Ask Line Visibility
   ShowLineBid(Prop.ShowLineBid);//Set Chart Bid Line Visibility
   ShowPeriodSep(Prop.ShowPeriodSep);//Set Chart Period Separator Visibility
   ShowOHLC(Prop.ShowOHLC);//Set Chart Open-High-Low-Close Visibility
   ShowGrid(Prop.ShowGrid);//Set Chart Grid Visibility
   ShowVolumes(Prop.ShowVolumes);//Set Chart Volumes Visibility
   AutoScroll(Prop.AutoScroll);//Set Chart Auto Scroll Option
   Shift(Prop.Shift);//Set Chart Shift Option
   ShiftSize(Prop.ShiftSize);//Set Chart Shift Size Value
   ShowObjectDescr(Prop.ShowObjectDescr);//Set Chart Show Object Descriptions
   ChartSetInteger(ChartId(),CHART_SHOW_TRADE_LEVELS,Prop.CHART_SHOW_TRADE_LEVELS);//Set Chart Trade Levels Visibility
   ChartSetInteger(ChartId(),CHART_SHOW_ONE_CLICK,Prop.CHART_SHOW_ONE_CLICK);//Set Chart One Click Trading Visibility
   ChartSetInteger(ChartId(),CHART_SHOW_TICKER,Prop.CHART_SHOW_TICKER);//Set Chart Ticker Visibility
   ChartSetInteger(ChartId(),CHART_DRAG_TRADE_LEVELS,Prop.CHART_DRAG_TRADE_LEVELS);//Set Chart Drag Trade levels
   Navigate(Prop.Navigate);//Set Chart Navigate
  }

En cuanto a la función GetChartPeriodName, recuperaremos el nombre del período del gráfico actual mediante una declaración switch.

//+------------------------------------------------------------------+
//|Retrieve Period name                                              |
//+------------------------------------------------------------------+
string CChartProperties::GetChartPeriodName()
  {
   switch(ChartPeriod(ChartId()))//Get chart Period with chart id
     {
      case PERIOD_M1:
         return("M1");
      case PERIOD_M2:
         return("M2");
      case PERIOD_M3:
         return("M3");
      case PERIOD_M4:
         return("M4");
      case PERIOD_M5:
         return("M5");
      case PERIOD_M6:
         return("M6");
      case PERIOD_M10:
         return("M10");
      case PERIOD_M12:
         return("M12");
      case PERIOD_M15:
         return("M15");
      case PERIOD_M20:
         return("M20");
      case PERIOD_M30:
         return("M30");
      case PERIOD_H1:
         return("H1");
      case PERIOD_H2:
         return("H2");
      case PERIOD_H3:
         return("H3");
      case PERIOD_H4:
         return("H4");
      case PERIOD_H6:
         return("H6");
      case PERIOD_H8:
         return("H8");
      case PERIOD_H12:
         return("H12");
      case PERIOD_D1:
         return("Daily");
      case PERIOD_W1:
         return("Weekly");
      case PERIOD_MN1:
         return("Monthly");
     }
   return("unknown period");
  }

Nuestro destructor restaurará la configuración del gráfico anterior antes de que realizáramos cualquier cambio en el gráfico.

//+------------------------------------------------------------------+
//|Destructor                                                        |
//+------------------------------------------------------------------+
CChartProperties::~CChartProperties()
  {
   ChartSet(DefaultChart);//restore chart default configuration
   m_chart_id=-1;//reset chart id
  }

Clase de propiedades de objeto

En esta clase se realizaron algunos cambios en el color del texto de todos los objetos personalizados. En la Parte 2 solo se puede usar un color de texto de objeto para todos los objetos de texto. Nuestra solución es declarar una variable de color fuera de la clase llamada TextObj_color.

#include "ChartProperties.mqh"
color TextObj_color;
//+------------------------------------------------------------------+
//|ObjectProperties class                                            |
//+------------------------------------------------------------------+
class CObjectProperties:public CChartProperties
  {
private:
   //Simple  chart objects structure
   struct ObjStruct
     {
      long           ChartId;
      string         Name;
     } Objects[];//ObjStruct variable array

   //-- Add chart object to Objects array
   void              AddObj(long chart_id,string name)
     {
      ArrayResize(Objects,Objects.Size()+1,Objects.Size()+2);
      Objects[Objects.Size()-1].ChartId=chart_id;
      Objects[Objects.Size()-1].Name=name;
     }

protected:
   void              DeleteObj()
     {
      for(uint i=0;i<Objects.Size();i++)
        {
         ObjectDelete(Objects[i].ChartId,Objects[i].Name);
        }
     }

public:
                     CObjectProperties(void) {}//Class constructor

   //-- Create Rectangle chart object
   void              Square(long chart_ID,string name,int x_coord,int y_coord,int width,int height,ENUM_ANCHOR_POINT Anchor);

   //-- Create text chart object
   void              TextObj(long chartID,string name,string text,int x_coord,int y_coord,
                             ENUM_BASE_CORNER Corner=CORNER_LEFT_UPPER,int fontsize=10);

   //-- Create Event object
   void               EventObj(long chartID,string name,string description,datetime eventdate);

   //-- Class destructor removes all chart objects created previously
                    ~CObjectProperties(void)
     {
      DeleteObj();
     }
  };

Como podemos ver a continuación los parámetros para la función Textobj son muchos, para evitar hacer los parámetros más largos solo usaremos Textobj_color para cambiar el color del objeto texto.

//+------------------------------------------------------------------+
//|Create text chart object                                          |
//+------------------------------------------------------------------+
void CObjectProperties::TextObj(long chartID,string name,string text,int x_coord,int y_coord,
                                ENUM_BASE_CORNER Corner=CORNER_LEFT_UPPER,int fontsize=10)
  {
   ObjectDelete(chartID,name);//Delete previous object with the same name and chart id
   if(ObjectCreate(chartID,name,OBJ_LABEL,0,0,0))//Create object label
     {
      AddObj(chartID,name);//Add object to array
      ObjectSetInteger(chartID,name,OBJPROP_XDISTANCE,x_coord);//Set x Distance/coordinate
      ObjectSetInteger(chartID,name,OBJPROP_YDISTANCE,y_coord);//Set y Distance/coordinate
      ObjectSetInteger(chartID,name,OBJPROP_CORNER,Corner);//Set object's corner anchor
      ObjectSetString(chartID,name,OBJPROP_TEXT,text);//Set object's text
      ObjectSetInteger(chartID,name,OBJPROP_COLOR,TextObj_color);//Set object's color
      ObjectSetInteger(chartID,name,OBJPROP_FONTSIZE,fontsize);//Set object's font-size
     }
   else
     {
      Print("Failed to create object: ",name);
     }
  }

Se realizó un pequeño cambio en nuestra función Square para permitir diferentes colores de fondo según el modo de color del gráfico.

//+------------------------------------------------------------------+
//|Create Rectangle chart object                                     |
//+------------------------------------------------------------------+
void CObjectProperties::Square(long chart_ID,string name,int x_coord,int y_coord,int width,int height,ENUM_ANCHOR_POINT Anchor)
  {
   const int              sub_window=0;             // subwindow index
   const int              x=x_coord;                // X coordinate
   const int              y=y_coord;                // Y coordinate
   const color            back_clr=(isLightMode)?clrWhite:clrBlack;// background color
   const ENUM_BORDER_TYPE border=BORDER_SUNKEN;     // border type
   const color            clr=clrRed;               // flat border color (Flat)
   const ENUM_LINE_STYLE  style=STYLE_SOLID;        // flat border style
   const int              line_width=0;             // flat border width
   const bool             back=false;               // in the background
   const bool             selection=false;          // highlight to move
   const bool             hidden=true;              // hidden in the object list

   ObjectDelete(chart_ID,name);//Delete previous object with the same name and chart id
   if(ObjectCreate(chart_ID,name,OBJ_RECTANGLE_LABEL,sub_window,0,0))//create rectangle object label
     {
      AddObj(chart_ID,name);//Add object to array
      ObjectSetInteger(chart_ID,name,OBJPROP_XDISTANCE,x);//Set x Distance/coordinate
      ObjectSetInteger(chart_ID,name,OBJPROP_YDISTANCE,y);//Set y Distance/coordinate
      ObjectSetInteger(chart_ID,name,OBJPROP_XSIZE,width);//Set object's width/x-size
      ObjectSetInteger(chart_ID,name,OBJPROP_YSIZE,height);//Set object's height/y-size
      ObjectSetInteger(chart_ID,name,OBJPROP_BGCOLOR,back_clr);//Set object's background color
      ObjectSetInteger(chart_ID,name,OBJPROP_BORDER_TYPE,border);//Set object's border type
      ObjectSetInteger(chart_ID,name,OBJPROP_ANCHOR,Anchor);//Set objects anchor point
      ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);//Set object's color
      ObjectSetInteger(chart_ID,name,OBJPROP_STYLE,style);//Set object's style
      ObjectSetInteger(chart_ID,name,OBJPROP_WIDTH,line_width);//Set object's flat border width
      ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);//Set if object is in foreground or not
      ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);//Set if object is selectable/dragable
      ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);//Set if object is Selected
      ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);//Set if object is hidden in object list
      ChartRedraw(chart_ID);
     }
   else
     {
      Print("Failed to create object: ",name);
     }
  }

Archivo CommonVariables

Para propósitos de trading decidí crear una base de datos en memoria, esta base de datos necesita un nombre y el nombre tomará en consideración el nombre del broker, el ID del gráfico actual, y si el experto está en el probador de estrategias o no.  

#define NEWS_DATABASE_MEMORY           StringFormat("Calendar_%s_%d_%s.sqlite",broker,ChartID(),(MQLInfoInteger(MQL_TESTER)?"TESTER":"REAL"))

La opción de enumeración Choice es para personalización y se utilizará para la entrada del experto, esto reemplazará el tipo de datos booleano. La enumeración DayOfTheWeek se utilizará para seleccionar el día de negociación de la semana sin sábado ni domingo. Mientras que la función booleana Answer convertirá la enumeración Choice en un tipo de datos booleano.

enum Choice
  {
   Yes,//YES
   No//NO
  };

enum DayOfTheWeek
  {
   Monday,//MONDAY
   Tuesday,//TUESDAY
   Wednesday,//WEDNESDAY
   Thursday,//THURSDAY
   Friday,//FRIDAY
   AllDays//ALL DAYS
  };

//+------------------------------------------------------------------+
//|Convert enumeration Choice into a boolean value                   |
//+------------------------------------------------------------------+
bool Answer(Choice choose)
  {
   return (choose==Yes)?true:false;
  }

Clase de variables de tiempo

El propósito de esta clase es almacenar datos de tiempo de velas, estos datos se utilizarán para verificar si se ha formado una nueva vela.

//+------------------------------------------------------------------+
//|TimeVariables class                                               |
//+------------------------------------------------------------------+
class CTimeVariables
  {
private:
   //---Array to store candlestick times
   datetime          CandleTime[2000];
public:
                     CTimeVariables(void);
   //---Set Array index time
   void              SetTime(uint index,datetime time);
   //---Get Array index time
   datetime          GetTime(uint index);
  };

En el constructor, estableceremos un tiempo predeterminado para todos los índices dentro de la matriz CandleTime.

//+------------------------------------------------------------------+
//|Constructor                                                       |
//+------------------------------------------------------------------+
CTimeVariables::CTimeVariables()
  {
   for(uint i=0; i<CandleTime.Size(); i++)
     {
      CandleTime[i]=D'1970.01.01';
     }
  }

En la función SetTime tenemos dos parámetros, uno para el índice del array y el otro para la fecha y hora. Si el argumento de índice es mayor o igual a cero y menor que el tamaño de CandleTime, entonces asignaremos el índice de la matriz con el argumento de tiempo. 

//+------------------------------------------------------------------+
//|Set Array index time                                              |
//+------------------------------------------------------------------+
void CTimeVariables::SetTime(uint index,datetime time)
  {
   if(index>=0&&index<CandleTime.Size())
     {
      CandleTime[index] = time;
     }
  }

La función GetTime aceptará un argumento entero positivo para recuperar la fecha y hora del valor del índice de la matriz CandleTime si el argumento del índice es válido.

//+------------------------------------------------------------------+
//|Get Array index time                                              |
//+------------------------------------------------------------------+
datetime CTimeVariables::GetTime(uint index)
  {
   return (index>=0&&index<CandleTime.Size())?CandleTime[index]:datetime(0);
  }

Clase de gestión del tiempo

Declararemos la enumeración DSTSchedule para que el usuario/comerciante seleccione entre DST automático o DST personalizado para la entrada del experto. La variable MySchedule se utilizará para almacenar el horario de verano personalizado.

//-- Enumeration for DST schedule
enum DSTSchedule
  {
   AutoDst_Selection,//AUTO DST
   CustomDst_Selection//CUSTOM DST
  } MyDST;

DST_type MySchedule;//Variable for custom DST schedule

La siguiente función devolverá la hora de una fecha específica en un tipo de datos entero. 

int               ReturnHour(datetime time);//Returns the Hour for a specific date

//+------------------------------------------------------------------+
//|Returns the Hour for a specific date                              |
//+------------------------------------------------------------------+
int CTimeManagement::ReturnHour(datetime time)
  {
   return Time(time).hour;
  }

La siguiente función devolverá el minuto de una fecha específica en un tipo de datos entero. 

int               ReturnMinute(datetime time);//Returns the Minute for a specific date

//+------------------------------------------------------------------+
//|Returns the Minute for a specific date                            |
//+------------------------------------------------------------------+
int CTimeManagement::ReturnMinute(datetime time)
  {
   return Time(time).min;
  }

La siguiente función devolverá los segundos de una fecha específica en un tipo de datos entero. 

int               ReturnSecond(datetime time);//Returns the Second for s specific date

//+------------------------------------------------------------------+
//|Returns the Second for s specific date                            |
//+------------------------------------------------------------------+
int CTimeManagement::ReturnSecond(datetime time)
  {
   return Time(time).sec;
  }

La siguiente función devolverá MqlDateTime para el argumento de fecha y hora.

//-- Will convert datetime to MqlDateTime
   MqlDateTime       Time(datetime Timetoformat);

//+------------------------------------------------------------------+
//|Will convert datetime to MqlDateTime                              |
//+------------------------------------------------------------------+
MqlDateTime CTimeManagement::Time(datetime Timetoformat)
  {
   TimeToStruct(Timetoformat,timeFormat);
   return timeFormat;
  }

La siguiente función devolverá la fecha y hora del argumento datetime con modificaciones a la hora, minuto y segundo.

//-- Will return a datetime with changes to the hour,minute and second
   datetime          Time(datetime time,int Hour,int Minute,int Second);

//+------------------------------------------------------------------+
//|Will return a datetime with changes to the hour,minute and second |
//+------------------------------------------------------------------+
datetime CTimeManagement::Time(datetime time,int Hour,int Minute,int Second)
  {
   timeFormat=Time(time);
   timeFormat.hour=Hour;
   timeFormat.min=Minute;
   timeFormat.sec=Second;
   return StructToTime(timeFormat);
  }

La siguiente función devolverá la fecha y hora del argumento datetime con modificaciones en la hora y los minutos.

//-- Will return a datetime with changes to the hour and minute
   datetime          Time(datetime time,int Hour,int Minute);

//+------------------------------------------------------------------+
//|Will return a datetime with changes to the hour and minute        |
//+------------------------------------------------------------------+
datetime CTimeManagement::Time(datetime time,int Hour,int Minute)
  {
   timeFormat=Time(time);
   timeFormat.hour=Hour;
   timeFormat.min=Minute;
   return StructToTime(timeFormat);
  }

La siguiente función devolverá verdadero si el tiempo de TimeTradeServer está dentro de los argumentos BeginTime y EndTime.

//-- Check current time is within a time range
   bool              TimeIsInRange(datetime BeginTime,datetime EndTime);

//+------------------------------------------------------------------+
//|Check current time is within a time range                         |
//+------------------------------------------------------------------+
bool CTimeManagement::TimeIsInRange(datetime BeginTime,datetime EndTime)
  {
   if(BeginTime<=TimeTradeServer()&&EndTime>=TimeTradeServer())
     {
      return true;
     }
   return false;
  }

La siguiente función devolverá verdadero si la fecha y hora de PreEvent es menor o igual que TimeTradeServer y EventTime es mayor que TimeTradeServer.

//-- Check if current time is within preEvent time and Event time
   bool              TimePreEvent(datetime PreEvent,datetime Event);

//+------------------------------------------------------------------+
//|Check if current time is within preEvent time and Event time      |
//+------------------------------------------------------------------+
bool CTimeManagement::TimePreEvent(datetime PreEventTime,datetime EventTime)
  {
   if(PreEventTime<=TimeTradeServer()&&EventTime>TimeTradeServer())
     {
      return true;
     }
   return false;
  }

La siguiente función devolverá MqlDateTime para la hora actual con modificaciones en la hora y los minutos.

//-- Return MqlDateTime for current date time with custom hour and minute
   MqlDateTime       Today(int Hour,int Minute);

//+------------------------------------------------------------------+
//|Return MqlDateTime for current date time with custom hour and     |
//|minute                                                            |
//+------------------------------------------------------------------+
MqlDateTime CTimeManagement::Today(int Hour,int Minute)
  {
   TimeTradeServer(today);
   today.hour=Hour;
   today.min=Minute;
   return today;
  }

La siguiente función devolverá MqlDateTime para la hora actual con modificaciones a la hora, minutos y segundos.

//-- Return MqlDateTime for current date time with custom hour, minute and second
   MqlDateTime       Today(int Hour,int Minute,int Second);

//+------------------------------------------------------------------+
//|Return MqlDateTime for current date time with custom hour, minute |
//|and second                                                        |
//+------------------------------------------------------------------+
MqlDateTime CTimeManagement::Today(int Hour,int Minute,int Second)
  {
   TimeTradeServer(today);
   today.hour=Hour;
   today.min=Minute;
   today.sec=Second;
   return today;
  }

La siguiente función devolverá verdadero si el día actual es igual al día correspondiente de la semana, o la enumeración DayOfTheWeek es igual a AllDays.

//-- Check current day of the week
   bool              isDayOfTheWeek(DayOfTheWeek Day);

//+------------------------------------------------------------------+
//|Check current day of the week                                     |
//+------------------------------------------------------------------+
bool CTimeManagement::isDayOfTheWeek(DayOfTheWeek Day)
  {
   switch(Day)
     {
      case  Monday://Monday
         if(DayOfWeek(TimeTradeServer())==MONDAY)
           {
            return true;
           }
         break;
      case Tuesday://Tuesday
         if(DayOfWeek(TimeTradeServer())==TUESDAY)
           {
            return true;
           }
         break;
      case Wednesday://Wednesday
         if(DayOfWeek(TimeTradeServer())==WEDNESDAY)
           {
            return true;
           }
         break;
      case Thursday://Thursday
         if(DayOfWeek(TimeTradeServer())==THURSDAY)
           {
            return true;
           }
         break;
      case Friday://Friday
         if(DayOfWeek(TimeTradeServer())==FRIDAY)
           {
            return true;
           }
         break;
      case AllDays://All days
         return true;
         break;
      default://Unknown
         break;
     }
   return false;
  }

La siguiente función devolverá el día de la semana de una fecha específica.

//-- Return enumeration Day of week for a certain date
   ENUM_DAY_OF_WEEK  DayOfWeek(datetime time);

//+------------------------------------------------------------------+
//|Return enumeration Day of week for a certain date                 |
//+------------------------------------------------------------------+
ENUM_DAY_OF_WEEK CTimeManagement::DayOfWeek(datetime time)
  {
   return (ENUM_DAY_OF_WEEK)Time(time).day_of_week;
  }

Clase de propiedades de las velas

Se ha agregado una nueva función a esta clase.

//+------------------------------------------------------------------+
//|CandleProperties class                                            |
//+------------------------------------------------------------------+
class CCandleProperties : public CChartProperties
  {
private:
   CTimeManagement   Time;//TimeManagement object
   CTimeVariables    CTV;//Timevariables object
public:
   double            Open(int CandleIndex,ENUM_TIMEFRAMES Period=PERIOD_CURRENT,string SYMBOL=NULL);//Retrieve Candle Open-Price
   double            Close(int CandleIndex,ENUM_TIMEFRAMES Period=PERIOD_CURRENT,string SYMBOL=NULL);//Retrieve Candle Close-Price
   double            High(int CandleIndex,ENUM_TIMEFRAMES Period=PERIOD_CURRENT,string SYMBOL=NULL);//Retrieve Candle High-Price
   double            Low(int CandleIndex,ENUM_TIMEFRAMES Period=PERIOD_CURRENT,string SYMBOL=NULL);//Retrieve Candle Low-Price
   bool              IsLargerThanPreviousAndNext(datetime CandleTime,int Offset,string SYMBOL);//Determine if one candle is larger than two others
   bool              NewCandle(int index,ENUM_TIMEFRAMES period=PERIOD_CURRENT,string SYMBOL=NULL);//Check if a new candle is present
  };

La función NewCandle devolverá verdadero cuando se haya formado una nueva vela y luego guardará el tiempo de apertura de la vela actual en la clase Timevariables usando la función SetTime. El tiempo guardado previamente se comparará con el tiempo de apertura de la vela actual para verificar si los tiempos son diferentes; si los tiempos son diferentes, entonces asumimos que se ha formado una nueva vela.

//+------------------------------------------------------------------+
//|Check if a new candle is present                                  |
//+------------------------------------------------------------------+
bool CCandleProperties::NewCandle(int index,ENUM_TIMEFRAMES period=PERIOD_CURRENT,string SYMBOL=NULL)
  {
   if(CTV.GetTime(index) == iTime(((SYMBOL==NULL)?Symbol():SYMBOL),period,0))
     {
      return false;//Candle time are equal no new candles have formed
     }
   else
     {
     //--- Candle time has changed set the new time
      CTV.SetTime(index,iTime(((SYMBOL==NULL)?Symbol():SYMBOL),period,0));
      return true;
     }
  }

Clase de sesiones

El propósito de esta clase es abordar los tiempos de negociación de las sesiones. No utilizaremos estos tiempos de sesiones comerciales en este artículo, pero le daremos un uso a esta clase más adelante. Esta clase heredará de la clase TimeManagement ya que esta clase utilizará las funciones de TimeManagement.

#include "Timemanagement.mqh"
//+------------------------------------------------------------------+
//|Sessions Class                                                    |
//+------------------------------------------------------------------+
class CSessions:CTimeManagement
  {
public:
                     CSessions(void) {}
                    ~CSessions(void) {}
   //--- Check if trading Session has began
   bool              isSessionStart(int offsethour=0,int offsetmin=0);
   //--- Check if trading Session has ended
   bool              isSessionEnd(int offsethour=0,int offsetmin=45);
   //--- Get Session End datetime
   datetime          SessionEnd(int offsethour=0,int offsetmin=45);
  };

La función a continuación verificará todas las sesiones comerciales válidas para el símbolo actual y el día de la semana. Una vez que se encuentre la sesión comercial más temprana, la agregaremos y compensaremos con este tiempo, por ejemplo. Si la sesión de negociación más temprana es de 01:00 a 05:00, entonces nuestra hora de compensación es 1 y el minuto de compensación es 0, nuestra sesión de negociación comenzará a las 02:00 a 05:00. El propósito de conocer la hora de inicio de la sesión es evitar grandes diferenciales que suelen producirse al comienzo de la sesión de negociación. Si nuestra sesión comercial está actualmente activa, la función devolverá verdadero. 

//+------------------------------------------------------------------+
//|Check if trading Session has started                              |
//+------------------------------------------------------------------+
bool CSessions::isSessionStart(int offsethour=0,int offsetmin=0)
  {
//--- Declarations
   datetime datefrom,dateto,DateFrom[],DateTo[];

//--- Find all session times
   for(int i=0; i<10; i++)
     {
      //--- Get the session dates for the current symbol and Day of week
      if(SymbolInfoSessionTrade(Symbol(),DayOfWeek(TimeTradeServer()),i,datefrom,dateto))
        {
         //--- Check if the end date's hour is at midnight
         if(ReturnHour(dateto)==00||ReturnHour(dateto)==24)
           {
            //--- Adjust the date to one minute before midnight
            dateto = Time(TimeTradeServer(),23,59);
           }
         //--- Re-adjust DateFrom Array size
         ArrayResize(DateFrom,int(ArraySize(DateFrom))+1,int(ArraySize(DateFrom))+2);
         //--- Assign the last array index datefrom value
         DateFrom[int(ArraySize(DateFrom))-1] = datefrom;
         //--- Re-adjust DateTo Array size
         ArrayResize(DateTo,int(ArraySize(DateTo))+1,int(ArraySize(DateTo))+2);
         //--- Assign the last array index dateto value
         DateTo[int(ArraySize(DateTo))-1] = dateto;
        }
     }

//--- Check if there are session times
   if(DateFrom.Size()>0)
     {
      /* Adjust DateFrom index zero date as the first index date will be the earliest date
       from the whole array, we add the offset to this date only*/
      DateFrom[0] = TimePlusOffset(DateFrom[0],MinutesS(startoffsetmin));
      DateFrom[0] = TimePlusOffset(DateFrom[0],HoursS(startoffsethour));
      //--- Iterate through the whole array
      for(uint i=0; i<DateFrom.Size(); i++)
        {
         //--- Check if the current time is within the trading session
         if(TimeIsInRange(DateFrom[i],DateTo[i]))
           {
            return true;
           }
        }
     }
   else
     {
      //--- If there are no trading session times
      return true;
     }
   return false;
  }

La siguiente función devolverá el valor verdadero si la sesión ha finalizado. En algunos corredores, una hora antes de que finalice la sesión de negociación, los diferenciales son enormes, por lo que esta función puede ayudarnos a evitar operar durante esos momentos.

//+------------------------------------------------------------------+
//|Check if trading Session has ended                                |
//+------------------------------------------------------------------+
bool CSessions::isSessionEnd(int offsethour=0,int offsetmin=45)
  {
//--- Declarations
   datetime datefrom,dateto,DateTo[],lastdate=0,sessionend;

//--- Find all session times
   for(int i=0; i<10; i++)
     {
      //--- Get the session dates for the current symbol and Day of week
      if(SymbolInfoSessionTrade(Symbol(),DayOfWeek(TimeTradeServer()),i,datefrom,dateto))
        {
         //--- Check if the end date's hour is at midnight
         if(ReturnHour(dateto)==00||ReturnHour(dateto)==24)
           {
            //--- Adjust the date to one minute before midnight
            dateto = Time(TimeTradeServer(),23,59);
           }
         //--- Re-adjust DateTo Array size
         ArrayResize(DateTo,int(ArraySize(DateTo))+1,int(ArraySize(DateTo))+2);
         //--- Assign the last array index dateto value
         DateTo[int(ArraySize(DateTo))-1] = dateto;
        }
     }

//--- Check if there are session times
   if(DateTo.Size()>0)
     {
      //--- Assign lastdate a default value
      lastdate = DateTo[0];
      //--- Iterate through the whole array
      for(uint i=0; i<DateTo.Size(); i++)
        {
         //--- Check for the latest date in the array
         if(DateTo[i]>lastdate)
           {
            lastdate = DateTo[i];
           }
        }
     }
   else
     {
      //--- If there are no trading session times
      return false;
     }
   /* get the current time and modify the hour and minute time to the lastdate variable
   and assign the new datetime to sessionend variable*/
   sessionend = Today(ReturnHour(lastdate),ReturnMinute(lastdate));
//--- Re-adjust the sessionend dates with the minute and hour offsets
   sessionend = TimeMinusOffset(sessionend,MinutesS(offsetmin));
   sessionend = TimeMinusOffset(sessionend,HoursS(offsethour));

//--- Check if sessionend date is more than the current time
   if(TimeTradeServer()<sessionend)
     {
      return false;
     }
   return true;
  }

La función de abajo devolverá la fecha de finalización de la sesión de negociación para el día actual, hay algunas limitaciones a los tiempos de la sesión de negociación en MQL5, me he dado cuenta de que durante un día festivo algunos símbolos pueden cerrar mucho antes de lo que el tiempo de la sesión de negociación indicaría por lo que es algo a tener en cuenta.

//+------------------------------------------------------------------+
//|Get Session End datetime                                          |
//+------------------------------------------------------------------+
datetime CSessions::SessionEnd(int offsethour=0,int offsetmin=45)
  {
//--- Declarations
   datetime datefrom,dateto,DateTo[],lastdate=0,sessionend;

//--- Find all session times
   for(int i=0; i<10; i++)
     {
      //--- Get the session dates for the current symbol and Day of week
      if(SymbolInfoSessionTrade(Symbol(),DayOfWeek(TimeTradeServer()),i,datefrom,dateto))
        {
         //--- Check if the end date's hour is at midnight
         if(CTV.ReturnHour(dateto)==00||CTV.ReturnHour(dateto)==24)
           {
            //--- Adjust the date to one minute before midnight
            dateto = Time(TimeTradeServer(),23,59);
           }
         //--- Re-adjust DateTo Array size
         ArrayResize(DateTo,int(ArraySize(DateTo))+1,int(ArraySize(DateTo))+2);
         //--- Assign the last array index dateto value
         DateTo[int(ArraySize(DateTo))-1] = dateto;
        }
     }

//--- Check if there are session times
   if(DateTo.Size()>0)
     {
      //--- Assign lastdate a default value
      lastdate = DateTo[0];
      //--- Iterate through the whole array
      for(uint i=0; i<DateTo.Size(); i++)
        {
         //--- Check for the latest date in the array
         if(DateTo[i]>lastdate)
           {
            lastdate = DateTo[i];
           }
        }
     }
   else
     {
      //--- If there are no trading session times
      return 0;
     }
   /* get the current time and modify the hour and minute time to the lastdate variable
   and assign the new datetime to sessionend variable*/
   sessionend = Today(ReturnHour(lastdate),ReturnMinute(lastdate));
//--- Re-adjust the sessionend dates with the minute and hour offsets
   sessionend = TimeMinusOffset(sessionend,MinutesS(offsetmin));
   sessionend = TimeMinusOffset(sessionend,HoursS(offsethour));
//--- return sessionend date
   return sessionend;
  }

Clase de noticias

Esta clase es la más importante de todo el proyecto y la más grande, abarcando más de 1000 líneas de código únicamente. A partir de la Parte 2, realizamos mejoras importantes en esta clase y en el código que interactúa con la base de datos del calendario en la carpeta común. En este artículo crearemos otra base de datos, pero esta vez, la base de datos estará en la memoria.

Beneficios de las bases de datos en memoria en comparación con las de almacenamiento.

• Velocidad: las bases de datos en memoria almacenan los datos directamente en la RAM, lo que agiliza considerablemente las operaciones de lectura y escritura. Esto es especialmente beneficioso para las aplicaciones que requieren análisis y procesamiento de datos en tiempo real. Dado que la RAM es mucho más rápida que el almacenamiento en disco, el acceso a los datos en una base de datos en memoria es más rápido. Esto reduce los tiempos de respuesta y mejora el rendimiento general.
• Rendimiento: la latencia reducida y el acceso más rápido a los datos se traducen en un mayor rendimiento, lo que significa que la base de datos puede gestionar más transacciones por segundo. Las bases de datos en memoria pueden procesar grandes volúmenes de datos de forma más eficiente, lo que las hace adecuadas para aplicaciones de big data, análisis y otras tareas informáticas intensivas.

Seguiremos usando nuestra base de datos en almacenamiento, recopilaremos los datos de la base de datos en almacenamiento y transferiremos estos datos a nuestra nueva base de datos en memoria para lograr un rendimiento equilibrado al realizar pruebas retrospectivas, ya que solo usar la base de datos en almacenamiento afectará drásticamente antes, dependiendo de las especificaciones de su computadora.

Comenzaremos con las declaraciones fuera de la clase para su uso en la entrada del experto. La variable entera DBMemoryConnection contendrá el identificador de conexión entera para nuestra base de datos en la memoria. Calendar_Importance se utilizará para seleccionar la importancia de los distintos eventos en el parámetro de entrada del experto. Event_Sector se utilizará para seleccionar distintos sectores de sucesos en el parámetro de entrada del experto. Event_Frequency se utilizará para seleccionar diferentes frecuencias de eventos para el parámetro de entrada del experto. Event_Type se utilizará para seleccionar diferentes tipos de eventos para el parámetro de entrada del experto. Event_Currency se utilizará para seleccionar diferentes opciones de divisa del evento en el parámetro de entrada del experto. La variable de estructura del calendario UpcomingNews almacenará los detalles del próximo evento económico para facilitar el acceso en otras clases/archivos; la declaramos fuera de la clase de noticias.

int       DBMemoryConnection;//In memory database handle

//--- Enumeration for Calendar Importance
enum Calendar_Importance
  {
   Calendar_Importance_None,//NONE
   Calendar_Importance_Low,//LOW
   Calendar_Importance_Moderate,//MODERATE
   Calendar_Importance_High,//HIGH
   Calendar_Importance_All//ALL
  } myImportance;

//--- Enumeration for Calendar Sector
enum Event_Sector
  {
   Event_Sector_None,//NONE
   Event_Sector_Market,//MARKET
   Event_Sector_Gdp,//GDP
   Event_Sector_Jobs,//JOBS
   Event_Sector_Prices,//PRICES
   Event_Sector_Money,//MONEY
   Event_Sector_Trade,//TRADE
   Event_Sector_Government,//GOVERNMENT
   Event_Sector_Business,//BUSINESS
   Event_Sector_Consumer,//CONSUMER
   Event_Sector_Housing,//HOUSING
   Event_Sector_Taxes,//TAXES
   Event_Sector_Holidays,//HOLIDAYS
   Event_Sector_ALL//ALL
  } mySector;

//--- Enumeration for Calendar Event Frequency
enum Event_Frequency
  {
   Event_Frequency_None,//NONE
   Event_Frequency_Week,//WEEK
   Event_Frequency_Month,//MONTH
   Event_Frequency_Quarter,//QUARTER
   Event_Frequency_Year,//YEAR
   Event_Frequency_Day,//DAY
   Event_Frequency_ALL//ALL
  } myFrequency;

//--- Enumeration for Calendar Event type
enum Event_Type
  {
   Event_Type_Event,//EVENT
   Event_Type_Indicator,//INDICATOR
   Event_Type_Holiday,//HOLIDAY
   Event_Type_All//ALL
  } myType;

//--- Enumeration for Calendar Event Currency
enum Event_Currency
  {
   Event_Currency_Symbol,//SYMBOL CURRENCIES
   Event_Currency_Margin,//SYMBOL MARGIN
   Event_Currency_Base,//SYMBOL BASE
   Event_Currency_Profit,//SYMBOL PROFIT
   Event_Currency_ALL,//ALL CURRENCIES
   Event_Currency_NZD_NZ,//NZD -> NZ
   Event_Currency_EUR_EU,//EUR -> EU
   Event_Currency_JPY_JP,//JPY -> JP
   Event_Currency_CAD_CA,//CAD -> CA
   Event_Currency_AUD_AU,//AUD -> AU
   Event_Currency_CNY_CN,//CNY -> CN
   Event_Currency_EUR_IT,//EUR -> IT
   Event_Currency_SGD_SG,//SGD -> SG
   Event_Currency_EUR_DE,//EUR -> DE
   Event_Currency_EUR_FR,//EUR -> FR
   Event_Currency_BRL_BR,//BRL -> BR
   Event_Currency_MXN_MX,//MXN -> MX
   Event_Currency_ZAR_ZA,//ZAR -> ZA
   Event_Currency_HKD_HK,//HKD -> HK
   Event_Currency_INR_IN,//INR -> IN
   Event_Currency_NOK_NO,//NOK -> NO
   Event_Currency_USD_US,//USD -> US
   Event_Currency_GBP_GB,//GBP -> GB
   Event_Currency_CHF_CH,//CHF -> CH
   Event_Currency_KRW_KR,//KRW -> KW
   Event_Currency_EUR_ES,//EUR -> ES
   Event_Currency_SEK_SE,//SEK -> SE
   Event_Currency_ALL_WW//ALL -> WW
  } myCurrency;

//--- Structure variable to store Calendar next Event data
Calendar UpcomingNews;

Funcionalidad adicional a la clase de noticias:

• Ampliación de la enumeración CalendarComponents: EventInfo_View se ha añadido para mostrar los detalles del evento en la base de datos de almacenamiento del calendario, Currencies_View se ha añadido para mostrar todas las monedas disponibles por el calendario económico MQL5.
• La estructura matriz CalendarContents ha aumentado de tamaño de 10 a 12 para acomodar las dos nuevas vistas EventInfo_View y Currencies_View.
• Declaración de la variable DBMemory del tipo de estructura MQL5CalendarContents para almacenar las propiedades de la base de datos.
• Declaración de la estructura CalendarData y las variables para almacenar todos los datos de la base de datos del calendario en la carpeta común.
• Declaración de la función GetCalendar, que solicitará todos los datos filtrados de la base de datos del calendario en la carpeta común y almacenará estos datos en el arreglo de la estructura CalendarData llamado Data. Este arreglo de datos se insertará en nuestra nueva base de datos del calendario en memoria una vez que se haya creado.
• Declaración de la función GetAutoDST para recuperar la enumeración DST_type de la tabla AutoDST en la base de datos del calendario en la carpeta común.
• Declaración de la función Request_Importance para recuperar la cadena de solicitud de la importancia del evento basada en la enumeración Calendar_Importance.
• Declaración de la función Request_Frequency para recuperar la cadena de solicitud de la frecuencia del evento basada en la enumeración Event_Frequency.
• Declaración de la función Request_Sector para recuperar la cadena de solicitud del sector del evento basada en la enumeración Event_Sector.
• Declaración de la función Request_Type para recuperar la cadena de solicitud del tipo de evento basada en la enumeración Event_Type.
• Declaración de la función Request_Currency para recuperar la cadena de solicitud de la moneda del evento basada en la enumeración Event_Currency.
• Declaración de la función EconomicDetailsMemory, que llenará el arreglo de la estructura Calendar NewsTime con los eventos para una fecha específica.
• Declaración de la función CreateEconomicDatabaseMemory, que creará la base de datos del calendario en memoria.
• Declaración de la función EconomicNextEvent, que actualizará la variable de la estructura UpcomingNews con los datos del próximo evento.
• Declaración de la función GetImpact, que recuperará los datos del impacto del próximo evento.
• Declaración de la función IMPORTANCE, que convertirá la cadena de importancia en la enumeración de importancia del evento del calendario.
• Declaración de la función IMPORTANCE, que convertirá la enumeración Calendar_Importance en la enumeración de importancia del evento del calendario.
• Declaración de la función GetImportance, que convertirá la enumeración de importancia del evento del calendario en la cadena de clasificación de importancia.
• Declaración de la función GetImportance_color, que recuperará el color para cada enumeración de importancia del evento del calendario.
• Declaración de la función SECTOR, que convertirá la enumeración Event_Sector en la enumeración de sector del evento del calendario.
• Declaración de la función FREQUENCY, que convertirá la enumeración Event_Frequency en la enumeración de frecuencia del evento del calendario.
• Declaración de la función TYPE, que convertirá la enumeración Event_Type en la enumeración de tipo de evento del calendario.

//+------------------------------------------------------------------+
//|News class                                                        |
//+------------------------------------------------------------------+
class CNews : private CCandleProperties
  {
   //Private Declarations Only accessable by this class/header file
private:

   //-- To keep track of what is in our database
   enum CalendarComponents
     {
      AutoDST_Table,//AutoDST Table
      CalendarAU_View,//View for DST_AU
      CalendarNONE_View,//View for DST_NONE
      CalendarUK_View,//View for DST_UK
      CalendarUS_View,//View for DST_US
      EventInfo_View,//View for Event Information
      Currencies_View,//View for Currencies
      Record_Table,// Record Table
      TimeSchedule_Table,//TimeSchedule Table
      MQL5Calendar_Table,//MQL5Calendar Table
      AutoDST_Trigger,//Table Trigger for AutoDST
      Record_Trigger//Table Trigger for Record
     };

   //-- structure to retrieve all the objects in the database
   struct SQLiteMaster
     {
      string         type;//will store object's type
      string         name;//will store object's name
      string         tbl_name;//will store table name
      int            rootpage;//will store rootpage
      string         sql;//Will store the sql create statement
     } DBContents[];//Array of type SQLiteMaster

   //--  MQL5CalendarContents inherits from SQLiteMaster structure
   struct MQL5CalendarContents:SQLiteMaster
     {
      CalendarComponents  Content;
      string         insert;//Will store the sql insert statement
     } CalendarContents[12],DBMemory;//Array to Store objects in our database

   CTimeManagement   CTime;//TimeManagement Object declaration
   CDaylightSavings_UK  Savings_UK;//DaylightSavings Object for the UK and EU
   CDaylightSavings_US  Savings_US;//DaylightSavings Object for the US
   CDaylightSavings_AU  Savings_AU;//DaylightSavings Object for the AU

   bool              AutoDetectDST(DST_type &dstType);//Function will determine Broker DST
   DST_type          DSTType;//variable of DST_type enumeration declared in the CommonVariables class/header file
   bool              InsertIntoTables(int db,Calendar &Evalues[]);//Function for inserting Economic Data in to a database's table
   void              CreateAutoDST(int db);//Function for creating and inserting Recommend DST for the Broker into a table
   bool              CreateCalendarTable(int db,bool &tableExists);//Function for creating a table in a database
   bool              CreateTimeTable(int db,bool &tableExists);//Function for creating a table in a database
   void              CreateCalendarViews(int db);//Function for creating views in a database
   void              CreateRecordTable(int db);//Creates a table to store the record of when last the Calendar database was updated/created
   string            DropRequest;//Variable for dropping tables in the database

   //-- Function for retrieving the MQL5CalendarContents structure for the enumartion type CalendarComponents
   MQL5CalendarContents CalendarStruct(CalendarComponents Content)
     {
      MQL5CalendarContents Calendar;
      for(uint i=0;i<CalendarContents.Size();i++)
        {
         if(CalendarContents[i].Content==Content)
           {
            return CalendarContents[i];
           }
        }
      return Calendar;
     }

   //--- To Store Calendar DB Data
   struct CalendarData
     {
      int            EventId;//Event Id
      string         Country;//Event Country
      string         EventName;//Event Name
      string         EventType;//Event Type
      string         EventImportance;//Event Importance
      string         EventCurrency;//Event Currency
      string         EventCode;//Event Code
      string         EventSector;//Event Sector
      string         EventForecast;//Event Forecast Value
      string         EventPreval;//Event Previous Value
      string         EventImpact;//Event Impact
      string         EventFrequency;//Event Frequency
      string         DST_UK;//DST UK
      string         DST_US;//DST US
      string         DST_AU;//DST AU
      string         DST_NONE;//DST NONE
     } DB_Data[],DB_Cal;//Structure variables

   //--- Will Retrieve all relevant Calendar data for DB in Memory from DB in Storage
   void              GetCalendar(CalendarData &Data[])
     {
      //--- Open calendar DB in Storage
      int db=DatabaseOpen(NEWS_DATABASE_FILE, DATABASE_OPEN_READWRITE | DATABASE_OPEN_CREATE| DATABASE_OPEN_COMMON);
      if(db==INVALID_HANDLE)//Checks if the database was able to be opened
        {
         //if opening the database failed
         if(!FileIsExist(NEWS_DATABASE_FILE,FILE_COMMON))//Checks if the database Calendar exists in the common folder
           {
            return;//Returns true when the database was failed to be opened and the file doesn't exist in the common folder
           }
        }
      //--- Get filtered calendar DB data
      string SqlRequest = StringFormat("Select MQ.EventId,MQ.Country,MQ.EventName,MQ.EventType,MQ.EventImportance,MQ.EventCurrency,"
                                       "MQ.EventCode,MQ.EventSector,MQ.EventForecast,MQ.EventPreValue,MQ.EventImpact,MQ.EventFrequency,"
                                       "TS.DST_UK,TS.DST_US,TS.DST_AU,TS.DST_NONE from %s MQ "
                                       "Inner Join %s TS on TS.ID=MQ.ID "
                                       "Where %s and %s and %s and %s and %s;",
                                       CalendarStruct(MQL5Calendar_Table).name,CalendarStruct(TimeSchedule_Table).name,
                                       Request_Importance(myImportance),Request_Frequency(myFrequency),
                                       Request_Sector(mySector),Request_Type(myType),Request_Currency(myCurrency));
      //--- Process Sql request
      int Request = DatabasePrepare(db,SqlRequest);
      if(Request==INVALID_HANDLE)
        {
         //--- Print details if request failed.
         Print("DB: ",NEWS_DATABASE_FILE, " request failed with code ", GetLastError());
         Print("SQL");
         Print(SqlRequest);
        }
      else
        {
         //--- Clear data from whole array
         ArrayRemove(Data,0,WHOLE_ARRAY);
         //--- create structure variable to get data from request
         CalendarData data;
         //Assigning values from the sql query into Data structure array
         for(int i=0; DatabaseReadBind(Request,data); i++)
           {
            //--- Resize Data Array
            ArrayResize(Data,i+1,i+2);
            Data[i]  = data;
           }
        }
      DatabaseFinalize(Request);//Finalize request
      //--- Close Calendar database
      DatabaseClose(db);
     }

   //--- Retrieve the AutoDST enumeration data from calendar DB in storage
   DST_type          GetAutoDST()
     {
      string Sch_Dst;
      //--- open the database 'Calendar' in the common folder
      int db=DatabaseOpen(NEWS_DATABASE_FILE, DATABASE_OPEN_READONLY|DATABASE_OPEN_COMMON);

      if(db==INVALID_HANDLE)//Checks if 'Calendar' failed to be opened
        {
         if(!FileIsExist(NEWS_DATABASE_FILE,FILE_COMMON))//Checks if 'Calendar' database exists
           {
            Print("Could not find Database!");
            return DST_NONE;//return default value when failed.
           }
        }

      //--- Sql query to get AutoDST value
      string request_text="SELECT DST FROM 'AutoDST'";
      //--- Process sql request
      int request=DatabasePrepare(db,request_text);
      if(request==INVALID_HANDLE)
        {
         Print("DB: ",NEWS_DATABASE_FILE, " request failed with code ", GetLastError());
         DatabaseClose(db);//Close Database
         return DST_NONE;//return default value when failed.
        }

      //--- Read Sql request output data
      if(DatabaseRead(request))
        {
         //-- Store the first column data into string variable Sch_Dst
         if(!DatabaseColumnText(request,0,Sch_Dst))
           {
            Print("DatabaseRead() failed with code ", GetLastError());
            DatabaseFinalize(request);//Finalize request
            DatabaseClose(db);//Closes the database 'Calendar'
            return DST_NONE;//return default value when failed.
           }
        }
      DatabaseFinalize(request);//Finalize request
      DatabaseClose(db);//Closes the database 'Calendar'
      return (Sch_Dst=="DST_UK")?DST_UK:(Sch_Dst=="DST_US")?DST_US:
             (Sch_Dst=="DST_AU")?DST_AU:DST_NONE;//Returns the enumeration value for each corresponding string
     }

   //--- Retrieve Sql request string for calendar event Importance
   string            Request_Importance(Calendar_Importance Importance)
     {
      //--- Constant request prefix string
      const string constant="MQ.EventImportance";
      //--- switch statement for Calendar_Importance enumeration
      switch(Importance)
        {
         case Calendar_Importance_All://String Request for all event Importance
            return constant+"<>'"+EnumToString(myImportance)+"'";
            break;
         default://String Request for any event Importance
            return constant+"='"+EnumToString(IMPORTANCE(myImportance))+"'";
            break;
        }
     }

   //--- Retrieve Sql request string for calendar event Frequency
   string            Request_Frequency(Event_Frequency Frequency)
     {
      //--- Constant request prefix string
      const string constant="MQ.EventFrequency";
      //--- switch statement for Event_Frequency enumeration
      switch(Frequency)
        {
         case Event_Frequency_ALL://String Request for all event frequencies
            return constant+"<>'"+EnumToString(myFrequency)+"'";
            break;
         default://String Request for any event frequency
            return constant+"='"+EnumToString(FREQUENCY(myFrequency))+"'";
            break;
        }
     }

   //--- Retrieve Sql request string for calendar event Sector
   string            Request_Sector(Event_Sector Sector)
     {
      //--- Constant request prefix string
      const string constant="MQ.EventSector";
      //--- switch statement for Event_Sector enumeration
      switch(Sector)
        {
         case Event_Sector_ALL://String Request for all event sectors
            return constant+"<>'"+EnumToString(mySector)+"'";
            break;
         default://String Request for any event sector
            return constant+"='"+EnumToString(SECTOR(mySector))+"'";
            break;
        }
     }

   //--- Retrieve Sql request string for calendar event type
   string            Request_Type(Event_Type Type)
     {
      //--- Constant request prefix string
      const string constant="MQ.EventType";
      //--- switch statement for Event_Type enumeration
      switch(Type)
        {
         case Event_Type_All://String Request for all event types
            return constant+"<>'"+EnumToString(myType)+"'";
            break;
         default://String request for any event type
            return constant+"='"+EnumToString(TYPE(myType))+"'";
            break;
        }
     }

   //--- Retrieve Sql request string for calendar event Currency
   string            Request_Currency(Event_Currency Currency)
     {
      //--- Constant request prefix string and request suffix
      const string constant_prefix="(MQ.EventCurrency",constant_suffix="')";
      //--- switch statement for Event_Currency enumeration
      switch(Currency)
        {
         case Event_Currency_ALL://String Request for all currencies
            return constant_prefix+"<>'"+EnumToString(myCurrency)+constant_suffix;
            break;
         case Event_Currency_Symbol://String Request for all symbol currencies
            return constant_prefix+"='"+CSymbol.CurrencyBase()+"' or MQ.EventCurrency='"+
                   CSymbol.CurrencyMargin()+"' or MQ.EventCurrency='"+CSymbol.CurrencyProfit()+constant_suffix;
            break;
         case Event_Currency_Margin://String Request for Margin currency
            return constant_prefix+"='"+CSymbol.CurrencyMargin()+constant_suffix;
            break;
         case Event_Currency_Base://String Request for Base currency
            return constant_prefix+"='"+CSymbol.CurrencyBase()+constant_suffix;
            break;
         case Event_Currency_Profit://String Request for Profit currency
            return constant_prefix+"='"+CSymbol.CurrencyProfit()+constant_suffix;
            break;
         case Event_Currency_NZD_NZ://String Request for NZD currency
            return constant_prefix+"='NZD' and MQ.EventCode='NZ"+constant_suffix;
            break;
         case Event_Currency_EUR_EU://String Request for EUR currency and EU code
            return constant_prefix+"='EUR' and MQ.EventCode='EU"+constant_suffix;
            break;
         case Event_Currency_JPY_JP://String Request for JPY currency
            return constant_prefix+"='JPY' and MQ.EventCode='JP"+constant_suffix;
            break;
         case Event_Currency_CAD_CA://String Request for CAD currency
            return constant_prefix+"='CAD' and MQ.EventCode='CA"+constant_suffix;
            break;
         case Event_Currency_AUD_AU://String Request for AUD currency
            return constant_prefix+"='AUD' and MQ.EventCode='AU"+constant_suffix;
            break;
         case Event_Currency_CNY_CN://String Request for CNY currency
            return constant_prefix+"='CNY' and MQ.EventCode='CN"+constant_suffix;
            break;
         case Event_Currency_EUR_IT://String Request for EUR currency and IT code
            return constant_prefix+"='EUR' and MQ.EventCode='IT"+constant_suffix;
            break;
         case Event_Currency_SGD_SG://String Request for SGD currency
            return constant_prefix+"='SGD' and MQ.EventCode='SG"+constant_suffix;
            break;
         case Event_Currency_EUR_DE://String Request for EUR currency and DE code
            return constant_prefix+"='EUR' and MQ.EventCode='DE"+constant_suffix;
            break;
         case Event_Currency_EUR_FR://String Request for EUR currency and FR code
            return constant_prefix+"='EUR' and MQ.EventCode='FR"+constant_suffix;
            break;
         case Event_Currency_BRL_BR://String Request for BRL currency
            return constant_prefix+"='BRL' and MQ.EventCode='BR"+constant_suffix;
            break;
         case Event_Currency_MXN_MX://String Request for MXN currency
            return constant_prefix+"='MXN' and MQ.EventCode='MX"+constant_suffix;
            break;
         case Event_Currency_ZAR_ZA://String Request for ZAR currency
            return constant_prefix+"='ZAR' and MQ.EventCode='ZA"+constant_suffix;
            break;
         case Event_Currency_HKD_HK://String Request for HKD currency
            return constant_prefix+"='HKD' and MQ.EventCode='HK"+constant_suffix;
            break;
         case Event_Currency_INR_IN://String Request for INR currency
            return constant_prefix+"='INR' and MQ.EventCode='IN"+constant_suffix;
            break;
         case Event_Currency_NOK_NO://String Request for NOK currency
            return constant_prefix+"='NOK' and MQ.EventCode='NO"+constant_suffix;
            break;
         case Event_Currency_USD_US://String Request for USD currency
            return constant_prefix+"='USD' and MQ.EventCode='US"+constant_suffix;
            break;
         case Event_Currency_GBP_GB://String Request for GBP currency
            return constant_prefix+"='GBP' and MQ.EventCode='GB"+constant_suffix;
            break;
         case Event_Currency_CHF_CH://String Request for CHF currency
            return constant_prefix+"='CHF' and MQ.EventCode='CH"+constant_suffix;
            break;
         case Event_Currency_KRW_KR://String Request for KRW currency
            return constant_prefix+"='KRW' and MQ.EventCode='KR"+constant_suffix;
            break;
         case Event_Currency_EUR_ES://String Request for EUR currency and ES code
            return constant_prefix+"='EUR' and MQ.EventCode='ES"+constant_suffix;
            break;
         case Event_Currency_SEK_SE://String Request for SEK currency
            return constant_prefix+"='SEK' and MQ.EventCode='SE"+constant_suffix;
            break;
         case Event_Currency_ALL_WW://String Request for ALL currency
            return constant_prefix+"='ALL' and MQ.EventCode='WW"+constant_suffix;
            break;
         default://String Request for no currencies
            return constant_prefix+"='"+constant_suffix;
            break;
        }
     }

   //Public declarations accessable via a class's Object
public:
                     CNews(void);//Constructor
                    ~CNews(void);//Destructor
   void              CreateEconomicDatabase();//Creates the Calendar database for a specific Broker
   datetime          GetLatestNewsDate();//Gets the latest/newest date in the Calendar database
   void              EconomicDetails(Calendar &NewsTime[],datetime date_from=0,datetime date_to=0);//Gets values from the MQL5 economic Calendar
   void              EconomicDetailsMemory(Calendar &NewsTime[],datetime date);//Gets values from the MQL5 DB Calendar in Memory
   void              CreateEconomicDatabaseMemory();//Create calendar database in memory
   void              EconomicNextEvent(datetime date=0);//Will update UpcomingNews structure variable with the next event data
   bool              UpdateRecords();//Checks if the main Calendar database needs an update or not
   ENUM_CALENDAR_EVENT_IMPACT GetImpact();//Will retrieve Upcoming Event Impact data

   //--- Convert Importance string into Calendar Event Importance Enumeration
   ENUM_CALENDAR_EVENT_IMPORTANCE IMPORTANCE(string Importance)
     {
      //--- Calendar Importance is High
      if(Importance==EnumToString(CALENDAR_IMPORTANCE_HIGH))
        {
         return CALENDAR_IMPORTANCE_HIGH;
        }
      else
         //--- Calendar Importance is Moderate
         if(Importance==EnumToString(CALENDAR_IMPORTANCE_MODERATE))
           {
            return CALENDAR_IMPORTANCE_MODERATE;
           }
         else
            //--- Calendar Importance is Low
            if(Importance==EnumToString(CALENDAR_IMPORTANCE_LOW))
              {
               return CALENDAR_IMPORTANCE_LOW;
              }
            else
               //--- Calendar Importance is None
              {
               return CALENDAR_IMPORTANCE_NONE;
              }
     }

   //--- Convert Calendar_Importance Enumeration into Calendar Event Importance Enumeration
   ENUM_CALENDAR_EVENT_IMPORTANCE IMPORTANCE(Calendar_Importance Importance)
     {
      //--- switch statement for Calendar_Importance enumeration
      switch(Importance)
        {
         case Calendar_Importance_None://None
            return CALENDAR_IMPORTANCE_NONE;
            break;
         case Calendar_Importance_Low://Low
            return CALENDAR_IMPORTANCE_LOW;
            break;
         case Calendar_Importance_Moderate://Moderate
            return CALENDAR_IMPORTANCE_MODERATE;
            break;
         case Calendar_Importance_High://High
            return CALENDAR_IMPORTANCE_HIGH;
            break;
         default://None
            return CALENDAR_IMPORTANCE_NONE;
            break;
        }
     }

   //--- Convert Calendar Event Importance Enumeration into string Importance Rating
   string            GetImportance(ENUM_CALENDAR_EVENT_IMPORTANCE Importance)
     {
      //--- switch statement for ENUM_CALENDAR_EVENT_IMPORTANCE enumeration
      switch(Importance)
        {
         case  CALENDAR_IMPORTANCE_HIGH://High
            return "HIGH";
            break;
         case CALENDAR_IMPORTANCE_MODERATE://Moderate
            return "MODERATE";
            break;
         case CALENDAR_IMPORTANCE_LOW://Low
            return "LOW";
            break;
         default://None
            return "NONE";
            break;
        }
     }

   //--- Retrieve color for each Calendar Event Importance Enumeration
   color             GetImportance_color(ENUM_CALENDAR_EVENT_IMPORTANCE Importance)
     {
      //--- switch statement for ENUM_CALENDAR_EVENT_IMPORTANCE enumeration
      switch(Importance)
        {
         case CALENDAR_IMPORTANCE_HIGH://High
            return clrRed;
            break;
         case CALENDAR_IMPORTANCE_MODERATE://Moderate
            return clrOrange;
            break;
         case CALENDAR_IMPORTANCE_LOW://Low
            return (isLightMode)?clrBlue:clrLightBlue;
            break;
         default://None
            return (isLightMode)?clrBlack:clrWheat;
            break;
        }
     }

   //--- Convert Event_Sector Enumeration into Calendar Event Sector Enumeration
   ENUM_CALENDAR_EVENT_SECTOR SECTOR(Event_Sector Sector)
     {
      //--- switch statement for Event_Sector enumeration
      switch(Sector)
        {
         case Event_Sector_None://NONE
            return CALENDAR_SECTOR_NONE;
            break;
         case Event_Sector_Market://MARKET
            return CALENDAR_SECTOR_MARKET;
            break;
         case Event_Sector_Gdp://GDP
            return CALENDAR_SECTOR_GDP;
            break;
         case Event_Sector_Jobs://JOBS
            return CALENDAR_SECTOR_JOBS;
            break;
         case Event_Sector_Prices://PRICES
            return CALENDAR_SECTOR_PRICES;
            break;
         case Event_Sector_Money://MONEY
            return CALENDAR_SECTOR_MONEY;
            break;
         case Event_Sector_Trade://TRADE
            return CALENDAR_SECTOR_TRADE;
            break;
         case Event_Sector_Government://GOVERNMENT
            return CALENDAR_SECTOR_GOVERNMENT;
            break;
         case Event_Sector_Business://BUSINESS
            return CALENDAR_SECTOR_BUSINESS;
            break;
         case Event_Sector_Consumer://CONSUMER
            return CALENDAR_SECTOR_CONSUMER;
            break;
         case Event_Sector_Housing://HOUSING
            return CALENDAR_SECTOR_HOUSING;
            break;
         case Event_Sector_Taxes://TAXES
            return CALENDAR_SECTOR_TAXES;
            break;
         case Event_Sector_Holidays://HOLIDAYS
            return CALENDAR_SECTOR_HOLIDAYS;
            break;
         default://Unknown
            return CALENDAR_SECTOR_NONE;
            break;
        }
     }

   //--- Convert Event_Frequency Enumeration into Calendar Event Frequency Enumeration
   ENUM_CALENDAR_EVENT_FREQUENCY FREQUENCY(Event_Frequency Frequency)
     {
      //--- switch statement for Event_Frequency enumeration
      switch(Frequency)
        {
         case  Event_Frequency_None://NONE
            return CALENDAR_FREQUENCY_NONE;
            break;
         case Event_Frequency_Day://DAY
            return CALENDAR_FREQUENCY_DAY;
            break;
         case Event_Frequency_Week://WEEK
            return CALENDAR_FREQUENCY_WEEK;
            break;
         case Event_Frequency_Month://MONTH
            return CALENDAR_FREQUENCY_MONTH;
            break;
         case Event_Frequency_Quarter://QUARTER
            return CALENDAR_FREQUENCY_QUARTER;
            break;
         case Event_Frequency_Year://YEAR
            return CALENDAR_FREQUENCY_YEAR;
            break;
         default://Unknown
            return CALENDAR_FREQUENCY_NONE;
            break;
        }
     }

   //--- Convert Event_Type Enumeration into Calendar Event Type Enumeration
   ENUM_CALENDAR_EVENT_TYPE TYPE(Event_Type Type)
     {
      //--- switch statement for Event_Type enumeration
      switch(Type)
        {
         case Event_Type_Event://EVENT
            return CALENDAR_TYPE_EVENT;
            break;
         case Event_Type_Indicator://INDICATOR
            return CALENDAR_TYPE_INDICATOR;
            break;
         case Event_Type_Holiday://HOLIDAY
            return CALENDAR_TYPE_HOLIDAY;
            break;
         default://Unknown
            return CALENDAR_TYPE_EVENT;
            break;
        }
     }
  };

Primero repasaremos la declaración SQL en la función GetCalendar que solicitará todos los datos de la base de datos de calendario en la carpeta común para nuestra base de datos de calendario en la memoria. En esta solicitud, seleccionamos todas las columnas de la tabla MQL5Calendar y la tabla TimeSchedule y unimos las tablas donde sus ID son los mismos. Luego, filtramos los datos según las enumeraciones seleccionadas por el trader/usuario en los parámetros de entrada del experto para la configuración de noticias.

//--- Get filtered calendar DB data
      string SqlRequest = StringFormat("Select MQ.EventId,MQ.Country,MQ.EventName,MQ.EventType,MQ.EventImportance,MQ.EventCurrency,"
                                       "MQ.EventCode,MQ.EventSector,MQ.EventForecast,MQ.EventPreValue,MQ.EventImpact,MQ.EventFrequency,"
                                       "TS.DST_UK,TS.DST_US,TS.DST_AU,TS.DST_NONE from %s MQ "
                                       "Inner Join %s TS on TS.ID=MQ.ID "
                                       "Where %s and %s and %s and %s and %s;",
                                       CalendarStruct(MQL5Calendar_Table).name,CalendarStruct(TimeSchedule_Table).name,
                                       Request_Importance(myImportance),Request_Frequency(myFrequency),
                                       Request_Sector(mySector),Request_Type(myType),Request_Currency(myCurrency));

Echaremos un vistazo a la solicitud SQL para la siguiente configuración de noticias en el símbolo EURUSD.

Como se muestra a continuación, podemos ver que cuando seleccionamos "todos" para la importancia del calendario, deliberadamente no convertimos nuestra variable de enumeración Calendar_Importance myImportance, ya que no existe ninguna importancia de evento con el valor 'Calendar_Importance_All'. Así que podemos seleccionar fácilmente todos los eventos donde EventImportance no sea igual a 'Calendar_Importance_All'. Lo mismo se puede decir para todos los parámetros de entrada de configuración de noticias que se seleccionan como "TODOS".

case Calendar_Importance_All://String Request for all event Importance
            return constant+"<>'"+EnumToString(myImportance)+"'";

Select MQ.EventId,MQ.Country,MQ.EventName,MQ.EventType,MQ.EventImportance,MQ.EventCurrency,MQ.EventCode,MQ.EventSector,
MQ.EventForecast,MQ.EventPreValue,MQ.EventImpact,MQ.EventFrequency,TS.DST_UK,TS.DST_US,TS.DST_AU,TS.DST_NONE from MQL5Calendar MQ
Inner Join TimeSchedule TS on TS.ID=MQ.ID Where MQ.EventImportance<>'Calendar_Importance_All' and MQ.EventFrequency<>'Event_Frequency_ALL'
and MQ.EventSector<>'Event_Sector_ALL' and MQ.EventType<>'Event_Type_All' and (MQ.EventCurrency='EUR' or MQ.EventCurrency='EUR' or 
MQ.EventCurrency='USD');

Echaremos otro vistazo a otra solicitud SQL de la función GetCalendar para la siguiente configuración de noticias en el símbolo EURUSD.

Como se muestra a continuación, cuando seleccionamos cualquier otra opción que no sea "todos" para la importancia del calendario, convertiremos nuestra variable de enumeración Calendar_Importance myImportance en el tipo de enumeración ENUM_CALENDAR_EVENT_IMPORTANCE, de manera que la cadena pueda coincidir con la que está almacenada en la tabla MQL5Calendar para obtener correctamente la importancia del evento de un tipo determinado.

default://String Request for any event Importance
            return constant+"='"+EnumToString(IMPORTANCE(myImportance))+"'";

Select MQ.EventId,MQ.Country,MQ.EventName,MQ.EventType,MQ.EventImportance,MQ.EventCurrency,MQ.EventCode,MQ.EventSector,MQ.EventForecast,
MQ.EventPreValue,MQ.EventImpact,MQ.EventFrequency,TS.DST_UK,TS.DST_US,TS.DST_AU,TS.DST_NONE from MQL5Calendar MQ Inner Join TimeSchedule TS 
on TS.ID=MQ.ID Where MQ.EventImportance='CALENDAR_IMPORTANCE_HIGH' and MQ.EventFrequency='CALENDAR_FREQUENCY_MONTH' and 
MQ.EventSector='CALENDAR_SECTOR_JOBS' and MQ.EventType='CALENDAR_TYPE_INDICATOR' and (MQ.EventCurrency<>'Event_Currency_ALL');

 En el constructor de la clase de noticias, debemos inicializar los índices de los arreglos para las nuevas vistas de nuestra base de datos del calendario en la carpeta común. Para la vista de Información del evento, así es como inicializaremos el índice de la matriz a continuación.

//--- initializing properties for the EventInfo view
   CalendarContents[5].Content = EventInfo_View;
   CalendarContents[5].name = "Event Info";
   CalendarContents[5].sql = "CREATE VIEW IF NOT EXISTS 'Event Info' "
                             "AS SELECT EVENTID as 'ID',COUNTRY as 'Country',EVENTNAME as 'Name',"
                             "REPLACE(EVENTTYPE,'CALENDAR_TYPE_','') as 'Type',REPLACE(EVENTSECTOR,'CALENDAR_SECTOR_','') as 'Sector',"
                             "REPLACE(EVENTIMPORTANCE,'CALENDAR_IMPORTANCE_','') as 'Importance',EVENTCURRENCY as 'Currency' "
                             "FROM MQL5Calendar GROUP BY \"Name\" ORDER BY \"Country\" Asc,"
                             "CASE \"Importance\" WHEN 'HIGH' THEN 1 WHEN 'MODERATE' THEN 2 WHEN 'LOW' THEN 3 ELSE 4 END,\"Sector\" Desc;";
   CalendarContents[5].tbl_name = "Event Info";
   CalendarContents[5].type = "view";

Repasemos la declaración SQL para crear la vista 'Event Info'. Primero solo creamos la vista si aún no existe, luego seleccionamos las columnas 'EVENTID' y le cambiamos el nombre a 'ID', 'COUNTRY' y le cambiamos el nombre a 'Country', 'EVENTNAME' y le cambiamos el nombre a 'Name', 'EVENTTYPE' reemplazamos el texto 'CALENDAR_TYPE_' con una cadena vacía y cambiamos el nombre de la columna a 'Type', 'EVENTSECTOR' reemplazamos el texto 'CALENDAR_SECTOR_' con una cadena vacía y cambiamos el nombre de la columna a 'Sector', 'EVENTIMPORTANCE' reemplazamos el texto 'CALENDAR_IMPORTANCE_' con una cadena vacía y cambiamos el nombre de la columna a 'Importance', 'EVENTCURRENCY' y le cambiamos el nombre a 'Currency' de la tabla MQL5Calendar. Luego, agrupamos la consulta por 'EVENTNAME', que ahora es 'Name', para que los eventos con el mismo nombre no se muestren varias veces en la vista. Luego, asignamos una secuencia de orden a la consulta. Primero, ordenamos el resultado por 'Country' en orden ascendente para que los países con la letra inicial A, como Australia, se muestren primero. Luego, ordenamos el resultado por 'EVENTIMPORTANCE', que ahora se llama 'Importance', de manera que los eventos con mayor importancia se muestren primero. Para hacer esto, asignamos un ranking a los valores de texto de la importancia. En este caso, cuando 'Importance' es 'HIGH', recibe la primera prioridad; 'MODERATE' recibe la segunda prioridad; 'LOW' recibe la tercera prioridad; y finalmente, cualquier otro valor recibe la última prioridad. Además, ordenamos el resultado de la consulta por 'EVENTSECTOR' que ahora se llama 'Sector' en orden descendente. A continuación se mostrarán muestras de vistas.

CREATE VIEW IF NOT EXISTS 'Event Info' AS SELECT MQ.EVENTID as 'ID',MQ.COUNTRY as 'Country',MQ.EVENTNAME as 'Name',REPLACE(MQ.EVENTTYPE,
'CALENDAR_TYPE_','') as 'Type',REPLACE(MQ.EVENTSECTOR,'CALENDAR_SECTOR_','') as 'Sector',REPLACE(MQ.EVENTIMPORTANCE,'CALENDAR_IMPORTANCE_','') 
as 'Importance',MQ.EVENTCURRENCY as 'Currency' FROM MQL5Calendar MQ INNER JOIN TimeSchedule TS on TS.ID=MQ.ID GROUP BY "Name" ORDER BY 
"Country" Asc,CASE "Importance" WHEN 'HIGH' THEN 1 WHEN 'MODERATE' THEN 2 WHEN 'LOW' THEN 3 ELSE 4 END,"Sector" Desc;

ID       Country  Name                                          Type            Sector        Importance   Currency
36030006 Australia  RBA Governor Lowe Speech                    EVENT           MONEY         HIGH         AUD 
36030008 Australia  RBA Interest Rate Decision                  INDICATOR       MONEY         HIGH         AUD 
36010029 Australia  PPI q/q                                     INDICATOR       PRICES        MODERATE     AUD 
36030014 Australia  RBA Trimmed Mean CPI q/q                    INDICATOR       PRICES        MODERATE     AUD 
36030009 Australia  RBA Weighted Median CPI q/q                 INDICATOR       PRICES        MODERATE     AUD 
36010031 Australia  Wage Price Index q/q                        INDICATOR       PRICES        MODERATE     AUD 
36030026 Australia  RBA Assistant Governor Boulton Speech       EVENT           MONEY         MODERATE     AUD 
36030024 Australia  RBA Assistant Governor Bullock Speech       EVENT           MONEY         MODERATE     AUD 
36030025 Australia  RBA Assistant Governor Ellis Speech         EVENT           MONEY         MODERATE     AUD 

62 lines later...

76020002 Brazil  BCB Interest Rate Decision                     INDICATOR       MONEY         HIGH         BRL 
76020004 Brazil  BCB Inflation Report                           EVENT           PRICES        MODERATE     BRL 
76050001 Brazil  FIPE CPI m/m                                   INDICATOR       PRICES        MODERATE     BRL 
76010005 Brazil  Mid-Month CPI m/m                              INDICATOR       PRICES        MODERATE     BRL 
76020001 Brazil  BCB Focus Market Report                        EVENT           MONEY         MODERATE     BRL 
76020003 Brazil  BCB MPC (Copom) Minutes                        EVENT           MONEY         MODERATE     BRL 
76020005 Brazil  BCB National Monetary Council Meeting          EVENT           MONEY         MODERATE     BRL 
76010009 Brazil  Unemployment Rate 3-months                     INDICATOR       JOBS          MODERATE     BRL 
76020010 Brazil  Nominal Budget Balance                         INDICATOR       GOVERNMENT    MODERATE     BRL 
76020011 Brazil  Primary Budget balance                         INDICATOR       GOVERNMENT    MODERATE     BRL 
76010014 Brazil  Services Volume m/m                            INDICATOR       BUSINESS      MODERATE     BRL 

98 lines later...

124040017 Canada  BoC Governor Macklem Speech                   EVENT           MONEY          HIGH         CAD 
124040003 Canada  BoC Governor Poloz Speech                     EVENT           MONEY          HIGH         CAD 
124040006 Canada  BoC Interest Rate Decision                    INDICATOR       MONEY          HIGH         CAD 
124040009 Canada  BoC Monetary Policy Report Press Conference   EVENT           MONEY          HIGH         CAD 
124010011 Canada  Employment Change                             INDICATOR       JOBS           HIGH         CAD 
124010021 Canada  GDP m/m                                       INDICATOR       GDP            HIGH         CAD 
124010008 Canada  Core Retail Sales m/m                         INDICATOR       CONSUMER       HIGH         CAD 
124020001 Canada  Ivey PMI                                      INDICATOR       BUSINESS       HIGH         CAD 
124010024 Canada  IPPI m/m                                      INDICATOR       PRICES         MODERATE     CAD 
124010026 Canada  RMPI m/m                                      INDICATOR       PRICES         MODERATE     CAD 
124040001 Canada  BoC Business Outlook Survey                   EVENT           MONEY          MODERATE     CAD 

Para nuestra vista de monedas, seleccionamos la moneda de evento única/distinta y el código de evento de la tabla MQL5Calendar.

//--- initializing properties for the Currencies view
   CalendarContents[6].Content = Currencies_View;
   CalendarContents[6].name = "Currencies";
   CalendarContents[6].sql = "CREATE VIEW IF NOT EXISTS Currencies AS "
                             "SELECT Distinct EventCurrency as 'Currency',EventCode as 'Code' FROM 'MQL5Calendar';";
   CalendarContents[6].tbl_name = "Currencies";
   CalendarContents[6].type = "view";

SELECT * FROM 'Currencies';

Currency  	Code
NZD  		NZ
EUR 		EU
JPY  		JP
CAD  		CA
AUD  		AU
CNY  		CN
EUR  		IT
SGD  		SG
EUR  		DE
EUR  		FR
BRL  		BR
MXN  		MX
ZAR  		ZA
HKD  		HK
INR  		IN
NOK  		NO
USD  		US
GBP  		GB
CHF  		CH
KRW  		KR
EUR  		ES
SEK  		SE
ALL  		WW

Ahora inicializaremos las propiedades de nuestra tabla MQL5Calendar que estará en nuestra base de datos en memoria. Esta tabla será una gran tabla que es esencialmente una combinación de las tablas en nuestra base de datos almacenada, estas tablas son MQL5Calendar y TimeSchedule.

//-- initializing properties for the MQL5Calendar table for DB in System Memory
   DBMemory.Content = MQL5Calendar_Table;
   DBMemory.name = "MQL5Calendar";
   DBMemory.sql = "CREATE TABLE IF NOT EXISTS MQL5Calendar(EVENTID  INT   NOT NULL,COUNTRY  TEXT   NOT NULL,"
                  "EVENTNAME   TEXT   NOT NULL,EVENTTYPE   TEXT   NOT NULL,EVENTIMPORTANCE   TEXT   NOT NULL,"
                  "EVENTCURRENCY  TEXT   NOT NULL,EVENTCODE   TEXT   NOT NULL,EVENTSECTOR TEXT   NOT NULL,"
                  "EVENTFORECAST  TEXT   NOT NULL,EVENTPREVALUE  TEXT   NOT NULL,EVENTIMPACT TEXT   NOT NULL,"
                  "EVENTFREQUENCY TEXT   NOT NULL,DST_UK   TEXT   NOT NULL,DST_US   TEXT   NOT NULL,"
                  "DST_AU   TEXT   NOT NULL,DST_NONE   TEXT   NOT NULL)STRICT;";
   DBMemory.tbl_name="MQL5Calendar";
   DBMemory.type = "table";
   DBMemory.insert = "INSERT INTO 'MQL5Calendar'(EVENTID,COUNTRY,EVENTNAME,EVENTTYPE,EVENTIMPORTANCE,EVENTCURRENCY,EVENTCODE,"
                     "EVENTSECTOR,EVENTFORECAST,EVENTPREVALUE,EVENTIMPACT,EVENTFREQUENCY,DST_UK,DST_US,DST_AU,DST_NONE) "
                     "VALUES (%d,'%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s','%s', '%s', '%s');";

En nuestro destructor, cerramos la conexión a la base de datos en memoria. Al cerrar la conexión, se eliminará toda la base de datos en memoria. Así que sólo cerramos la conexión cuando ya no necesitamos la base de datos.

//+------------------------------------------------------------------+
//|Destructor                                                        |
//+------------------------------------------------------------------+
CNews::~CNews(void)
  {
   if(FileIsExist(NEWS_TEXT_FILE,FILE_COMMON))//Check if the news database open text file exists
     {
      FileDelete(NEWS_TEXT_FILE,FILE_COMMON);
     }
   DatabaseClose(DBMemoryConnection);//Close DB in memory
  }

Anteriormente en nuestra función UpdateRecords recorrimos una secuencia para verificar si debemos actualizar la base de datos del calendario en el almacenamiento. La secuencia fue la siguiente:

1. Verificaríamos si la base de datos del Calendario existe en la carpeta común, si la base de datos no existe realizamos una actualización.
2. Comprobaríamos si todos los objetos de la base de datos existen en la base de datos y que sus declaraciones SQL son las que esperamos, si no, realizamos una actualización.
3. Verificaríamos si la fecha en la tabla Registros es igual a la fecha actual, si no, realizamos una actualización.

Para este artículo, agregaremos un paso más a la secuencia. El propósito de este paso agregado es verificar si los datos de noticias en la vista Calendar_NONE son precisos. He notado que a veces los datos de noticias del calendario MQL5 pueden cambiar con el tiempo y, si hemos almacenado noticias que no han cambiado, debemos poder verificar si hay inconsistencias entre lo que hemos almacenado y lo que se ha actualizado del calendario MQL5, si es que hay alguno.

En el código siguiente recuperamos los datos de noticias del día actual utilizando la función EconomicDetails y almacenamos estos datos en la matriz TodayNews. Una vez que los datos de noticias están dentro de la matriz TodayNews, iteramos a través de cada evento de noticias en la matriz y verificamos si hay una coincidencia en nuestra vista Calendar_NONE, si no podemos encontrar una coincidencia, realizaremos una actualización. Si todos los datos de noticias tienen una coincidencia en la vista Calendar_NONE, no realizamos ninguna actualización en la base de datos almacenada.

      Calendar TodaysNews[];
      datetime Today = CTime.Time(TimeTradeServer(),0,0,0);
      EconomicDetails(TodaysNews,Today,Today+CTime.DaysS());

      for(uint i=0;i<TodaysNews.Size();i++)
        {
         request_text=StringFormat("SELECT ID FROM %s where Replace(Date,'.','-')=Replace('%s','.','-') and ID=%d;",
                                   CalendarStruct(CalendarNONE_View).name,TodaysNews[i].EventDate,TodaysNews[i].EventId);
         request=DatabasePrepare(db,request_text);//Creates a handle of a request, which can then be executed using DatabaseRead()
         if(request==INVALID_HANDLE)//Checks if the request failed to be completed
           {
            Print("DB: ",NEWS_DATABASE_FILE, " request failed with code ", GetLastError());
            DatabaseFinalize(request);
            DatabaseClose(db);
            return perform_update;
           }
         //PrintFormat(request_text);
         if(!DatabaseRead(request))//Will be true if there are results from the sql query/request
           {
            DatabaseFinalize(request);
            DatabaseClose(db);
            return perform_update;
           }
         DatabaseFinalize(request);
        }
      DatabaseClose(db);//Closes the database
      perform_update=false;
      return perform_update;

El código a continuación será responsable de crear la base de datos en la memoria. Primero abrimos la conexión a la base de datos, luego eliminamos la tabla MQL5Calendar si ya existe, luego creamos la tabla MQL5Calendar. Una vez creada la tabla, obtenemos todos los datos relevantes de la función GetCalendar, luego insertamos todos los datos recuperados de la función en nuestra tabla MQL5Calendar en nuestra base de datos en la memoria. Además, borramos toda la matriz DB_Data y establecemos nuestro cronograma de horario de verano en la variable MySchedule. Para operar fuera del probador de estrategias, el usuario/comerciante no podrá cambiar manualmente el horario de verano. Esto es para evitar configurar el horario de verano incorrecto, ya que configurar el horario de verano solo es necesario para el probador de estrategias.

//+------------------------------------------------------------------+
//|Create calendar database in memory                                |
//+------------------------------------------------------------------+
void CNews::CreateEconomicDatabaseMemory()
  {
//--- Open/create the database in memory
   DBMemoryConnection=DatabaseOpen(NEWS_DATABASE_MEMORY,DATABASE_OPEN_MEMORY);
   if(DBMemoryConnection==INVALID_HANDLE)//Checks if the database failed to open/create
     {
      Print("DB: ",NEWS_DATABASE_MEMORY, " open failed with code ", GetLastError());
      return;//will terminate execution of the rest of the code below
     }
//--- Drop the table if it already exists
   DatabaseExecute(DBMemoryConnection,StringFormat("Drop table IF EXISTS %s",DBMemory.name));
//--- Attempt to create the table
   if(!DatabaseExecute(DBMemoryConnection,DBMemory.sql))
     {
      Print("DB: create the Calendar table failed with code ", GetLastError());
      return;
     }
//--- Check if the table exists
   if(DatabaseTableExists(DBMemoryConnection,DBMemory.tbl_name))
     {
      //--- Get all news data and time from the database in storage
      GetCalendar(DB_Data);
      //--- Insert all the news data and times into the table
      for(uint i=0;i<DB_Data.Size();i++)
        {
         string request_text=StringFormat(DBMemory.insert,DB_Data[i].EventId,DB_Data[i].Country,
                                          DB_Data[i].EventName,DB_Data[i].EventType,DB_Data[i].EventImportance,
                                          DB_Data[i].EventCurrency,DB_Data[i].EventCode,DB_Data[i].EventSector,
                                          DB_Data[i].EventForecast,DB_Data[i].EventPreval,DB_Data[i].EventImpact,
                                          DB_Data[i].EventFrequency,DB_Data[i].DST_UK,DB_Data[i].DST_US,
                                          DB_Data[i].DST_AU,DB_Data[i].DST_NONE);

         if(!DatabaseExecute(DBMemoryConnection, request_text))//Will attempt to run this sql request/query
           {
            //--- failed to run sql request/query
            Print(GetLastError());
            PrintFormat(request_text);
            return;
           }
        }
     }
//--- Remove all data from the array
   ArrayRemove(DB_Data,0,WHOLE_ARRAY);
//--- Assign the DST schedule
   MySchedule = (MQLInfoInteger(MQL_TESTER))?(MyDST==AutoDst_Selection)?GetAutoDST():MySchedule:DST_NONE;
  }

Bien, ahora la siguiente función llamada EconomicDetailsMemory recupera todos los eventos de noticias que tienen lugar en una fecha específica y luego almacena los datos de noticias en la matriz NewsTime, que se pasa por referencia.

//+------------------------------------------------------------------+
//|Gets values from the MQL5 DB Calendar in Memory                   |
//+------------------------------------------------------------------+
void CNews::EconomicDetailsMemory(Calendar &NewsTime[],datetime date)
  {
//--- SQL query to retrieve news data for a certain date
   string request_text=StringFormat("WITH MySubQuery AS (SELECT EventId as 'Id',Country,EventName as 'Name',EventType as 'Type'"
                                    ",EventImportance as 'Importance',%s as 'CTime',EventCurrency as 'Currency',EventCode as 'Code',"
                                    "EventSector as 'Sector',EventForecast as 'Forecast',EventPrevalue as 'Prevalue',EventImpact as'Impact',"
                                    "EventFrequency as 'Freq',RANK() OVER (PARTITION BY %s Order BY CASE EventPrevalue WHEN 'None' "
                                    "THEN 2 ELSE 1 END,CASE EventForecast WHEN 'None' THEN 2 ELSE 1 END,CASE EventImportance WHEN "
                                    "'CALENDAR_IMPORTANCE_HIGH' THEN 1 WHEN 'CALENDAR_IMPORTANCE_MODERATE' THEN 2 WHEN 'CALENDAR_IMPORTANCE_LOW'"
                                    " THEN 3 ELSE 4 END) Ranking FROM %s) SELECT Id,Country,Name,Type,Importance,CTime,Currency,Code,Sector,"
                                    "Forecast,Prevalue,Impact,Freq FROM MySubQuery where Date(Replace(CTime,'.','-'))=Date(Replace('%s','.','-')) and "
                                    "Ranking<2 Group by CTime;",EnumToString(MySchedule),EnumToString(MySchedule),DBMemory.name,
                                    TimeToString(date));
   int request=DatabasePrepare(DBMemoryConnection,request_text);//Creates a handle of a request, which can then be executed using DatabaseRead()
   if(request==INVALID_HANDLE)//Checks if the request failed to be completed
     {
      Print("DB: ",NEWS_DATABASE_MEMORY, " request failed with code ", GetLastError());
      PrintFormat(request_text);
     }
//--- Calendar structure variable
   Calendar ReadDB_Data;
//--- Remove any data in the array
   ArrayRemove(NewsTime,0,WHOLE_ARRAY);
   for(int i=0; DatabaseReadBind(request,ReadDB_Data); i++)//Will read all the results from the sql query/request
     {
      //--- Resize array NewsTime
      ArrayResize(NewsTime,i+1,i+2);
      //--- Assign calendar structure values into NewsTime array index
      NewsTime[i]  = ReadDB_Data;
     }
//--- Removes a request created in DatabasePrepare()
   DatabaseFinalize(request);
  }

Vamos a desglosar la consulta SQL, ya que es más compleja que cualquiera de nuestras consultas anteriores. Así que en esta consulta hacemos uso de una cláusula WITH y una función RANK().

¿Qué es una cláusula WITH y cómo funciona?

La cláusula WITH, también conocida como expresión común de tabla (Common Table Expression, CTE), se utiliza para definir conjuntos de resultados temporales a los que se puede hacer referencia dentro de una sentencia SELECT, INSERT, UPDATE o DELETE. La cláusula WITH facilita la comprensión y el mantenimiento de las consultas complejas al dividirlas en partes más sencillas. También puede ayudar a mejorar el rendimiento reutilizando los resultados de subconsultas costosas. Los CTE son temporales y sólo existen mientras dura la consulta. No crean ningún objeto permanente en la base de datos.

¿Qué es una función RANK() y cómo funciona?

La función RANK() se utiliza para asignar un rango único a cada fila dentro de un conjunto de resultados en función de los valores de una o más columnas. Las filas se ordenan según los criterios especificados y el rango se asigna en consecuencia. La función RANK() es parte de las funciones de ventana en SQL, lo que significa que opera sobre una ventana (o subconjunto) de filas y puede devolver varias filas para cada fila del conjunto de entrada. La función RANK() asigna un rango a cada fila según el orden especificado en la cláusula ORDER BY dentro de la definición de la función de ventana. Si varias filas tienen los mismos valores en las columnas especificadas para ordenar, se les asigna el mismo rango y se omite el siguiente rango por la cantidad de rangos idénticos. PARTITION BY (opcional) divide el conjunto de resultados en particiones y la función RANK() se aplica a cada partición de forma independiente.

En esta cláusula WITH destacada a continuación, seleccionamos los campos EventId, Country, EventName, EventType, EventImportance, DST_NONE (programación DST establecida por el usuario/trader en los parámetros de entrada del experto), EventCurrency, EventCode, EventSector, EventForecast, EventPrevalue, EventImpact, EventFrequency. Luego, utilizamos una función de clasificación (rank). El propósito de esta función es asignar un ranking a cada resultado de la consulta SELECT. Este ranking será siempre 1 para un tiempo de evento único (DST_NONE). Si tenemos múltiples eventos con el mismo tiempo de evento, entonces aplicamos la clasificación. Si el evento tiene un EventPrevalue igual a 'None', recibe un ranking de 2; de lo contrario, recibe un ranking de 1, y así sucesivamente para el resto de la cláusula ORDER BY.

WITH MySubQuery AS (SELECT EventId as 'Id',Country,EventName as 'Name',EventType as 'Type',EventImportance as 'Importance',
DST_NONE as 'CTime',EventCurrency as 'Currency',EventCode as 'Code',EventSector as 'Sector',EventForecast as 'Forecast',
EventPrevalue as 'Prevalue',EventImpact as'Impact',EventFrequency as 'Freq',RANK() OVER (PARTITION BY DST_NONE 
Order BY CASE EventPrevalue WHEN 'None' THEN 2 ELSE 1 END,CASE EventForecast WHEN 'None' THEN 2 ELSE 1 END,
CASE EventImportance WHEN 'CALENDAR_IMPORTANCE_HIGH' THEN 1 WHEN 'CALENDAR_IMPORTANCE_MODERATE' THEN 2 
WHEN 'CALENDAR_IMPORTANCE_LOW' THEN 3 ELSE 4 END) Ranking FROM MQL5Calendar) SELECT Id,Country,Name,Type,
Importance,CTime,Currency,Code,Sector,Forecast,Prevalue,Impact,Freq FROM MySubQuery where 
Date(Replace(CTime,'.','-'))=Date(Replace('2024.07.30 00:00','.','-')) and Ranking<2 Group by CTime;

A continuación se muestra un ejemplo de los resultados de la CTE (**MySubQuery**). He resaltado los eventos que serán eliminados de los resultados, ya que su clasificación supera 1. Solo consideramos los eventos con un ranking menor a 2 y luego agrupamos el resultado por su tiempo. Esto se debe a que, al trazar los eventos en el gráfico, no queremos crear múltiples objetos de evento con el mismo tiempo, sino mostrar únicamente el evento de mayor importancia.

Id 		Country 	Name 					Type 			Importance 			CTime 		Currency Code Sector 			Forecast  Prevalue   Impact 		Freq 			  Ranking
392030007 	Japan 		Unemployment Rate 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 01:30 JPY 	 JP   CALENDAR_SECTOR_JOBS 	2500000   2600000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
392050002 	Japan 		Jobs to Applicants Ratio 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 01:30 JPY 	 JP   CALENDAR_SECTOR_JOBS 	1240000   1240000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
36010001 	Australia 	Building Approvals m/m 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 03:30 AUD 	 AU   CALENDAR_SECTOR_BUSINESS 	-900000   5500000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
36010002 	Australia 	Private House Approvals m/m 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 03:30 AUD 	 AU   CALENDAR_SECTOR_BUSINESS 	None 	  2100000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
250010005 	France 		GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 07:30 EUR 	 FR   CALENDAR_SECTOR_GDP 	200000 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
250010006 	France 		GDP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 07:30 EUR 	 FR   CALENDAR_SECTOR_GDP 	1000000	  1100000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 2
250010008 	France 		Consumer Spending m/m 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 07:30 EUR 	 FR   CALENDAR_SECTOR_CONSUMER 	800000 	  1500000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
756050001 	Switzerland 	KOF Economic Barometer 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 09:00 CHF 	 CH   CALENDAR_SECTOR_BUSINESS 	101500000 102700000  CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
724010001 	Spain 		CPI m/m 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 09:00 EUR 	 ES   CALENDAR_SECTOR_PRICES 	200000 	  400000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
724010003 	Spain 		HICP m/m 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 09:00 EUR 	 ES   CALENDAR_SECTOR_PRICES 	300000 	  400000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
724010005 	Spain 		GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 09:00 EUR 	 ES   CALENDAR_SECTOR_GDP 	300000 	  800000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
724010002 	Spain 		CPI y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 EUR  	 ES   CALENDAR_SECTOR_PRICES 	3000000   3400000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
724010004 	Spain 		HICP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 EUR 	 ES   CALENDAR_SECTOR_PRICES 	3500000   3600000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
724010006 	Spain 		GDP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 EUR 	 ES   CALENDAR_SECTOR_GDP 	1900000   2500000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 5
752020001 	Sweden 		Business Confidence 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 SEK 	 SE   CALENDAR_SECTOR_BUSINESS 	95500000  97300000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
752020002 	Sweden 		Manufacturing Confidence 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 SEK 	 SE   CALENDAR_SECTOR_BUSINESS 	99000000  99200000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
752020003 	Sweden 		Consumer Confidence 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 SEK 	 SE   CALENDAR_SECTOR_CONSUMER 	95300000  93300000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
752020004 	Sweden 		Inflation Expectations 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 SEK 	 SE   CALENDAR_SECTOR_CONSUMER 	6300000   6200000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
752020005 	Sweden 		Economic Tendency Indicator 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 09:00 SEK 	 SE   CALENDAR_SECTOR_BUSINESS 	94800000  96300000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   5
276010008 	Germany 	GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 10:00 EUR 	 DE   CALENDAR_SECTOR_GDP 	100000 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
380010020 	Italy 		GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 10:00 EUR 	 IT   CALENDAR_SECTOR_GDP 	200000 	  300000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 2
276010009 	Germany 	GDP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 10:00 EUR 	 DE   CALENDAR_SECTOR_GDP 	-400000   -900000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 2
380010021 	Italy 		GDP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 10:00 EUR 	 IT   CALENDAR_SECTOR_GDP 	400000 	  700000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 4
999030016 	European Union 	GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_GDP 	200000 	  300000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
999030017 	European Union 	GDP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_GDP 	400000 	  400000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 2
999040003 	European Union 	Industrial Confidence Indicator 	CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_BUSINESS 	-9700000  -10100000  CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   3
999040004 	European Union 	Services Sentiment Indicator 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_BUSINESS 	8300000   6500000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   3
999040005 	European Union 	Economic Sentiment Indicator 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_BUSINESS 	95300000  95900000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   3
999040006 	European Union 	Consumer Confidence Index 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_CONSUMER 	-13000000 -13000000  CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   3
999040007 	European Union 	Consumer Price Expectations 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:00 EUR  	 EU   CALENDAR_SECTOR_CONSUMER 	14400000  13100000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   3
999040008 	European Union 	Industry Selling Price Expectations 	CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_BUSINESS 	6300000   6100000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   3
380020007 	Italy 		10-Year BTP Auction 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 11:30 EUR 	 IT   CALENDAR_SECTOR_MARKET 	None 	  4010000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_NONE    1
380020005 	Italy 		5-Year BTP Auction 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:30 EUR 	 IT   CALENDAR_SECTOR_MARKET 	None 	  3550000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_NONE    2
826130002 	United Kingdom 	10-Year Treasury Gilt Auction 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 11:30 GBP 	 GB   CALENDAR_SECTOR_MARKET 	None 	  4371000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_NONE    2
724080001 	Spain 		Business Confidence 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 12:00 EUR 	 ES   CALENDAR_SECTOR_BUSINESS 	-4100000  -5700000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
76030002 	Brazil 		FGV IGP-M Inflation Index m/m 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 13:00 BRL 	 BR   CALENDAR_SECTOR_PRICES 	1000000   810000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
484020016 	Mexico 		GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 14:00 MXN 	 MX   CALENDAR_SECTOR_GDP 	0 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
276010020 	Germany 	CPI m/m 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 14:00 EUR 	 DE   CALENDAR_SECTOR_PRICES 	0 	  100000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
276010022 	Germany 	HICP m/m 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 14:00 EUR 	 DE   CALENDAR_SECTOR_PRICES 	-100000   200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
76010012 	Brazil 		PPI m/m 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 14:00 BRL 	 BR   CALENDAR_SECTOR_PRICES 	700000 	  450000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
484020017 	Mexico 		GDP n.s.a. y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 14:00 MXN 	 MX   CALENDAR_SECTOR_GDP 	2000000   1600000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 2
276010021 	Germany 	CPI y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 14:00 EUR 	 DE   CALENDAR_SECTOR_PRICES 	2200000   2200000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   6
276010023 	Germany 	HICP y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 14:00 EUR 	 DE   CALENDAR_SECTOR_PRICES 	2500000   2500000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   6
76010013 	Brazil 		PPI y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 14:00 BRL 	 BR   CALENDAR_SECTOR_PRICES 	2200000   170000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   6
840170001 	United States 	S&P/CS HPI Composite-20 y/y 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	6800000   7200000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
840110001 	United States 	HPI m/m 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	300000 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
840110002 	United States 	HPI y/y 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	5700000   6300000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
840110003 	United States 	HPI 					CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	427700000 424300000  CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
840170002 	United States 	S&P/CS HPI Composite-20 n.s.a. m/m 	CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	700000 	  1400000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
840170003 	United States 	S&P/CS HPI Composite-20 s.a. m/m 	CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	200000 	  400000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   2
840030021 	United States 	JOLTS Job Openings 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 16:00 USD 	 US   CALENDAR_SECTOR_JOBS 	7979000   8140000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
840180002 	United States 	CB Consumer Confidence Index 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 16:00 USD 	 US   CALENDAR_SECTOR_CONSUMER 	108000000 100400000  CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
840060003 	United States 	Dallas Fed Services Revenues 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 16:30 USD 	 US   CALENDAR_SECTOR_BUSINESS 	3900000   1900000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
840060004 	United States 	Dallas Fed Services Business Activity 	CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 16:30 USD 	 US   CALENDAR_SECTOR_BUSINESS 	-6700000  -4100000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
484010001 	Mexico Fiscal 	Balance 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 22:30 MXN 	 MX   CALENDAR_SECTOR_TRADE 	-900000   -174071000 CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1

A continuación se muestran los resultados finales.

Id 		Country 	Name 					Type 			Importance 			CTime 		Currency Code Sector 			Forecast  Prevalue   Impact 		Freq 			  Ranking
392030007 	Japan 		Unemployment Rate 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 01:30 JPY 	 JP   CALENDAR_SECTOR_JOBS 	2500000   2600000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
36010001 	Australia 	Building Approvals m/m 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 03:30 AUD 	 AU   CALENDAR_SECTOR_BUSINESS 	-900000   5500000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
250010005 	France 		GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 07:30 EUR 	 FR   CALENDAR_SECTOR_GDP 	200000 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
756050001 	Switzerland 	KOF Economic Barometer 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 09:00 CHF 	 CH   CALENDAR_SECTOR_BUSINESS 	101500000 102700000  CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
276010008 	Germany 	GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 10:00 EUR 	 DE   CALENDAR_SECTOR_GDP 	100000 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
999030016 	European Union 	GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 11:00 EUR 	 EU   CALENDAR_SECTOR_GDP 	200000 	  300000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
380020007 	Italy 		10-Year BTP Auction 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 11:30 EUR 	 IT   CALENDAR_SECTOR_MARKET 	None 	  4010000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_NONE    1
724080001 	Spain 		Business Confidence 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 12:00 EUR 	 ES   CALENDAR_SECTOR_BUSINESS 	-4100000  -5700000   CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
76030002 	Brazil 		FGV IGP-M Inflation Index m/m 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 13:00 BRL 	 BR   CALENDAR_SECTOR_PRICES 	1000000   810000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
484020016 	Mexico 		GDP q/q 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 14:00 MXN 	 MX   CALENDAR_SECTOR_GDP 	0 	  200000     CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_QUARTER 1
840170001 	United States 	S&P/CS HPI Composite-20 y/y 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 15:00 USD 	 US   CALENDAR_SECTOR_HOUSING 	6800000   7200000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
840030021 	United States 	JOLTS Job Openings 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_HIGH 	2024.07.30 16:00 USD 	 US   CALENDAR_SECTOR_JOBS 	7979000   8140000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
840060003 	United States 	Dallas Fed Services Revenues 		CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 16:30 USD 	 US   CALENDAR_SECTOR_BUSINESS 	3900000   1900000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1
484010001 	Mexico Fiscal 	Balance 				CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_LOW 	2024.07.30 22:30 MXN 	 MX   CALENDAR_SECTOR_TRADE 	-900000   -174071000 CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1

Estos resultados se almacenarán en la siguiente variable:

Calendar &NewsTime[]

La función debajo de EconomicNextEvent es similar a la función mencionada anteriormente, que es EconomicDetailsMemory, la principal diferencia es que el propósito de la función a continuación es obtener el próximo evento en lugar de recuperar todos los eventos para una fecha específica.

//+------------------------------------------------------------------+
//|Will update UpcomingNews structure variable with the next event   |
//|data                                                              |
//+------------------------------------------------------------------+
void CNews::EconomicNextEvent(datetime date=0)
  {
//--- Declare unassigned Calendar structure variable Empty
   Calendar Empty;
//--- assign empty values to Calendar structure variable UpcomingNews
   UpcomingNews = Empty;
//--- If date variable is zero then assign current date
   date = (date==0)?TimeTradeServer():date;
//--- Query to retrieve next upcoming event.
   string request_text=StringFormat("WITH MySubQuery AS (SELECT EventId as 'Id',Country,EventName as 'Name',"
                                    "EventType as 'Type',EventImportance as 'Importance',%s as 'CTime',EventCurrency as 'Currency',"
                                    "EventCode as 'Code',EventSector as 'Sector',EventForecast as 'Forecast',"
                                    "EventPrevalue as 'Prevalue',EventImpact as 'Impact',EventFrequency as 'Freq',"
                                    "RANK() OVER (PARTITION BY %s ORDER BY CASE EventPrevalue WHEN 'None' THEN 2 ELSE 1 END"
                                    ", CASE EventForecast WHEN 'None' THEN 2 ELSE 1 END,CASE EventImportance "
                                    "WHEN 'CALENDAR_IMPORTANCE_HIGH' THEN 1 WHEN 'CALENDAR_IMPORTANCE_MODERATE' THEN 2 WHEN"
                                    " 'CALENDAR_IMPORTANCE_LOW' THEN 3 ELSE 4 END) Ranking FROM %s) SELECT Id,Country,Name,"
                                    "Type,Importance,CTime,Currency,Code,Sector,Forecast,Prevalue,Impact,Freq FROM MySubQuery "
                                    "where Replace(CTime,'.','-')>=Replace('%s','.','-') AND Ranking<2 Group by CTime LIMIT 1;",
                                    EnumToString(MySchedule),EnumToString(MySchedule),DBMemory.name,TimeToString(date));

   int request=DatabasePrepare(DBMemoryConnection,request_text);//Creates a handle of a request, which can then be executed using DatabaseRead()
   if(request==INVALID_HANDLE)//Checks if the request failed to be completed
     {
      Print("DB: ",NEWS_DATABASE_MEMORY, " request failed with code ", GetLastError());
      PrintFormat(request_text);
     }
//--- Assign query results to Calendar structure variable UpcomingNews
   DatabaseReadBind(request,UpcomingNews);
//--- Removes a request created in DatabasePrepare()
   DatabaseFinalize(request);
  }

La consulta a continuación para la función EconomicNextEvent es similar a la consulta en la función EconomicDetailsMemory, que explicamos anteriormente. La única diferencia es que esta consulta limitará los resultados a 1.

WITH MySubQuery AS (SELECT EventId as 'Id',Country,EventName as 'Name',EventType as 'Type',EventImportance as 'Importance',
DST_NONE as 'CTime',EventCurrency as 'Currency',EventCode as 'Code',EventSector as 'Sector',EventForecast as 'Forecast',
EventPrevalue as 'Prevalue',EventImpact as'Impact',EventFrequency as 'Freq',RANK() OVER (PARTITION BY DST_NONE 
Order BY CASE EventPrevalue WHEN 'None' THEN 2 ELSE 1 END,CASE EventForecast WHEN 'None' THEN 2 ELSE 1 END,
CASE EventImportance WHEN 'CALENDAR_IMPORTANCE_HIGH' THEN 1 WHEN 'CALENDAR_IMPORTANCE_MODERATE' THEN 2 
WHEN 'CALENDAR_IMPORTANCE_LOW' THEN 3 ELSE 4 END) Ranking FROM MQL5Calendar) SELECT Id,Country,Name,Type,
Importance,CTime,Currency,Code,Sector,Forecast,Prevalue,Impact,Freq FROM MySubQuery where 
Date(Replace(CTime,'.','-'))=Date(Replace('2024.07.30 00:00','.','-')) and Ranking<2 Group by CTime LIMIT 1;

A continuación se muestran ejemplos de resultados de la consulta anterior.

Id 		Country 	Name 					Type 			Importance 			CTime 		Currency Code Sector 			Forecast  Prevalue   Impact 		Freq 			  Ranking
392030007 	Japan 		Unemployment Rate 			CALENDAR_TYPE_INDICATOR CALENDAR_IMPORTANCE_MODERATE 	2024.07.30 01:30 JPY 	 JP   CALENDAR_SECTOR_JOBS 	2500000   2600000    CALENDAR_IMPACT_NA CALENDAR_FREQUENCY_MONTH   1

El resultado de muestra anterior se almacenará en la variable que declaramos fuera de la clase de noticias llamada UpcomingNews.

//--- Assign query results to Calendar structure variable UpcomingNews
   DatabaseReadBind(request,UpcomingNews);

La última función recién agregada en la clase de noticias de la Parte 2 se llama GetImpact y se muestra a continuación. El propósito de esta función es devolver el valor de enumeración para la enumeración llamada ENUM_CALENDAR_EVENT_IMPACT para el próximo evento basado en eventos anteriores con propiedades o valores similares al próximo evento. Permítanme que me explique mejor.

//+------------------------------------------------------------------+
//|Will retrieve Upcoming Event Impact data                          |
//+------------------------------------------------------------------+
ENUM_CALENDAR_EVENT_IMPACT CNews::GetImpact()
  {
//--- Declaration of string variable
   string impact=NULL;
//--- Query to get impact data from previous event with the same event id and matching EventPrevalue and EventForecast scenarios.
   string request_text=StringFormat("SELECT EventImpact FROM %s where Replace(%s,'.','-')<Replace('%s','.','-') AND EventId=%d"
                                    " %s ORDER BY %s DESC LIMIT 1;",DBMemory.name,EnumToString(MySchedule),UpcomingNews.EventDate,
                                    UpcomingNews.EventId,((UpcomingNews.EventPreval=="None"||UpcomingNews.EventForecast=="None")?
                                          "AND EventImpact='CALENDAR_IMPACT_NA'":(int(UpcomingNews.EventPreval)<int(UpcomingNews.EventForecast))?
                                          "AND EventPrevalue<EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA'":
                                          (int(UpcomingNews.EventPreval)>int(UpcomingNews.EventForecast))?
                                          "AND EventPrevalue>EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA'":
                                          "AND EventPrevalue=EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA'"),
                                    EnumToString(MySchedule));

   int request=DatabasePrepare(DBMemoryConnection,request_text);//Creates a handle of a request, which can then be executed using DatabaseRead()

   if(request==INVALID_HANDLE)//Checks if the request failed to be completed
     {
      Print("DB: ",NEWS_DATABASE_MEMORY, " request failed with code ", GetLastError());
      PrintFormat(request_text);
     }
   if(DatabaseRead(request))//Will read the one record in the 'Record' table
     {
      //--- assign first column result into impact variable
      DatabaseColumnText(request,0,impact);
     }
//--- Removes a request created in DatabasePrepare()
   DatabaseFinalize(request);
//--- Return equivalent Event impact in the enumeration ENUM_CALENDAR_EVENT_IMPACT
   if(impact=="CALENDAR_IMPACT_POSITIVE")
     {
      return CALENDAR_IMPACT_POSITIVE;
     }
   else
      if(impact=="CALENDAR_IMPACT_NEGATIVE")
        {
         return CALENDAR_IMPACT_NEGATIVE;
        }
      else
        {
         return CALENDAR_IMPACT_NA;
        }
  }

Según mis observaciones, el impacto del evento funciona básicamente de tal manera que los próximos eventos o eventos que ocurren en el día actual tienen todos el valor de enumeración CALENDAR_IMPACT_NA del impacto, lo que significa que el impacto no está disponible para el evento. El impacto del suceso sólo se actualiza una vez que ha pasado el día del suceso y sólo si el suceso tenía tanto el valor del suceso anterior como los valores del suceso previsto disponibles antes de que ocurriera el suceso, hay algunos casos en los que el impacto del suceso seguirá registrado como no disponible aunque se cumplan todos estos requisitos. 

¿Por qué necesitamos el valor del impacto del suceso anterior y cómo lo utilizamos?

En primer lugar, la razón por la que necesitamos el impacto del evento anterior es para predecir cuál podría ser el resultado del impacto del próximo evento. Entonces, cuando el valor anterior del próximo evento no es 'Ninguno' y además el valor pronosticado, verificaremos si estos valores son iguales o qué valor es mayor que el otro. Una vez que descubrimos qué valor es mayor que el otro o si los valores son iguales, buscamos eventos anteriores que tuvieron la misma configuración y recuperamos el impacto del evento anterior para predecir cuál podría ser el impacto del próximo evento. Ejemplo: Si el valor anterior del próximo evento es 3000 y el pronóstico es 10000, buscamos el último evento con el mismo ID de evento que tuvo un valor anterior menor que el valor del pronóstico y usamos el impacto de este evento para el próximo evento.

¿Cuál es el impacto del evento y en qué se basa?

El impacto del evento es la medida del efecto percibido que un evento específico tuvo en una moneda, el impacto se basa en la moneda del evento. Entonces, si la tasa de desempleo es el próximo evento y el evento anterior, con valores previos y de pronóstico similares, tuvo un impacto de CALENDAR_IMPACT_NEGATIVE y la moneda del evento es USD, esto significa que el dólar estadounidense se vio afectado negativamente en la tasa de desempleo anterior. Por lo tanto, si estuvieras en el símbolo EURUSD justo después de que ocurriera la tasa de desempleo anterior, idealmente veríamos que EURUSD se fortalece, lo que significa que el euro habría ganado valor frente al dólar estadounidense. 

En la consulta a continuación, seleccionamos el impacto del evento de la tabla MQL5Calendar en la base de datos en memoria. En la cláusula WHERE, buscamos eventos con fechas anteriores a la fecha del próximo evento y filtramos por el mismo ID de evento. A continuación, filtramos por el mismo escenario de relación entre el valor anterior del evento (EventPreval) y el valor de previsión del evento (EventForecast), si UpcomingNews.EventPreval es igual a 'None' o UpcomingNews.EventForecast es igual a 'None' entonces ya sabemos que el impacto del evento será 'None', si UpcomingNews.EventPreval es menor que el UpcomingNews. EventForecast entonces buscamos eventos anteriores donde EventPrevalue<EventForecast y el impacto del evento no es NA, si el UpcomingNews.EventPreval es mayor que UpcomingNews.EventForecast entonces buscamos eventos anteriores donde EventPreval>EventForecast y el impacto del evento no es NA, sino buscamos donde el EventPrevalue=EventForecast y el impacto del evento no es NA. Todos los resultados se filtran por la fecha más reciente ya que la cláusula ORDER BY está en orden descendente para la fecha del evento y la cláusula LIMIT permitirá que sólo se devuelva/salga un registro.

//--- Query to get impact data from previous event with the same event id and matching EventPrevalue and EventForecast scenarios.
   string request_text=StringFormat("SELECT EventImpact FROM %s where Replace(%s,'.','-')<Replace('%s','.','-') AND EventId=%d"
                                    " %s ORDER BY %s DESC LIMIT 1;",DBMemory.name,EnumToString(MySchedule),UpcomingNews.EventDate,
                                    UpcomingNews.EventId,((UpcomingNews.EventPreval=="None"||UpcomingNews.EventForecast=="None")?
                                          "AND EventImpact='CALENDAR_IMPACT_NA'":(int(UpcomingNews.EventPreval)<int(UpcomingNews.EventForecast))?
                                          "AND EventPrevalue<EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA'":
                                          (int(UpcomingNews.EventPreval)>int(UpcomingNews.EventForecast))?
                                          "AND EventPrevalue>EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA'":
                                          "AND EventPrevalue=EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA'"),
                                    EnumToString(MySchedule));

Un ejemplo de cómo se ve la consulta anterior cuando todas las variables están llenas de datos. Como puedes ver a continuación, seleccionamos EventImpact de MQL5Calendar donde DST_NONE es menor que '2024.08.01 16:30', el EventId es igual a 124500001, EventPrevalue es menor que EventForecast y EventImpact no es igual a 'CALENDAR_IMPACT_NA'. Luego, ordenamos los resultados en orden descendente en relación con DST_NONE y, finalmente, limitamos los resultados a un solo registro.

SELECT EventImpact FROM MQL5Calendar where Replace(DST_NONE,'.','-')<Replace('2024.08.01 16:30','.','-') AND EventId=124500001 
AND EventPrevalue<EventForecast AND EventImpact<>'CALENDAR_IMPACT_NA' ORDER BY DST_NONE DESC LIMIT 1;

Clase de gráficos comunes

Esta clase es la responsable de mostrar los elementos visuales del experto en el gráfico, por lo que a estas alturas ya te habrás dado cuenta de que los elementos visuales de la Parte 3 son un paso mayor que los de la Parte 2 y también lo será el código que crea estos elementos visuales. Veamos el código. Entonces, esta clase necesitará acceso a información de noticias, información de gestión de riesgos, información de cuentas, por eso estas clases están incluidas.

#include "ObjectProperties.mqh"
#include "RiskManagement.mqh"
#include "CommonVariables.mqh"
#include "News.mqh"
//+------------------------------------------------------------------+
//|CommonGraphics class                                              |
//+------------------------------------------------------------------+
class CCommonGraphics:CObjectProperties
  {
private:
   //--- GraphicText structure this structure is responsible for managing the graphical text
   struct GraphicText
     {
      //--- private declaration for struct GraphicText
   private:
      //--- this structure will store properties for the subtext
      struct subtextformat
        {
         string      Label;//Store text label
         string      Text;//Store text value
        };
      //--- this structure inherits from subtextformat and is responsible for finding text
      struct found:subtextformat
        {
         bool        isFound;//Check if text is found
         int         index;//Get index for the text
        };
      //--- structure array for subtexts
      subtextformat  sub_text[];
      //--- function to find text properties from text's label
      found          FoundText(string label)
        {
         found find;
         find.Label="";
         find.Text="";
         find.isFound=false;
         find.index=-1;
         for(uint i=0;i<sub_text.Size();i++)
           {
            //--- If text label is found in array
            if(label==sub_text[i].Label)
              {
               //--- Assign text properties
               find.Label=sub_text[i].Label;
               find.Text=sub_text[i].Text;
               find.isFound=true;
               find.index=int(i);
               return find;//return found text properties
              }
           }
         return find;//return text properties
        }
      //--- public declaration for struct GraphicText
   public:
      //--- string variable
      string         text;
      //--- function to set/add text properties
      void           subtext(string label,string value)
        {
         //--- Get text properties from label
         found result = FoundText(label);
         //--- Check if text label was found/exists in array sub_text
         if(!result.isFound)
           {
            //--- Resize array sub_text
            ArrayResize(sub_text,sub_text.Size()+1,sub_text.Size()+2);
            //--- Add text properties for new array index
            sub_text[sub_text.Size()-1].Label = label;
            sub_text[sub_text.Size()-1].Text = value;
           }
         else
           {
            /* Set new text/override text from text label that exists
            in the array sub_text array */
            sub_text[result.index].Text = value;
           }
        }
      //--- function to retrieve text from text label
      string         subtext(string label)
        {
         return FoundText(label).Text;
        }
     };// End of struct GraphicText

   //--- AccountInfo object declaration
   CAccountInfo      CAccount;
   //--- News object declaration
   CNews             NewsObj;
   //--- TimeManagement object declaration
   CTimeManagement   CTime;
   //--- Calendar structure array declaration
   Calendar          CalendarArray[];
   //--- color variable declaration
   color             EventColor;
   //--- unit variable declarations
   uint              Fontsize,X_start,Y_start;
   //--- void function declarations for Graphical blocks
   void              Block_1();
   void              Block_2(uint SecondsPreEvent=5);
   CRiskManagement   CRisk;//Risk management class object
   //--- GraphicText structure array declarations
   GraphicText       Texts_Block1[9],Texts_Block2[7];
   //--- structure to store text height and width
   struct Text_Prop_Size
     {
      uint           Height;//store text height
      uint           Width;//store text width
     };

   //--- void function to retrieve sum of the texts height and the maximum width of texts from GraphicText array Texts
   void              GetTextMaxWidthAndHeight(GraphicText &Texts[],uint &Max_Height,uint &Max_Width,uint FontSize)
     {
      //--- set fontsize properties to get accurate text height and width sizes
      TextSetFont("Arial",(-1*FontSize)-100);
      //--- set variables to default value of zero
      Max_Height=0;
      Max_Width=0;
      //--- loop through all texts in the GraphicText array Texts
      for(uint i=0;i<Texts.Size();i++)
        {
         //--- temporary declarations for height and width
         uint Height=0,Width=0;
         //--- retrieve text height and width from index in Texts array
         TextGetSize(Texts[i].text,Width,Height);
         //--- sum texts height to variable Max_Height
         Max_Height+=Height;
         //--- assign width if text width is more than variable Max_Width value
         Max_Width=(Width>Max_Width)?Width:Max_Width;
        }
     }
   //--- function to retrieve text height and width properties in the structure Text_Prop_Size format
   Text_Prop_Size    GetText(string Text,uint FontSize)
     {
      //--- structure Text_Prop_Size variable
      Text_Prop_Size Size;
      //--- set fontsize properties to get accurate text height and width sizes
      TextSetFont("Arial",(-1*FontSize)-100);
      //--- retrieve text height and width from Text string variable
      TextGetSize(Text,Size.Width,Size.Height);
      //--- return structure Text_Prop_Size variable
      return Size;
     }
   //--- Function to get texts height sum and max width in the structure Text_Prop_Size format
   Text_Prop_Size    GetTextMax(GraphicText &Texts[],uint FontSize)
     {
      //--- structure Text_Prop_Size variable
      Text_Prop_Size Size;
      //--- uint variable declarations for text properties
      uint Max_Height;
      uint Max_Width;
      //--- Retrieve sum of texts height and maximum texts width into Max_Height,Max_Width
      GetTextMaxWidthAndHeight(Texts,Max_Height,Max_Width,FontSize);
      //--- assign values into structure Text_Prop_Size variable
      Size.Height = Max_Height;
      Size.Width = Max_Width;
      //--- return structure Text_Prop_Size variable
      return Size;
     }
   //--- Boolean declarations
   bool              is_date,is_spread,is_news,is_events;

public:
   //--- class constructor
                     CCommonGraphics(bool display_date,bool display_spread,bool display_news,bool display_events);
                    ~CCommonGraphics(void) {}//class destructor
   void              GraphicsRefresh(uint SecondsPreEvent=5);//will create/refresh the chart objects
   //--- will update certain graphics at an interval
   void              Block_2_Realtime(uint SecondsPreEvent=5);
   //--- will create chart event objects
   void              NewsEvent();
  };

La siguiente estructura llamada GraphicText no es una estructura común en MQL5, esta estructura contiene declaraciones privadas y/o públicas de estructuras, matrices de estructuras, funciones y una variable de cadena (string). En este caso, la estructura GraphicText se comporta como una clase completamente separada. El propósito de esta estructura es gestionar y almacenar textos gráficos, la estructura array sub_text almacenará todas las propiedades del texto y la función FoundText buscará cualquier coincidencia de etiqueta de texto dentro de la estructura array sub_text, si hay una coincidencia devolveremos los detalles de esta coincidencia dentro de la estructura llamada found que hereda de la estructura subtextformat. En las declaraciones públicas la variable de cadena llamada texto almacenará la longitud completa del texto en el array de la estructura sub_text. La función void subtext agregará la etiqueta de texto y el texto/subtexto en el array sub_text o sobrescribirá el texto/subtexto almacenado en el array si la variable de tipo string se encuentra dentro del array. La función de cadena llamada subtext recuperará el texto de la etiqueta asociada con las etiquetas en la matriz de estructura sub_text.

   //--- GraphicText structure this structure is responsible for managing the graphical text
   struct GraphicText
     {
      //--- private declaration for struct GraphicText
   private:
      //--- this structure will store properties for the subtext
      struct subtextformat
        {
         string      Label;//Store text label
         string      Text;//Store text value
        };
      //--- this structure inherits from subtextformat and is responsible for finding text
      struct found:subtextformat
        {
         bool        isFound;//Check if text is found
         int         index;//Get index for the text
        };
      //--- structure array for subtexts
      subtextformat  sub_text[];
      //--- function to find text properties from text's label
      found          FoundText(string label)
        {
         found find;
         find.Label="";
         find.Text="";
         find.isFound=false;
         find.index=-1;
         for(uint i=0;i<sub_text.Size();i++)
           {
            //--- If text label is found in array
            if(label==sub_text[i].Label)
              {
               //--- Assign text properties
               find.Label=sub_text[i].Label;
               find.Text=sub_text[i].Text;
               find.isFound=true;
               find.index=int(i);
               return find;//return found text properties
              }
           }
         return find;//return text properties
        }
      //--- public declaration for struct GraphicText
   public:
      //--- string variable
      string         text;
      //--- function to set/add text properties
      void           subtext(string label,string value)
        {
         //--- Get text properties from label
         found result = FoundText(label);
         //--- Check if text label was found/exists in array sub_text
         if(!result.isFound)
           {
            //--- Resize array sub_text
            ArrayResize(sub_text,sub_text.Size()+1,sub_text.Size()+2);
            //--- Add text properties for new array index
            sub_text[sub_text.Size()-1].Label = label;
            sub_text[sub_text.Size()-1].Text = value;
           }
         else
           {
            /* Set new text/override text from text label that exists
            in the array sub_text array */
            sub_text[result.index].Text = value;
           }
        }
      //--- function to retrieve text from text label
      string         subtext(string label)
        {
         return FoundText(label).Text;
        }
     };// End of struct GraphicText

La función a continuación se crea para recuperar la suma de las alturas de texto en la estructura de array Texts, así como el ancho máximo de los textos en el array.

 //--- void function to retrieve sum of the texts height and the maximum width of texts from GraphicText array Texts
   void              GetTextMaxWidthAndHeight(GraphicText &Texts[],uint &Max_Height,uint &Max_Width,uint FontSize)
     {
      //--- set fontsize properties to get accurate text height and width sizes
      TextSetFont("Arial",(-1*FontSize)-100);
      //--- set variables to default value of zero
      Max_Height=0;
      Max_Width=0;
      //--- loop through all texts in the GraphicText array Texts
      for(uint i=0;i<Texts.Size();i++)
        {
         //--- temporary declarations for height and width
         uint Height=0,Width=0;
         //--- retrieve text height and width from index in Texts array
         TextGetSize(Texts[i].text,Width,Height);
         //--- sum texts height to variable Max_Height
         Max_Height+=Height;
         //--- assign width if text width is more than variable Max_Width value
         Max_Width=(Width>Max_Width)?Width:Max_Width;
        }
     }

La función a continuación se crea para recuperar las propiedades de altura y ancho en el formato de la estructura Text_Prop_Size a partir de la variable de tipo string Text.

//--- function to retrieve text height and width properties in the structure Text_Prop_Size format
   Text_Prop_Size    GetText(string Text,uint FontSize)
     {
      //--- structure Text_Prop_Size variable
      Text_Prop_Size Size;
      //--- set fontsize properties to get accurate text height and width sizes
      TextSetFont("Arial",(-1*FontSize)-100);
      //--- retrieve text height and width from Text string variable
      TextGetSize(Text,Size.Width,Size.Height);
      //--- return structure Text_Prop_Size variable
      return Size;
     }

La función a continuación se crea para recuperar la suma de las alturas y las propiedades de ancho máximo en el formato de la estructura Text_Prop_Size a partir del array de estructuras Texts.

//--- Function to get texts height sum and max width in the structure Text_Prop_Size format
   Text_Prop_Size    GetTextMax(GraphicText &Texts[],uint FontSize)
     {
      //--- structure Text_Prop_Size variable
      Text_Prop_Size Size;
      //--- uint variable declarations for text properties
      uint Max_Height;
      uint Max_Width;
      //--- Retrieve sum of texts height and maximum texts width into Max_Height,Max_Width
      GetTextMaxWidthAndHeight(Texts,Max_Height,Max_Width,FontSize);
      //--- assign values into structure Text_Prop_Size variable
      Size.Height = Max_Height;
      Size.Width = Max_Width;
      //--- return structure Text_Prop_Size variable
      return Size;
     }

En el constructor de la clase, inicializaremos nuestras variables previamente declaradas, que son is_date (que se usará para decidir si se debe mostrar la información de la fecha en el gráfico), is_spread (que se usará para decidir si se debe mostrar la información del spread en el gráfico), is_news (que se usará para decidir si se debe mostrar la información de noticias en el gráfico) y is_events (que se usará para decidir si se debe mostrar la información del objeto de eventos en el gráfico). NewsObject. La función EconomicNextEvent actualizará la variable UpcomingNews con los detalles de la próxima noticia.

//+------------------------------------------------------------------+
//|Constructor                                                       |
//+------------------------------------------------------------------+
CCommonGraphics::CCommonGraphics(bool display_date,bool display_spread,bool display_news,bool display_events):
//--- Assign variables
   is_date(display_date),is_spread(display_spread),is_news(display_news),is_events(display_events)
  {
//--- get next news event
   NewsObject.EconomicNextEvent();
  }

GraphicsRefresh se encargará en primer lugar de limpiar el gráfico de los objetos creados anteriormente, si los hubiera, y a continuación llamará a otras funciones que crearán objetos de gráfico para mostrar diversa información en el gráfico actual.

//+------------------------------------------------------------------+
//|will create/refresh the chart objects                             |
//+------------------------------------------------------------------+
void CCommonGraphics::GraphicsRefresh(uint SecondsPreEvent=5)
  {
//--- create graphics if outside the strategy tester or in the strategy tester and visual mode is enabled
   if((!MQLInfoInteger(MQL_TESTER))||(MQLInfoInteger(MQL_TESTER)&&MQLInfoInteger(MQL_VISUAL_MODE)))
     {
      //--- Delete chart objects
      DeleteObj();//function from Object properties class
      Block_1();//Create graphics for block 1
      //--- Check whether to create graphics for block 2
      if(is_date||is_news||is_spread)
        {
         Block_2(SecondsPreEvent);//Create graphics for block 2
        }
      //--- creates event objects
      NewsEvent();
     }
  }

La función que se indica a continuación llamada Block_1 será la encargada de crear los elementos gráficos para el bloque gráfico 1 que se indica a continuación y que consta de:

• Nombre del símbolo
• Periodo del símbolo
• Descripción del símbolo
• Símbolo Tamaño del contrato
• Símbolo Tamaño mínimo del lote
• Símbolo Tamaño máximo del lote
• Paso de volumen del símbolo
• Límite de volumen del símbolo
• Opción de riesgo
• Nivel mínimo de riesgo
• Límite máximo de riesgo

//+------------------------------------------------------------------+
//|Graphical Block 1                                                 |
//+------------------------------------------------------------------+
void CCommonGraphics::Block_1()
  {
//--- Set text object color depending if the chart color mode is LightMode or not
   TextObj_color = (isLightMode)?clrBlack:clrWheat;
//--- Set text properties for Symbol name,Symbol period and Symbol description # section 1
   Texts_Block1[0].text = Symbol()+", "+GetChartPeriodName()+": "+CSymbol.Description();//set main text
   Texts_Block1[0].subtext("Symbol Name",Symbol()+",");//set subtext - label,value
   Texts_Block1[0].subtext("Symbol Period",GetChartPeriodName());//set subtext - label,value
   Texts_Block1[0].subtext("Symbol Desc",": "+CSymbol.Description());//set subtext - label,value
//--- Set text properties for Contract size # section 2
   Texts_Block1[1].text = "Contract Size: "+string(CSymbol.ContractSize());//set main text
   Texts_Block1[1].subtext("Contract Size Text","Contract Size:");//set subtext - label,value
   Texts_Block1[1].subtext("Contract Size",string(CSymbol.ContractSize()));//set subtext - label,value
//--- Set text properties for Minimum lot # section 3
   Texts_Block1[2].text = "Minimum Lot: "+string(CSymbol.LotsMin());//set main text
   Texts_Block1[2].subtext("Minimum Lot Text","Minimum Lot:");//set subtext - label,value
   Texts_Block1[2].subtext("Minimum Lot",string(CSymbol.LotsMin()));//set subtext - label,value
//--- Set text properties for Max lot # section 4
   Texts_Block1[3].text = "Max Lot: "+string(CSymbol.LotsMax());//set main text
   Texts_Block1[3].subtext("Max Lot Text","Max Lot:");//set subtext - label,value
   Texts_Block1[3].subtext("Max Lot",string(CSymbol.LotsMax()));//set subtext - label,value
//--- Set text properties for Volume step # section 5
   Texts_Block1[4].text = "Volume Step: "+string(CSymbol.LotsStep());//set main text
   Texts_Block1[4].subtext("Volume Step Text","Volume Step:");//set subtext - label,value
   Texts_Block1[4].subtext("Volume Step",string(CSymbol.LotsStep()));//set subtext - label,value
//--- Set text properties for Volume limit # section 6
   Texts_Block1[5].text = "Volume Limit: "+string(CSymbol.LotsLimit());//set main text
   Texts_Block1[5].subtext("Volume Limit Text","Volume Limit:");//set subtext - label,value
   Texts_Block1[5].subtext("Volume Limit",string(CSymbol.LotsLimit()));//set subtext - label,value
//--- Set text properties for Risk option # section 7
   Texts_Block1[6].text = "Risk Option: "+CRisk.GetRiskOption();//set main text
   Texts_Block1[6].subtext("Risk Option Text","Risk Option:");//set subtext - label,value
   Texts_Block1[6].subtext("Risk Option",CRisk.GetRiskOption());//set subtext - label,value
//--- Set text properties for Risk floor # section 8
   Texts_Block1[7].text = "Risk Floor: "+CRisk.GetRiskFloor();//set main text
   Texts_Block1[7].subtext("Risk Floor Text","Risk Floor:");//set subtext - label,value
   Texts_Block1[7].subtext("Risk Floor",CRisk.GetRiskFloor());//set subtext - label,value
//--- Set text properties for Risk ceiling # section 9
   Texts_Block1[8].text = "Risk Ceiling: "+CRisk.GetRiskCeil();//set main text
   Texts_Block1[8].subtext("Risk Ceiling Text","Risk Ceiling:");//set subtext - label,value
   Texts_Block1[8].subtext("Risk Ceiling",CRisk.GetRiskCeil());//set subtext - label,value

//--- Set basic properties
   Fontsize=10;//Set Fontsize
   X_start=2;//Set X distance
   Y_start=2;//Set Y distance

/* Create objects # section 1*/
//-- Create the background object for width and height+3 of section 1 text
   Square(0,"Symbol Name background",X_start,Y_start,GetText(Texts_Block1[0].text,Fontsize).Width,
          GetText(Texts_Block1[0].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 1
   TextObj(0,"Symbol Name",Texts_Block1[0].subtext("Symbol Name"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[0].subtext("Symbol Name"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol Period",Texts_Block1[0].subtext("Symbol Period"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[0].subtext("Symbol Period"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol Desc",Texts_Block1[0].subtext("Symbol Desc"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 2*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[0].text,Fontsize).Height;//Re-adjust Y distance, add height from section 1
   //-- Create the background object for width and height+3 of section 2 text
   Square(0,"Symbol Contract Size background",X_start,Y_start,GetText(Texts_Block1[1].text,Fontsize).Width,
          GetText(Texts_Block1[1].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 2
   TextObj(0,"Symbol Contract Size Text",Texts_Block1[1].subtext("Contract Size Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[1].subtext("Contract Size Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol Contract Size",Texts_Block1[1].subtext("Contract Size"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 3*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[1].text,Fontsize).Height;//Re-adjust Y distance, add height from section 2
   //-- Create the background object for width and height+3 of section 3 text
   Square(0,"Symbol MinLot background",X_start,Y_start,GetText(Texts_Block1[2].text,Fontsize).Width,
          GetText(Texts_Block1[2].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 3
   TextObj(0,"Symbol MinLot Text",Texts_Block1[2].subtext("Minimum Lot Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[2].subtext("Minimum Lot Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol MinLot",Texts_Block1[2].subtext("Minimum Lot"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 4*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[2].text,Fontsize).Height;//Re-adjust Y distance, add height from section 3
   //-- Create the background object for width and height+3 of section 4 text
   Square(0,"Symbol MaxLot background",X_start,Y_start,GetText(Texts_Block1[3].text,Fontsize).Width,
          GetText(Texts_Block1[3].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 4
   TextObj(0,"Symbol MaxLot Text",Texts_Block1[3].subtext("Max Lot Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[3].subtext("Max Lot Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol MaxLot",Texts_Block1[3].subtext("Max Lot"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 5*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[3].text,Fontsize).Height;//Re-adjust Y distance, add height from section 4
   //-- Create the background object for width and height+3 of section 5 text
   Square(0,"Symbol Volume Step background",X_start,Y_start,GetText(Texts_Block1[4].text,Fontsize).Width,
          GetText(Texts_Block1[4].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 5
   TextObj(0,"Symbol Volume Step Text",Texts_Block1[4].subtext("Volume Step Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[4].subtext("Volume Step Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol Volume Step",Texts_Block1[4].subtext("Volume Step"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 6*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[4].text,Fontsize).Height;//Re-adjust Y distance, add height from section 5
   //-- Create the background object for width and height+3 of section 6 text
   Square(0,"Symbol Volume Limit background",X_start,Y_start,GetText(Texts_Block1[5].text,Fontsize).Width,
          GetText(Texts_Block1[5].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 6
   TextObj(0,"Symbol Volume Limit Text",Texts_Block1[5].subtext("Volume Limit Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[5].subtext("Volume Limit Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Symbol Volume Limit",Texts_Block1[5].subtext("Volume Limit"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 7*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[5].text,Fontsize).Height;//Re-adjust Y distance, add height from section 6
   //-- Create the background object for width and height+3 of section 7 text
   Square(0,"Risk Option background",X_start,Y_start,GetText(Texts_Block1[6].text,Fontsize).Width,
          GetText(Texts_Block1[6].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 7
   TextObj(0,"Risk Option Text",Texts_Block1[6].subtext("Risk Option Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[6].subtext("Risk Option Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Risk Option",Texts_Block1[6].subtext("Risk Option"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 8*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[6].text,Fontsize).Height;//Re-adjust Y distance, add height from section 7
   //-- Create the background object for width and height+3 of section 8 text
   Square(0,"Risk Floor background",X_start,Y_start,GetText(Texts_Block1[7].text,Fontsize).Width,
          GetText(Texts_Block1[7].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 8
   TextObj(0,"Risk Floor Text",Texts_Block1[7].subtext("Risk Floor Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[7].subtext("Risk Floor Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Risk Floor",Texts_Block1[7].subtext("Risk Floor"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Create objects # section 9*/
   X_start=2;//Reset X distance
   Y_start+=GetText(Texts_Block1[7].text,Fontsize).Height;//Re-adjust Y distance, add height from section 8
   //-- Create the background object for width and height+3 of section 9 text
   Square(0,"Risk Ceil background",X_start,Y_start,GetText(Texts_Block1[8].text,Fontsize).Width,
          GetText(Texts_Block1[8].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
   Y_start+=3;//Re-adjust Y distance
   X_start+=2;//Re-adjust X distance
//-- Will create the text objects for section 9
   TextObj(0,"Risk Ceil Text",Texts_Block1[8].subtext("Risk Ceiling Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
   X_start+=GetText(Texts_Block1[8].subtext("Risk Ceiling Text"),Fontsize).Width;//Re-adjust X distance
   TextObj(0,"Risk Ceil",Texts_Block1[8].subtext("Risk Ceiling"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
  }

La función que se indica a continuación denominada Block_2 será la encargada de crear los elementos gráficos para el bloque gráfico 2 que se indica a continuación y que consta de:

• Fecha y hora actuales
• Fecha del evento
• Nombre del evento
• País del evento
• Moneda del evento
• Importancia del evento
• Clasificación de propagación (Spread)

//+------------------------------------------------------------------+
//|Graphical Block 2                                                 |
//+------------------------------------------------------------------+
void CCommonGraphics::Block_2(uint SecondsPreEvent=5)
  {
//--- Set text object color depending if the chart color mode is LightMode or not
   TextObj_color=(isLightMode)?clrBlack:clrWheat;
   if(is_date)//Check whether to display date information
     {
      //--- Set text properties for Date and Time # section 10
      Texts_Block2[0].text = "Date:"+TimeToString(TimeTradeServer(),TIME_DATE)+"|| Time:"+TimeToString(TimeTradeServer(),TIME_MINUTES)
                             +"   ";//set main text
      Texts_Block2[0].subtext("Date Text","Date:");//set subtext - label,value
      Texts_Block2[0].subtext("Date",TimeToString(TimeTradeServer(),TIME_DATE));//set subtext - label,value
      Texts_Block2[0].subtext("Time Text","|| Time:");//set subtext - label,value
      Texts_Block2[0].subtext("Time",TimeToString(TimeTradeServer(),TIME_MINUTES));//set subtext - label,value
     }
   if(is_news)//Check whether to display news information
     {
      //--- Set text object color depending on upcoming news event's Importance
      EventColor = NewsObj.GetImportance_color(NewsObj.IMPORTANCE(UpcomingNews.EventImportance));
      //--- Set text properties for Event Date # section 11
      Texts_Block2[1].text = "Event: @"+UpcomingNews.EventDate+" ";//set main text
      Texts_Block2[1].subtext("Event Date Text","Event: @");//set subtext - label,value
      Texts_Block2[1].subtext("Event Date",UpcomingNews.EventDate);//set subtext - label,value
      //--- Set text properties for Event Name # section 12
      Texts_Block2[2].text = "Name: "+UpcomingNews.EventName+" ";//set main text
      Texts_Block2[2].subtext("Event Name Text","Name: ");//set subtext - label,value
      Texts_Block2[2].subtext("Event Name",UpcomingNews.EventName);//set subtext - label,value
      //--- Set text properties for Event Country # section 13
      Texts_Block2[3].text = "Country: "+UpcomingNews.CountryName+" ";//set main text
      Texts_Block2[3].subtext("Event Country Text","Country: ");//set subtext - label,value
      Texts_Block2[3].subtext("Event Country",UpcomingNews.CountryName);//set subtext - label,value
      //--- Set text properties for Event Currency # section 14
      Texts_Block2[4].text = "Currency: "+UpcomingNews.EventCurrency+" ";//set main text
      Texts_Block2[4].subtext("Event Currency Text","Currency: ");//set subtext - label,value
      Texts_Block2[4].subtext("Event Currency",UpcomingNews.EventCurrency);//set subtext - label,value
      //--- Set text properties for Event Importance # section 15
      Texts_Block2[5].text = "Importance: "+NewsObj.GetImportance(NewsObj.IMPORTANCE(UpcomingNews.EventImportance))+" ";//set main text
      Texts_Block2[5].subtext("Importance Text","Importance: ");//set subtext - label,value
      Texts_Block2[5].subtext("Importance",NewsObj.GetImportance(NewsObj.IMPORTANCE(UpcomingNews.EventImportance)));//set subtext - label,value
     }
   if(is_spread)//Check whether to display spread information
     {
      //--- Set text properties for Spread # section 16
      Texts_Block2[6].text = "Spread: "+string(CSymbol.Spread())+" Rating: "+CSymbol.SpreadDesc()+" ";//set main text
      Texts_Block2[6].subtext("Spread Text","Spread:");//set subtext - label,value
      Texts_Block2[6].subtext("Spread",string(CSymbol.Spread()));//set subtext - label,value
      Texts_Block2[6].subtext("Rating Text"," Rating:");//set subtext - label,value
      Texts_Block2[6].subtext("Rating Desc",CSymbol.SpreadDesc());//set subtext - label,value
     }

//--- Set basic properties
   Fontsize=10;
   X_start=2;//Reset X distance
   Y_start=GetTextMax(Texts_Block1,Fontsize).Height+29;//Re-adjust Y distance from graphical block 1 Height

   /* Create objects # section 10*/
   if(is_date)//Check whether to display date information
     {
      //-- Create the background object for width and height+3 of section 10 text
      Square(0,"Datetime background",X_start,Y_start,GetText(Texts_Block2[0].text,Fontsize).Width,
             GetText(Texts_Block2[0].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //-- Will create the text objects for section 10
      TextObj(0,"Date Text",Texts_Block2[0].subtext("Date Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[0].subtext("Date Text"),Fontsize).Width;//Re-adjust X distance
      TextObj(0,"Date",Texts_Block2[0].subtext("Date"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[0].subtext("Date"),Fontsize).Width;//Re-adjust X distance
      TextObj(0,"Time Text",Texts_Block2[0].subtext("Time Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[0].subtext("Time Text"),Fontsize).Width;//Re-adjust X distance
      //--- Adjust text color depending if chart color mode is LightMode and if a news event is occurring
      TextObj_color = CTime.TimeIsInRange(CTime.TimeMinusOffset(datetime(UpcomingNews.EventDate),SecondsPreEvent),
                                          CTime.TimePlusOffset(datetime(UpcomingNews.EventDate),59))?clrRed:(isLightMode)?clrBlack:clrWheat;
      TextObj(0,"Time",Texts_Block2[0].subtext("Time"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
     }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   if(UpcomingNews.CountryName!=NULL&&is_news)//Check whether to display news information and if upcoming news is available
     {
      /* Create objects # section 11*/
      Y_start+=(is_date)?GetText(Texts_Block2[0].text,Fontsize).Height:0;//Re-adjust Y distance depending if section 10 is shown
      X_start=2;//Reset X distance
      //-- Create the background object for width and height+3 of section 11 text
      Square(0,"Event Date background",X_start,Y_start,GetText(Texts_Block2[1].text,Fontsize).Width,
             GetText(Texts_Block2[1].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will create the text objects for section 11
      TextObj(0,"Event Date Text",Texts_Block2[1].subtext("Event Date Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[1].subtext("Event Date Text"),Fontsize).Width;//Re-adjust X distance
      //--- Adjust text color depending if chart color mode is LightMode and if a news event is occurring
      TextObj_color = CTime.TimeIsInRange(CTime.TimeMinusOffset(datetime(UpcomingNews.EventDate),SecondsPreEvent),
                                          CTime.TimePlusOffset(datetime(UpcomingNews.EventDate),59))?clrRed:(isLightMode)?clrBlack:clrWheat;
      TextObj(0,"Event Date",Texts_Block2[1].subtext("Event Date"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 12*/
      Y_start+=GetText(Texts_Block2[1].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Create the background object for width and height+3 of section 12 text
      Square(0,"Event Name background",X_start,Y_start,GetText(Texts_Block2[2].text,Fontsize).Width,
             GetText(Texts_Block2[2].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will create the text objects for section 12
      TextObj(0,"Event Name Text",Texts_Block2[2].subtext("Event Name Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[2].subtext("Event Name Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Event Name",Texts_Block2[2].subtext("Event Name"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 13*/
      Y_start+=GetText(Texts_Block2[2].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Create the background object for width and height+3 of section 13 text
      Square(0,"Event Country background",X_start,Y_start,GetText(Texts_Block2[3].text,Fontsize).Width,
             GetText(Texts_Block2[3].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will create the text objects for section 13
      TextObj(0,"Event Country Text",Texts_Block2[3].subtext("Event Country Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[3].subtext("Event Country Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Event Country",Texts_Block2[3].subtext("Event Country"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 14*/
      Y_start+=GetText(Texts_Block2[3].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Create the background object for width and height+3 of section 14 text
      Square(0,"Event Currency background",X_start,Y_start,GetText(Texts_Block2[4].text,Fontsize).Width,
             GetText(Texts_Block2[4].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will create the text objects for section 14
      TextObj(0,"Event Currency Text",Texts_Block2[4].subtext("Event Currency Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[4].subtext("Event Currency Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Event Currency",Texts_Block2[4].subtext("Event Currency"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 15*/
      Y_start+=GetText(Texts_Block2[4].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Create the background object for width and height+3 of section 15 text
      Square(0,"Event Importance background",X_start,Y_start,GetText(Texts_Block2[5].text,Fontsize).Width,
             GetText(Texts_Block2[5].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will create the text objects for section 15
      TextObj(0,"Importance Text",Texts_Block2[5].subtext("Importance Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[5].subtext("Importance Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Importance",Texts_Block2[5].subtext("Importance"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 16*/
      if(is_spread)//Check whether to display spread information
        {
         Y_start+=GetText(Texts_Block2[5].text,Fontsize).Height;//Re-adjust Y distance
         X_start=2;//Reset X distance
         //-- Create the background object for width and height+3 of section 16 text
         Square(0,"Spread background",X_start,Y_start,GetText(Texts_Block2[6].text,Fontsize).Width,
                GetText(Texts_Block2[6].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
         Y_start+=3;//Re-adjust Y distance
         X_start+=2;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         color Spread_clr=CSymbol.SpreadColor();
         //--- Set text object color depending if the chart color mode is LightMode or not
         TextObj_color=(isLightMode)?clrBlack:clrWheat;
         //-- Will create the text objects for section 16
         TextObj(0,"Symbol Spread Text",Texts_Block2[6].subtext("Spread Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Spread Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         TextObj(0,"Symbol Spread",Texts_Block2[6].subtext("Spread"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Spread"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending if the chart color mode is LightMode or not
         TextObj_color=(isLightMode)?clrBlack:clrWheat;
         TextObj(0,"Symbol Rating Text",Texts_Block2[6].subtext("Rating Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Rating Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         TextObj(0,"Symbol Rating",Texts_Block2[6].subtext("Rating Desc"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
        }
     }
   else
      /* Create objects # section 16*/
      if(is_spread)//Check whether to display spread information
        {
         Y_start+=(is_date)?GetText(Texts_Block2[0].text,Fontsize).Height:0;//Re-adjust Y distance depending if section 10 is shown
         X_start=2;//Reset X distance
         //-- Create the background object for width and height+3 of section 16 text
         Square(0,"Spread background",X_start,Y_start,GetText(Texts_Block2[6].text,Fontsize).Width,
                GetText(Texts_Block2[6].text,Fontsize).Height+3,ANCHOR_LEFT_UPPER);
         Y_start+=3;//Re-adjust Y distance
         X_start+=2;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         color Spread_clr=CSymbol.SpreadColor();
         //--- Set text object color depending if the chart color mode is LightMode or not
         TextObj_color=(isLightMode)?clrBlack:clrWheat;
         //-- Will create the text objects for section 16
         TextObj(0,"Symbol Spread Text",Texts_Block2[6].subtext("Spread Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Spread Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         TextObj(0,"Symbol Spread",Texts_Block2[6].subtext("Spread"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Spread"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending if the chart color mode is LightMode or not
         TextObj_color=(isLightMode)?clrBlack:clrWheat;
         TextObj(0,"Symbol Rating Text",Texts_Block2[6].subtext("Rating Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Rating Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         TextObj(0,"Symbol Rating",Texts_Block2[6].subtext("Rating Desc"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
        }
  }

La siguiente función actualizará cualquier cambio en las secciones gráficas del Bloque 2. Y no volverá a crear todos los elementos de la función Block_2.

//+------------------------------------------------------------------+
//|will update certain graphics at an interval                       |
//+------------------------------------------------------------------+
void CCommonGraphics::Block_2_Realtime(uint SecondsPreEvent=5)
  {
   if(MQLInfoInteger(MQL_TESTER)&&!MQLInfoInteger(MQL_VISUAL_MODE))
     {
      return;//exit if in strategy tester and not in visual mode
     }

   if(is_date)//Check whether to display date information
     {
      //--- Set text properties for Date and Time # section 10
      Texts_Block2[0].text = "Date:"+TimeToString(TimeTradeServer(),TIME_DATE)+"|| Time:"+TimeToString(TimeTradeServer(),TIME_SECONDS)
                             +"   ";//set main text
      Texts_Block2[0].subtext("Date Text","Date:");//set subtext - label,value
      Texts_Block2[0].subtext("Date",TimeToString(TimeTradeServer(),TIME_DATE));//set subtext - label,value
      Texts_Block2[0].subtext("Time Text","|| Time:");//set subtext - label,value
      Texts_Block2[0].subtext("Time",TimeToString(TimeTradeServer(),TIME_SECONDS));//set subtext - label,value
     }
   if(is_news)//Check whether to display news information
     {
      //--- Set text object color depending on upcoming news event's Importance
      EventColor = NewsObj.GetImportance_color(NewsObj.IMPORTANCE(UpcomingNews.EventImportance));
      //--- Set text properties for Event Date # section 11
      Texts_Block2[1].text = "Event: @"+UpcomingNews.EventDate+" ";//set main text
      Texts_Block2[1].subtext("Event Date Text","Event: @");//set subtext - label,value
      Texts_Block2[1].subtext("Event Date",UpcomingNews.EventDate);//set subtext - label,value
      //--- Set text properties for Event Name # section 12
      Texts_Block2[2].text = "Name: "+UpcomingNews.EventName+" ";//set main text
      Texts_Block2[2].subtext("Event Name Text","Name: ");//set subtext - label,value
      Texts_Block2[2].subtext("Event Name",UpcomingNews.EventName);//set subtext - label,value
      //--- Set text properties for Event Country # section 13
      Texts_Block2[3].text = "Country: "+UpcomingNews.CountryName+" ";//set main text
      Texts_Block2[3].subtext("Event Country Text","Country: ");//set subtext - label,value
      Texts_Block2[3].subtext("Event Country",UpcomingNews.CountryName);//set subtext - label,value
      //--- Set text properties for Event Currency # section 14
      Texts_Block2[4].text = "Currency: "+UpcomingNews.EventCurrency+" ";//set main text
      Texts_Block2[4].subtext("Event Currency Text","Currency: ");//set subtext - label,value
      Texts_Block2[4].subtext("Event Currency",UpcomingNews.EventCurrency);//set subtext - label,value
      //--- Set text properties for Event Importance # section 15
      Texts_Block2[5].text = "Importance: "+NewsObj.GetImportance(NewsObj.IMPORTANCE(UpcomingNews.EventImportance))+" ";//set main text
      Texts_Block2[5].subtext("Importance Text","Importance: ");//set subtext - label,value
      Texts_Block2[5].subtext("Importance",NewsObj.GetImportance(NewsObj.IMPORTANCE(UpcomingNews.EventImportance)));//set subtext - label,value
     }
   if(is_spread)//Check whether to display spread information
     {
      //--- Set text properties for Spread # section 16
      Texts_Block2[6].text = "Spread: "+string(CSymbol.Spread())+" Rating: "+CSymbol.SpreadDesc()+" ";//set main text
      Texts_Block2[6].subtext("Spread Text","Spread:");//set subtext - label,value
      Texts_Block2[6].subtext("Spread",string(CSymbol.Spread()));//set subtext - label,value
      Texts_Block2[6].subtext("Rating Text"," Rating:");//set subtext - label,value
      Texts_Block2[6].subtext("Rating Desc",CSymbol.SpreadDesc());//set subtext - label,value
     }

//--- Set basic properties
   Fontsize=10;
   X_start=2;//Reset X distance
   Y_start=GetTextMax(Texts_Block1,Fontsize).Height+29;//Re-adjust Y distance from section block 1

   /* Create objects # section 10*/
   if(is_date)//Check whether to display date information
     {
      //-- Check if the background object x-size for section 10 is the same size as section 10 text width
      if(ObjectGetInteger(0,"Datetime background",OBJPROP_XSIZE)!=GetText(Texts_Block2[0].text,Fontsize).Width)
        {
         //-- Will re-adjust background object to any changes of section 10 text width
         ObjectSetInteger(0,"Datetime background",OBJPROP_XSIZE,long(GetText(Texts_Block2[0].text,Fontsize).Width));
        }
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will update the text objects for section 10
      TextObj(0,"Date Text",Texts_Block2[0].subtext("Date Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[0].subtext("Date Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      TextObj(0,"Date",Texts_Block2[0].subtext("Date"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[0].subtext("Date"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      TextObj(0,"Time Text",Texts_Block2[0].subtext("Time Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[0].subtext("Time Text"),Fontsize).Width;//Re-adjust X distance
      //--- Adjust text color depending if chart color mode is LightMode and if a news event is occurring
      TextObj_color = CTime.TimeIsInRange(CTime.TimeMinusOffset(datetime(UpcomingNews.EventDate),SecondsPreEvent),
                                          CTime.TimePlusOffset(datetime(UpcomingNews.EventDate),59))?clrRed:(isLightMode)?clrBlack:clrWheat;
      TextObj(0,"Time",Texts_Block2[0].subtext("Time"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
     }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   if(UpcomingNews.CountryName!=NULL&&is_news)//Check whether to display news information
     {
      /* Create objects # section 11*/
      Y_start+=(is_date)?GetText(Texts_Block2[0].text,Fontsize).Height:0;
      X_start=2;//Reset X distance
      //-- Check if the background object x-size for section 11 is the same size as section 11 text width
      if(ObjectGetInteger(0,"Event Date background",OBJPROP_XSIZE)!=GetText(Texts_Block2[1].text,Fontsize).Width)
        {
         //-- Will re-adjust background object to any changes of section 11 text width
         ObjectSetInteger(0,"Event Date background",OBJPROP_XSIZE,long(GetText(Texts_Block2[1].text,Fontsize).Width));
        }
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will update the text objects for section 11
      TextObj(0,"Event Date Text",Texts_Block2[1].subtext("Event Date Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[1].subtext("Event Date Text"),Fontsize).Width;//Re-adjust X distance
      //--- Adjust text color depending if chart color mode is LightMode and if a news event is occurring
      TextObj_color = CTime.TimeIsInRange(CTime.TimeMinusOffset(datetime(UpcomingNews.EventDate),SecondsPreEvent),
                                          CTime.TimePlusOffset(datetime(UpcomingNews.EventDate),59))?clrRed:(isLightMode)?clrBlack:clrWheat;
      TextObj(0,"Event Date",Texts_Block2[1].subtext("Event Date"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 12*/
      Y_start+=GetText(Texts_Block2[1].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Check if the background object x-size for section 12 is the same size as section 12 text width
      if(ObjectGetInteger(0,"Event Name background",OBJPROP_XSIZE)!=GetText(Texts_Block2[2].text,Fontsize).Width)
        {
         //-- Will re-adjust background object to any changes of section 12 text width
         ObjectSetInteger(0,"Event Name background",OBJPROP_XSIZE,long(GetText(Texts_Block2[2].text,Fontsize).Width));
        }
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will update the text objects for section 12
      TextObj(0,"Event Name Text",Texts_Block2[2].subtext("Event Name Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[2].subtext("Event Name Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Event Name",Texts_Block2[2].subtext("Event Name"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 13*/
      Y_start+=GetText(Texts_Block2[2].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Check if the background object x-size for section 13 is the same size as section 13 text width
      if(ObjectGetInteger(0,"Event Country background",OBJPROP_XSIZE)!=GetText(Texts_Block2[3].text,Fontsize).Width)
        {
         //-- Will re-adjust background object to any changes of section 13 text width
         ObjectSetInteger(0,"Event Country background",OBJPROP_XSIZE,long(GetText(Texts_Block2[3].text,Fontsize).Width));
        }
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will update the text objects for section 13
      TextObj(0,"Event Country Text",Texts_Block2[3].subtext("Event Country Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[3].subtext("Event Country Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Event Country",Texts_Block2[3].subtext("Event Country"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 14*/
      Y_start+=GetText(Texts_Block2[3].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Check if the background object x-size for section 14 is the same size as section 14 text width
      if(ObjectGetInteger(0,"Event Currency background",OBJPROP_XSIZE)!=GetText(Texts_Block2[4].text,Fontsize).Width)
        {
         //-- Will re-adjust background object to any changes of section 14 text width
         ObjectSetInteger(0,"Event Currency background",OBJPROP_XSIZE,long(GetText(Texts_Block2[4].text,Fontsize).Width));
        }
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will update the text objects for section 14
      TextObj(0,"Event Currency Text",Texts_Block2[4].subtext("Event Currency Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[4].subtext("Event Currency Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Event Currency",Texts_Block2[4].subtext("Event Currency"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 15*/
      Y_start+=GetText(Texts_Block2[4].text,Fontsize).Height;//Re-adjust Y distance
      X_start=2;//Reset X distance
      //-- Check if the background object x-size for section 15 is the same size as section 15 text width
      if(ObjectGetInteger(0,"Event Importance background",OBJPROP_XSIZE)!=GetText(Texts_Block2[5].text,Fontsize).Width)
        {
         //-- Will re-adjust background object to any changes of section 15 text width
         ObjectSetInteger(0,"Event Importance background",OBJPROP_XSIZE,long(GetText(Texts_Block2[5].text,Fontsize).Width));
        }
      Y_start+=3;//Re-adjust Y distance
      X_start+=2;//Re-adjust X distance
      //--- Set text object color depending if the chart color mode is LightMode or not
      TextObj_color=(isLightMode)?clrBlack:clrWheat;
      //-- Will update the text objects for section 15
      TextObj(0,"Importance Text",Texts_Block2[5].subtext("Importance Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      X_start+=GetText(Texts_Block2[5].subtext("Importance Text"),Fontsize).Width;//Re-adjust X distance
      //--- Set text object color depending on upcoming news event's Importance
      TextObj_color=EventColor;
      TextObj(0,"Importance",Texts_Block2[5].subtext("Importance"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      /* Create objects # section 16*/
      if(is_spread)//Check whether to display spread information
        {
         Y_start+=GetText(Texts_Block2[5].text,Fontsize).Height;//Re-adjust Y distance
         X_start=2;//Reset X distance
         //-- Check if the background object x-size for section 16 is the same size as section 16 text width
         if(ObjectGetInteger(0,"Spread background",OBJPROP_XSIZE)!=GetText(Texts_Block2[6].text,Fontsize).Width)
           {
            //-- Will re-adjust background object to any changes of section 16 text width
            ObjectSetInteger(0,"Spread background",OBJPROP_XSIZE,long(GetText(Texts_Block2[6].text,Fontsize).Width));
           }
         Y_start+=3;//Re-adjust Y distance
         X_start+=2;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         color Spread_clr=CSymbol.SpreadColor();
         //-- Will create the text object for the Symbol's name
         X_start+=GetText(Texts_Block2[6].subtext("Spread Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         //-- Will update the text objects for section 16
         TextObj(0,"Symbol Spread",Texts_Block2[6].subtext("Spread"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Spread"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending if the chart color mode is LightMode or not
         TextObj_color=(isLightMode)?clrBlack:clrWheat;
         TextObj(0,"Symbol Rating Text",Texts_Block2[6].subtext("Rating Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Rating Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         TextObj(0,"Symbol Rating",Texts_Block2[6].subtext("Rating Desc"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
        }
     }
   else
      /* Create objects # section 16*/
      if(is_spread)//Check whether to display spread information
        {
         Y_start+=(is_date)?GetText(Texts_Block2[0].text,Fontsize).Height:0;//Re-adjust Y distance
         X_start=2;//Reset X distance
         //-- Check if the background object x-size for section 16 is the same size as section 16 text width
         if(ObjectGetInteger(0,"Spread background",OBJPROP_XSIZE)!=GetText(Texts_Block2[6].text,Fontsize).Width)
           {
            //-- Will re-adjust background object to any changes of section 16 text width
            ObjectSetInteger(0,"Spread background",OBJPROP_XSIZE,long(GetText(Texts_Block2[6].text,Fontsize).Width));
           }
         Y_start+=3;//Re-adjust Y distance
         X_start+=2;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         color Spread_clr=CSymbol.SpreadColor();
         //-- Will create the text object for the Symbol's name
         X_start+=GetText(Texts_Block2[6].subtext("Spread Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         //-- Will update the text objects for section 16
         TextObj(0,"Symbol Spread",Texts_Block2[6].subtext("Spread"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Spread"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending if the chart color mode is LightMode or not
         TextObj_color=(isLightMode)?clrBlack:clrWheat;
         TextObj(0,"Symbol Rating Text",Texts_Block2[6].subtext("Rating Text"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
         X_start+=GetText(Texts_Block2[6].subtext("Rating Text"),Fontsize).Width;//Re-adjust X distance
         //--- Set text object color depending on spread rating
         TextObj_color=Spread_clr;
         TextObj(0,"Symbol Rating",Texts_Block2[6].subtext("Rating Desc"),X_start,Y_start,CORNER_LEFT_UPPER,Fontsize);
        }
  }

La siguiente función creará el objeto de evento en el gráfico con todos los eventos de noticias disponibles para el día actual.

//+------------------------------------------------------------------+
//|will create chart event objects                                   |
//+------------------------------------------------------------------+
void CCommonGraphics::NewsEvent()
  {
   if(!is_events||(MQLInfoInteger(MQL_TESTER)&&!MQLInfoInteger(MQL_VISUAL_MODE)))
     {return;}//exit if in strategy tester and not in visual mode or is_events variable is false
//--- Retrieve news events for the current Daily period into array CalendarArray
   NewsObj.EconomicDetailsMemory(CalendarArray,iTime(Symbol(),PERIOD_D1,0));
//--- Iterate through all events in CalendarArray
   for(uint i=0;i<CalendarArray.Size();i++)
     {
      //--- Create event object with the news properties
      EventObj(0,CalendarArray[i].EventName+" "+CalendarArray[i].CountryName+" "+CalendarArray[i].EventDate,
               CalendarArray[i].EventName+"["+CalendarArray[i].CountryName+"]",StringToTime(CalendarArray[i].EventDate));
     }
//--- Refresh the chart/ update the chart
   ChartRefresh();
  }

Clase de gestión comercial

Esta clase se encargará de abrir operaciones para nuestro experto. La funcionalidad de esta clase se ampliará probablemente en artículos posteriores. La clase de gestión comercial heredará de la clase de gestión de riesgos para configurar los tamaños de lote para cada operación.

#include <Trade\Trade.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\SymbolInfo.mqh>
#include "RiskManagement.mqh"
#include "TimeManagement.mqh"
//+------------------------------------------------------------------+
//|TradeManagement class                                             |
//+------------------------------------------------------------------+
class CTradeManagement:CRiskManagement
  {
private:
   CTrade            Trade;//Trade class object
   CSymbolProperties CSymbol;//SymbolProperties class object
   CTimeManagement   CTime;//TimeManagement class object
   bool              TradeResult;//boolean to store trade result
   double            mySL;//double variable to store Stoploss
   double            myTP;//double variable to store Takeprofit
public:
   //--- Class constructor
                     CTradeManagement(string SYMBOL=NULL)
     {
      //--- Set symbol name
      CSymbol.SetSymbolName(SYMBOL);
     }
   //--- Class destructor
                    ~CTradeManagement(void) {}
   //--- Will retrieve if there are any open trades
   bool              OpenTrade(ENUM_POSITION_TYPE Type,ulong Magic,string COMMENT=NULL);
   //--- Will retrieve if there are any deals
   bool              OpenedDeal(ENUM_DEAL_TYPE Type,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open buy trade
   bool              Buy(double SL,double TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open buy trade with integer SL
   bool              Buy(int SL,double TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open buy trade with integer TP
   bool              Buy(double SL,int TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open buy trade with integer SL & TP
   bool              Buy(int SL,int TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open sell trade
   bool              Sell(double SL,double TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open sell trade with integer SL
   bool              Sell(int SL,double TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open sell trade with integer TP
   bool              Sell(double SL,int TP,ulong Magic,string COMMENT=NULL);
   //--- Will attempt open sell trade with integer SL & TP
   bool              Sell(int SL,int TP,ulong Magic,string COMMENT=NULL);
  };

La siguiente función verificará si hay posiciones abiertas con un tipo específico (Compra/Venta), un Magic Number (identificador único) y un Comentario (detalles de la posición). Utilizaremos esta función para comprobar si ya hemos abierto una operación cuando se produce el evento de noticias, de forma que evitemos abrir operaciones adicionales/innecesarias.

//+------------------------------------------------------------------+
//|Will retrieve if there are any open trades                        |
//+------------------------------------------------------------------+
bool CTradeManagement::OpenTrade(ENUM_POSITION_TYPE Type,ulong Magic,string COMMENT=NULL)
  {
//--- Iterate through all open positions
   for(int i=0; i<PositionsTotal(); i++)
     {
      //--- Check if Position ticket is above zero
      if(PositionGetTicket(i)>0)
        {
         //--- Check if the Position's Symbol,Magic,Type,Comment is correct
         if(PositionGetString(POSITION_SYMBOL)==CSymbol.GetSymbolName()&&PositionGetInteger(POSITION_MAGIC)==Magic
            &&PositionGetInteger(POSITION_TYPE)==Type&&PositionGetString(POSITION_COMMENT)==COMMENT)
           {
            //--- Return true when there is an open position
            return true;
           }
        }
     }
//--- No open positions found.
   return false;
  }

La función OpenedDeal comprobará si hay operaciones abiertas, es decir, operaciones de compra/venta/operaciones abiertas. Necesitamos esta función para evitar que nosotros/el experto abramos nuevas operaciones cuando una operación se cerró durante un evento noticioso. Sin esta función, el experto abrirá una operación de compra por ejemplo cuando el NFP está a punto de suceder, si la operación abierta se cierra debido a la volatilidad no queremos que el experto abra otra, esto es porque ya operamos el evento no hay necesidad de más operaciones que podrían resultar en pérdidas innecesarias. 

//+------------------------------------------------------------------+
//|Will retrieve if there are any deals                              |
//+------------------------------------------------------------------+
bool CTradeManagement::OpenedDeal(ENUM_DEAL_TYPE Type,ulong Magic,string COMMENT=NULL)
  {
//--- Check History starting from 2 minutes ago
   if(HistorySelect(CTime.TimeMinusOffset(TimeTradeServer(),CTime.MinutesS(2)),TimeTradeServer()))
     {
      //--- Iterate through all history deals
      for(int i=0; i<HistoryDealsTotal(); i++)
        {
         //--- Assign history deal ticket
         ulong ticket = HistoryDealGetTicket(i);
         //--- Check if ticket is more than zero
         if(ticket>0)
           {
            //--- Check if the Deal's Symbol,Magic,Type,Comment is correct
            if(HistoryDealGetString(ticket,DEAL_SYMBOL)==CSymbol.GetSymbolName()&&
               HistoryDealGetInteger(ticket,DEAL_MAGIC)==Magic&&HistoryDealGetInteger(ticket,DEAL_TYPE)==Type
               &&HistoryDealGetString(ticket,DEAL_COMMENT)==COMMENT)
              {
               //--- Return true when there are any deals
               return true;
              }
           }
        }
     }
//--- No deals found.
   return false;
  }

La siguiente función abrirá todas las órdenes de mercado para operaciones de compra/venta.

//+------------------------------------------------------------------+
//|Will attempt open buy trade                                       |
//+------------------------------------------------------------------+
bool CTradeManagement::Buy(double SL,double TP,ulong Magic,string COMMENT=NULL)
  {
//--- Normalize the SL Price
   CSymbol.NormalizePrice(SL);
//--- Normalize the TP Price
   CSymbol.NormalizePrice(TP);
//--- Set the order type for Risk management calculation
   SetOrderType(ORDER_TYPE_BUY);
//--- Set open price for Risk management calculation
   OpenPrice = CSymbol.Ask();
//--- Set close price for Risk management calculation
   ClosePrice = SL;
//--- Set Trade magic number
   Trade.SetExpertMagicNumber(Magic);
//--- Check if there are any open trades or opened deals already
   if(!OpenTrade(POSITION_TYPE_BUY,Magic,COMMENT)&&!OpenedDeal(DEAL_TYPE_BUY,Magic,COMMENT))
     {
      //--- Iterate through the Lot-sizes if they're more than max-lot
      for(double i=Volume();i>=CSymbol.LotsMin();i-=CSymbol.LotsMax())
        {
         //--- normalize Lot-size
         NormalizeLotsize(i);
         //--- Open trade with a Lot-size not more than max-lot
         TradeResult = Trade.Buy((i>CSymbol.LotsMax())?CSymbol.LotsMax():i,CSymbol.GetSymbolName(),CSymbol.Ask(),SL,TP,COMMENT);
         //--- Check if trade failed.
         if(!TradeResult)
           {
            return TradeResult;
           }
        }
     }
   else
     {
      //--- Trade failed because there is an open trade or opened deal
      return false;
     }
//--- Return trade result.
   return TradeResult;
  }

La siguiente función abrirá todas las órdenes de mercado para operaciones de venta/corta.

//+------------------------------------------------------------------+
//|Will attempt open sell trade                                      |
//+------------------------------------------------------------------+
bool CTradeManagement::Sell(double SL,double TP,ulong Magic,string COMMENT=NULL)
  {
//--- Normalize the SL Price
   CSymbol.NormalizePrice(SL);
//--- Normalize the TP Price
   CSymbol.NormalizePrice(TP);
//--- Set the order type for Risk management calculation
   SetOrderType(ORDER_TYPE_SELL);
//--- Set open price for Risk management calculation
   OpenPrice = CSymbol.Bid();
//--- Set close price for Risk management calculation
   ClosePrice = SL;
//--- Set Trade magic number
   Trade.SetExpertMagicNumber(Magic);
//--- Check if there are any open trades or opened deals already
   if(!OpenTrade(POSITION_TYPE_SELL,Magic,COMMENT)&&!OpenedDeal(DEAL_TYPE_SELL,Magic,COMMENT))
     {
      //--- Iterate through the Lot-sizes if they're more than max-lot
      for(double i=Volume();i>=CSymbol.LotsMin();i-=CSymbol.LotsMax())
        {
         //--- normalize Lot-size
         NormalizeLotsize(i);
         //--- Open trade with a Lot-size not more than max-lot
         TradeResult = Trade.Sell((i>CSymbol.LotsMax())?CSymbol.LotsMax():i,CSymbol.GetSymbolName(),CSymbol.Bid(),SL,TP,COMMENT);
         //--- Check if trade failed.
         if(!TradeResult)
           {
            return TradeResult;
           }
        }
     }
   else
     {
      //--- Trade failed because there is an open trade or opened deal
      return false;
     }
//--- Return trade result.
   return TradeResult;
  }

Experto en negociación de noticias

Tenemos nuevas entradas para el experto, ya hemos visto las explicaciones en la introducción.

//--- width and height of the canvas (used for drawing)
#define IMG_WIDTH  200
#define IMG_HEIGHT 100
//--- enable to set color format
ENUM_COLOR_FORMAT clr_format=COLOR_FORMAT_XRGB_NOALPHA;
//--- drawing array (buffer)
uint ExtImg[IMG_WIDTH*IMG_HEIGHT];

#include "News.mqh"
CNews NewsObject;//Class object for News
#include "TimeManagement.mqh"
CTimeManagement CTM;//Class object for Time Management
#include "WorkingWithFolders.mqh"
CFolders Folder;//Class object for Folders
#include "ChartProperties.mqh"
CChartProperties Chart;//Class object for Chart Properties
#include "RiskManagement.mqh"
CRiskManagement CRisk;//Class object for Risk Management
#include "CommonGraphics.mqh"
CCommonGraphics *CGraphics;//Class pointer object for Common Graphics
CCandleProperties *CP;//Class pointer object for Candle Properties
#include "TradeManagement.mqh"
CTradeManagement Trade;//Class object for Trade Management

//--- used to separate Input Menu
enum iSeparator
  {
   Delimiter//__________________________
  };

//--- for chart color Mode selection
enum DisplayMode
  {
   Display_LightMode,//LIGHT MODE
   Display_DarkMode//DARK MODE
  };

sinput group "+--------|   DISPLAY   |--------+";
sinput DisplayMode iDisplayMode=Display_LightMode;//CHART COLOUR MODE
sinput Choice iDisplay_NewsInfo=Yes;//DISPLAY NEWS INFO
sinput Choice iDisplay_EventObj=Yes;//DISPLAY EVENT OBJ
sinput Choice iDisplay_Spread=Yes;//DISPLAY SPREAD RATING
sinput Choice iDisplay_Date=Yes;//DISPLAY DATE
sinput group "";
sinput group "+--------|   DST SCHEDULE   |--------+";
input DSTSchedule ScheduleDST=AutoDst_Selection;//SELECT DST OPTION
sinput iSeparator iCustomSchedule=Delimiter;//__________________________
sinput iSeparator iCustomScheduleL=Delimiter;//CUSTOM DST
input DST_type CustomSchedule=DST_NONE;//SELECT CUSTOM DST
sinput group "";
sinput group "+--------| RISK MANAGEMENT |--------+";
input RiskOptions RISK_Type=MINIMUM_LOT;//SELECT RISK OPTION
input RiskFloor RISK_Mini=RiskFloorMin;//RISK FLOOR
input double RISK_Mini_Percent=75;//MAX-RISK [100<-->0.01]%
input RiskCeil  RISK_Maxi=RiskCeilMax;//RISK CEILING
sinput iSeparator iRisk_1=Delimiter;//__________________________
sinput iSeparator iRisk_1L=Delimiter;//PERCENTAGE OF [BALANCE | FREE-MARGIN]
input double Risk_1_PERCENTAGE=3;//[100<-->0.01]%
sinput iSeparator iRisk_2=Delimiter;//__________________________
sinput iSeparator iRisk_2L=Delimiter;//AMOUNT PER [BALANCE | FREE-MARGIN]
input double Risk_2_VALUE=1000;//[BALANCE | FREE-MARGIN]
input double Risk_2_AMOUNT=10;//EACH AMOUNT
sinput iSeparator iRisk_3=Delimiter;//__________________________
sinput iSeparator iRisk_3L=Delimiter;//LOTSIZE PER [BALANCE | FREE-MARGIN]
input double Risk_3_VALUE=1000;//[BALANCE | FREE-MARGIN]
input double Risk_3_LOTSIZE=0.1;//EACH LOTS(VOLUME)
sinput iSeparator iRisk_4=Delimiter;//__________________________
sinput iSeparator iRisk_4L=Delimiter;//CUSTOM LOTSIZE
input double Risk_4_LOTSIZE=0.01;//LOTS(VOLUME)
sinput iSeparator iRisk_5=Delimiter;//__________________________
sinput iSeparator iRisk_5L=Delimiter;//PERCENTAGE OF MAX-RISK
input double Risk_5_PERCENTAGE=1;//[100<-->0.01]%
sinput group "";
sinput group "+--------| NEWS SETTINGS |--------+";
input Calendar_Importance iImportance=Calendar_Importance_High;//CALENDAR IMPORTANCE
input Event_Frequency iFrequency=Event_Frequency_ALL;//EVENT FREQUENCY
input Event_Sector iSector=Event_Sector_ALL;//EVENT SECTOR
input Event_Type iType=Event_Type_Indicator;//EVENT TYPE
input Event_Currency iCurrency=Event_Currency_Symbol;//EVENT CURRENCY
sinput group "";
sinput group "+--------| TRADE SETTINGS |--------+";
input uint iStoploss=500;//STOPLOSS [0=NONE]
input uint iTakeprofit=500;//TAKEPROFIT [0=NONE]
input uint iSecondsPreEvent=5;//PRE-ENTRY SEC
input DayOfTheWeek TradingDay=AllDays;//TRADING DAY OF WEEK
sinput group "";
//--- to keep track of start-up time
datetime Startup_date;

En la función OnInit pasamos por diferentes procedimientos al configurar el experto para operar ya sea en el probador de estrategias o no.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Assign if in LightMode or not
   isLightMode=(iDisplayMode==Display_LightMode)?true:false;
//--- call function for common initialization procedure
   InitCommon();
//--- store Init result
   int InitResult;
   if(!MQLInfoInteger(MQL_TESTER))//Checks whether the program is in the strategy tester
     {
      //--- initialization procedure outside strategy tester
      InitResult=InitNonTester();
     }
   else
     {
      //--- initialization procedure inside strategy tester
      InitResult=InitTester();
     }
//--- Create DB in memory
   NewsObject.CreateEconomicDatabaseMemory();
//--- Initialize Common graphics class pointer object
   CGraphics = new CCommonGraphics(Answer(iDisplay_Date),Answer(iDisplay_Spread),Answer(iDisplay_NewsInfo),Answer(iDisplay_EventObj));
   CGraphics.GraphicsRefresh(iSecondsPreEvent);//-- Create chart objects
//--- Initialize Candle properties pointer object
   CP = new CCandleProperties();
//--- Store start-up time.
   Startup_date = TimeTradeServer();
//--- return Init result
   return InitResult;
  }

En la siguiente función, inicializamos las propiedades tanto para el probador de estrategias como para el entorno de negociación normal.

//+------------------------------------------------------------------+
//|function for common initialization procedure                      |
//+------------------------------------------------------------------+
void InitCommon()
  {
//Initializing CRiskManagement variable for Risk options
   RiskProfileOption = RISK_Type;
//Initializing CRiskManagement variable for Risk floor
   RiskFloorOption = RISK_Mini;
//Initializing CRiskManagement variable for RiskFloorMax
   RiskFloorPercentage = (RISK_Mini_Percent>100)?100:
                         (RISK_Mini_Percent<0.01)?0.01:RISK_Mini_Percent;//Percentage cannot be more than 100% or less than 0.01%
//Initializing CRiskManagement variable for Risk ceiling
   RiskCeilOption = RISK_Maxi;
//Initializing CRiskManagement variable for Risk options (PERCENTAGE OF BALANCE and PERCENTAGE OF FREE-MARGIN)
   Risk_Profile_1 = (Risk_1_PERCENTAGE>100)?100:
                    (Risk_1_PERCENTAGE<0.01)?0.01:Risk_1_PERCENTAGE;//Percentage cannot be more than 100% or less than 0.01%
//Initializing CRiskManagement variables for Risk options (AMOUNT PER BALANCE and AMOUNT PER FREE-MARGIN)
   Risk_Profile_2.RiskAmountBoF = Risk_2_VALUE;
   Risk_Profile_2.RiskAmount = Risk_2_AMOUNT;
//Initializing CRiskManagement variables for Risk options (LOTSIZE PER BALANCE and LOTSIZE PER FREE-MARGIN)
   Risk_Profile_3.RiskLotBoF = Risk_3_VALUE;
   Risk_Profile_3.RiskLot = Risk_3_LOTSIZE;
//Initializing CRiskManagement variable for Risk option (CUSTOM LOTSIZE)
   Risk_Profile_4 = Risk_4_LOTSIZE;
//Initializing CRiskManagement variable for Risk option (PERCENTAGE OF MAX-RISK)
   Risk_Profile_5 = (Risk_5_PERCENTAGE>100)?100:
                    (Risk_5_PERCENTAGE<0.01)?0.01:Risk_5_PERCENTAGE;//Percentage cannot be more than 100% or less than 0.01%
//--- Initializing DST Schedule variables
   MyDST = ScheduleDST;
   MySchedule = CustomSchedule;
//--- Initializing News filter variables
   myFrequency=iFrequency;
   myImportance=iImportance;
   mySector=iSector;
   myType=iType;
   myCurrency=iCurrency;
   Chart.ChartRefresh();//Load chart configurations
  }

La función a continuación se inicializará sólo para el entorno de negociación normal.

//+------------------------------------------------------------------+
//|function for initialization procedure outside strategy tester     |
//+------------------------------------------------------------------+
int InitNonTester()
  {
//--- Check if in Strategy tester!
   if(MQLInfoInteger(MQL_TESTER))
     {
      //--- Initialization failed.
      return(INIT_SUCCEEDED);
     }
//--- create OBJ_BITMAP_LABEL object for drawing
   ObjectCreate(0,"STATUS",OBJ_BITMAP_LABEL,0,0,0);
   ObjectSetInteger(0,"STATUS",OBJPROP_XDISTANCE,5);
   ObjectSetInteger(0,"STATUS",OBJPROP_YDISTANCE,22);
//--- specify the name of the graphical resource
   ObjectSetString(0,"STATUS",OBJPROP_BMPFILE,"::PROGRESS");
   uint   w,h;          // variables for receiving text string sizes
   uint    x,y;          // variables for calculation of the current coordinates of text string anchor points
   /*
   In the Do while loop below, the code will check if the terminal is connected to the internet.
   If the the program is stopped the loop will break, if the program is not stopped and the terminal
   is connected to the internet the function CreateEconomicDatabase will be called from the News.mqh header file's
   object called NewsObject and the loop will break once called.
   */
   bool done=false;
   do
     {
      //--- clear the drawing buffer array
      ArrayFill(ExtImg,0,IMG_WIDTH*IMG_HEIGHT,0);

      if(!TerminalInfoInteger(TERMINAL_CONNECTED))
        {
         //-- integer dots used as a loading animation
         static int dots=0;
         //--- set the font
         TextSetFont("Arial",-150,FW_EXTRABOLD,0);
         TextGetSize("Waiting",w,h);//get text width and height values
         //--- calculate the coordinates of the 'Waiting' text
         x=10;//horizontal alignment
         y=IMG_HEIGHT/2-(h/2);//alignment for the text to be centered vertically
         //--- output the 'Waiting' text to ExtImg[] buffer
         TextOut("Waiting",x,y,TA_LEFT|TA_TOP,ExtImg,IMG_WIDTH,IMG_HEIGHT,ColorToARGB(CSymbol.Background()),clr_format);
         //--- calculate the coordinates for the dots after the 'Waiting' text
         x=w+13;//horizontal alignment
         y=IMG_HEIGHT/2-(h/2);//alignment for the text to be centered vertically
         TextSetFont("Arial",-160,FW_EXTRABOLD,0);
         //--- output of dots to ExtImg[] buffer
         TextOut(StringSubstr("...",0,dots),x,y,TA_LEFT|TA_TOP,ExtImg,IMG_WIDTH,IMG_HEIGHT,ColorToARGB(CSymbol.Background()),clr_format);
         //--- update the graphical resource
         ResourceCreate("::PROGRESS",ExtImg,IMG_WIDTH,IMG_HEIGHT,0,0,IMG_WIDTH,clr_format);
         //--- force chart update
         Chart.Redraw();
         dots=(dots==3)?0:dots+1;
         //-- Notify user that program is waiting for connection
         Print("Waiting for connection...");
         Sleep(500);
         continue;
        }
      else
        {
         //--- set the font
         TextSetFont("Arial",-120,FW_EXTRABOLD,0);
         TextGetSize("Getting Ready",w,h);//get text width and height values
         x=20;//horizontal alignment
         y=IMG_HEIGHT/2-(h/2);//alignment for the text to be centered vertically
         //--- output the text 'Getting Ready...' to ExtImg[] buffer
         TextOut("Getting Ready...",x,y,TA_LEFT|TA_TOP,ExtImg,IMG_WIDTH,IMG_HEIGHT,ColorToARGB(CSymbol.Background()),clr_format);
         //--- update the graphical resource
         ResourceCreate("::PROGRESS",ExtImg,IMG_WIDTH,IMG_HEIGHT,0,0,IMG_WIDTH,clr_format);
         //--- force chart update
         Chart.Redraw();
         //-- Notify user that connection is successful
         Print("Connection Successful!");
         NewsObject.CreateEconomicDatabase();//calling the database create function
         done=true;
        }
     }
   while(!done&&!IsStopped());
//-- Delete chart object
   ObjectDelete(0,"STATUS");
//-- force chart to update
   Chart.Redraw();
//--- Initialization succeeded.
   return(INIT_SUCCEEDED);
  }

La función a continuación se inicializará únicamente para el entorno del probador de estrategias.

//+------------------------------------------------------------------+
//|function for initialization procedure inside strategy tester      |
//+------------------------------------------------------------------+
int InitTester()
  {
//--- Check if not in Strategy tester!
   if(!MQLInfoInteger(MQL_TESTER))
     {
      //--- Initialization failed.
      return(INIT_SUCCEEDED);
     }
//Checks whether the database file exists
   if(!FileIsExist(NEWS_DATABASE_FILE,FILE_COMMON))
     {
      //--- Warning messages
      Print("Necessary Files Do not Exist!");
      Print("Run Program outside of the Strategy Tester");
      Print("Necessary Files Should be Created First");
      //--- Initialization failed.
      return(INIT_FAILED);
     }
   else
     {
      //Checks whether the latest database date includes the time and date being tested
      datetime latestdate = CTM.TimeMinusOffset(NewsObject.GetLatestNewsDate(),CTM.DaysS());//Day before the latest recorded time in the database
      if(latestdate<TimeTradeServer())
        {
         Print("Necessary Files outdated!");
         Print("To Update Files: Run Program outside of the Strategy Tester");
        }
      Print("Database Dates End at: ",latestdate);
      PrintFormat("Dates after %s will not be available for backtest",TimeToString(latestdate));
     }
//--- Initialization succeeded.
   return(INIT_SUCCEEDED);
  }

La función a continuación se ejecutará en cada nuevo tick.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Run procedures
   Execution();
  }

En esta función a continuación, llamamos a todas las funciones que harán que el experto sea funcional. No todas las funciones necesitan ejecutarse en cada tick, por lo que solo llamamos a ciertas funciones en cada nueva vela determinada, por ejemplo, cada vela diaria. Esto ayuda con el rendimiento y reduce las llamadas de funciones innecesarias y el uso de recursos.

//+------------------------------------------------------------------+
//|Execute program procedures                                        |
//+------------------------------------------------------------------+
void Execution()
  {
//--- Update realtime Graphic every 1 min
   if(CP.NewCandle(1,PERIOD_M1))
     {
      CGraphics.Block_2_Realtime(iSecondsPreEvent);
     }
//--- function to open trades
   EnterTrade();
//--- Check if not start-up date
   if(!CTM.DateisToday(Startup_date))
     {
      //--- Run every New Daily Candle
      if(CP.NewCandle(2,PERIOD_D1))
        {
         //--- Check if not in strategy tester
         if(!MQLInfoInteger(MQL_TESTER))
           {
            //--- Update/Create DB in Memory
            NewsObject.CreateEconomicDatabaseMemory();
           }
         CGraphics.GraphicsRefresh(iSecondsPreEvent);//-- Create/Re-create chart objects
         //--- Update Realtime Graphics
         CGraphics.Block_2_Realtime(iSecondsPreEvent);
        }
      //--- Check if not in strategy tester
      if(!MQLInfoInteger(MQL_TESTER))
        {
         //--- Run every New Hourly Candle
         if(CP.NewCandle(3,PERIOD_H1))
           {
            //--- Check if DB in Storage needs an update
            if(NewsObject.UpdateRecords())
              {
               //--- initialization procedure outside strategy tester
               InitNonTester();
              }
           }
        }
     }
   else
     {
      //--- Run every New Daily Candle
      if(CP.NewCandle(4,PERIOD_D1))
        {
         //--- Update Event objects on chart
         CGraphics.NewsEvent();
        }
     }
  }

La función a continuación será responsable de abrir operaciones para órdenes de mercado en función del impacto del evento y la moneda del evento. Si la moneda del evento es igual a la moneda de Profit y el tipo de impacto es CALENDAR_IMPACT_NEGATIVE, abrimos una operación de compra, ya que asumimos que la moneda de Profit se debilitará durante el evento de noticias; si la moneda del evento es igual a la moneda de Profit y el tipo de impacto es CALENDAR_IMPACT_POSITIVE, abrimos una operación de venta, ya que asumimos que la moneda de Profit se fortalecerá durante el evento de noticias. 

//+------------------------------------------------------------------+
//|function to open trades                                           |
//+------------------------------------------------------------------+
void EnterTrade()
  {
//--- static variable for storing upcoming event Impact value
   static ENUM_CALENDAR_EVENT_IMPACT Impact=CALENDAR_IMPACT_NA;
//--- Check if Upcoming news date has passed and if upcoming news is not null and if new minute candle has formed.
   if(datetime(UpcomingNews.EventDate)<TimeTradeServer()&&UpcomingNews.CountryName!=NULL&&CP.NewCandle(5,PERIOD_M1))
     {
      //--- Update for next upcoming news
      NewsObject.EconomicNextEvent();
      //--- Get impact value for upcoming news
      Impact=NewsObject.GetImpact();
     }
//--- Check if upcoming news date is about to occur and if it is the trading day of week
   if(CTM.TimePreEvent(CTM.TimeMinusOffset(datetime(UpcomingNews.EventDate),(iSecondsPreEvent==0)?1:iSecondsPreEvent)
                       ,datetime(UpcomingNews.EventDate))
      &&CTM.isDayOfTheWeek(TradingDay))
     {
      //--- Check each Impact value type
      switch(Impact)
        {
         //--- When Impact news is negative
         case CALENDAR_IMPACT_NEGATIVE:
            //--- Check if profit currency is news event currency
            if(UpcomingNews.EventCurrency==CSymbol.CurrencyProfit())
              {
               //--- Open buy trade with Event id as Magic number
               Trade.Buy(iStoploss,iTakeprofit,ulong(UpcomingNews.EventId),"NewsTrading");
              }
            else
              {
               //--- Open sell trade with Event id as Magic number
               Trade.Sell(iStoploss,iTakeprofit,ulong(UpcomingNews.EventId),"NewsTrading");
              }
            break;
         //--- When Impact news is positive
         case CALENDAR_IMPACT_POSITIVE:
            //--- Check if profit currency is news event currency
            if(UpcomingNews.EventCurrency==CSymbol.CurrencyProfit())
              {
               //--- Open sell trade with Event id as Magic number
               Trade.Sell(iStoploss,iTakeprofit,ulong(UpcomingNews.EventId),"NewsTrading");
              }
            else
              {
               //--- Open buy trade with Event id as Magic number
               Trade.Buy(iStoploss,iTakeprofit,ulong(UpcomingNews.EventId),"NewsTrading");
              }
            break;
         //--- Unknown
         default:
            break;
        }
     }
  }

Conclusión

En este artículo, pasamos por la adición de una base de datos en la memoria y la creación de vistas adicionales para proporcionar más información sobre los eventos en el calendario económico MQL5. Creamos objetos gráficos adicionales en el gráfico para mostrar información sobre el próximo acontecimiento, e implementamos una función de modo oscuro. Además, hemos añadido opciones de entrada relevantes para que el usuario/operador filtre los datos de noticias según sus preferencias, así como entradas de Asesor Experto para operar. Además, el artículo ofrece una explicación de cómo abrimos órdenes de mercado basándonos en el impacto del evento y cómo el impacto del evento es relevante para nuestra estrategia de negociación.

Estoy abierto a escuchar tus comentarios y agradeceré cualquier opinión que compartas. En el próximo artículo, añadiremos más funcionalidad a los parámetros de noticias para cubrir eventos económicos individuales y el trading con órdenes pendientes, ofreciendo mayor flexibilidad, así como operaciones que no requieran el impacto de los eventos. ¡Gracias por leer!

Video: