Galeria de UIs escritas em MQL - página 69
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Há um repositório de alguma coisa (que, na minha opinião, dificilmente pode ser chamado de código-fonte ) e documentação
Foi adicionada a capacidade de alterar programaticamente a cor dos quadros de elementos e associá-los a valores de parâmetros. Esse é um indicador informativo e útil que ajuda a perceber rapidamente o nível de risco dos valores inseridos. Ele se mostrou prático e claro. Além disso, no caso de exceder os limites definidos, são exibidas janelas de aviso.
Alguns exemplos:
Amanhã, veremos isso com exemplos e código.
Antes de continuar com o tópico da implementação da proteção escalonada dos limites dos parâmetros e dos avisos ao usuário, devemos mencionar outro tópico que o precede diretamente. Ou seja, a predefinição de parâmetros.
Começarei com o que é bem conhecido: a maioria dos programas MQL tem variáveis da categoria de entrada. Elas são declaradas em nível global e são visíveis em uma única janela de configurações. A janela aparece no início do programa e, dentro dela, o usuário pode alterar os valores iniciais das variáveis "externas", se houver necessidade. Mas antes disso, o usuário inicializa as variáveis externas dentro do programa. A questão é que as predefinições do programa não são universais, e é por isso que há uma categoria de variáveis que exigem a possibilidade de configuração a cada inicialização. Sabe-se também que qualquer tentativa de acessar manualmente as variáveis externas durante a execução do programa é impossível e requer uma reinicialização. Com uma interface gráfica, essa necessidade é eliminada. As configurações do programa podem ser abertas em tempo de execução.
Entretanto, ainda há a mesma necessidade de definir valores iniciais para os parâmetros do programa no início.
Se tivermos uma interface gráfica , não faz sentido declarar variáveis do tipo de entrada, porque não precisamos mais da janela de configurações padrão , mas a essência continua a mesma. Em vez de variáveis de entrada, precisamos definir valores iniciais para os parâmetros dos controles.
Na inicialização do programa, devemos chamar alguma função que defina os valores iniciais para nossas próprias janelas, e não para a janela padrão. Como opção, isso pode ser feito no construtor KIB, no estágio de construção da interface, quando os valores V_CURRENT são definidos, ou os estados ON/OFF, etc., mas agora é possível inicializar os elementos de forma programática. Agora é possível combinar a inicialização de elementos no construtor e no programa.
Portanto, precisamos de uma função especial chamada de OnInit() para fazer esse trabalho.
O que exatamente essa função fará:
Como a função será chamada?
Eu a chamaria de Initialize(), mas qualquer pessoa pode criar sua própria variante.
Oprincipal é que essa função deve estar em qualquer Expert Advisor de interface. Ela pode ser comparada à função OnTick() de um Expert Advisor ou OnCalculate() de um indicador. É importante entender isso.
Que valor a função retornará?
A função terá o tipo void. Não há necessidade de retornar um valor. Quando chamada, ela abrirá as janelas necessárias, inicializará os parâmetros dos elementos e possivelmente predefinirá algumas propriedades. Isso é basicamente tudo. Teoricamente, é possível definir limites de parâmetros iniciais, mas acho que o controle de valores será implementado em uma função separada chamada em eventos de elementos do arquivo API e do timer. Provavelmente escreverei uma impressão das chamadas de controle na próxima versão.
*É importante levarem conta que, no momento, o conceito de Expert Advisors de interface está apenas sendo formado e muitas descobertas estão à nossa frente.
Aqui está um exemplo da função de inicialização de um Expert Advisor de interface no contexto do projeto de demonstração atual:
1. Chamada de função:
2. implementação da função:
Até o momento, vejo a estrutura da função da seguinte forma. Uma função muito simples. Ela abre janelas e envia os valores necessários para os parâmetros do elemento. É possível alterar a inicialização de elementos e a abertura de janelas em alguns lugares, porque a abertura de janelas mostrará imediatamente os valores necessários dos elementos sem redesenho adicional. No entanto, essas são questões menores.
Vamos então passar ao tópico principal: implementação da proteção passo a passo dos parâmetros.
14.Realização da proteção por etapas dos limites dos parâmetros:
//------------------------------------------------------------------------------------------------------------
Escrever a lógica de controle das configurações dentro dos limites predefinidos e criar um sistema de aviso:
//-----------------------------------------------------------------------------
Vamos prosseguir:
1. defina os valores iniciais dos parâmetros dos elementos selecionados e abra as janelas necessárias. Para fazer isso, vamos escrever a funçãoInitialise() e chamá-la na função _OnInit().
Resultado: As janelas necessárias são abertas e os valores iniciais são definidos para os elementos de destino.
2) Abra o arquivo API e escreva a conexão dos elementos. No caso de cada elemento, escreva chamadas e passe o valor para os outros elementos de destino na cadeia:
3. Teste a conexão:
Resultado: os valores dos elementos estão conectados como pretendido.
4. Escreva uma função para controlar os parâmetros do nosso grupo de elementos: void Risk_management_group_1().
Chame a função Risk_management_group_1() a partir da função _OnInit():
Resultado: funciona como pretendido, mas ao inserir um valor no campo de entrada, a janela de aviso não redefine o valor inserido quando aparece(requer aprimoramento).
(*Além disso, a configuração da cor do quadro foi adicionada na atualização, mas não está presente na versão atual).
A próxima tarefa é considerar o cancelamento dos parâmetros inseridos pressionando o botão "Cancel".
Essa é uma tarefa muito difícil, mas eu já a implementei parcialmente. Tentarei restaurar a funcionalidade anterior.
No último detalhamento, mostrei como aplicar a indicação colorida de risco e abrir janelas de bloqueio ao cruzar os limites dos parâmetros definidos. Entretanto, dois problemas que eu não esperava foram descobertos.
1. A função de gerenciamento de risco abre a primeira janela de aviso quando um nível perigoso é ultrapassado, mas se você mantiver o cursor pressionado sobre o elemento nesse momento, o valor continua a crescer e atinge o próximo nível condicional. - Crítico.
2. Quando o valor crítico é ultrapassado, a última janela de aviso é aberta, mas isso também não impede que o valor mude se o usuário continuar a manter pressionado o botão esquerdo do mouse.
3 Se o usuário soltar o botão do mouse e quiser fechar as janelas de aviso, ele não poderá fazê-lo. Mais precisamente, ele não poderá fechar as janelas de aviso. Para ser mais preciso, ele não pode. O motivo é que as duas janelas de bloqueio começam a bloquear uma à outra. Quando uma das janelas de bloqueio está aberta, ela pode ser facilmente fechada, mas quando duas janelas estão abertas ao mesmo tempo, nada mais na interface pode funcionar. O programa entra em um estado de estupor, embora ainda funcione.
A imagem abaixo mostra como isso aconteceu:
Em seguida, corrigi os problemas de travamento mútuo das janelas de configurações e agora as janelas não interferem umas nas outras. Elas executam a função de bloqueio juntas sem entrar em conflito umas com as outras.
Agora preciso fazer com que a janela de aviso interrompa automaticamente as alterações no valor do parâmetro, mesmo que o botão esquerdo do mouse seja pressionado e o item esteja ativo.