Galeria de UIs escritas em MQL - página 65
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
Definiro statusON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK para diferentes elementos
Como obter o estado ligado/desligado de um botão?
Como obter o estado ligado/desligado do botão?
Esse é o próximo tópico. Vamos analisá-lo hoje.
Devo acrescentar que os elementos dessa GUI são desenhados, portanto, o método padrão de obter o estado ObjectGetInteger(0, "button1", OBJPROP_STATE); não funcionará.
Além disso, gostaria de lembrá-lo de que os eventos dos elementos, incluindo os botões, são enviados para o arquivo de API.
Uma lista geral de tópicos a serem considerados:
1. orientação na lista do intellisense e seleção da função da janela correta.
2. Abrir e fechar janelas de forma programática.
3. orientação na lista do intellisense e seleção do elemento certo na janela certa.
4. Navegar pelas listas de propriedades de elementos individuais.
5. Analisar o nome de uma função de elemento e janela.
6. Retorno do valor do parâmetro de um elemento selecionado para uma variável de seu tipo. Considerar três tipos de vários elementos diferentes.
7. Definir valores nos parâmetros de diferentes tipos de elementos. Vamos ver como os valores aparecerão nas janelas de interface desses elementos.
8. Retornar os valores dos parâmetros de um elemento, modificar e encaminhar esse valor para outro elemento. Considere diferentes tipos de elementos e valores e teste o encaminhamento entre diferentes tipos de elementos em diferentes janelas.
9. Retornar o valor anterior (_V_LAST). Quando e para quais casos o último valor é necessário (não confundir com o valor atual).
10. Teste a configuração dos estados ON/OFF/LOCK_ON/LOCK_OFF/LOCK/UNLOCK para diferentes tipos de elementos.
11. Vamos tentar vincular e sincronizar as alterações de valores de elementos de tipos diferentes: por exemplo, campo de entrada com botões e controle deslizante. Vamos supor que, quando o valor de um elemento (manual ou de software) for alterado, o valor do segundo elemento será alterado de forma correspondente.
12. Vamos tentar redefinir programaticamente os limites do intervalo do controle deslizante e do campo de entrada com botões por meio de funções de wrapper. Não tive tempo de testar isso, mas algo sugere que funcionará. No entanto, vamos ver.
13. Vamos tentar retornar os estados dos elementos por meio de funções de wrapper. Isso está incluído na funcionalidade, mas não tive tempo de testá-la. Então, vamos ver... O resultado é desconhecido.
14. Vamos obter e definir cores para texto e bases de elementos. Podemos tentar associar essas cores a alguns eventos simples ou limites de valores.
15. Vou lhe dizer mais sobre como navegar e ler a impressão do novo arquivo da API.
//------------------------------------------
Os tópicos que já abordamos estão destacados em amarelo.
Hoje vamos revisar:
11. Sincronização (vinculação) da alteração de valores de elementos de tipos diferentes: por exemplo, campo de entrada com botões e controle deslizante. Assim, ao alterar o valor de um elemento (manual ou de software), o valor do segundo elemento será alterado de forma correspondente.
12. Vamos tentar redefinir programaticamente os limites do intervalo do controle deslizante e do campo de entrada com botões por meio de funções de wrapper. Não tive tempo de testar isso, mas algo sugere que funcionará. No entanto, vamos ver.
13. Vamos tentar retornar os estados dos elementos por meio de funções de wrapper. Isso está incluído na funcionalidade, mas não tive tempo de testá-la. Então, vamos ver... O resultado é desconhecido.
11. Vinculação de parâmetros de elementos de tipos diferentes.
Uma pessoa atenta notou que, em uma GUI com várias janelas, diferentes elementos são frequentemente vinculados por valores de parâmetros, propriedades e estados. Por exemplo:
//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
Você pensaria que há uma conexão de elemento invisível acontecendo em algum lugar. E realmente existe. Mas ela é invisível apenas para um observador externo. Para um desenvolvedor, ela é bastante óbvia e hoje vamos analisá-la em detalhes.
1. A conexão de elementos tem dois lados:
A realização técnica das conexões é simplificada devido à presença de um mecanismo gráfico.
Deixe-me explicar:
Em um Expert Advisor convencional, cada parâmetro é inventado, nomeado, armazenado e processado pelo usuário. Esse é um trabalho de rotina que não pode ser contornado. Entretanto, no caso do uso de um mecanismo gráfico, os itens criados no construtor recebem automaticamente o parâmetro juntamente com o local de armazenamento e a função de processamento/retorno. Além disso, o usuário obtém suas propriedades, como tipo, intervalo, valor passado etc. Isso simplifica muito o trabalho. Teoricamente, é possível usar parâmetros prontos de elementos da GUI como outros parâmetros do usuário, vinculando-os diretamente à lógica de negociação. Por exemplo, lote, trailing stop, take profit e outros, não a partir de suas próprias variáveis, mas a partir dos campos de configuração responsáveis por seus valores.
Algumas conclusões gerais:
1. A presença de um controle gráfico em um programa = a presença de um parâmetro de programa pronto + suas propriedades + a função de retornar/definir o valor.
2. Quanto mais controles forem colocados nas janelas do programa de interface, mais parâmetros estarão envolvidos na lógica de negociação e na entrada/saída de informações de negociação.
3. quanto mais configurações e janelas, maior o controle e maior a largura de banda da saída de dados de mercado (sem prejuízo da automação).
4. Quanto maior o controle e maior a largura de banda da saída de dados do mercado, melhor será a percepção do trader.
5. Consciência multiplicada por automação e controle = aumento das oportunidades do trader.
Devo acrescentar que a automação muitas vezes se opõe ao controle manual. Dizem que ter uma interface gráfica significa negociação manual. Mas não é assim. A interface do software não exclui, mas expande a automação, acrescentando um "gradiente" a ela - ela abre três opções: controle manual, negociação semiautomática e modo autônomo.
Tudo o que o operador precisa fazer é selecionar uma opção.
É muito fácil criar uma janela para esse fim.
//---------------------------------------------------------------------------------------------------
2. Vamos passar para a implementação técnica dos parâmetros de vinculação dos controles.
Vamos considerar alguns exemplos práticos:
1. vamos abrir uma janela de configurações familiar:
2. abra o arquivo API e encontre os elementos da janela aberta dentro da função On_Gui_Event():
Lembrete: todos os eventos de controle entram na função On_Gui_Event();
Nesse sentido, escreveremos alguns dos links de parâmetros dentro dessa função e outros fora de seu corpo.
1. Vamos estabelecer uma conexão entre o campo com botões (S_EDIT) "Spin the value" e o controle deslizante (H_SLIDER) "Roll the value":
Resultado: alteramos o valor no campo com os botões e o controle deslizante se move sozinho.
(*Importante: o controle deslizante pode se mover somente dentro de seu intervalo (nesse caso, de 0 a 100). Se o intervalo for ultrapassado, o valor não será alterado, mas um erro será exibido no registro).
//----------------------------------------------------------------------------------------------------------------
3. Vamos fazer a inversão de papéis. O controle deslizante controlará o valor no campo de entrada:
Resultado: Ao mover a alça do controle deslizante, o campo com botões altera o valor de forma síncrona.
//----------------------------------------------------------------------------------------------------------------
4. Vamos escrever o controle mútuo do controle deslizante e do campo com botões um pelo outro:
Resultado: O controle deslizante e os campos de entrada controlam um ao outro simultaneamente.
//---------------------------------------------------------------------------------------------------
Amanhã publicarei a segunda parte desse tema com outros elementos.
Esse material é fantástico! Pretendo dar uma olhada neste tópico com mais detalhes quando tiver tempo. Eu achava que meu trabalho estava ultrapassando os limites da GUI do mt4, mas o seu trabalho é de outro nível.
Este é um material incrível! Pretendo explorar esse tópico com mais detalhes quando tiver tempo. Achei que meu trabalho estava ultrapassando os limites da GUI do mt4, mas o seu trabalho é de outro nível.
Muito obrigado por suas palavras gentis!
11. Parâmetros de vinculação de elementos de diferentes tipos.
Continuação do tópico.
Parte 2.
//--------------------------------------------------------------------------------------------------------------------------------
Vamos ver se podemos aplicar o método de vinculação mostrado a outros elementos. Por exemplo, a caixas de seleção.
1. Vamos fazer com que a caixa de seleção superior bloqueie e desbloqueie a caixa de seleção abaixo dela:
Para fazer isso:
1. Vamos localizar a caixa de seleção"Set an option" no arquivo API.
2. Escreva uma chamada de função para a caixa de seleção"Set another option" que deve bloquear/desbloquear.
Resultado: a caixa de seleção é bloqueada e desbloqueada como pretendido:
//--------------------------------------------------------------------------------------------------------------------------------
2) Agora, vamos fazer com que a caixa de seleção bloqueie e desbloqueie as duas caixas de seleção abaixo dela:
Resultado: a caixa de seleção bloqueia e desbloqueia as duas caixas de seleção abaixo dela:
Foi assim que aconteceu na dinâmica:
//--------------------------------------------------------------------------------------------------------------------------------
3. agora vamos resolver o problema mostrado no diagrama abaixo: as caixas de seleção devem bloquear e desbloquear as listas suspensas opostas a elas.
Para fazer isso:
Resultado: as caixas de seleção bloqueiam as listas suspensas e se bloqueiam com a caixa de seleção principal:
//--------------------------------------------------------------------------------------------------------------------------------
4. Vamos passar para a próxima tarefa: as listas suspensas devem traduzir o valor selecionado pelo usuário em um campo de outra janela.
Para fazer isso:
*Resultado: ambas as listas suspensas enviam com sucesso seus valores para os campos de entrada na janela oposta:
//--------------------------------------------------------------------------------------------------------------------------------
5. A seguinte tarefa é mostrada neste diagrama: Você precisa que os botões de opção que estão alternados enviem seus nomes para os campos de entrada opostos.
Para fazer isso:
*Observação importante: os botões de rádio são alternados porque o operador SWITCH foi aplicado a eles no código KIB. Portanto, eles têm um parâmetro comum para todos eles e estão no arquivo de API no mesmo caso.
Resultado: a alternância dos botões faz com que o texto no campo de entrada seja alterado. *Há um pequeno problema técnico com essa opção. Eleserá corrigido na próxima versão.
A segunda parte está concluída.
Na terceira parte, trabalharemos com a tabela.
A parte final do tópico de vinculação de parâmetros.
Vamos passar os valores dos parâmetros do elemento para as células da tabela.
Esquema:
Solução:
Resultado: os valores são colocados com segurança nas células da tabela selecionadas.
Como você pode ver nos exemplos acima, desenvolvemos uma solução simples e conveniente. Espero que ela seja útil para as pessoas.
Isso conclui o tópico de vinculação de parâmetros de elementos.
Os tópicos a seguir ainda precisam ser abordados:
12. Obter/definir programaticamente os limites de valor do controle deslizante e do campo de botão(_V_MIN, _V_MAX, _V_STEP, _DIGITS).
13. Consultar o status dos elementos(_GET_STATE).
14. Vinculação das cores do texto e do quadro aos limites de valores espaçados.
15. Orientação no arquivo API.
Adição de um tema:
16. Realização da lógica do programa de aparência das janelas de mensagem e aviso.