Del básico al intermedio: Indicador (IV)

Introducción

En el artículo anterior, "Del básico al intermedio: Indicador (III)", vimos cómo crear cualquier tipo de indicador de forma simple, fácil y práctica utilizando directivas de compilación. Sin embargo, no siempre podemos o necesitamos hacer las cosas de esa manera. Ese enfoque se llama implementación estática, ya que una vez definido el tipo de indicador no podemos —o, mejor dicho, no permitimos— que el usuario cambie el tipo de trazado que se va a realizar.

Ahora bien, los indicadores pueden ser mucho más de lo que se ha mostrado hasta ahora. Es cierto que para una amplia gama de actividades este tipo de implementación ya será más que suficiente. No obstante, existen situaciones en las que podemos necesitar indicadores un poco diferentes para operar o analizar el mercado.

En este artículo, aprenderemos a crear algunos indicadores diferentes. Estos indicadores son muy útiles para comunicarnos con otros operadores y para analizar ciertos tipos de movimiento de forma automatizada. Si se le puede llamar así.

Entonces, comenzaremos con uno muy sencillo y, en mi opinión, bastante divertido. Se debe a que puedes crear otros muchos utilizando un concepto muy sencillo y fácil de entender.

Indicador de Inside bar

Existe un tipo de indicador, o mejor dicho, una metodología operativa que utiliza lo que se conoce como inside bar. Una inside bar sería, literalmente, una barra o vela que queda dentro de la inmediatamente anterior. Si bien, dependiendo del operador y del símbolo, se puede considerar un inside bar cualquier barra que esté dentro de otra, no necesariamente la inmediatamente anterior, siempre que el movimiento no haya violado esta misma barra y pueda estar a cierta distancia. No obstante, esta última forma de considerar algo como un inside bar no es un principio adoptado por la mayoría de los operadores.

Otros lo consideran algo válido. n cualquier caso, esta metodología operativa existe y es muy asertiva en diversos momentos. Aunque analizar el gráfico todo el tiempo para saber si estamos o no ante una inside bar es, como mínimo, una tarea bastante complicada para mucha gente, principalmente para los principiantes. Por esta razón, podemos utilizar un indicador que siga el gráfico y nos muestre si hay o no dicha formación cuando el gráfico esté abierto y activo.

Detalle: un inside bar NO ES, necesariamente, un DOJI.

Vale, pero, ¿por qué decidiste mostrar cómo crear este indicador? El motivo es muy simple, querido lector. Muchos principiantes intentan crear indicadores para poder añadir patrones de colores a las velas o barras, como suelen llamarlas. Y estos programadores principiantes terminan desistiendo por la cuestión relacionada con la forma en que el indicador necesita ser declarado. No es que crear un patrón de colores en velas sea una tarea difícil. El problema es otro. Crear el indicador en sí es una tarea bastante simple, como ya te imaginarás.

Sin embargo, al igual que ocurre con otros indicadores mostrados en artículos anteriores, debemos tener cuidado al declarar los buffers. Si ya has intentado crear un patrón de colores en velas, sabrás muy bien que esto puede suponer un desafío para cualquier principiante. Por tanto, si no lo hacemos en el orden correcto o indicamos el índice de los buffers en la secuencia equivocada, MetaTrader 5 trazará algo diferente a lo que esperábamos ver en el gráfico. Y la culpa no podrá recaer ni en MetaTrader 5 ni en el programador, ya que, dependiendo de lo que se quiera implementar, lo que para algunos será un error, para otros será exactamente el resultado deseado.

Así pues, empezaremos viendo cómo se declara el indicador propiamente dicho, incluso antes de crear el indicador de inside bar. Normalmente, podrías pensar que podrías declarar las cosas de cualquier manera, como se ve en el código de abajo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1       DRAW_COLOR_CANDLES
05. #property indicator_color1      clrRed, clrRoyalBlue, clrGreen
06. //+----------------+
07. #property indicator_buffers     5
08. #property indicator_plots       1
09. //+----------------+
10. double  gl_Buff_High[],
11.         gl_Buff_Open[],
12.         gl_Buff_Close[],
13.         gl_Buff_Low[],
14.         gl_Buff_Color[];
15. //+------------------------------------------------------------------+
16. int OnInit()
17. {
18.     SetIndexBuffer(0, gl_Buff_High, INDICATOR_DATA);
19.     SetIndexBuffer(1, gl_Buff_Open, INDICATOR_DATA);
20.     SetIndexBuffer(2, gl_Buff_Close, INDICATOR_DATA);
21.     SetIndexBuffer(3, gl_Buff_Low, INDICATOR_DATA);
22.     SetIndexBuffer(4, gl_Buff_Color, INDICATOR_COLOR_INDEX);
23. 
24.     return INIT_SUCCEEDED;
25. };
26. //+------------------------------------------------------------------+
27. int OnCalculate(const int rates_total, const int prev_calculated, const datetime &Time[], const double &Open[], const double &High[], const double &Low[], const double &Close[], const long &TickVolume[], const long &Volume[], const int &Spread[])
28. {
29.     for (int c = (prev_calculated > 0 ? prev_calculated - 1 : 0); c < rates_total; c++)
30.     {
31.         gl_Buff_High[c] = High[c];
32.         gl_Buff_Open[c] = Open[c];
33.         gl_Buff_Close[c] = Close[c];
34.         gl_Buff_Low[c] = Low[c];
35. 
36.         gl_Buff_Color[c] = (Open[c] > Close[c] ? 0 : 2);
37.     }
38. 
39.     return rates_total;
40. };
41. //+------------------------------------------------------------------+

Código 01

Ahora te pregunto, querido lector: ¿esto que ves en el código 01 está bien o mal? Pues bien, la respuesta correcta a esta cuestión es: depende del objetivo que estés buscando obtener. En cualquier caso, esta implementación del código 01 no es del todo errónea, ya que el código se compilará y se podrá utilizar. Pero, dependiendo del objetivo que se quiera alcanzar, es posible que este código esté equivocado. Por tanto, presta atención a lo que ocurrirá cuando utilices este código en cualquier gráfico. Esto se puede ver en la animación de abajo.

Animación 01

Es decir, el resultado no fue exactamente el esperado. ¿Por qué? No lo entendí. Aparentemente, el código es correcto. No hice nada mal al declarar los buffers. Sin embargo, el resultado no fue el esperado, ya que las barras cambiaron de formato y no solo de color. No consigo entender dónde está el error. ¿Existe algún tipo de truco para que las cosas funcionen y se obtenga el resultado deseado? En este caso, sí, mi querido lector.

Aunque el código es correcto, ya que cambió el color de las barras como se esperaba, no podemos decir lo mismo del cambio de formato. Si el objetivo fuera cambiar los colores y, al mismo tiempo, modificar las barras, entonces sí. Pero no era eso lo que pretendíamos. El motivo es precisamente que el orden en que se declararon los buffers es incorrecto. Así, cuando MetaTrader 5 utilice los buffers, lo hará en un orden determinado. Con este orden erróneo, se alteró el formato de las barras. Sabiendo esto, todo lo que necesitamos hacer es cambiar ese orden por otro adecuado. Este sencillo cambio puede observarse en el código siguiente. 

                   .
                   .
                   .
18.     SetIndexBuffer(1, gl_Buff_High, INDICATOR_DATA);
19.     SetIndexBuffer(0, gl_Buff_Open, INDICATOR_DATA);
20.     SetIndexBuffer(3, gl_Buff_Close, INDICATOR_DATA);
21.     SetIndexBuffer(2, gl_Buff_Low, INDICATOR_DATA);
                   .
                   .
                   .

Código 02

Fíjate en que, en este fragmento del código 02, lo único que se ha cambiado es el valor del índice de cada buffer. Usando esta secuencia de buffers (precio de apertura, máximo, mínimo y precio de cierre), el resultado que generará el código 01 se puede observar justo abajo.

Animación 02

¿Han notado cómo ahora MetaTrader 5 ha logrado entender cómo debe dibujarse cada barra o vela? Este es un problema muy sencillo para quien ya sabe cómo hacerlo. Sin embargo, para quien no lo entiende, esto es definitivamente lo más complicado y difícil que existe. En cualquier caso, ahora ya sabes cómo hacer tal cosa, por lo que puedes empezar a construir patrones de colores para crear indicadores y modelar este o aquel sistema de trading. Para demostrar cómo podemos hacerlo, vamos a ver cómo se puede resolver e indicar un inside bar directamente en el gráfico.

Para resolver esta cuestión, observa en la línea 36 cómo calculamos el índice de color. Será el índice cero para una barra de venta o el índice dos para una barra de compra. Pero, ¿y el índice uno, para qué nos servirá? Bien, este índice lo estamos reservando para lo que sería una inside bar.

Ahora viene el punto clave. El bucle de la línea 29 comienza en un punto antiguo que puede o no ser la primera barra del gráfico y avanza hasta encontrar la barra más reciente presente en él. Es importante saber y entender esto, pues un inside bar solo puede indicarse si existe una barra anterior con una característica determinada. De lo contrario, la barra actual no podrá considerarse ni mostrarse en el gráfico como un inside bar.

Vale, una vez entendido esto, todo lo que necesitamos hacer es implementar el criterio de verificación. Para ello, debemos modificar el código anterior para poder dar color a las barras o velas y, además, comprobar la presencia o ausencia de inside bar. Este incremento se muestra en el fragmento de código 03, justo debajo.

                   .
                   .
                   .
36.         gl_Buff_Color[c] = (Open[c] > Close[c] ? 0 : 2);
37.         if ((c - 1) > 0)
38.             gl_Buff_Color[c] = ((High[c - 1] > High[c]) && (Low[c - 1] < Low[c]) ? 1 : gl_Buff_Color[c]);
39.     }
40. 
41.     return rates_total;
42. };
43. //+------------------------------------------------------------------+

Código 03

Ahora sí, con cada evento Calculate que reciba nuestro indicador, vamos a verificar si hay o no una inside bar en el gráfico. Pero espera un momento. ¿Por qué debemos probar este tipo de cosas en cada instante? El motivo es simple, querido lector: durante una fase de negociación, puede que haya una inside bar en el gráfico. No obstante, puede ocurrir —y no es raro— que este llegue a desconfigurarse. Esto se debe a que solo podemos considerar si hay o no un inside bar después de que se produzca el cierre de la barra o vela. Antes de eso, es prematuro afirmar que tenemos un inside bar en el gráfico.

Sin embargo, como la línea 38 va a comprobar periódicamente si la condición de inside bar puede aplicarse o no, sucede que, al final, si la barra llega a desconfigurar el inside bar, la prueba no pasará. Por ello, como ya actualizamos el color en la línea 36, la indicación anterior deja de mostrarse en el gráfico.

Aunque se sabe que funciona, lo ideal es que veas cómo ocurre en la práctica para entender por qué hice la implementación de esta manera. De todos modos, en la animación de abajo podemos ver cómo ocurre el proceso inicial. No obstante, no es fácil mostrar este segundo paso, que es la desconfiguración de lo que sería un inside bar, ya que se necesitaría un momento muy específico y se tardaría mucho tiempo en grabar el punto exacto De todas formas, la animación de abajo ya te dará una idea de cómo ocurre el proceso.

Animación 03

Perfecto, aquí tenemos la indicación de lo que sería un inside bar. Pero, como se ha dicho, hay operadores que observan varias barras y consideran todas estas nuevas barras como un inside bar mientras las nuevas barras estén dentro de la anterior. Y aquí surge la pregunta: ¿cómo podríamos implementar este mismo tipo de indicador? ¿Solo modificando el indicador anterior?

Esta es una cuestión que puede tener diversas respuestas o, mejor dicho, formas distintas de implementar el mecanismo involucrado. El verdadero problema no es implementar exactamente el código, sino idear una forma de mantener un valor durante un largo período. A continuación, voy a mostrar una posible propuesta. Claro que, dependiendo del caso, puedes usar otra que te resulte más interesante o adecuada.

Bien, pues como quiero dejar las cosas lo más simples posible, solo voy a realizar un cambio en la implementación del manejador de eventos OnCalculate. De este modo, el código original que creó la animación 03 se modificará como se muestra en el fragmento siguiente.

                   .
                   .
                   .
26. //+------------------------------------------------------------------+
27. int OnCalculate(const int rates_total, const int prev_calculated, const datetime &Time[], const double &Open[], const double &High[], const double &Low[], const double &Close[], const long &TickVolume[], const long &Volume[], const int &Spread[])
28. {
29.    static double  high = DBL_MIN,
30.                   low = DBL_MAX;
31. 
32.    for (int c = (prev_calculated > 0 ? prev_calculated - 1 : 0); c < rates_total; c++)
33.    {
34.       gl_Buff_High[c] = High[c];
35.       gl_Buff_Open[c] = Open[c];
36.       gl_Buff_Close[c] = Close[c];
37.       gl_Buff_Low[c] = Low[c];
38. 
39.       gl_Buff_Color[c] = (Open[c] > Close[c] ? 0 : 2);
40.       if ((c - 1) > 0)
41.       {
42.          high = (High[c - 1] > high ? High[c - 1] : high);
43.          low = (Low[c - 1] < low ? Low[c - 1] : low);
44.          gl_Buff_Color[c] = ((high > High[c]) && (low < Low[c]) ? 1 : gl_Buff_Color[c]);
45.          if (gl_Buff_Color[c] != 1)
46.          {
47.             high = DBL_MIN;
48.             low = DBL_MAX;
49.          }
50.       }
51.    }
52. 
53.    return rates_total;
54. };
55. //+------------------------------------------------------------------+

Código 04

Ahora, presta atención, querido lector. Cuando el fragmento mostrado en el código 04 se coloque en el código que generaba la animación 03, el resultado será diferente al de la animación anterior. Para que esto quede realmente claro, observa atentamente y compara la animación de abajo con la anterior.

Animación 04

En esta animación 04, estamos haciendo exactamente lo que muchos operadores pueden llegar a considerar un inside bar. Es decir, mientras no se produzca una violación del máximo o mínimo de la barra o vela anterior, consideraremos la barra que se está analizando actualmente como un inside bar. Sé que esto parece muy confuso, sobre todo si no estás acostumbrado a operar o a observar inside bars. Pero este fragmento del código 04 es capaz de reconocer el patrón, incluso si surgen diversas barras y todas están dentro de una barra mucho más antigua.

Entonces, ¿cómo funciona este fragmento de código? ¿Y cómo logra detectar un inside bar de esta forma, como se muestra en la animación 04? Para entenderlo, primero necesitas entender cómo funciona el indicador anterior y más simple. Solo así lograrás entender este. Además, necesitas comprender cómo funcionan las variables estáticas. Como ya se dedicó un artículo a explicar solo y exclusivamente esta cuestión, daré por hecho que ya has comprendido el tema de las variables estáticas.

Quien no haya leído el artículo, puede encontrarlo en "Del básico al intermedio: Variables (II)". Ahora, al observar el código 04, se puede ver claramente que el cambio necesario se realizó precisamente en la prueba del inside bar. Dicha prueba sigue realizándose allí. Sin embargo, ha cambiado de posición, ya que ahora, antes de que ocurra, tenemos otras dos pruebas en ejecución. La primera se hace en la línea 42, donde verificamos si hubo o no una violación del máximo. En la línea 43, realizamos una verificación similar, pero en este caso comprobamos la violación del mínimo. De este modo, tenemos en cuenta el límite en el que puede existir un inside bar entre varias barras diferentes, no solo en la inmediatamente anterior. Solo después de conocer estos límites verificamos si existe o no una barra de continuación en la barra que se está analizando. Esto se hace en la línea 44.

Lo importante es la línea 45. En ella verificamos si la prueba de la línea 44 ha señalado la presencia de un inside bar. Si no hay un inside bar, debemos destruir los límites impuestos para buscar la presencia de una nueva formación de inside bar. Si no se realizara esta verificación de la línea 45, se darían indicaciones falsas constantemente.

Para que puedas entender algo sobre este indicador inside bar que mostré aquí, mira la animación de abajo.

Animación 05

En esta animación 05 podemos observar algo muy interesante: la existencia de un inside bar en un momento determinado. Sin embargo, como se produjo una violación —en este caso, se violó el mínimo—, lo que antes era un inside bar dejó de serlo y pasó a ser una barra como todas las demás. Y aunque el precio vuelva hasta el punto en que podríamos pensar que de nuevo tenemos un inside bar, el indicador no lo mostrará, como puedes observar en la imagen de abajo.

Imagen 01

Observa que el símbolo volvió a negociarse dentro de la barra o vela que generó las tres indicaciones anteriores de inside bar. Sin embargo, según los criterios implementados en el indicador, esta última barra ya no podría considerarse un inside bar. En resumen, el indicador funciona, pero necesitamos definir y dejar muy claros los criterios que se van a adoptar para que nos proporcione la información adecuada y deseada.

Muy bien, se ha explicado de manera adecuada cómo implementar indicadores de colores en velas. Entonces, podemos abordar otras cuestiones que pueden o no estar relacionadas con los indicadores. Sin embargo, debido a la naturaleza del propio concepto de lo que sería o no un indicador, creo que es adecuado mostrar otras cosas dentro de este mismo tipo de escenario.

Qué ver y qué no ver

No es raro que utilicemos perfiles diferentes para una misma metodología de operación en el mercado. Algunos operadores prefieren tener diversas informaciones mostradas todo el tiempo en el gráfico. Otros prefieren tener la mínima información. Decidir qué mostrar es algo particular de cada operador o perfil operativo. Sin embargo, para nosotros, los programadores, esto es algo completamente irrelevante. No nos importa cómo prefiere tener configurado su gráfico cada uno. Lo único que nos importa es proporcionar medios sencillos y fáciles para que cualquier persona pueda ajustar el gráfico a su gusto.

De acuerdo, MetaTrader 5 nos permite configurar muchas de estas cosas sin necesidad de ninguna aplicación externa. Sin embargo, existen elementos que no se pueden eliminar o modificar mediante las opciones que ofrece MetaTrader 5, y es aquí donde entra en juego la programación. Tú, mi querido lector, como programador, necesitas entender que NO EXISTEN LÍMITES para lo que podemos o no podemos hacer. Lo que de hecho existe es la mayor o menor capacidad técnica de cada programador. Algunos lograrán hacer las cosas de forma más sencilla, mientras que otros necesitarán medios que, en mi opinión, serán más complicados.

En cualquier caso, el objetivo es desarrollar una aplicación que logre transformar el gráfico en lo que queremos, aunque para otros operadores sea un completo desorden. Pero, si tú lo comprendes y consigues ganar dinero operando, perfecto, eso es lo que realmente importa.

Pues bien, con MQL5 podemos definir y controlar diversos elementos del gráfico. Para empezar, haremos algunos cambios sencillos que pueden ser interesantes en determinados momentos. El objetivo es mostrar que, al usar MQL5, tendremos total libertad y control sobre cualquier elemento del gráfico. Por ejemplo, ¿sabías que podemos eliminar la región donde se observa la cotización y el horario de un gráfico? Si intentas hacerlo directamente desde MetaTrader 5, no vas a conseguir tener éxito. Sin embargo, una de las maneras de hacerlo es mediante código. El código que hay que implementar es bastante simple, dicho sea de paso. Así que vamos a comenzar por este punto. El código inicial se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.     ChartSetInteger(0, CHART_SHOW_DATE_SCALE, false);
07.     ChartSetInteger(0, CHART_SHOW_PRICE_SCALE, false);
08.     
09.     return INIT_SUCCEEDED;
10. };
11. //+------------------------------------------------------------------+
12. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
13. {
14.     return rates_total;
15. };
16. //+------------------------------------------------------------------+

Código 05

Observa el nivel de simplicidad de este código 05. Sin necesidad de explicar nada, puedes entender claramente lo que estamos haciendo. De hecho, al ejecutar este código en un gráfico, obtendrás el resultado que se muestra en la animación de abajo.

Animación 06

Es cierto que estamos siendo muy maleducados, ya que, después de haber eliminado la escala de precio y la escala de tiempo sin pedir la autorización del usuario, no las estamos devolviendo al gráfico, ni siquiera cuando se retira el indicador. Aunque pueda parecer adecuado para muchos, este tipo de acciones es considerado por otros como una falta de respeto por parte de la aplicación, ya que para recuperar las escalas de precio y tiempo es necesario cerrar el gráfico y volver a abrirlo, algo que no desearían hacer la mayoría.

Pero surge una pregunta: ¿cómo podríamos devolver el gráfico a su estado original? Y, si podemos, ¿cuál sería el mejor momento para hacerlo? Bien, mi querido lector, en realidad existen formas de hacerlo mediante la captura del evento Deinit. Sin embargo, es necesario que entiendas lo siguiente: no hay un mejor momento para hacerlo, sino un momento más propicio. Lo digo porque puede suceder que tu aplicación haga algo que fuerce a MetaTrader 5 a eliminarla del gráfico. Si esto ocurre, el evento Deinit no se ejecutará, ya que la eliminación será forzada. De esta forma, cualquier modificación que haya realizado tu aplicación permanecerá en el gráfico, por lo que será necesario cerrarlo y abrirlo de nuevo para que todo vuelva a la normalidad.

Por esta razón, dichos cambios deben realizarse siempre con la debida precaución. Y, siempre que sea posible, permite que el usuario seleccione qué desea eliminar del gráfico, sobre todo si tu aplicación tiene como objetivo simplificar y facilitar las operaciones.

Muy bien, entonces vamos a crear una forma más educada de implementar lo que se vio en la animación 06. Para ello, modificaremos el código 05, como se muestra a continuación.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. input bool user01 = true;       //Show time scale
05. input bool user02 = true;       //Show price scale
06. //+----------------+
07. struct st_Mem
08. {
09.     long    View_DateScale,
10.             View_PriceScale;
11. }gl_StyleGraphic;
12. //+------------------------------------------------------------------+
13. int OnInit()
14. {
15.     gl_StyleGraphic.View_DateScale = ChartGetInteger(0, CHART_SHOW_DATE_SCALE);
16.     gl_StyleGraphic.View_PriceScale = ChartGetInteger(0, CHART_SHOW_PRICE_SCALE);
17. 
18.     ChartSetInteger(0, CHART_SHOW_DATE_SCALE, user01);
19.     ChartSetInteger(0, CHART_SHOW_PRICE_SCALE, user02);
20. 
21.     return INIT_SUCCEEDED;
22. };
23. //+------------------------------------------------------------------+
24. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
25. {
26.     return rates_total;
27. };
28. //+------------------------------------------------------------------+
29. void OnDeinit(const int reason)
30. {
31.     ChartSetInteger(0, CHART_SHOW_DATE_SCALE, gl_StyleGraphic.View_DateScale);
32.     ChartSetInteger(0, CHART_SHOW_PRICE_SCALE, gl_StyleGraphic.View_PriceScale);    
33. };
34. //+------------------------------------------------------------------+

Código 06

Ahora, querido lector, observa que somos mucho más educados. Esto se debe a que en las líneas cuatro y cinco otorgamos permiso al usuario para eliminar las escalas, tanto la de precio como la de tiempo. En la línea siete, utilizamos una estructura para almacenar los valores originales y poder devolver el gráfico al estado en el que se encontraba antes de aplicar el indicador, independientemente de los cambios que haya realizado el usuario.

Así como el código 05 era sencillo y fácil de entender, aquí se aplica lo mismo. Sin embargo, quiero llamar tu atención sobre otro punto: el manejador del evento Deinit. Este se encuentra en la línea 29. La cuestión es la siguiente: incluso después de eliminar el indicador del gráfico, MetaTrader 5 tarda algún tiempo en actualizar el gráfico donde estaría el indicador, a veces segundos y a veces un poco más. Durante este pequeño período de tiempo, es posible que algunas informaciones estén ausentes, mientras que otras aún no hayan sido eliminadas. Esto puede dar la impresión de que la plataforma es lenta o de que el equipo del usuario es antiguo. Sin embargo, el problema radica precisamente en que MetaTrader 5 está ocupado haciendo algo más.

Para hacer las cosas más agradables, mi sugerencia es que utilices una llamada a la biblioteca estándar de MQL5 en algunos momentos, con el fin de forzar a MetaTrader 5 a actualizar el gráfico lo antes posible. En diversos momentos, esto será completamente innecesario. Sin embargo, si notas cierta demora entre un evento y otro, puedes utilizar dicha llamada para saltarte la fila de eventos con la que MetaTrader 5 estaría lidiando en ese momento.

El cambio a realizar puede observarse en el fragmento de código justo abajo.

                   .
                   .
                   .
28. //+------------------------------------------------------------------+
29. void OnDeinit(const int reason)
30. {
31.     ChartSetInteger(0, CHART_SHOW_DATE_SCALE, gl_StyleGraphic.View_DateScale);
32.     ChartSetInteger(0, CHART_SHOW_PRICE_SCALE, gl_StyleGraphic.View_PriceScale);
33.     ChartRedraw();
34. };
35. //+------------------------------------------------------------------+

Código 07

La simple adición de esta línea 33, que se puede ver en el código 07, será suficiente para que el usuario, e incluso tú mismo, experimentéis una aparente mejora en el rendimiento de MetaTrader 5, aunque hay que recordar que esta mejora es solo aparente. No existe una mejora real del rendimiento. Esta llamada de la línea 33 le indicará a MetaTrader 5 que queremos saltarnos la fila de eventos para que el gráfico se actualice lo antes posible. Sin embargo, recuerda lo siguiente: al saltarnos la fila, estaremos posponiendo algún evento que podría ser importante y dispararse en otro momento. Así que ten cuidado al alterar el orden de ejecución.

Consideraciones finales

En este artículo, hemos visto lo fácil que es crear e implementar una metodología operativa para colorear velas, un concepto que aprecian enormemente diversos operadores. Es necesario tener cuidado al implementar este tipo de cosas para que las barras o velas mantengan su apariencia original y no se dificulte la lectura vela por vela.

De forma adicional, se demostró cómo podemos cambiar diversos elementos de un gráfico, aunque en el artículo solo se mostró cómo hacerlo con dos propiedades: las escalas de tiempo y precio. Escalas que, a su vez, no podrían eliminarse mediante algún recurso accesible directamente para un usuario estándar. Sin embargo, es perfectamente posible y factible hacerlo mediante código. Pero debemos recordar que, siempre que sea posible, debemos restablecer el gráfico a su estado inicial, ya que así la experiencia del usuario es más agradable y se demuestra que la aplicación está bien planificada.

Como existen varios atributos y propiedades que pueden modificarse, y sería difícil abordarlos uno a uno, te sugiero que practiques y experimentes con el uso y la modificación de dichas propiedades mediante código MQL5. Para facilitarte la tarea, puedes hacer uso de la lista de propiedades del gráfico, ya que muchos de los elementos y valores mostrados solo serán accesibles mediante código MQL5. Entonces, ¡que te vaya bien con tus estudios!Recuerda que en el anexo tendremos solo los códigos realmente necesarios para que puedas practicar y estudiar lo mostrado en el artículo.