photo
+ Responder ao Tópico
Resultados de 1 a 9 de 9

Thread: Exemplos de como trabalhar com um gráfico

  1. #1 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0

    Exemplos de como trabalhar com um gráfico

    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.

    Name:  chart_properties_panel.png
Views: 320
Size:  60.8 KB

    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  2. #2 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  3. #3 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  4. #4 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  5. #5 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  6. #6 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  7. #7 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0

    Continuação

    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  8. #8 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    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);
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


  9. The Following User Says Thank You to jssuser For This Useful Post:

    Não registrado (1 )

  10. #9 Fechar a publicação
    Senior Member jssuser's Avatar jssuser's Avatar
    Data de afiliação
    Aug 2018
    Postagens
    1,503
    Obrigado
    209
    Agradecimentos 787 Tempos em 476 Postagens
    AssinarAssinar
    subscritar: 0
    //+-----------------------------------------------------------------------+
    //| 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;
    }
    }

    Though trading on financial markets involves high risk, it can still generate extra income in case you apply the right approach. By choosing a reliable broker such as InstaForex you get access to the international financial markets and open your way towards financial independence. You can sign up here.


+ Responder ao Tópico

Permissões de postagens

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts