Exemplos de como trabalhar com um gráfico

[jssuser]

Exemplos de como trabalhar com propriedades do gráfico. Uma ou duas funções completas são exibidas para cada propriedade. Estas funções permitem configurar/receber o valor da propriedade. Essas funções podem ser utilizadas "como estão" em aplicativos personalizados MQL5.

a imagem abaixo mostra o painel gráfico ilustrando como modificara propriedade do gráficomudando sua aparência. Clicando próximo botão permite definir o novo valor da propriedade apropriada e visualizar as alterações na janela do gráfico.



Propriedades do Gráfico e Exemplos de Funções para Trabalhar com Eles
CHART_IS_OBJECT define se um objeto é um gráfico real ou um objeto 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,val ue))
{
//--- 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);
}



CHART_BRING_TO_TOP exibe o gráfico no topo de outros gráficos.
//+-------------------------------------------------------------------------+
//| 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);
}



CHART_MOUSE_SCROLL é uma propriedade para rolagem do gráfico usando botão esquerdo do mouse.
//+--------------------------------------------------------------------------+
//| 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);
}



CHART_EVENT_MOUSE_MOVE é uma propriedade de enviar mensagens sobre mudança de eventos e cliques de mouse para aplicações MQL5 CHARTEVENT_MOUSE_MOVE).
//+------------------------------------------------------------------+
//| 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_MOV E,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_MOV E,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);
}



CHART_EVENT_OBJECT_CREATE é uma propriedade de enviar mensagens sobre o evento da criação do objeto gráfico para aplicações MQL5 (CHARTEVENT_OBJECT_CREATE).
//+---------------------------------------------------------------------+
//| 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_CR EATE,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_CR EATE,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);
}



CHART_EVENT_OBJECT_DELETE é uma propriedade de enviar mensagens sobre o evento da exclusão do objeto gráfico para aplicações MQL5 (CHARTEVENT_OBJECT_DELETE).
//+---------------------------------------------------------------------+
//| 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_DE LETE,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_DE LETE,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);
}



CHART_MODE — tipo de gráfico (candles, barras ou linha).
//+------------------------------------------------------------------+
//| 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);
}



CHART_FOREGROUND é uma propriedade de exibição do gráfico de preço no primeiro plano.
//+------------------------------------------------------------------+
//| 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,va lue))
{
//--- 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,va lue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_SHIFT — modo de encaixe do gráfico de preço a partir da borda direita.
//+------------------------------------------------------------------------------------+
//| 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);
}



CHART_AUTOSCROLL — modo de movimentação automática para a borda direita do gráfico.
//+---------------------------------------------------------------------+
//| 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,va lue))
{
//--- 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,va lue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_SCALE — chart scale property.
//+------------------------------------------------------------------+
//| 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);
}



CHART_SCALEFIX — o modo de especificar a escala do gráfico em pontos por barra.
//+------------------------------------------------------------------+
//| 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,valu e))
{
//--- 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,valu e))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}

[jssuser]

CHART_SCALE_PT_PER_BAR — o modo de especificar a escala do gráfico em pontos por barra.
//+------------------------------------------------------------------------------+
//| 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_BA R,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_BA R,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);
}



CHART_SHOW_OHLC — propriedade de exibe valores OHLC no canto superior esquerdo.
//+------------------------------------------------------------------+
//| 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,val ue))
{
//--- 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,val ue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_SHOW_BID_LINE — a propriedade mostra o valor Bid como uma linha horizontal no gráfico.
//+-----------------------------------------------------------------------------+
//| 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);
}



CHART_SHOW_ASK_LINE — a propriedade de mostrar o valor Ask como uma linha horizontal no gráfico.
//+-----------------------------------------------------------------------+
//| 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);
}



CHART_SHOW_LAST_LINE — a propriedade de exibir último valor como uma linha horizontal no gráfico.
//+---------------------------------------------------------------------------------+
//| 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);
}



CHART_SHOW_PERIOD_SEP — a propriedade de exibir separadores verticais entre os períodos adjacentes.
//+------------------------------------------------------------------+
//| 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);
}

[jssuser]

CHART_SHOW_GRID — a propriedade de mostrar a grade do gráfico.
//+------------------------------------------------------------------+
//| 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,val ue))
{
//--- 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,val ue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_SHOW_VOLUMES — a propriedade de mostrar os volumes num gráfico.
//+------------------------------------------------------------------------+
//| 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,va lue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_SHOW_OBJECT_DESCR — a propriedade mostrar descrições pop-up do objeto gráfico.
//+-------------------------------------------------------------------+
//| 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_DES CR,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_DES CR,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);
}



CHART_VISIBLE_BARS define o número de barras no gráfico que são disponibilizadas para exibição.
//+-----------------------------------------------------------------------+
//| 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);
}



CHART_WINDOWS_TOTAL define o número total de janelas do gráfico incluindo sub-janelas do indicador.
//+--------------------------------------------------------------------------+
//| 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);
}



CHART_WINDOW_IS_VISIBLE define a visibilidade da sub-janela.
//+------------------------------------------------------------------+
//| 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_VISIB LE,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);
}



CHART_WINDOW_HANDLE retorna o manipulador do gráfico.
//+------------------------------------------------------------------+
//| 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);
}



CHART_WINDOW_YDISTANCE define a distância em pixels entre a quadro superior do sub-janela do indicador e o quadro superior da janela principal do gráfico.
//+------------------------------------------------------------------+
//| 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_YDISTANC E,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);
}



CHART_FIRST_VISIBLE_BAR retorna o número da primeira barra visível no gráfico (barra de indexação que corresponde a série temporal).
//+---------------------------------------------------------------------------------------+
//| 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_B AR,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);
}

[jssuser]

CHART_WIDTH_IN_BARS retorna a largura do gráfico de barras.
//+------------------------------------------------------------------+
//| 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);
}



CHART_WIDTH_IN_PIXELS retorna a largura da do gráfico em pixels.
//+------------------------------------------------------------------+
//| 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);
}



CHART_HEIGHT_IN_PIXELS — propriedade em pixels da altura do gráfico.
//+------------------------------------------------------------------+
//| 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_PIXEL S,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_PIXEL S,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);
}



CHART_COLOR_BACKGROUND - cor do fundo do gráfico.
//+------------------------------------------------------------------+
//| 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_BACKGROUN D,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_BACKGROUN D,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_FOREGROUND — Cor dos eixos, escala e linha OHLC.
//+------------------------------------------------------------------+
//| 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_FOREGROUN D,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_FOREGROUN D,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_GRID — cor da grade do gráfico.
//+------------------------------------------------------------------+
//| 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,re sult))
{
//--- 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);
}



CHART_COLOR_VOLUME - cor dos volumes e níveis de abertura de posição.
//+------------------------------------------------------------------+
//| 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,cl r))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_CHART_UP — cor da barra de alta, sombra e borda da barra de alta (também denominado como castiçal ou vela de alta).
//+------------------------------------------------------------------+
//| 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);
}

[jssuser]

CHART_COLOR_CHART_DOWN — cor da barra de baixa, a sua sombra e limite do corpo do candlestick de baixa.
//+------------------------------------------------------------------+
//| 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_DOW N,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_DOW N,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_CHART_LINE — Cor da linha do gráfico e barra Doji (também denominado como castiçal ou vela Doji).
//+------------------------------------------------------------------------+
//| 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_LIN E,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_LIN E,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_CANDLE_BULL — cor do corpo da barra de alta (também denominado como castiçal ou vela de alta).
//+------------------------------------------------------------------+
//| 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_BU LL,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_BU LL,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_CANDLE_BEAR — cor do corpo da barra de baixa (também denominado como castiçal ou vela de baixa).
//+------------------------------------------------------------------+
//| 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_BE AR,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_BE AR,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_COLOR_BID — Cor de linha de preço de venda.
//+------------------------------------------------------------------+
//| 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,res ult))
{
//--- 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);
}



CHART_COLOR_ASK — Cor de linha de preço de compra.
//+------------------------------------------------------------------+
//| 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,res ult))
{
//--- 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);
}



CHART_COLOR_LAST — cor de linha do último preço de operação executada.
//+----------------------------------------------------------------------+
//| 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,re sult))
{
//--- 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);
}



CHART_COLOR_STOP_LEVEL — cor de níveis de ordem de stop (Stop Loss e Take Profit).
//+--------------------------------------------------------------------+
//| 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_LEVE L,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_LEVE L,clr))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_SHOW_TRADE_LEVELS — propriedade de exibição de níveis de negociação no gráfico (níveis de abertura de posição, Stop Loss, Take Profit e ordens pendentes.
//+---------------------------------------------------------------------+
//| 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_LEVE LS,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_LEVE LS,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);
}



CHART_DRAG_TRADE_LEVELS — propriedade de habilitar a capacidade de arrastar os níveis de negociação no gráfico usando o mouse.
//+---------------------------------------------------------------------------+
//| 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_LEVE LS,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_LEVE LS,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);
}



CHART_SHOW_DATE_SCALE — propriedade de exibição da escala de tempo em um gráfico.
//+--------------------------------------------------------------------+
//| 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);
}



CHART_SHOW_PRICE_SCALE — propriedade de mostrar a escala de preços no gráfico.
//+--------------------------------------------------------------------+
//| 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_SCAL E,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_SCAL E,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);
}

[jssuser]

CHART_SHOW_ONE_CLICK — Propriedade de exibição do painel "negociar à um clique" num gráfico.
//+------------------------------------------------------------------+
//| 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);
}



CHART_SHIFT_SIZE — o tamanho da barra zero encaixada a partir da borda direita em porcentagens.
//+---------------------------------------------------------------------------+
//| 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,res ult))
{
//--- 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);
}



CHART_FIXED_POSITION — posição fixa do gráfico a partir da borda esquerda em valor percentual.
//+--------------------------------------------------------------------------+
//| 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,v alue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_FIXED_MAX — propriedade para fixação máxima do gráfico.
//+------------------------------------------------------------------+
//| 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,resu lt))
{
//--- 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);
}



CHART_FIXED_MIN — propriedade para fixação mínima do gráfico.
//+------------------------------------------------------------------+
//| 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,resu lt))
{
//--- 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);
}



CHART_POINTS_PER_BAR — valor da escala em pontos por barra.
//+---------------------------------------------------------------------------+
//| 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,v alue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_PRICE_MIN retorna o valor do mínimo do gráfico.
//+---------------------------------------------------------------------------------+
//| 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_wi ndow,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);
}



CHART_PRICE_MAX retorna o valor do máximo do gráfico.
//+--------------------------------------------------------------------------------+
//| 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_wi ndow,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);
}



CHART_COMMENT — comentar sobre o gráfico.
//+----------------------------------------------------------------------+
//| 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);
}



CHART_IS_MAXIMIZED — janela do gráfico maximizada
//+------------------------------------------------------------------+
//| 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);
}




CHART_IS_MINIMIZED — janela de gráfico minimizada
//+------------------------------------------------------------------+
//| função determina se a janela do gráfica está minimizada |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
{
//--- preparamos a variável para obter o valor da propriedade
long value;
//--- restauramos o valor de erro
ResetLastError();
//--- obtemos o valor da propriedade
if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
{
//--- 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);
}

[jssuser]

CHART_SHOW_ONE_CLICK — Propriedade de exibição do painel "negociar à um clique" num gráfico.
//+------------------------------------------------------------------+
//| 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);
}



CHART_SHIFT_SIZE — o tamanho da barra zero encaixada a partir da borda direita em porcentagens.
//+---------------------------------------------------------------------------+
//| 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,res ult))
{
//--- 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);
}



CHART_FIXED_POSITION — posição fixa do gráfico a partir da borda esquerda em valor percentual.
//+--------------------------------------------------------------------------+
//| 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,v alue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_FIXED_MAX — propriedade para fixação máxima do gráfico.
//+------------------------------------------------------------------+
//| 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,resu lt))
{
//--- 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);
}



CHART_FIXED_MIN — propriedade para fixação mínima do gráfico.
//+------------------------------------------------------------------+
//| 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,resu lt))
{
//--- 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);
}



CHART_POINTS_PER_BAR — valor da escala em pontos por barra.
//+---------------------------------------------------------------------------+
//| 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,v alue))
{
//--- exibe uma mensagem para o diário Experts
Print(__FUNCTION__+", Código de erro = ",GetLastError());
return(false);
}
//--- sucesso na execução
return(true);
}



CHART_PRICE_MIN retorna o valor do mínimo do gráfico.
//+---------------------------------------------------------------------------------+
//| 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_wi ndow,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);
}



CHART_PRICE_MAX retorna o valor do máximo do gráfico.
//+--------------------------------------------------------------------------------+
//| 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_wi ndow,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);
}



CHART_COMMENT — comentar sobre o gráfico.
//+----------------------------------------------------------------------+
//| 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);
}



CHART_IS_MAXIMIZED — janela do gráfico maximizada
//+------------------------------------------------------------------+
//| 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);
}




CHART_IS_MINIMIZED — janela de gráfico minimizada
//+------------------------------------------------------------------+
//| função determina se a janela do gráfica está minimizada |
//+------------------------------------------------------------------+
bool ChartWindowsIsMinimized(bool &result,const long chart_ID=0)
{
//--- preparamos a variável para obter o valor da propriedade
long value;
//--- restauramos o valor de erro
ResetLastError();
//--- obtemos o valor da propriedade
if(!ChartGetInteger(chart_ID,CHART_IS_MINIMIZED))
{
//--- 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);
}

[jssuser]

Painel para propriedades do gráfico

//--- conectar a biblioteca de elementos de controle
#include <ChartObjects\ChartObjectsTxtControls.mqh>
//--- constantes predefinidas
#define X_PROPERTY_NAME_1 10 // x coordenadas do nome da propriedade na primeira coluna
#define X_PROPERTY_VALUE_1 225 // x coordenadas do valor da propriedade na primeira coluna
#define X_PROPERTY_NAME_2 345 // x coordenadas do nome da propriedade na segunda e terceira colunas
#define X_PROPERTY_VALUE_2 550 // x coordenadas do valor da propriedade na segunda e terceira coluna
#define X_BUTTON_1 285 // x coordenadas do botão na primeira coluna
#define X_BUTTON_2 700 // x coordenadas do botão na segunda coluna
#define Y_PROPERTY_1 30 // y coordenadas do do início da primeira e segunda coluna
#define Y_PROPERTY_2 286 // y coordenadas do início da terceira coluna
#define Y_DISTANCE 16 // eixo y da distância entre as linhas
#define LAST_PROPERTY_NUMBER 111 // número da última propriedade gráfica
//--- parâmetros de entrada
input color InpFirstColor=clrDodgerBlue; // Cor de linhas ímpares
input color InpSecondColor=clrGoldenrod; // Cor de linhas pares
//--- variáveis ​​e arrays
CChartObjectLabel ExtLabelsName[]; // etiquetas para exibir nomes das propriedades
CChartObjectLabel ExtLabelsValue[]; // etiquetas para exibição dos valores da propriedade
CChartObjectButton ExtButtons[]; // botões
int ExtNumbers[]; // índices das propriedades
string ExtNames[]; // nomes das propriedades
uchar ExtDataTypes[]; // tipos de dados de propriedade (integer, double, string)
uint ExtGroupTypes[]; // array que armazena os dados de propriedades pertencente a um dos grupos
uchar ExtDrawTypes[]; // array que armazena os dados sobre o tipo de exibição da propriedade
double ExtMaxValue[]; // valores máximos possíveis das propriedades para se trabalhar com painel
double ExtMinValue[]; // valores mínimos possíveis das propriedades para se trabalhar com painel
double ExtStep[]; // passos para alterar as propriedades
int ExtCount; // número total de todas as propriedades
color ExtColors[2]; // array de cores para exibição das linhas
string ExtComments[2]; // array de comentários (para propriedade CHART_COMMENT)
//+------------------------------------------------------------------+
//| Função de inicialização do indicador customizado |
//+------------------------------------------------------------------+
int OnInit()
{
//--- exibir a comentário no gráfico
Comment("SomeComment");
//--- armazenam cores no array para alternarem entre eles mais tarde
ExtColors[0]=InpFirstColor;
ExtColors[1]=InpSecondColor;
//--- armazenam comentários no array para alternarem entre eles mais tarde
ExtComments[0]="FirstComment";
ExtComments[1]="SecondComment";
//--- preparar e exibir o painel de controle para o gerenciamento das propriedades do gráfico
if(!PrepareControls())
return(INIT_FAILED);
//--- sucesso na execução
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Função de finalização do expert |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//--- remover o comentário no gráfico
Comment("");
}
//+------------------------------------------------------------------+
//| Manipular eventos de um gráfico |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam)
{
//--- verificar o evento clicando no objeto do gráfico
if(id==CHARTEVENT_OBJECT_CLICK)
{
//--- divide o nome do objeto pelo separador
string obj_name[];
StringSplit(sparam,'_',obj_name);
//--- verifica se o objeto é um botão
if(obj_name[0]=="Button")
{
//--- receber índice de botão
int index=(int)StringToInteger(obj_name[1]);
//--- desfazer pressionando o botão
ExtButtons[index].State(false);
//--- definir o novo valor da propriedade dependendo do seu tipo
if(ExtDataTypes[index]=='I')
ChangeIntegerProperty(index);
if(ExtDataTypes[index]=='D')
ChangeDoubleProperty(index);
if(ExtDataTypes[index]=='S')
ChangeStringProperty(index);
}
}
//--- re-desenhar valores de propriedades
RedrawProperties();
ChartRedraw();
}
//+------------------------------------------------------------------+
//| Alterar a propriedade inteira do gráfico |
//+------------------------------------------------------------------+
void ChangeIntegerProperty(const int index)
{
//--- receber o valor atual da propriedade
long value=ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEG ER)ExtNumbers[index]);
//--- definir o seguinte valor da propriedade
switch(ExtDrawTypes[index])
{
case 'C':
value=GetNextColor((color)value);
break;
default:
value=(long)GetNextValue((double)value,index);
break;
}
//--- definir o novo valor de propriedade
ChartSetInteger(0,(ENUM_CHART_PROPERTY_INTEGER)Ext Numbers[index],0,value);
}
//+------------------------------------------------------------------+
//| Alterar a propriedade double do gráfico |
//+------------------------------------------------------------------+
void ChangeDoubleProperty(const int index)
{
//--- receber o valor atual da propriedade
double value=ChartGetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE )ExtNumbers[index]);
//--- definir o seguinte valor da propriedade
value=GetNextValue(value,index);
//--- definir o novo valor de propriedade
ChartSetDouble(0,(ENUM_CHART_PROPERTY_DOUBLE)ExtNu mbers[index],value);
}
//+------------------------------------------------------------------+
//| Alterar a propriedade string do gráfico |
//+------------------------------------------------------------------+
void ChangeStringProperty(const int index)
{
//--- variável estática para comutação dentro do array ExtComments
static uint comment_index=1;
//--- alterar o índice para receber outro comentário
comment_index=1-comment_index;
//--- definir o novo valor de propriedade
ChartSetString(0,(ENUM_CHART_PROPERTY_STRING)ExtNu mbers[index],ExtComments[comment_index]);
}
//+------------------------------------------------------------------+
//| Definir o próximos valor da propriedade |
//+------------------------------------------------------------------+
double GetNextValue(const double value,const int index)
{
if(value+ExtStep[index]<=ExtMaxValue[index])
return(value+ExtStep[index]);
else
return(ExtMinValue[index]);
}
//+------------------------------------------------------------------+
//| Receber a próxima cor para a propriedade tipo color |
//+------------------------------------------------------------------+
color GetNextColor(const color clr)
{
//--- retornar o seguinte valor de cor
switch(clr)
{
case clrWhite: return(clrRed);
case clrRed: return(clrGreen);
case clrGreen: return(clrBlue);
case clrBlue: return(clrBlack);
default: return(clrWhite);
}
}
//+------------------------------------------------------------------+
//| Re-desenhar valores de propriedades |
//+------------------------------------------------------------------+
void RedrawProperties(void)
{
//--- texto de valor da propriedade
string text;
long value;
//--- loop do número de propriedades
for(int i=0;i<ExtCount;i++)
{
text="";
switch(ExtDataTypes[i])
{
case 'I':
//--- receber o valor atual da propriedade
if(!ChartGetInteger(0,(ENUM_CHART_PROPERTY_INTEGER )ExtNumbers[i],0,value))
break;
//--- texto de propriedade inteiro
switch(ExtDrawTypes[i])
{
//--- propriedade color
case 'C':
text=(string)((color)value);
break;
//--- propriedade boolean
case 'B':
text=(string)((bool)value);
break;
//--- propriedade do enumerador ENUM_CHART_MODE
case 'M':
text=EnumToString((ENUM_CHART_MODE)value);
break;
//--- propriedade do enumerador ENUM_CHART_VOLUME_MODE
case 'V':
text=EnumToString((ENUM_CHART_VOLUME_MODE)value);
break;
//--- número tipo int
default:
text=IntegerToString(value);
break;
}
break;
case 'D':
//--- texto de propriedade double
text=DoubleToString(ChartGetDouble(0,(ENUM_CHART_P ROPERTY_DOUBLE)ExtNumbers[i]),4);
break;
case 'S':
//--- texto de propriedade string
text=ChartGetString(0,(ENUM_CHART_PROPERTY_STRING) ExtNumbers[i]);
break;
}
//--- mostrar valor de propriedade
ExtLabelsValue[i].Description(text);
}
}
//+------------------------------------------------------------------+
//| Criar o painel para o gerenciamento das propriedades do gráfico |
//+------------------------------------------------------------------+
bool PrepareControls(void)
{
//--- alocar memória para arrays com uma reserva
MemoryAllocation(LAST_PROPERTY_NUMBER+1);
//--- variáveis
int i=0; // loop variável
int col_1=0; // número de propriedades na primeira coluna
int col_2=0; // número de propriedade na segunda coluna
int col_3=0; // múmero de propriedade na terceira coluna
//--- número atual de propriedades - 0
ExtCount=0;
//--- observando propriedades no loop
while(i<=LAST_PROPERTY_NUMBER)
{
//--- armazenar o número atual de propriedades
ExtNumbers[ExtCount]=i;
//--- incrementar o valor da variável do loop
i++;
//--- verificar se existe uma propriedade com tal número
if(CheckNumber(ExtNumbers[ExtCount],ExtNames[ExtCount],ExtDataTypes[ExtCount],ExtGroupTypes[ExtCount],ExtDrawTypes[ExtCount]))
{
//--- criar elementos de controle para a propriedade
switch(ExtGroupTypes[ExtCount])
{
case 1:
//--- criar etiquetas e um botão para a propriedade
if(!ShowProperty(ExtCount,0,X_PROPERTY_NAME_1,X_PR OPERTY_VALUE_1,X_BUTTON_1,Y_PROPERTY_1+col_1*Y_DIS TANCE,true))
return(false);
//--- número de elementos na primeira coluna foi incrementado
col_1++;
break;
case 2:
//--- criar etiquetas e um botão para a propriedade
if(!ShowProperty(ExtCount,1,X_PROPERTY_NAME_2,X_PR OPERTY_VALUE_2,X_BUTTON_2,Y_PROPERTY_1+col_2*Y_DIS TANCE,true))
return(false);
//--- número de elementos na segunda coluna foi incrementado
col_2++;
break;
case 3:
//--- criar apenas etiquetas para a propriedade
if(!ShowProperty(ExtCount,2,X_PROPERTY_NAME_2,X_PR OPERTY_VALUE_2,0,Y_PROPERTY_2+col_3*Y_DISTANCE,fal se))
return(false);
//--- número de elementos na terceira coluna foi incrementado
col_3++;
break;
}
//--- definir o máximo e o mínimo do valor e da etapa da propriedade
GetMaxMinStep(ExtNumbers[ExtCount],ExtMaxValue[ExtCount],ExtMinValue[ExtCount],ExtStep[ExtCount]);
//--- incrementar o número de propriedades
ExtCount++;
}
}
//--- liberar a memória não usada pelos arrays
MemoryAllocation(ExtCount);
//--- re-desenhar valores de propriedades
RedrawProperties();
ChartRedraw();
//--- sucesso na execução
return(true);
}
//+------------------------------------------------------------------+
//| Alocar memória para os 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);
}
//+------------------------------------------------------------------+
//| Verificar se o índice de propriedade pertence a um de |
//| enumerador ENUM_CHART_PROPERTIES |
//+------------------------------------------------------------------+
bool CheckNumber(const int ind,string &name,uchar &data_type,uint &group_type,uchar &draw_type)
{
//--- verificar se a propriedade é do tipo integer
ResetLastError();
name=EnumToString((ENUM_CHART_PROPERTY_INTEGER)ind );
if(_LastError==0)
{
data_type='I'; // propriedade do enumerador ENUM_CHART_PROPERTY_INTEGER
GetTypes(ind,group_type,draw_type); // definir parâmetros da propriedade display
return(true);
}
//--- verificar se a propriedade é do tipo double
ResetLastError();
name=EnumToString((ENUM_CHART_PROPERTY_DOUBLE)ind) ;
if(_LastError==0)
{
data_type='D'; // propriedade do enumerador ENUM_CHART_PROPERTY_DOUBLE
GetTypes(ind,group_type,draw_type); // definir parâmetros da propriedade display
return(true);
}
//--- verificar se a proprieade é do tipo string
ResetLastError();
name=EnumToString((ENUM_CHART_PROPERTY_STRING)ind) ;
if(_LastError==0)
{
data_type='S'; // propriedade do enumerador ENUM_CHART_PROPERTY_STRING
GetTypes(ind,group_type,draw_type); // definir parâmetros da propriedade display
return(true);
}
//--- propriedade não pertence a qualquer enumeração
return(false);
}
//+------------------------------------------------------------------+
//| Definir o grupo que a propriedade será armazenada em |
//| bem como seu tipo de exibição |
//+------------------------------------------------------------------+
void GetTypes(const int property_number,uint &group_type,uchar &draw_type)
{
//--- verificar se a propriedade pertence ao terceiro grupo
//--- propriedades terceiro grupo são apresentados na segunda coluna, a partir de CHART_BRING_TO_TOP
if(CheckThirdGroup(property_number,group_type,draw _type))
return;
//--- verificar se a propriedade pertence ao segundo grupo
//--- propriedades segundo grupo são apresentados no início da segunda coluna
if(CheckSecondGroup(property_number,group_type,dra w_type))
return;
//--- se você está aqui, a propriedade pertence ao primeiro grupo (primeira coluna)
CheckFirstGroup(property_number,group_type,draw_ty pe);
}
//+----------------------------------------------------------------------+
//| A função verifica se a propriedade pertence ao terceiro grupo e |
//| define o seu tipo display no caso de uma resposta positiva |
//+----------------------------------------------------------------------+
bool CheckThirdGroup(const int property_number,uint &group_type,uchar &draw_type)
{
//--- verificar se a propriedade pertence ao terceiro grupo
switch(property_number)
{
//--- propriedades boolean
case CHART_IS_OBJECT:
case CHART_WINDOW_IS_VISIBLE:
draw_type='B';
break;
//--- propriedades inteiro
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;
//--- propriedades double
case CHART_PRICE_MIN:
case CHART_PRICE_MAX:
draw_type='D';
break;
//--- na verdade, esta propriedade é um comando para exibir o gráfico em cima de todos os outros
//--- não há necessidade de aplicar este painel, como a janela sempre será
//--- em cima das outras antes de a usarmos
case CHART_BRING_TO_TOP:
draw_type=' ';
break;
//--- propriedade não pertencem ao terceiro grupo
default:
return(false);
}
//--- propriedade pertencem ao terceiro grupo
group_type=3;
return(true);
}
//+----------------------------------------------------------------------+
//| A função verifica se a propriedade pertence ao segundo grupo e |
//| define o seu tipo display no caso de uma resposta positiva |
//+----------------------------------------------------------------------+
bool CheckSecondGroup(const int property_number,uint &group_type,uchar &draw_type)
{
//--- verificar se a propriedade pertence ao segundo grupo
switch(property_number)
{
//--- propriedade de tipo ENUM_CHART_MODE
case CHART_MODE:
draw_type='M';
break;
//--- propriedade de tipo ENUM_CHART_VOLUME_MODE
case CHART_SHOW_VOLUMES:
draw_type='V';
break;
//--- propriedade string
case CHART_COMMENT:
draw_type='S';
break;
//--- propriedade 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;
//--- propriedade não pertence ao segundo grupo
default:
return(false);
}
//--- propriedade pertence ao segundo grupo
group_type=2;
return(true);
}

[jssuser]

//+-----------------------------------------------------------------------+
//| Esta função é chamada apenas se ela já é conhecida |
//| a propriedade não é do segundo e terceiro grupos de propriedades |
//+-----------------------------------------------------------------------+
void CheckFirstGroup(const int property_number,uint &group_type,uchar &draw_type)
{
//--- a propriedade pertence ao primeiro grupo
group_type=1;
//--- definir a propriedade tipo display
switch(property_number)
{
//--- propriedades inteiro
case CHART_SCALE:
case CHART_HEIGHT_IN_PIXELS:
draw_type='I';
return;
//--- propriedades 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;
//--- ficaram apenas as propriedades boolean
default:
draw_type='B';
return;
}
}
//+------------------------------------------------------------------+
//| Criar uma etiqueta e um botão para a propriedade |
//+------------------------------------------------------------------+
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 comutar dentro do array de cor ExtColors
static uint color_index[3]={1,1,1};
//--- alterar o índice para receber uma outra cor
color_index[type]=1-color_index[type];
//--- etiquetas display e um botão (se btn = true) para a propriedade
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);
//--- sucesso na execução
return(true);
}
//+------------------------------------------------------------------+
//| criar um rótulo |
//+------------------------------------------------------------------+
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);
//--- sucesso na execução
return(true);
}
//+------------------------------------------------------------------+
//| Criar o botão |
//+------------------------------------------------------------------+
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("Próximo")) 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);
//--- sucesso na execução
return(true);
}
//+------------------------------------------------------------------+
//| Definir o máximo e o mínimo do valor e da etapa propriedade |
//+------------------------------------------------------------------+
void GetMaxMinStep(const int property_number,double &max,double &min,double &step)
{
double value;
//--- definir os valores dependendo do tipo de propriedade
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 padrão
default:
max=1;
min=0;
step=1;
}
}