photo

Fórum Forex Brasil

Lugar da Comunidade Forex

+ 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 1,009 Tempos em 579 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: 336
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 1,009 Tempos em 579 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 1,009 Tempos em 579 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 1,009 Tempos em 579 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 1,009 Tempos em 579 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 1,009 Tempos em 579 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 1,009 Tempos em 579 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 1,009 Tempos em 579 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. #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 1,009 Tempos em 579 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