Manual de referencia de MQL5Constantes, Enumeraciones y EstruturasConstantes de gráficosEjemplos de trabajo con el gráfico

Ejemplos de trabajo con el gráfico

Este apartado contiene varios ejemplos para el trabajo con las propiedades del gráfico. Para cada propiedad se exponen una o dos funciones terminadas que permiten establecer / obtener el valor de esta propiedad. Puede utilizar estas funciones en sus programas MQL5 tal como están.

En la imagen de abajo se ve un panel gráfico que demuestra de forma muy clara cómo el cambio de una propiedad del gráfico cambia su apariencia. El hacer click en el botón "Next" permite establecer un valor nuevo para la propiedad correspondiente y ver los cambios en la ventana del gráfico que eso provoca.

chart_properties_panel

El código fuente de este panel se encuentra más abajo.

Propiedades del gráfico y ejemplos de las funciones para trabajar con ellas

CHART_IS_OBJECT — determina si el objeto es un gráfico real o un objeto gráfico.

//+------------------------------------------------------------------+
//| Determinar que si el objeto es un gráfico. Si es                 |
//| un objeto gráfico, el resultado es true. Si es un                |
//| gráfico real, entonces la variable result obtiene el valor false.|
//+------------------------------------------------------------------+
bool ChartIsObject(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos la propiedad del gráfico
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      //--- devolvemos false
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }

CHART_BRING_TO_TOP — muestra el gráfico por encima de los demás.

//+------------------------------------------------------------------+
//| Enviar al terminal los comandos para mostrar el gráfico          |
//| por encima de los demás.                                         |
//+------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- mostramos el gráfico por encima de los demás
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_MOUSE_SCROLL — la propiedad de desplazamiento del gráfico con el botón izquierdo del ratón.

//+------------------------------------------------------------------+
//| La función determina si se puede desplazar el gráfico utilizando |
//| el botón izquierdo del ratón.                                    |
//+------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de desplazamiento          |
//| del gráfico con el botón izquierdo del ratón.                    |
//+------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_EVENT_MOUSE_MOVE — la propiedad del envío de los mensajes sobre los eventos de desplazamiento y pulsación de los botones del ratón a los programas mql5 (CHARTEVENT_MOUSE_MOVE).

//+------------------------------------------------------------------+
//| Comprobar si se envían los mensajes sobre los eventos            |
//| de desplazamiento y pulsación de los botones del ratón           |
//| en este gráfico a los programas mql5.                            |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo del envío de los mensajes  |
//| sobre los eventos de desplazamiento y pulsación de los botones   |
//| del ratón a todos los programas mql5 en este gráfico.            |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_EVENT_OBJECT_CREATE — la propiedad del envío de los mensajes sobre el evento de creación de un objeto gráfico a los programas mql5 (CHARTEVENT_OBJECT_CREATE).

//+------------------------------------------------------------------+
//| Comprobar si se envían los mensajes sobre el evento de creación  |
//| del objeto gráfico a todos los programas mql5 en este gráfico.   |
//+------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo del envío de los mensajes  |
//| sobre el evento de creación de un objeto gráfico a todos         |
//| los programas mql5 en este gráfico.                              |
//+------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_EVENT_OBJECT_DELETE — la propiedad del envío de los mensajes sobre el evento de eliminación de un objeto gráfico a los programas mql5 (CHARTEVENT_OBJECT_DELETE).

//+------------------------------------------------------------------+
//| Comprobar si se envían los mensajes sobre el evento              |
//| de eliminación del objeto gráfico a todos los programas          |
//| mql5 en este gráfico.                                            |
//+------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo del envío de los mensajes  |
//| sobre el evento de eliminación de un objeto gráfico a todos      |
//| los programas mql5 en este gráfico.                              |
//+------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_MODE — tipo del gráfico (velas, barras u línea).

//+------------------------------------------------------------------+
//| Obtener el tipo de visualización del gráfico (en forma de velas, |
//| barras o línea).                                                 |
//+------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=WRONG_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((ENUM_CHART_MODE)result);
  }
//+------------------------------------------------------------------+
//| Establecer el tipo de visualización del gráfico (en forma de     |
//| velas, barras o línea).                                          |
//+------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_FOREGROUND — la propiedad de visualización del gráfico de precios en el primer plano.

//+------------------------------------------------------------------+
//| La función determina si se visualiza el gráfico de precios en    |
//| el primer plano.                                                 |
//+------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización del       |
//| gráfico de precios en el primer plano.                           |
//+------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHIFT — el modo de desplazamiento del gráfico de precios desde el borde derecho.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de visualización   |
//| del gráfico de precios con el desplazamiento desde               |
//|  el borde derecho.                                               |
//+------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización del       |
//| gráfico de precios con el desplazamiento desde el borde derecho. |
//+------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_AUTOSCROLL — el modo de desplazamiento automático hacia el borde derecho del gráfico.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de desplazamiento  |
//| automático del gráfico hacia la derecha cuando se reciben        |
//| nuevos ticks.                                                    |
//+------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de desplazamiento          |
//| automático del gráfico hacia la derecha cuando se reciben        |
//| nuevos ticks.                                                    |
//+------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SCALE — la propiedad de la escala del gráfico.

//+------------------------------------------------------------------+
//| Obtener la escala del gráfico (de 0 a 5).                        |
//+------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Establecer la escala del gráfico (de 0 a 5).                     |
//+------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SCALEFIX — el modo de la escala fija del gráfico.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de la escala       |
//| fija del gráfico.                                                |
//+------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de la escala fija.         |
//+------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SCALEFIX_11 — el modo de la escala del gráfico 1:1.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de la escala "1:1".|
//+------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de la escala "1:1"         |
//+------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SCALE_PT_PER_BAR — el modo de especificación de la escala del gráfico en puntos por barra.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de especificación  |
//| de la escala en puntos por barra.                                |
//+------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de especificación de la    |
//| escala en puntos por barra.                                      |
//+------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_OHLC — la propiedad de visualización de los valores OHLC en la esquina superior izquierda.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de visualización de|
//| los valores OHLC en la esquina superior izquierda.               |
//+------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de los    |
//| valores OHLC en la esquina superior izquierda del gráfico.       |
//+------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_BID_LINE — la propiedad de visualización del valor Bid como una línea horizontal en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de visualización de|
//| la línea Bid en el gráfico.                                      |
//+------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de la     |
//| línea Bid en el gráfico.                                         |
//+------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_ASK_LINE — la propiedad de visualización del valor Ask como una línea horizontal en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de visualización   |
//| de la línea Ask en el gráfico.                                   |
//+------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de la     |
//| línea Ask en el gráfico.                                         |
//+------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_LAST_LINE — la propiedad de visualización del valor Last como una línea horizontal en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de visualización   |
//| de la línea para el precio de la última transacción realizada.   |
//+------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de la     |
//| línea del precio de la última transacción realizada.             |
//+------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_PERIOD_SEP — la propiedad de visualización de los separadores verticales entre los períodos adyacentes.

//+------------------------------------------------------------------+
//| La función determina si está activado el modo de visualización   |
//| de los separadores verticales entre los períodos adyacentes.     |
//+------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de        |
//| los separadores verticales entre los períodos adyacentes.        |
//+------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_GRID — la propiedad de visualización de cuadrícula en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si la cuadrícula se visualiza en el gráfico.|
//+------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva la visualización de la cuadrícula  |
//| en el gráfico.                                                   |
//+------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_VOLUMES — la propiedad de visualización de volúmenes en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si se visualizan los volúmenes en el gráfico|
//| (no se muestran, se muestran los de ticks, se muestran           |
//| los reales).                                                     |
//+------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=WRONG_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+------------------------------------------------------------------+
//| La función establece el modo de visualización de los volúmenes   |
//| en el gráfico.                                                   |
//+------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_OBJECT_DESCR — la propiedad de las descripciones emergentes de los objetos gráficos.

//+------------------------------------------------------------------+
//| La función determina si se visualizan las descripciones          |
//| emergentes de los objetos gráficos al situar el cursor           |
//| sobre ellos.                                                     |
//+------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de las    |
//| descripciones emergentes de los objetos gráficos al situar       |
//|  el cursor sobre ellos.                                          |
//+------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_VISIBLE_BARS — determina el número de barras en el gráfico que están disponibles para la visualización.

//+------------------------------------------------------------------+
//| La función obtiene el número de barras que se muestran           |
//| (están visibles) en la ventana del gráfico.                      |
//+------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_WINDOWS_TOTAL — determina el número total de las ventanas del gráfico, incluyendo las subventanas de los indicadores.

//+------------------------------------------------------------------+
//| La función obtiene el número total de las ventanas del gráfico,  |
//| incluyendo las subventanas de los indicadores.                   |
//+------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_WINDOW_IS_VISIBLE — determina la visibilidad de la subventana.

//+------------------------------------------------------------------+
//| La función determina si esta ventana o subventana del gráfico es |
//| visible.                                                         |
//+------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }

CHART_WINDOW_HANDLE — devuelve el manejador del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el manejador del gráfico                      |
//+------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_WINDOW_YDISTANCE — determina la distancia en píxeles entre el marco superior de la subventana del indicador y el marco superior de la ventana principal del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene la distancia en píxeles entre el marco        |
//| superior de la subventana y el marco superior de la ventana      |
//| principal del gráfico.                                           |
//+------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_FIRST_VISIBLE_BAR — devuelve el número de la primera barra visible en el gráfico (la indexación de las barras corresponde a la serie temporal).

//+------------------------------------------------------------------+
//| La función obtiene el número de la primera barra visible en      |
//| el gráfico. La indexación se realiza como en una serie temporal, |
//| las últimas barras tienen los índices menores.                   |
//+------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_WIDTH_IN_BARS — devuelve el ancho del gráfico en barras.

//+------------------------------------------------------------------+
//| La función obtiene el valor del ancho del gráfico en barras.     |
//+------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_WIDTH_IN_PIXELS — devuelve el ancho del gráfico en píxeles.

//+------------------------------------------------------------------+
//| La función obtiene el valor del ancho del gráfico en píxeles.    |
//+------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }

CHART_HEIGHT_IN_PIXELS — la propiedad del alto del gráfico en píxeles.

//+------------------------------------------------------------------+
//| La función obtiene el valor del alto del gráfico en píxeles.     |
//+------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long result=-1;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((int)result);
  }
//+------------------------------------------------------------------+
//| La función establece el valor del alto del gráfico en píxeles.   |
//+------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_BACKGROUND — color del fondo del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el color del fondo del gráfico.               |
//+------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color del fondo del gráfico
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color del fondo del gráfico.             |
//+------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color del fondo del gráfico
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_FOREGROUND — el color de los ejes, escala y la línea OHLC.

//+------------------------------------------------------------------+
//| La función obtiene el color de los ejes, escala y la línea       |
//| OHLC del gráfico.                                                |
//+------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de los ejes, escala y la línea OHLC del gráfico
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de los ejes, escala y la línea     |
//| OHLC del gráfico.                                                |
//+------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de los ejes, escala y la línea OHLC del gráfico
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_GRID — el color de la cuadrícula del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el color de la cuadrícula del gráfico.        |
//+------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la cuadrícula del gráfico
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la cuadrícula del gráfico.      |
//+------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la cuadrícula del gráfico
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_VOLUME — el color de los volúmenes y niveles de la apertura de posiciones.

//+------------------------------------------------------------------+
//| La función obtiene el color de visualización de los volúmenes    |
//| y niveles de la apertura de posiciones.                          |
//+------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de volúmenes y niveles de la apertura de posiciones
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de visualización de los volúmenes  |
//| y niveles de la apertura de posiciones.                          |
//+------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de volúmenes y niveles de la apertura de posiciones
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_CHART_UP — el color de la barra arriba, sombra y borde del cuerpo de vela alcista.

//+------------------------------------------------------------------+
//| La función obtiene el color de la barra que va arriba, el color  |
//| de la sombra y del borde del cuerpo de vela alcista.             |
//+------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la barra arriba, sombra y borde del cuerpo de la vela alcista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la barra que va arriba, el color|
//| de la sombra y del borde del cuerpo de vela alcista.             |
//+------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la barra arriba, sombra y borde del cuerpo de la vela alcista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_CHART_DOWN — el color de la barra abajo, sombra y borde del cuerpo de vela bajista.

//+------------------------------------------------------------------+
//| La función obtiene el color de la barra que va abajo, el color de|
//| la sombra y del borde del cuerpo de vela bajista.                |
//+------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la barra abajo, sombra y borde del cuerpo de la vela bajista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la barra que va abajo, el color |
//| de la sombra y del borde del cuerpo de vela bajista.             |
//+------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la barra abajo, sombra y borde del cuerpo de la vela bajista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_CHART_LINE — el color de la línea del gráfico y de las velas japonesas "Doji".

//+------------------------------------------------------------------+
//| La función obtiene el color de la línea del gráfico y de las     |
//| velas japonesas "Doji".                                          |
//+------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la línea del gráfico y de las velas japonesas "Doji"
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la línea del gráfico y de las   |
//| velas japonesas "Doji".                                          |
//+------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la línea del gráfico y de las velas japonesas "Doji"
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_CANDLE_BULL — el color del cuerpo de la vela alcista.

//+------------------------------------------------------------------+
//| La función obtiene el color del cuerpo de la vela alcista.       |
//+------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color del cuerpo de la vela alcista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color del cuerpo de la vela alcista.     |
//+------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color del cuerpo de la vela alcista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_CANDLE_BEAR — el color del cuerpo de la vela bajista.

//+------------------------------------------------------------------+
//| La función obtiene el color del cuerpo de la vela bajista.       |
//+------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color del cuerpo de la vela bajista
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color del cuerpo de la vela bajista.     |
//+------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color del cuerpo de la vela bajista
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_BID — el color de la línea del precio Bid.

//+------------------------------------------------------------------+
//| La función obtiene el color de la línea del precio Bid.          |
//+------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la línea del precio Bid
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la línea del precio Bid.        |
//+------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la línea del precio Bid
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_ASK — el color de la línea del precio Ask.

//+------------------------------------------------------------------+
//| La función obtiene el color de la línea del precio Ask.          |
//+------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la línea del precio Ask
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la línea del precio Ask.        |
//+------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la línea del precio Ask
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_LAST — el color de la línea del precio de la última transacción realizada (Last).

//+------------------------------------------------------------------+
//| La función obtiene el color de la línea del precio de la última  |
//| transacción realizada.                                           |
//+------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de la línea del precio de la última transacción realizada (Last)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de la línea del precio de la última|
//| transacción realizada.                                           |
//+------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de la línea del precio de la última transacción realizada (Last)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_COLOR_STOP_LEVEL — el color de los niveles de las órdenes Stop (Stop Loss y Take Profit).

//+------------------------------------------------------------------+
//| La función obtiene el color de los niveles Stop Loss             |
//| y Take Profit.                                                   |
//+------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el color
   long result=clrNONE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el color de los niveles de las órdenes Stop (Stop Loss y Take Profit)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| La función establece el color de los niveles Stop Loss y         |
//| Take Profit.                                                     |
//+------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el color de los niveles de las órdenes Stop (Stop Loss y Take Profit)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_TRADE_LEVELS — la propiedad de visualización de los niveles de trad¡ng en el gráfico (niveles de posiciones abiertas, Stop Loss, Take Profit y órdenes pendientes).

//+------------------------------------------------------------------+
//| La función determina si los niveles de trading se visualizan     |
//| en el gráfico.                                                   |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de los    |
//| niveles de trading.                                              |
//+------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_DRAG_TRADE_LEVELS — la propiedad del permiso para arrastrar los niveles de trading por el gráfico utilizando el ratón.

//+------------------------------------------------------------------+
//| La función determina si se puede arrastrar los niveles de trading|
//| en el gráfico utilizando el ratón.                               |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de arrastre de los niveles |
//| de trading en el gráfico utilizando el ratón.                    |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_DATE_SCALE — la propiedad de visualización de la escala de tiempo en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si la escala de tiempo se visualiza         |
//| en el gráfico.                                                   |
//+------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de la     |
//| escala de tiempo en el gráfico.                                  |
//+------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_PRICE_SCALE — la propiedad de visualización de la escala de precios en el gráfico.

//+------------------------------------------------------------------+
//| La función determina si la escala de precios se visualiza        |
//| en el gráfico.                                                   |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa / desactiva el modo de visualización de la     |
//| escala de precios en el gráfico.                                 |
//+------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHOW_ONE_CLICK — visualización del panel del trading rápido en el gráfico (opción "Trading con un clic").

//+------------------------------------------------------------------+
//| La función determina si se visualiza el panel del                |
//| trading rápido en el gráfico (opción "Trading con un clic")      |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- preparamos la variable para obtener el valor de la propiedad
   long value;
//--- anulamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función activa/desactiva el modo de visualización del         |
//| panel de trading rápido en el gráfico                            |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- anulamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_SHIFT_SIZE — el tamaño de desplazamiento de la barra cero desde el borde derecho en por cientos.

//+------------------------------------------------------------------+
//| La función obtiene el tamaño de desplazamiento de la barra cero  |
//| desde el borde derecho del gráfico en por cientos (de 10% a 50%).|
//+------------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| La función establece el tamaño de desplazamiento de la barra cero|
//| desde el borde derecho del gráfico en por cientos (de 10% a 50%).|
//| Para activar el modo de desplazamiento, hay que establecer el    |
//| valor de la propiedad CHART_SHIFT igual atrue.                   |
//+------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_FIXED_POSITION — la posición fija del gráfico desde el borde izquierdo en por cientos.

//+------------------------------------------------------------------+
//| La función obtiene la posición fija del gráfico desde            |
//| el borde izquierdo en por cientos.                               |
//+------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| La función establece la posición fija del gráfico desde          |
//| el borde izquierdo en por cientos. Para ver la                   |
//| posición fija en el gráfico, antes hay que establecer            |
//| el valor de la propiedad CHART_AUTOSCROLL igual a false.         |
//+------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_FIXED_MAX — la propiedad del máximo fijo del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el valor del máximo fijo del gráfico.         |
//+------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| La función establece el valor del máximo fijo del gráfico.       |
//| Para poder modificar el valor de esta propiedad, hace falta      |
//| establecer antes el valor de la propiedad CHART_SCALEFIX igual a |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_FIXED_MIN — la propiedad del mínimo fijo del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el valor del mínimo fijo del gráfico.         |
//+------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| La función establece el valor del mínimo fijo del gráfico.       |
//| Para poder modificar el valor de esta propiedad, hace falta      |
//| establecer antes el valor de la propiedad CHART_SCALEFIX igual a |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_POINTS_PER_BAR — el valor de la escala en puntos por barra.

//+------------------------------------------------------------------+
//| La función obtiene el valor de la escala del gráfico             |
//| en puntos por barra.                                             |
//+------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| La función establece el valor de la escala del gráfico en puntos |
//| por barra. Para ver el resultado del cambio del valor de esta    |
//| propiedad, antes hay que establecer el valor de la propiedad     |
//| CHART_SCALE_PT_PER_BAR igual a true.                             |
//+------------------------------------------------------------------+
bool ChartPointsPerBarSet(const double value,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_PRICE_MIN — devuelve el valor del mínimo del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el valor del mínimo del gráfico en la ventana |
//| principal o subventana.                                          |
//+------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }

CHART_PRICE_MAX — devuelve el valor del máximo del gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el valor del máximo del gráfico en la ventana |
//| principal o subventana.                                          |
//+------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- preparamos la variable para recibir el resultado
   double result=EMPTY_VALUE;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
     }
//--- devolvemos el valor de la propiedad del gráfico
   return(result);
  }

CHART_COMMENT — texto del comentario en el gráfico.

//+------------------------------------------------------------------+
//| La función obtiene el texto del comentario en la esquina superior|
//| izquierda del gráfico.                                           |
//+------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| La función establece el texto del comentario en la esquina       |
//| superior izquierda del gráfico.                                  |
//+------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- reseteamos el valor del error
   ResetLastError();
//--- establecemos el valor de la propiedad
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- mostramos el mensaje del error en el diario "Asesores Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- ejecución con éxito
   return(true);
  }

CHART_IS_MAXIMIZED — окно графика развернуто

//+------------------------------------------------------------------+
//| La función determina si la ventana actual del gráfico            |
//| está maximizada                                                  |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- preparando la variable para obtener el valor de las propiedades
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- mostramos un mensaje sobre el error en el diario de registro "Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecutado con éxito
   return(true);
  }

CHART_IS_MINIMIZED — la ventana del gráfico está minimizada

//+------------------------------------------------------------------+
//| La función determina si la ventana actual del gráfico            |
//| está minimizada                                                  |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
  {
//--- preparando la variable para obtener el valor de las propiedades
   long value;
//--- reseteamos el valor del error
   ResetLastError();
//--- obtenemos el valor de la propiedad
   if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
     {
      //--- mostramos un mensaje sobre el error en el diario de registro "Expertos"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- guardamos en la variable el valor de la propiedad del gráfico
   result=value;
//--- ejecutado con éxito
   return(true);
  }

Panel para las propiedades del gráfico

//--- conectamos la biblioteca de los elementos de control
#include <ChartObjects\ChartObjectsTxtControls.mqh>
//--- constantes predefinidas
#define X_PROPERTY_NAME_1    10  // coordenada X del nombre de la propiedad en la primera columna
#define X_PROPERTY_VALUE_1   225 // x-coordenada X del valor de la propiedad en la primera columna
#define X_PROPERTY_NAME_2    345 // coordenada X del nombre de la propiedad en la segunda y la tercera columnas
#define X_PROPERTY_VALUE_2   550 // coordenada X del valor de la propiedad en la segunda y la tercera columnas
#define X_BUTTON_1           285 // coordenada X del botón en la primera columna
#define X_BUTTON_2           700 // coordenada X del botón en la segunda columna
#define Y_PROPERTY_1         30  // coordenada Y del inicio de la primera y la segunda columnas
#define Y_PROPERTY_2         286 // coordenada Y del inicio de la tercera columna
#define Y_DISTANCE           16  // distancia por el eje Y entre las filas
#define LAST_PROPERTY_NUMBER 111 // el número de la última propiedad gráfica
//--- parámetros de entrada
input color InpFirstColor=clrDodgerBlue; // Color de las filas impares
input color InpSecondColor=clrGoldenrod; // Color de las filas pares
//--- variables y arrays
CChartObjectLabel  ExtLabelsName[];  // etiquetas para visualizar los nombres de propiedades
CChartObjectLabel  ExtLabelsValue[]; // etiquetas para visualizar los valores de propiedades
CChartObjectButton ExtButtons[];     // botones
int                ExtNumbers[];     // índices de propiedades
string             ExtNames[];       // nombres de propiedades
uchar              ExtDataTypes[];   // tipos de datos de propiedades (integer, double, string)
uint               ExtGroupTypes[];  // array que almacena los datos sobre la pertenencia de las propiedades a uno de los grupos
uchar              ExtDrawTypes[];   // array que almacena los datos sobre el modo de visualización de las propiedades
double             ExtMaxValue[];    // valores máximos permitidos para las propiedades durante su trabajo con este panel
double             ExtMinValue[];    // valores mínimos permitidos para las propiedades durante su trabajo con este panel
double             ExtStep[];        // pasos para cambiar las propiedades
int                ExtCount;         // número total de todas las propiedades
color              ExtColors[2];     // array de colores para visualizar las filas
string             ExtComments[2];   // array de comentarios (para la propiedad CHART_COMMENT)
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- mostramos el comentario sobre el gráfico
   Comment("SomeComment");
//--- guardamos los colores en el array para conmutarse luego entre ellos
   ExtColors[0]=InpFirstColor;
   ExtColors[1]=InpSecondColor;
//--- guardamos los comentarios en el array para conmutarse luego entre ellos
   ExtComments[0]="FirstComment";
   ExtComments[1]="SecondComment";
//--- preparamos y visualizamos el panel de control de las propiedades del gráfico
   if(!PrepareControls())
      return(INIT_FAILED);
//--- ejecución con éxito
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Deinitialization function of the expert                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- quitamos el texto del comentario en el gráfico
   Comment("");
  }
//+------------------------------------------------------------------+
//| Manejador de eventos del gráfico                                 |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//--- comprobación del evento de pinchar sobre un objeto del gráfico
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- dividimos el nombre del objeto por el separador
      string obj_name[];
      StringSplit(sparam,'_',obj_name);
      //--- prueba de que si el objeto es un botón
      if(obj_name[0]=="Button")
        {
         //--- obtenemos el índice del botón
         int index=(int)StringToInteger(obj_name[1]);
         //--- ponemos el botón en el estado no presionado
         ExtButtons[index].State(false);
         //--- establecemos nuevo valor de la propiedad en función de su tipo
         if(ExtDataTypes[index]=='I')
            ChangeIntegerProperty(index);
         if(ExtDataTypes[index]=='D')
            ChangeDoubleProperty(index);
         if(ExtDataTypes[index]=='S')
            ChangeStringProperty(index);
        }
     }
//--- redibujo de valores de propiedad
   RedrawProperties();
   ChartRedraw();
  }
//+------------------------------------------------------------------+
//| Cambio de la propiedad integer del gráfico                       |
//+------------------------------------------------------------------+
void ChangeIntegerProperty(const int index)
  {
//--- obtenemos el valor actual de la propiedad
   long value=ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index]);
//--- determinamos el siguiente valor de la propiedad
   switch(ExtDrawTypes[index])
     {
      case 'C':
         value=GetNextColor((color)value);
         break;
      default:
         value=(long)GetNextValue((double)value,index);
         break;
     }
//--- establecemos nuevo valor de la propiedad
   ChartSetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[index],0,value);
  }
//+------------------------------------------------------------------+
//| Cambio de la propiedad double del gráfico                        |
//+------------------------------------------------------------------+
void ChangeDoubleProperty(const int index)
  {
//--- obtenemos el valor actual de la propiedad
   double value=ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index]);
//--- determinamos el siguiente valor de la propiedad
   value=GetNextValue(value,index);
//--- establecemos nuevo valor de la propiedad
   ChartSetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[index],value);
  }
//+------------------------------------------------------------------+
//| Cambio de la propiedad string del gráfico                        |
//+------------------------------------------------------------------+
void ChangeStringProperty(const int index)
  {
//--- variable estática para conmutar dentro del array de comentarios ExtComments
   static uint comment_index=1;
//--- cambiamos el índice para obtener otro comentario
   comment_index=1-comment_index;
//--- establecemos nuevo valor de la propiedad
   ChartSetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[index],ExtComments[comment_index]);
  }
//+------------------------------------------------------------------+
//| Determinación del siguiente valor de la propiedad                         |
//+------------------------------------------------------------------+
double GetNextValue(const double value,const int index)
  {
   if(value+ExtStep[index]<=ExtMaxValue[index])
      return(value+ExtStep[index]);
   else
      return(ExtMinValue[index]);
  }
//+------------------------------------------------------------------+
//| Obtención del siguiente color para la propiedad del tipo color               |
//+------------------------------------------------------------------+
color GetNextColor(const color clr)
  {
//--- devolvemos el siguiente valor del color
   switch(clr)
     {
      case clrWhite: return(clrRed);
      case clrRed:   return(clrGreen);
      case clrGreen: return(clrBlue);
      case clrBlue:  return(clrBlack);
      default:       return(clrWhite);
     }
  }
//+------------------------------------------------------------------+
//| Redibujo de valores de las propiedades                                     |
//+------------------------------------------------------------------+
void RedrawProperties(void)
  {
//--- texto del valor de la propiedad
   string text;
   long   value;
//--- ciclo según el número de propiedades
   for(int i=0;i<ExtCount;i++)
     {
      text="";
      switch(ExtDataTypes[i])
        {
         case 'I':
            //--- obtenemos el valor actual de la propiedad
            if(!ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)ExtNumbers[i],0,value))
            break;
            //--- texto de la propiedad integer
            switch(ExtDrawTypes[i])
              {
               //--- propiedad del color
               case 'C':
                  text=(string)((color)value);
                  break;
                  //--- propiedad booleana
               case 'B':
                  text=(string)((bool)value);
                  break;
                  //--- propiedad de la enumeración ENUM_CHART_MODE
               case 'M':
                  text=EnumToString((ENUM_CHART_MODE)value);
                  break;
                  //--- propiedad de la enumeración ENUM_CHART_VOLUME_MODE
               case 'V':
                  text=EnumToString((ENUM_CHART_VOLUME_MODE)value);
                  break;
                  //--- número del tipo int
               default:
                  text=IntegerToString(value);
                  break;
              }
            break;
         case 'D':
            //--- texto de la propiedad double
            text=DoubleToString(ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNumbers[i]),4);
            break;
         case 'S':
            //--- texto de la propiedad string
            text=ChartGetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNumbers[i]);
            break;
        }
      //--- visualizamos el valor de la propiedad
      ExtLabelsValue[i].Description(text);
     }
  }
//+------------------------------------------------------------------+
//| Crear el panel para gestionar las propiedades del gráfico                |
//+------------------------------------------------------------------+
bool PrepareControls(void)
  {
//--- adjudicamos la memoria para los arrays con reserva
   MemoryAllocation(LAST_PROPERTY_NUMBER+1);
//--- variables
   int i=0;     // variable del ciclo
   int col_1=0; // número de propiedades en la primera columna
   int col_2=0; // número de propiedades en la segunda columna
   int col_3=0; // número de propiedades en la tercera columna
//--- número de propiedades actuales - 0
   ExtCount=0;
//--- buscamos las propiedades en el ciclo
   while(i<=LAST_PROPERTY_NUMBER)
     {
      //--- guardamos el número actual de la propiedad
      ExtNumbers[ExtCount]=i;
      //--- aumentamos el valor de la variable del ciclo
      i++;
      //--- comprobamos si hay propiedad con este número
      if(CheckNumber(ExtNumbers[ExtCount],ExtNames[ExtCount],ExtDataTypes[ExtCount],ExtGroupTypes[ExtCount],ExtDrawTypes[ExtCount]))
        {
         //--- creamos los elementos de control para la propiedad
         switch(ExtGroupTypes[ExtCount])
           {
            case 1:
               //--- creamos las etiquetas y el botón para la propiedad
               if(!ShowProperty(ExtCount,0,X_PROPERTY_NAME_1,X_PROPERTY_VALUE_1,X_BUTTON_1,Y_PROPERTY_1+col_1*Y_DISTANCE,true))
               return(false);
               //--- el número de elementos en la primera columna se ha aumentado
               col_1++;
               break;
            case 2:
               //--- creamos las etiquetas y el botón para la propiedad
               if(!ShowProperty(ExtCount,1,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,X_BUTTON_2,Y_PROPERTY_1+col_2*Y_DISTANCE,true))
               return(false);
               //--- el número de elementos en la segunda columna se ha aumentado
               col_2++;
               break;
            case 3:
               //--- creamos sólo las etiquetas para la propiedad
               if(!ShowProperty(ExtCount,2,X_PROPERTY_NAME_2,X_PROPERTY_VALUE_2,0,Y_PROPERTY_2+col_3*Y_DISTANCE,false))
               return(false);
               //--- el número de elementos en la tercera columna se ha aumentado
               col_3++;
               break;
           }
         //--- determinamos el valor máximo, mínimo y el paso
         GetMaxMinStep(ExtNumbers[ExtCount],ExtMaxValue[ExtCount],ExtMinValue[ExtCount],ExtStep[ExtCount]);
         //--- aumentamos el número de propiedades
         ExtCount++;
        }
     }
//--- liberamos la memoria que no se utiliza por los arrays
   MemoryAllocation(ExtCount);
//--- redibujamos los valores de las propiedades
   RedrawProperties();
   ChartRedraw();
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Adjudicación de memoria para los arrays                                    |
//+------------------------------------------------------------------+
void MemoryAllocation(const int size)
  {
   ArrayResize(ExtLabelsName,size);
   ArrayResize(ExtLabelsValue,size);
   ArrayResize(ExtButtons,size);
   ArrayResize(ExtNumbers,size);
   ArrayResize(ExtNames,size);
   ArrayResize(ExtDataTypes,size);
   ArrayResize(ExtGroupTypes,size);
   ArrayResize(ExtDrawTypes,size);
   ArrayResize(ExtMaxValue,size);
   ArrayResize(ExtMinValue,size);
   ArrayResize(ExtStep,size);
  }
//+------------------------------------------------------------------+
//| Comprobamos si el índice de la propiedad pertenece a una de          |
//| las enumeraciones ENUM_CHART_PROPERTIES                               |
//+------------------------------------------------------------------+
bool CheckNumber(const int ind,string &name,uchar &data_type,uint &group_type,uchar &draw_type)
  {
//--- comprobamos si la propiedad es del tipo entero (integer)
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_INTEGER)ind);
   if(_LastError==0)
     {
      data_type='I';                      // propiedad de la enumeración ENUM_CHART_PROPERTY_INTEGER
      GetTypes(ind,group_type,draw_type); // definimos los parámetros de visualización de la propiedad
      return(true);
     }
//--- comprobamos si la propiedad es del tipo real (double)
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_DOUBLE)ind);
   if(_LastError==0)
     {
      data_type='D';                      // propiedad de la enumeración ENUM_CHART_PROPERTY_DOUBLE
      GetTypes(ind,group_type,draw_type); // definimos los parámetros de visualización de la propiedad
      return(true);
     }
//--- comprobamos si la propiedad es del tipo literal (string)
   ResetLastError();
   name=EnumToString((ENUM_CHART_PROPERTY_STRING)ind);
   if(_LastError==0)
     {
      data_type='S';                      // propiedad de la enumeración ENUM_CHART_PROPERTY_STRING
      GetTypes(ind,group_type,draw_type); // definimos los parámetros de visualización de la propiedad
      return(true);
     }
//--- la propiedad no pertenece a ninguna de las enumeraciones
   return(false);
  }
//+------------------------------------------------------------------+
//| Determinación del grupo en el que debe almacenarse la propiedad,     |
//| así como su tipo de visualización                                            |
//+------------------------------------------------------------------+
void GetTypes(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- comprobamos si la propiedad pertenece al tercer grupo
//--- las propiedades del tercer grupo se muestran en la segunda columna empezando de CHART_BRING_TO_TOP
   if(CheckThirdGroup(property_number,group_type,draw_type))
      return;
//--- comprobamos si la propiedad pertenece al segundo grupo
//--- las propiedades del segundo grupo se muestran en la segunda columna desde su inicio
   if(CheckSecondGroup(property_number,group_type,draw_type))
      return;
//--- si nos hemos encontrado aquí, entonces la propiedad pertenece al primer grupo (primera columna)
   CheckFirstGroup(property_number,group_type,draw_type);
  }
//+------------------------------------------------------------------+
//| La función comprueba si la propiedad pertenece al tercer grupo, y     |
//| si es así, determina su tipo de visualización                       |
//+------------------------------------------------------------------+
bool CheckThirdGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- comprobamos si la propiedad pertenece al tercer grupo
   switch(property_number)
     {
      //--- propiedades booleanas
      case CHART_IS_OBJECT:
      case CHART_WINDOW_IS_VISIBLE:
         draw_type='B';
         break;
         //--- propiedades enteras (integer)
      case CHART_VISIBLE_BARS:
      case CHART_WINDOWS_TOTAL:
      case CHART_WINDOW_HANDLE:
      case CHART_WINDOW_YDISTANCE:
      case CHART_FIRST_VISIBLE_BAR:
      case CHART_WIDTH_IN_BARS:
      case CHART_WIDTH_IN_PIXELS:
         draw_type='I';
         break;
         //--- propiedades reales (double)
      case CHART_PRICE_MIN:
      case CHART_PRICE_MAX:
         draw_type='D';
         break;
         //--- de hecho, esta propiedad es un comando de visualización del gráfico por encima de todos los demás
         //--- no hay necesidad de aplicarla para este panel, porque la ventana siempre
         //--- va a colocarse por encima de todas las demás antes de que la utilicemos
      case CHART_BRING_TO_TOP:
         draw_type=' ';
         break;
         //--- la propiedad no pertenece al tercer grupo
      default:
         return(false);
     }
//--- la propiedad pertenece al tercer grupo
   group_type=3;
   return(true);
  }
//+------------------------------------------------------------------+
//| La función comprueba si la propiedad pertenece al segundo grupo, y si |
//| es así, determina su tipo de visualización                            |
//+------------------------------------------------------------------+
bool CheckSecondGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- comprobamos si la propiedad pertenece al segundo grupo
   switch(property_number)
     {
      //--- la propiedad del tipo ENUM_CHART_MODE
      case CHART_MODE:
         draw_type='M';
         break;
         //--- la propiedad del tipo ENUM_CHART_VOLUME_MODE
      case CHART_SHOW_VOLUMES:
         draw_type='V';
         break;
         //--- propiedad literal (string)
      case CHART_COMMENT:
         draw_type='S';
         break;
         //--- propiedad del color
      case CHART_COLOR_BACKGROUND:
      case CHART_COLOR_FOREGROUND:
      case CHART_COLOR_GRID:
      case CHART_COLOR_VOLUME:
      case CHART_COLOR_CHART_UP:
      case CHART_COLOR_CHART_DOWN:
      case CHART_COLOR_CHART_LINE:
      case CHART_COLOR_CANDLE_BULL:
      case CHART_COLOR_CANDLE_BEAR:
      case CHART_COLOR_BID:
      case CHART_COLOR_ASK:
      case CHART_COLOR_LAST:
      case CHART_COLOR_STOP_LEVEL:
         draw_type='C';
         break;
         //--- la propiedad no pertenece al segundo grupo
      default:
         return(false);
     }
//--- la propiedad pertenece al segundo grupo
   group_type=2;
   return(true);
  }
//+------------------------------------------------------------------+
//| Esta función se invoca sólo si ya se sabe   |
//| que la propiedad no pertenece ni al segundo, ni al tercer grupo de propiedades     |
//+------------------------------------------------------------------+
void CheckFirstGroup(const int property_number,uint &group_type,uchar &draw_type)
  {
//--- la propiedad pertenece al primer grupo
   group_type=1;
//--- determinamos el tipo de visualización de la propiedad
   switch(property_number)
     {
      //--- propiedades enteras (integer)
      case CHART_SCALE:
      case CHART_HEIGHT_IN_PIXELS:
         draw_type='I';
         return;
         //--- propiedades reales (double)
      case CHART_SHIFT_SIZE:
      case CHART_FIXED_POSITION:
      case CHART_FIXED_MAX:
      case CHART_FIXED_MIN:
      case CHART_POINTS_PER_BAR:
         draw_type='D';
         return;
         //--- sólo quedan las propiedades booleanas
      default:
         draw_type='B';
         return;
     }
  }
//+------------------------------------------------------------------+
//| Crear las etiquetas y el botón para la propiedad                           |
//+------------------------------------------------------------------+
bool ShowProperty(const int ind,const int type,const int x1,const int x2,
                  const int xb,const int y,const bool btn)
  {
//--- array estático para conmutar dentro del array de color ExtColors
   static uint color_index[3]={1,1,1};
//--- cambiamos el índice para obtener otro color
   color_index[type]=1-color_index[type];
//--- mostramos etiquetas y el botón (si btn=true) para la propiedad
   if(!LabelCreate(ExtLabelsName[ind],"name_"+(string)ind,ExtNames[ind],ExtColors[color_index[type]],x1,y))
      return(false);
   if(!LabelCreate(ExtLabelsValue[ind],"value_"+(string)ind,"",ExtColors[color_index[type]],x2,y))
      return(false);
   if(btn && !ButtonCreate(ExtButtons[ind],(string)ind,xb,y+1))
      return(false);
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Crear etiqueta                                                 |
//+------------------------------------------------------------------+
bool LabelCreate(CChartObjectLabel &lbl,const string name,const string text,
                 const color clr,const int x,const int y)
  {
   if(!lbl.Create(0,"Label_"+name,0,x,y)) return(false);
   if(!lbl.Description(text))             return(false);
   if(!lbl.FontSize(10))                  return(false);
   if(!lbl.Color(clr))                    return(false);
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Crear el botón                                                  |
//+------------------------------------------------------------------+
bool ButtonCreate(CChartObjectButton &btn,const string name,
                  const int x,const int y)
  {
   if(!btn.Create(0,"Button_"+name,0,x,y,50,15)) return(false);
   if(!btn.Description("Next"))                  return(false);
   if(!btn.FontSize(10))                         return(false);
   if(!btn.Color(clrBlack))                      return(false);
   if(!btn.BackColor(clrWhite))                  return(false);
   if(!btn.BorderColor(clrBlack))                return(false);
//--- ejecución con éxito
   return(true);
  }
//+------------------------------------------------------------------+
//| Establecemos el valor máximo, mínimo y el paso  |
//+------------------------------------------------------------------+
void GetMaxMinStep(const int property_number,double &max,double &min,double &step)
  {
   double value;
//--- establecemos valores en función del tipo de la propiedad
   switch(property_number)
     {
      case CHART_SCALE:
         max=5;
         min=0;
         step=1;
         break;
      case CHART_MODE:
      case CHART_SHOW_VOLUMES:
         max=2;
         min=0;
         step=1;
         break;
      case CHART_SHIFT_SIZE:
         max=50;
         min=10;
         step=2.5;
         break;
      case CHART_FIXED_POSITION:
         max=90;
         min=0;
         step=15;
         break;
      case CHART_POINTS_PER_BAR:
         max=19;
         min=1;
         step=3;
         break;
      case CHART_FIXED_MAX:
         value=ChartGetDouble(0,CHART_FIXED_MAX);
         max=value*1.25;
         min=value;
         step=value/32;
         break;
      case CHART_FIXED_MIN:
         value=ChartGetDouble(0,CHART_FIXED_MIN);
         max=value;
         min=value*0.75;
         step=value/32;
         break;
      case CHART_HEIGHT_IN_PIXELS:
         max=700;
         min=520;
         step=30;
         break;
         //--- valores por defecto
      default:
         max=1;
         min=0;
         step=1;
     }
  }

Visualización de gráficos

Constantes de objetos