DocumentaciónSecciones
Manual de referencia de MQL5Indicadores personalizadosEstilos de indicadores en ejemplosDRAW_COLOR_ARROW 

DRAW_COLOR_ARROW

El estilo DRAW_COLOR_ARROW dibuja en el gráfico las flechas de color (símbolos del conjunto Wingdings) basándose en el valor del búfer indicador. A diferencia del estilo DRAW_ARROW, este estilo permite establecer para cada símbolo su color desde un conjunto predefinido de colores especificados por medio de la propiedad indicator_color1.

El grosor y el color de los símbolo se puede establecer de la misma manera como para el estilo DRAW_ARROW — con las directivas del compilador, o bien dinámicamente, utilizando la función PlotIndexSetInteger(). El cambio dinámico de las propiedades de la construcción gráfica permite cambiar la apariencia del indicador en función de la situación actual.

El código del símbolo a mostrar en el gráfico se establece a través de la propiedad PLOT_ARROW.

//--- estableceremos el código del símbolo desde el fuente Wingdings para dibujar en PLOT_ARROW
   PlotIndexSetInteger(0,PLOT_ARROW,code);

Por defecto, el valor de PLOT_ARROW=159 (un círculo).

Cada flecha prácticamente es un símbolo que tiene su alto y su punto de enlace, y puede cubrir alguna información importante en el gráfico (por ejemplo, el precio del cierre en la barra). Por eso se puede indicar adicionalmente el desplazamiento vertical en píxeles, que no depende de la escala del gráfico. Las flechas se desplazarán visualmente por la línea vertical a esta especificada cantidad de píxeles, aunque los valores del indicador se quedarán los mismos:

//--- estableceremos el desplazamiento de flechas por la línea vertical en píxeles
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,shift);

Un valor negativo de PLOT_ARROW_SHIFT significa el desplazamiento de las flechas hacia arriba, un valor positivo significa el desplazamiento de la flecha hacia abajo.

El estilo DRAW_COLOR_ARROW se puede utilizar tanto en una subventana separada del gráfico, como en la ventana principal. Los valores vacíos no se dibujan y no se muestran en la "Ventana de datos", todos los valores hay que establecer en los búfers indicadores de forma explícita. Los búfers no se inicializan con valores vacíos.

//--- estableceremos el valor vacío
   PlotIndexSetDouble(índice_ de_construcción_DRAW_COLOR_ARROW,PLOT_EMPTY_VALUE,0);

El número de búfers requeridos para construir DRAW_COLOR_ARROW – 2:

  • un búfer para almacenar los valores del precio a base del cual se dibuja el símbolo (más el desplazamiento en píxeles que se fila por la propiedad PLOT_ARROW_SHIFT);
  • un búfer para almacenar el índice de color con el que se colorea la flecha (tiene sentido establecer sólo para los valores no vacíos).

Aquí tenemos un ejemplo del indicador que dibuja las flechas en cada barra cuyo precio de cierre Close es más alto que el precio de cierre de la barra anterior. El grosor, desplazamiento y el código del símbolo de todas las flechas se cambian de forma aleatoria cada N tics. El precio del símbolo depende del número de la barra en la que está dibujado.

Ejemplo del estilo DRAW_COLOR_ARROW

En el ejemplo, inicialmente para la construcción gráfica plot1 con el estilo DRAW_COLOR_ARROW las propiedades del color y el tamaño se establecen mediante la directiva del compilador #property, y luego en la función OnCalculate() las propiedades se cambian de forma aleatoria. El parámetro N está pasado a los parámetros externos del indicador para que exista la posibilidad de establecerlo manualmente (pestaña "Parámetros" en la ventana de propiedades del indicador).

Fíjense, inicialmente se establecen 8 colores mediante la directiva del compilador #property, y luego en la función OnCalculate() el color se elige aleatoriamente de 14 colores que se guardan en el array colors[].

//+------------------------------------------------------------------+
//|                                             DRAW_COLOR_ARROW.mq5 |
//|                         Copyright 2000-2024, MetaQuotes Ltd. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2000-2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
 
#property description "Indicador para demostrar DRAW_COLOR_ARROW"
#property description "Dibuja en el gráfico las flechas de diferentes colores determinadas por los caracteres de Unicode"
#property description "El color, tamaño, desplazamiento y el código del símbolo de la flecha se cambian"
#property description " de forma aleatoria cada N tics"
#property description "El parámetro code establece el valor base: código=159 (círculo)"
 
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots   1
//--- plot ColorArrow
#property indicator_label1  "ColorArrow"
#property indicator_type1   DRAW_COLOR_ARROW
//--- estableceremos 8 colores para colorear el histograma por días de la semana (se almacenan en un array especial)
#property indicator_color1  clrRed,clrBlue,clrSeaGreen,clrGold,clrDarkOrange,clrMagenta,clrYellowGreen,clrChocolate
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
 
//--- parámetros input
input int      N=5;         // número de tics para el cambio 
input ushort   code=159;    // código del símbolo a dibujar en DRAW_ARROW
int            color_sections;
//--- búfer indicador para la construcción
double         ColorArrowBuffer[];
//--- búfer para guardar los índices del color
double         ColorArrowColors[];
//--- el array para almacenar colores tiene 14 elementos
color colors[]=
  {
   clrRed,clrBlue,clrGreen,clrChocolate,clrMagenta,clrDodgerBlue,clrGoldenrod,
   clrIndigo,clrLightBlue,clrAliceBlue,clrMoccasin,clrWhiteSmoke,clrCyan,clrMediumPurple
  };
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,ColorArrowBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,ColorArrowColors,INDICATOR_COLOR_INDEX);
//--- estableceremos el código del símbolo para dibujar en PLOT_ARROW
   PlotIndexSetInteger(0,PLOT_ARROW,code);
//--- estableceremos el desplazamiento de flechas por la línea vertical en píxeles
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,5);
//--- estableceremos un 0 como valor vacío
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);   
//---- número de colores para colorear la sinusoide
   color_sections=8;   //  ver comentario para la propiedad #property indicator_color1 
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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 &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   static int ticks=0;
//--- contamos los tics para el cambio del color, tamaño, desplazamiento y código de la flecha
   ticks++;
//--- si tenemos acumulado un número crítico de tics,
   if(ticks>=N)
     {
      //--- cambiamos las propiedades de las flechas
      ChangeLineAppearance();
      //--- cambiamos los colores con los que se dibuja el histograma
      ChangeColors(colors,color_sections);
      //--- actualizamos el contador de tics pasándolo a cero
      ticks=0;
     }
 
//--- bloque para calcular los valores del indicador
   int start=1;
   if(prev_calculated>0) start=prev_calculated-1;
//--- ciclo del cálculo
   for(int i=1;i<rates_total;i++)
     {
      //--- si el precio actual Close es más alto que el anterior, colocamos la flecha
      if(close[i]>close[i-1])
         ColorArrowBuffer[i]=close[i];
      //--- en caso contrario, mostramos el valor cero
      else
         ColorArrowBuffer[i]=0;
      //--- color de la flecha
      int index=i%color_sections;
      ColorArrowColors[i]=index;
     }
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//|  cambia el color de segmentos de la línea                        |
//+------------------------------------------------------------------+
void  ChangeColors(color  &cols[],int plot_colors)
  {
//--- número de colores
   int size=ArraySize(cols);
//--- 
   string comm=ChartGetString(0,CHART_COMMENT)+"\r\n\r\n";
 
//--- definimos de forma aleatoria un color nuevo para cada índice de colores
   for(int plot_color_ind=0;plot_color_ind<plot_colors;plot_color_ind++)
     {
      //--- obtendremos un número aleatorio
      int number=MathRand();
      //--- obtendremos un índice en el array col[] como el remanente de la división de números enteros
      int i=number%size;
      //--- estableceremos el color para cada índice como la propiedad PLOT_LINE_COLOR
      PlotIndexSetInteger(0,                    //  número del estilo gráfico
                          PLOT_LINE_COLOR,      //  identificador de la propiedad
                          plot_color_ind,       //  índice del color donde escribiremos el color
                          cols[i]);             //  nuevo color
      //--- apuntaremos los colores
      comm=comm+StringFormat("ArrowColorIndex[%d]=%s \r\n",plot_color_ind,ColorToString(cols[i],true));
      ChartSetString(0,CHART_COMMENT,comm);
     }
//---
  }
//+------------------------------------------------------------------+
//| cambia la apariencia de la línea trazada en el indicador         |
//+------------------------------------------------------------------+
void ChangeLineAppearance()
  {
//--- cadena para formar la información sobre las propiedades de la línea
   string comm="";
//--- bloque de cambio del grosor de la línea
   int number=MathRand();
//--- obtenemos el grosor como el remanente de la división de números enteros
   int width=number%5; // el grosor puede ser de 0 a 4
//--- estableceremos el color como la propiedad PLOT_LINE_WIDTH
   PlotIndexSetInteger(0,PLOT_LINE_WIDTH,width);
//--- apuntaremos el grosor de la línea
   comm=comm+" Width="+IntegerToString(width);
   
//--- bloque del cambio del código de la flecha (PLOT_ARROW)
   number=MathRand();
//--- obtendremos el remanente de la división de números enteros para calcular nuevo código de la flecha (de 0 a 19)
   int code_add=number%20;
//--- estableceremos el nuevo código del símbolo como la suma code+code_add
   PlotIndexSetInteger(0,PLOT_ARROW,code+code_add);
//--- apuntaremos el código del símbolo PLOT_ARROW
   comm="\r\n"+"PLOT_ARROW="+IntegerToString(code+code_add)+comm;   
 
//--- bloque del cambio del desplazamiento de flechas por la línea vertical en píxeles
   number=MathRand();
//--- obtenemos el desplazamiento como el remanente de la división de números enteros
   int shift=20-number%41;
//--- estableceremos nuevo desplazamiento
   PlotIndexSetInteger(0,PLOT_ARROW_SHIFT,shift);
//--- apuntaremos el desplazamiento PLOT_ARROW_SHIFT
   comm="\r\n"+"PLOT_ARROW_SHIFT="+IntegerToString(shift)+comm;
 
//--- mostraremos la información en el gráfico a través del comentario
   Comment(comm);
  }