Exemplos de como trabalhar com um gráfico

//+-------------------------------------------------------------------------+
//| Definir se um objeto é um gráfico. Se ele for                           |
//| um objeto gráfico, o resultado é verdadeiro. Se ele for um gráfico real |
//| o resultado da variável foi o valor falso.                              |
//+-------------------------------------------------------------------------+
bool ChartIsObject(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- obter a propriedade do gráfico
   if(!ChartGetInteger(chart_ID,CHART_IS_OBJECT,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      //--- retorna false
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }

//+-------------------------------------------------------------------------+
//| Enviar comando para o terminal para exibir o gráfico acima dos outros.  |
//+-------------------------------------------------------------------------+
bool ChartBringToTop(const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- exibe o gráfico no topo de outros gráficos
   if(!ChartSetInteger(chart_ID,CHART_BRING_TO_TOP,0,true))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+--------------------------------------------------------------------------+
//| A função define se a rolagem do gráfico usando o botão esquerdo do mouse |
//| está habilitado.                                                         |
//+--------------------------------------------------------------------------+
bool ChartMouseScrollGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------+
//| A função habilita/desabilita a rolagem do gráfico usando botão     |
//| esquerdo do mouse.                                                 |
//+--------------------------------------------------------------------+
bool ChartMouseScrollSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_MOUSE_SCROLL,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| Verificar se mudança de eventos e cliques de mouse               |
//| são enviadas para todas as aplicações mql5 no gráfico.           |
//+------------------------------------------------------------------+
bool ChartEventMouseMoveGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de envio de mensagens sobre mudança      |
//| de eventos e cliques de mouse para aplicações no                             |
//| gráfico.                                                                     |
//+------------------------------------------------------------------------------+
bool ChartEventMouseMoveSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_EVENT_MOUSE_MOVE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------+
//| Verificar se é mensagens do evento da criação de um objeto gráfico  |
//| são enviadas para todas as aplicações mql5 no gráfico.              |
//+---------------------------------------------------------------------+
bool ChartEventObjectCreateGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de envio de mensagens sobre          |
//| o evento da criação do objeto gráfico para aplicações mql5 no            |
//| gráfico.                                                                 |
//+--------------------------------------------------------------------------+
bool ChartEventObjectCreateSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_CREATE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------+
//| Verificar se mensagens é do evento da exclusão de um objeto gráfico |
//| são enviadas para todas as aplicações mql5 no gráfico.              |
//+---------------------------------------------------------------------+
bool ChartEventObjectDeleteGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de envio de mensagens sobre          |
//| o evento da exclusão do objeto gráfico para aplicações mql5 no           |
//| gráfico.                                                                 |
//+--------------------------------------------------------------------------+
bool ChartEventObjectDeleteSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_EVENT_OBJECT_DELETE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| Obter tipo de gráfico (candles, barras ou                        |
//| linha).                                                          |
//+------------------------------------------------------------------+
ENUM_CHART_MODE ChartModeGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=WRONG_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_MODE,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((ENUM_CHART_MODE)result);
  }
//+------------------------------------------------------------------+
//| Define tipo de gráfico (candles, barras ou                       |
//| linha).                                                          |
//+------------------------------------------------------------------+
bool ChartModeSet(const long value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_MODE,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função define se um gráfico de preço é exibido no              |
//| primeiro plano.                                                  |
//+------------------------------------------------------------------+
bool ChartForegroundGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+---------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição do gráfico de preço no    |
//| primeiro plano.                                                           |
//+---------------------------------------------------------------------------+
bool ChartForegroundSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_FOREGROUND,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------------------------+
//| A função define se o modo de deslocamento do gráfico de preço do limite direito    |
//| está habilitado.                                                                   |
//+------------------------------------------------------------------------------------+
bool ChartShiftGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição do gráfico de preço com  |
//| deslocamento do limite direito.                                          |
//+--------------------------------------------------------------------------+
bool ChartShiftSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHIFT,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------+
//| A função define o modo de auto-rolamento do gráfico                 |
//| para a direita no caso de chegada de novos ticks estar habilitado.  |
//+---------------------------------------------------------------------+
bool ChartAutoscrollGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| A função habilita/desabilita o modo de auto-rolamento do gráfico |
//| para a direita no caso da chegada de novos ticks.                |
//+------------------------------------------------------------------+
bool ChartAutoscrollSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_AUTOSCROLL,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| Obter escala do gráfico (de 0 a 5).                              |
//+------------------------------------------------------------------+
int ChartScaleGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SCALE,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }
//+------------------------------------------------------------------+
//| Definir escala do gráfico (de 0 a 5).                            |
//+------------------------------------------------------------------+
bool ChartScaleSet(const long value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SCALE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função define se o modo de fixar a escala está habilitado.     |
//+------------------------------------------------------------------+
bool ChartScaleFixGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| A função habilita/desabilita o modo de fixar a escala.              |
//+------------------------------------------------------------------+
bool ChartScaleFixSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função define se a escala "1:1" está habilitada.               |
//+------------------------------------------------------------------+
bool ChartScaleFix11Get(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| A função habilita/desabilita o modo de escala "1:1"              |
//+------------------------------------------------------------------+
bool ChartScaleFix11Set(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SCALEFIX_11,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------------------+
//| A função define se o modo de especificar a escala do gráfico é por pontos    |
//| barra está habilitada.                                                       |
//+------------------------------------------------------------------------------+
bool ChartScalePerBarGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de definir a escala do gráfico em pontos por   |
//| barra.                                                                             |
//+------------------------------------------------------------------------------------+
bool ChartScalePerBarSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SCALE_PT_PER_BAR,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função define se o modo de exibição dos valores OHLC           |
//| no canto superior esquerdo está habilitado.                      |
//+------------------------------------------------------------------+
bool ChartShowOHLCGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição dos valores OHLC no      |
//| canto superior esquerdo do gráfico.                                      |
//+--------------------------------------------------------------------------+
bool ChartShowOHLCSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OHLC,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+-----------------------------------------------------------------------------+
//| A função define se é o modo de exibição da linha do valor Bid no gráfico    |
//| está habilitado.                                                            |
//+-----------------------------------------------------------------------------+
bool ChartShowBidLineGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição da linha Bid no    |
//| gráfico.                                                           |
//+--------------------------------------------------------------------+
bool ChartShowBidLineSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_BID_LINE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+-----------------------------------------------------------------------+
//| A função define se é o modo de exibição da linha de valor Ask no      |
//| gráfico.                                                              |
//+-----------------------------------------------------------------------+
bool ChartShowAskLineGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+-----------------------------------------------------------------------+
//| A função habibita/desabilita o modo de exibição da linha ASk no       |
//| gráfico.                                                              |
//+-----------------------------------------------------------------------+
bool ChartShowAskLineSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ASK_LINE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------------------+
//| A função define se o modo da exibição da linha para a última execução           |
//| do preço de negociação está habilitada.                                         |
//+---------------------------------------------------------------------------------+
bool ChartShowLastLineGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------------------------+
//| A função habilita/desabilita o modo da exibição da linha para a última execução      |
//| do preço de negociação.                                                              |
//+--------------------------------------------------------------------------------------+
bool ChartShowLastLineSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_LAST_LINE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função define se o modo da exibição dos separadores vertical   |
//| entre os períodos adjacentes está habilitado.                    |
//+------------------------------------------------------------------+
bool ChartShowPeriodSeparatorGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição dos separadores  |
//| vertical entre os períodos adjacentes.                           |
//+------------------------------------------------------------------+
bool ChartShowPeriodSepapatorSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PERIOD_SEP,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função define se a grade do gráfico é exibida.                 |
//+------------------------------------------------------------------+
bool ChartShowGridGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| A função habilita/desabilita a grade do gráfico.                 |
//+------------------------------------------------------------------+
bool ChartShowGridSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- definir o valor da propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_GRID,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------------+
//| A função define se os volumes são exibidos no gráfico (ou não são      |
//| mostrados, ticks são mostrados, os atuais são mostrados).              |
//+------------------------------------------------------------------------+
ENUM_CHART_VOLUME_MODE ChartShowVolumesGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=WRONG_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_VOLUMES,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((ENUM_CHART_VOLUME_MODE)result);
  }
//+------------------------------------------------------------------+
//| A função define o mode de exibição dos volumes no gráfico.       |
//+------------------------------------------------------------------+
bool ChartShowVolumesSet(const long value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_VOLUMES,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+-------------------------------------------------------------------+
//| A função define se descrições pop-up de objetos gráficos são      |
//| exibidas quando colocado o cursor do mouse sobre eles.            |
//+-------------------------------------------------------------------+
bool ChartShowObjectDescriptionGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição de descrições pop-up     |
//| de objetos gráficos quando colocado o cursor do mouse sobre eles.        |
//+--------------------------------------------------------------------------+
bool ChartShowObjectDescriptionSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_OBJECT_DESCR,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+-----------------------------------------------------------------------+
//| A função recebe o número de barras que são mostradas (visíveis)       |
//| na janela do gráfico.                                                 |
//+-----------------------------------------------------------------------+
int ChartVisibleBars(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_VISIBLE_BARS,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+--------------------------------------------------------------------------+
//| A função obtém o número total de janelas do gráfico incluindo            |
//| subjanelas do indicador.                                                 |
//+--------------------------------------------------------------------------+
int ChartWindowsTotal(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_WINDOWS_TOTAL,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+------------------------------------------------------------------+
//| A função define se a atual janela do gráfico ou sub-janela       |
//| está visível.                                                    |
//+------------------------------------------------------------------+
bool ChartWindowsIsVisible(bool &result,const long chart_ID=0,const int sub_window=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_IS_VISIBLE,sub_window,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função obtém o manipulador do gráfico                          |
//+------------------------------------------------------------------+
int ChartWindowsHandle(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_HANDLE,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+------------------------------------------------------------------+
//| A função obtém a distância em pixels entre a quadro superior da  |
//| sub-janela e o quadro superior da janela principal do gráfico.   |
//+------------------------------------------------------------------+
int ChartWindowsYDistance(const long chart_ID=0,const int sub_window=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_WINDOW_YDISTANCE,sub_window,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+---------------------------------------------------------------------------------------+
//| A função recebe o número da primeira barra visível no gráfico.                        |
//| Indexação é executada como em séries temporais, as últimas barras têm índices menores |
//+---------------------------------------------------------------------------------------+
int ChartFirstVisibleBar(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_FIRST_VISIBLE_BAR,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+------------------------------------------------------------------+
//| A função recebe a largura do gráfico de barras.                  |
//+------------------------------------------------------------------+
int ChartWidthInBars(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_BARS,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+------------------------------------------------------------------+
//| A função recebe a largura da do gráfico em pixels.               |
//+------------------------------------------------------------------+
int ChartWidthInPixels(const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_WIDTH_IN_PIXELS,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }

//+------------------------------------------------------------------+
//| A função recebe o valor da altura do gráfico em pixels.          |
//+------------------------------------------------------------------+
int ChartHeightInPixelsGet(const long chart_ID=0,const int sub_window=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long result=-1;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((int)result);
  }
//+------------------------------------------------------------------+
//| A função define o valor da altura do gráfico em pixels.          |
//+------------------------------------------------------------------+
bool ChartHeightInPixelsSet(const int value,const long chart_ID=0,const int sub_window=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_HEIGHT_IN_PIXELS,sub_window,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor do fundo do gráfico.                       |
//+------------------------------------------------------------------+
color ChartBackColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor do fundo do gráfico
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BACKGROUND,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função define a cor de fundo do gráfico.                       |
//+------------------------------------------------------------------+
bool ChartBackColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- definir a cor do fundo do gráfico
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BACKGROUND,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor dos eixos, da escala e da linha OHLC.      |
//+------------------------------------------------------------------+
color ChartForeColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber cor dos eixos, escala e linha OHLC
   if(!ChartGetInteger(chart_ID,CHART_COLOR_FOREGROUND,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor dos eixos, da escala e da linha OHLC.   |
//+------------------------------------------------------------------+
bool ChartForeColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- definir cor dos eixos, escala e linha OHLC
   if(!ChartSetInteger(chart_ID,CHART_COLOR_FOREGROUND,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor da grade do gráfico.                       |
//+------------------------------------------------------------------+
color ChartGridColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor da grade do gráfico
   if(!ChartGetInteger(chart_ID,CHART_COLOR_GRID,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor da grade do gráfico.                    |
//+------------------------------------------------------------------+
bool ChartGridColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da grade do gráfico
   if(!ChartSetInteger(chart_ID,CHART_COLOR_GRID,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe cor de volumes e níveis de entrada               |
//| no mercado.                                                     |
//+------------------------------------------------------------------+
color ChartVolumeColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- recebe cor de volumes e níveis de entrada no mercado
   if(!ChartGetInteger(chart_ID,CHART_COLOR_VOLUME,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor de volumes e entrada                    |
//| no mercado.                                                      |
//+------------------------------------------------------------------+
bool ChartVolumeColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar cor de volumes e níveis de entrada no mercado
   if(!ChartSetInteger(chart_ID,CHART_COLOR_VOLUME,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe cor da barra de alta, a sua sombra e             |
//| o limite do corpo do candlestick de alta.                        |
//+------------------------------------------------------------------+
color ChartUpColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- recebe cor da barra de alta, a sua sombra e o limite do corpo do candlestick de alta
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_UP,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura cor da barra de alta, sua sombra e            |
//| o limite do corpo do candlestick de alta.                        |
//+------------------------------------------------------------------+
bool ChartUpColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da barra de alta, a sua sombra e o limite do corpo do candlestick de alta
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_UP,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe cor da barra de alta, a sua sombra e             |
//| limite do corpo do candlestick de baixa.                         |
//+------------------------------------------------------------------+
color ChartDownColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- recebe cor da barra de baixa, a sua sombra e o limite do corpo do candlestick de baixa
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_DOWN,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor da barra de baixa, sua sombra e         |
//| limite do corpo do candlestick de baixa.                         |
//+------------------------------------------------------------------+
bool ChartDownColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da barra de baixa, sua sombra e e o limite do corpo do candlestick de baixa
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_DOWN,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------------+
//| A função recebe cor da linha do gráfico e candlesticks Doji.           |
//+------------------------------------------------------------------------+
color ChartLineColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber cor da linha do gráfico e candlesticks Doji.
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CHART_LINE,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor da linha do gráfico e                   |
//| candlesticks Doji.                                               |
//+------------------------------------------------------------------+
bool ChartLineColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da linha do gráfico e candlesticks Doji
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CHART_LINE,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor do corpo do candlestick de alta.           |
//+------------------------------------------------------------------+
color ChartBullColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor do corpo do candlestick de alta
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor do corpo do candlestick de alta.        |
//+------------------------------------------------------------------+
bool ChartBullColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor do corpo do candlestick de alta.
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BULL,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor do corpo do candlestick de baixa.          |
//+------------------------------------------------------------------+
color ChartBearColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor do corpo do candlestick de baixa
   if(!ChartGetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor do corpo do candlestick de baixa.       |
//+------------------------------------------------------------------+
bool ChartBearColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor do corpo do candlestick de baixa
   if(!ChartSetInteger(chart_ID,CHART_COLOR_CANDLE_BEAR,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor da linha Bid.                              |
//+------------------------------------------------------------------+
color ChartBidColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor da linha Bid
   if(!ChartGetInteger(chart_ID,CHART_COLOR_BID,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor da linha Bid.                           |
//+------------------------------------------------------------------+
bool ChartBidColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da linha Bid.
   if(!ChartSetInteger(chart_ID,CHART_COLOR_BID,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe a cor da linha Ask.                              |
//+------------------------------------------------------------------+
color ChartAskColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor da linha Ask
   if(!ChartGetInteger(chart_ID,CHART_COLOR_ASK,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor da linha Ask.                           |
//+------------------------------------------------------------------+
bool ChartAskColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da linha Ask
   if(!ChartSetInteger(chart_ID,CHART_COLOR_ASK,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+----------------------------------------------------------------------+
//| A função recebe a cor da linha do preço do último negócio realizado. |
//+----------------------------------------------------------------------+
color ChartLastColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber cor de linha do último preço de operação executada.
   if(!ChartGetInteger(chart_ID,CHART_COLOR_LAST,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura a cor do preço do último negócio realizado    |
//| linha.                                                           |
//+------------------------------------------------------------------+
bool ChartLastColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- configurar a cor da linha do preço do último negócio realizado (Last)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_LAST,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+--------------------------------------------------------------------+
//| A função recebe as cores dos níveis de Stop Loss e Take Profit.    |
//+--------------------------------------------------------------------+
color ChartStopLevelColorGet(const long chart_ID=0)
  {
//--- preparar a variável para receber a cor
   long result=clrNONE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber a cor de níveis de ordem de stop (Stop Loss e Take Profit)
   if(!ChartGetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return((color)result);
  }
//+------------------------------------------------------------------+
//| A função configura cores dos níveis de Stop Loss e Take Profit.  |
//+------------------------------------------------------------------+
bool ChartStopLevelColorSet(const color clr,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- definir a cor de níveis de ordem de stop (Stop Loss e Take Profit)
   if(!ChartSetInteger(chart_ID,CHART_COLOR_STOP_LEVEL,clr))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------+
//| A função define se níveis de negociação são exibidos no gráfico.    |
//+---------------------------------------------------------------------+
bool ChartShowTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+----------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibição níveis de negociação |
//+----------------------------------------------------------------------+
bool ChartShowTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_TRADE_LEVELS,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------------+
//| Função define se arrastar os níveis de negociação no gráfico com o mouse  |
//| é permitido.                                                              |
//+---------------------------------------------------------------------------+
bool ChartDragTradeLevelsGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| Função habilita/desabilita o modo arrastar os níveis de negócios |
//| no gráfico usando o mouse.                                       |
//+------------------------------------------------------------------+
bool ChartDragTradeLevelsSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_DRAG_TRADE_LEVELS,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+--------------------------------------------------------------------+
//| A função configura se a escala de tempo é exibida no gráfico.      |
//+--------------------------------------------------------------------+
bool ChartShowDateScaleGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+--------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibir a escala de tempo no |
//| gráfico.                                                           |
//+--------------------------------------------------------------------+
bool ChartShowDateScaleSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_DATE_SCALE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+--------------------------------------------------------------------+
//| A função define se a escala de preços é exibida no gráfico.        |
//+--------------------------------------------------------------------+
bool ChartShowPriceScaleGet(bool &result,const long chart_ID=0)
  {
//--- preparar a variável para obter o valor da propriedade
   long value;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- armazenar o valor da propriedade do gráfico na memória
   result=value;
//--- sucesso na execução
   return(true);
  }
//+----------------------------------------------------------------------------+
//| A função habilita/desabilita o modo de exibir a escala de preços no        |
//| gráfico.                                                                   |
//+----------------------------------------------------------------------------+
bool ChartShowPriceScaleSet(const bool value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_PRICE_SCALE,0,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| Verifique se o painel "negociar à um clique" é exibido no gráfico|
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelGet(bool &result,const long chart_ID=0)
  {
//--- Preparar a variável para obter o valor da propriedade
   long value;
//--- Redefinir o valor de erro
   ResetLastError();
//--- Receber o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- Exibir a mensagem de erro no diário de Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- Armazenar o valor da propriedade gráfica na memória
   result=value;
//--- Execução bem-sucedida
   return(true);
  }
//+------------------------------------------------------------------+
//| Ativa/desativa a exibição do painel "Negociar à um clique"       |
//| no gráfico                                                       |
//+------------------------------------------------------------------+
bool ChartShowOneClickPanelSet(const bool value,const long chart_ID=0)
  {
//--- Redefinir o valor de erro
   ResetLastError();
//--- definir o vaolr da propriedade
   if(!ChartSetInteger(chart_ID,CHART_SHOW_ONE_CLICK,0,value))
     {
      //--- Exibir a mensagem de erro no diário de Experts
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- Execução bem-sucedida
   return(true);
  }

//+---------------------------------------------------------------------------+
//| A função recebe a tamanho do deslocamento da barra zero do limite direito |
//| do gráfico em valores percentuais (de 10% até 50%).                       |
//+---------------------------------------------------------------------------+
double ChartShiftSizeGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_SHIFT_SIZE,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }
//+--------------------------------------------------------------------------------------+
//| A função configura o tamanho do deslocamento da barra zero da direita                |
//| limite do gráfico em valores percentuais (de 10% até 50%).                           |
//| Para habilitar o deslocamento modo, valor da propriedade CHART_SHIFT                 |
//| será configurada para true.                                                          |
//+--------------------------------------------------------------------------------------+
bool ChartShiftSizeSet(const double value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetDouble(chart_ID,CHART_SHIFT_SIZE,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+--------------------------------------------------------------------------+
//| A função recebe a a localização da posição fixa do gráfico de limite     |
//| esquerdo em valor percentual.                                            |
//+--------------------------------------------------------------------------+
double ChartFixedPositionGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_FIXED_POSITION,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }
//+---------------------------------------------------------------------+
//| Função configura a localização da posição fixa do gráfico de limite |
//| esquerdo em valor percentual.    Para visualizar a localização da   |
//| posição fixa do gráfico, o valor de propriedade                     |
//| CHART_AUTOSCROLL deve ser definida como falsa.                      |
//+---------------------------------------------------------------------+
bool ChartFixedPositionSet(const double value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetDouble(chart_ID,CHART_FIXED_POSITION,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe o valor de fixação máxima do gráfico.            |
//+------------------------------------------------------------------+
double ChartFixedMaxGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MAX,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| A função configura o valor de fixação máxima do gráfico.         |
//| Para alterar o valor da propriedade, valor da propriedade        |
//| CHART_SCALEFIX será preliminarmente definida para                |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMaxSet(const double value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MAX,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função recebe o valor de fixação mínima do gráfico.            |
//+------------------------------------------------------------------+
double ChartFixedMinGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_FIXED_MIN,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }
//+------------------------------------------------------------------+
//| A função configura o valor de fixação mínima do gráfico.         |
//| Para alterar o valor da propriedade, valor da propriedade        |
//| CHART_SCALEFIX será preliminarmente definida para                |
//| true.                                                            |
//+------------------------------------------------------------------+
bool ChartFixedMinSet(const double value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetDouble(chart_ID,CHART_FIXED_MIN,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------------+
//| A função recebe a o valor da escala do gráfico em pontos por barra.       |
//+---------------------------------------------------------------------------+
double ChartPointsPerBarGet(const long chart_ID=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_POINTS_PER_BAR,0,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }
//+----------------------------------------------------------------------+
//| Função configura o valor da escala do gráfico em pontos por barra.   |
//| Para ver o resultado da mudança do valor dessa propriedade,          |
//| o valor de propriedade                                               |
//| CHART_SCALE_PT_PER_BAR deve ser preliminarmente definido como true.  |
//+----------------------------------------------------------------------+
bool ChartPointsPerBarSet(const double value,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetDouble(chart_ID,CHART_POINTS_PER_BAR,value))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+---------------------------------------------------------------------------------+
//| A função recebe a o valor mínimo do gráfico na janela principal, ou numa        |
//| subjanela.                                                                      |
//+---------------------------------------------------------------------------------+
double ChartPriceMin(const long chart_ID=0,const int sub_window=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MIN,sub_window,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }

//+--------------------------------------------------------------------------------+
//| A função recebe a o valor máximo gráfico na janela principal, ou numa          |
//| subjanela.                                                                     |
//+--------------------------------------------------------------------------------+
double ChartPriceMax(const long chart_ID=0,const int sub_window=0)
  {
//--- preparar a variável para obter o resultado
   double result=EMPTY_VALUE;
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetDouble(chart_ID,CHART_PRICE_MAX,sub_window,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
     }
//--- retorna o valor da propriedade do gráfico
   return(result);
  }

//+----------------------------------------------------------------------+
//| A função recebe comentário no canto superior esquerdo do gráfico.    |
//+----------------------------------------------------------------------+
bool ChartCommentGet(string &result,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- receber o valor da propriedade
   if(!ChartGetString(chart_ID,CHART_COMMENT,result))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| A função configura comentário no canto superior esquerda do      |
//| gráfico.                                                         |
//+------------------------------------------------------------------+
bool ChartCommentSet(const string str,const long chart_ID=0)
  {
//--- redefine o valor de erro
   ResetLastError();
//--- define valor de propriedade
   if(!ChartSetString(chart_ID,CHART_COMMENT,str))
     {
      //--- exibe uma mensagem para o diário Experts
      Print(__FUNCTION__+", Código de erro = ",GetLastError());
      return(false);
     }
//--- sucesso na execução
   return(true);
  }

//+------------------------------------------------------------------+
//| A função determina se a janela do gráfica está maximizada        |
//+------------------------------------------------------------------+
bool ChartWindowsIsMaximized(bool &result,const long chart_ID=0)
  {
//--- preparamos a variável para o valor da propriedade
   long value;
//--- restauramos o valor de erro
   ResetLastError();
//--- obtemos o valor da propriedade
   if(!ChartGetInteger(chart_ID,CHART_IS_MAXIMIZED))
     {
      //--- exibimos a mensagem de erro no diário do "Expert"
      Print(__FUNCTION__+", Error Code = ",GetLastError());
      return(false);
     }
//--- memorizamos na variável o valor dos gráficos
   result=value;
//--- implementação bem-sucedida
   return(true);
  }