Galeria de UIs escritas em MQL - página 16

Novo comentário
 
Nikolai Semko #:

Estou entendendo, Peter.
Obrigado. É claro que não é conveniente para um desenvolvedor.
Há muito código e movimentos desnecessários. Ainda assim, a variante com um ponteiro para uma função é muito melhor.

Por que é inconveniente? Você tentará e depois tirará suas conclusões))

1. O construtor imprime todos os manipuladores de elementos por si só, basta conectá-los.

2. o Intellisense fornece as funções necessárias, basta escolher.)))

3. Todas as regras são simples, não é difícil de lembrar.

Apenas o editor visual pode ser mais fácil, mas isso fica para depois.

P.S. Depois de um intervalo de 4 anos, concluí sua tarefa em 10 minutos. O resto do tempo eu estava tentando entender por que sua função não funcionava e depois estava filmando o gif. )))
 
Реter Konow #:
Por que é desconfortável? Você experimentará e depois tirará suas conclusões)).

1. Todos os manipuladores de elementos são impressos pelo próprio construtor, basta conectá-los.

2. O Intellisense fornece as funções necessárias, basta escolher uma.))

3. Todas as regras são simples e fáceis de memorizar.


Apenas o editor visual pode ser mais fácil, mas isso fica para depois.

P.S. Depois de um intervalo de 4 anos, concluí sua tarefa em 10 minutos. O resto do tempo eu estava tentando descobrir por que sua função não funcionava e depois fotografando o gif. )))

Vejo que o arquivo Internal_API.mqh que um desenvolvedor terá de escrever é bastante grande e complexo.



Quantas linhas de código haverá nele em uma tarefa como essa com um botão? É importante que um desenvolvedor desenvolva sua GUI da maneira usual, criando um objeto. Por exemplo, tenho uma tarefa como a seguinte:

#resource "//Images//eclipse-alt.png" as uchar eclipse_alt[] // загружаем в ресурс изображение иконки с файла png
#include  <My\IconsMenu.mqh>

//+------------------------------------------------------------------+
IconsMenu menu(5,15,1,ANCHOR_RIGHT_UPPER,true,27, CheckBox, 0x00EEEEEE); // создаем меню
//+------------------------------------------------------------------+
void TimerMenu() { // таймер необходим для всплывающей подсказки
   menu.Timer();
}
//+------------------------------------------------------------------+
int OnInit() {
   InitMenu();
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
}
//+------------------------------------------------------------------+
void OnTick() {
}
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam) {
   menu.ChartEvent(id,lparam,dparam,sparam);
}
//+------------------------------------------------------------------+
void InitMenu() {
   menu.SetTimerFunction(TimerMenu); // установка функции таймера
   bool dark_mode = W.Color!=0;      // определяем текущую цветовую схему чарта
   menu.AddPng(eclipse_alt,"dark/light theme",ChangeColorScheme,dark_mode); // создаем элемент кнопки-иконки
   menu.Draw();
}
//+------------------------------------------------------------------+
void ChangeColorScheme (bool checked) {
   struct ColorScheme {
      uint           background;
      uint           foreground;
      uint           grid;
      uint           bar;
      uint           bull;
      uint           bear;
      uint           volume;
   };
   static const ColorScheme c[2] = {{0x00000000,0x00DDAAAA,0x00804040,0x0000FF00,0x00000000,0x00FFFFFF,0x0032CD32},
      {0x00FFFFFF,0x00000000,0x00C0C0C0,0x00000000,0x00FFFFFF,0x00000000,0x00008000}
   };
   int clr_scheme = checked?1:0;

   if (checked) {
      menu.clr_off = 0x00606060;
      menu.clr_hover = 0x30808080;
   } else {
      menu.clr_off = 0x00EEEEEE;
      menu.clr_hover = 0x30FFFFFF;
   }
   menu.ChangeColorAll();
   menu.Draw();

   ChartSetInteger(0,CHART_COLOR_BACKGROUND,c[clr_scheme].background);
   ChartSetInteger(0,CHART_COLOR_FOREGROUND,c[clr_scheme].foreground);
   ChartSetInteger(0,CHART_COLOR_CHART_LINE,c[clr_scheme].bar);
   ChartSetInteger(0,CHART_COLOR_CHART_DOWN,c[clr_scheme].bar);
   ChartSetInteger(0,CHART_COLOR_CHART_UP,c[clr_scheme].bar);
   ChartSetInteger(0,CHART_COLOR_CANDLE_BULL,c[clr_scheme].bull);
   ChartSetInteger(0,CHART_COLOR_CANDLE_BEAR,c[clr_scheme].bear);
   ChartSetInteger(0,CHART_COLOR_GRID,c[clr_scheme].grid);
   ChartSetInteger(0,CHART_COLOR_VOLUME,c[clr_scheme].volume);
   ChartRedraw();
}

Tudo o que diz respeito à criação e à personalização da GUI está destacado em amarelo.
Você não precisa fazer mais nada. Cada novo elemento da GUI é uma linha de código + função de manipulador de eventos desse elemento.



Arquivos anexados:
SimplestGUI.mq5  7 kb
SimplestGUI.ex5  244 kb
 
Nikolai, eu já expliquei tudo.

1. O arquivo é impresso automaticamente ao salvar a GUI criada.

2. Ninguém o escreve especialmente.

3. Dentro do arquivo, há manipuladores prontos de controles que o usuário declarou na linguagem de marcação.

4.. Os manipuladores recebem eventos de interface do mecanismo.

5. O usuário apenas insere seu código nos manipuladores.

Isso é tudo. Não vou me repetir, desculpe.

 
Реter Konow controles que o usuário declarou na linguagem de marcação.

4.. Os manipuladores recebem eventos de interface do mecanismo.

5. O usuário só insere seu código nos manipuladores.

Isso é tudo. Não vou me repetir, desculpe.



OK, você não forneceu esse arquivo, por isso fiz suposições. Vamos aguardar a versão com todos os arquivos, para que possamos testá-la ao vivo.

 
Sobre a questão de quantas linhas de código.

Ao resolver seu problema, inseri duas linhas do intellisense no manipulador. Mostrado na figura. Escrevi apenas o nome das cores entre colchetes. E duas linhas de função (em vez das suas). Nada mais.
 
Estou "limpando" o código antes do lançamento, "reconstruindo" o mecanismo, removendo coisas desnecessárias (se eu conseguir encontrá-las) e, ao mesmo tempo, lembrando como tudo funcionava.

Em geral, vou colocá-lo no ar em breve.
 
Реter Konow # :
Estou "limpando" o código antes do lançamento, "reconstruindo" o mecanismo, removendo coisas desnecessárias (se eu conseguir encontrá-las) e, ao mesmo tempo, lembrando como tudo funcionava.

Em geral, vou colocá-lo no ar em breve.

Estou ansioso pelo seu lançamento, quero entender suas ideias de codificação.

 
Nikolai Semko # :

Peter, não estou entendendo você. Você não respondeu às perguntas.
É importante que os programadores saibam como interagir com sua GUI durante o trabalho.
Aqui está um exemplo de minha GUI. Cliquei no atalho do tema claro/escuro e esse evento acionou imediatamente a função para alterar as cores e as linhas do plano de fundo. Como você faz essa interação?


O que significa "O usuário NÃO interagirá (de forma alguma) com meu código . "?
O programador precisa interagir, não com o código, mas com os eventos que devem gerar esse código.

Afinal de contas, a GUI não é um programa separado e independente. Em última análise, a GUI deve interagir com o programa principal do desenvolvedor. Seja ele um indicador ou um EA.

A GUI que você mostra em suas fotos é incrível. Você pode nos dizer como conseguiu isso?

 
hini #:

Estou ansioso pelo seu lançamento, quero entender suas ideias de codificação.

Certo.

Vou fazer um pequeno esclarecimento sobre o lançamento. Após um intervalo de quatro anos, a versão mais recente do mecanismo foi perdida. Isso não foi descoberto imediatamente. A versão antiga está funcionando, mas requer uma atualização para a versão do construtor. Para isso, preciso me aprofundar bastante no código, que havia esquecido um pouco. No entanto, isso não é um grande problema e será concluído.

Devido ao atraso com o mecanismo, decidi que a versão será dividida em duas partes. Primeiro, mostrarei o construtor. Aqueles que desejarem poderão se familiarizar com a linguagem de marcação e escrever a GUI necessária. Depois de algum tempo, disponibilizarei ao público o mecanismo atualizado. Depois disso, ajudarei a conectar a GUI criada e ela funcionará em conjunto com Expert Advisors ou indicadores personalizados. Assim, todos aprenderão princípios simples de trabalho com a linguagem de marcação e métodos de conexão da interface com seus aplicativos.

É mais fácil fazer um lançamento em duas partes porque o construtor está quase pronto para ser lançado, e o mecanismo requer uma pequena modificação.

Bem, é claro, fornecerei exemplos de código de marcação e instruções adicionais para escrevê-lo junto com a liberação do construtor.

Aguarde no fim de semana).
 
Gostaria de acrescentar um esclarecimento ao que foi dito acima: após o lançamento do designer, aqueles que quiserem projetar sua GUI em tempo real diretamente do ME.

1. Para fazer isso, eles abrirão o arquivo de inclusão "KIB-source.mqh" da compilação da versão.

2. Eles o salvarão na pasta de indicadores e o compilarão depois disso.

3. Como resultado, ele verá um novo indicador chamado "KIB-source.ex5" nas ramificações do navegador MT5 e o lançará em um gráfico livre.

4. O usuário criará no navegador MQL5 a pasta\include\... para arquivos com código de marcação.

Por exemplo, MQL5\include\My_GUI\Project_1\.....

Nessa pasta, ele armazenará arquivos com a interface de seus projetos. Neles, ele também escreverá, editará, experimentará e projetará a interface do usuário no código de marcação.

5. É importante especificar que, ao trabalhar com a linguagem de marcação durante a construção da interface do usuário, o resultado é exibido no gráfico do MT5, onde o indicador "KIB-source.ex5" e o Expert Advisor (construtor) "KIB.ex5", que fornecerei na primeira versão, devem estar no mesmo gráfico. Ambos devem estar no mesmo gráfico.

Além disso (muito importante), durante a compilação do arquivo "KIB-source.mq5" aberto em paralelo no ME (junto com os arquivos do projeto da GUI personalizada), todo o código de marcação é enviado para o construtor no mesmo gráfico e ele reconstrói completamente a GUI. Isso leva de 200 ms a 1000 ms, dependendo do número de janelas e elementos na interface. E o usuário vê imediatamente o resultado das alterações feitas. Tudo acontece muito rapidamente e quase em tempo real - você faz alterações no código de marcação, compila o "KIB-source.mq5" e, em uma fração de segundo, vê o resultado no gráfico MT5. Portanto, é desejável trabalhar em dois monitores. O MT5 é aberto em um e o ME, no outro.

6. A conveniência da linguagem de marcação está em sua simplicidade e na capacidade de criar modelos de elementos e janelas que podem ser facilmente copiados entre janelas ou projetos.

7. Gostaria de acrescentar que o designer é de código aberto no arquivo. Portanto, o usuário terá as seguintes tarefas:

1. Abrir o arquivo.
2. Colocar a pasta KIB na pasta MQL5\include\.
3. Coloque o arquivo CONNECTION.mqh do arquivo na pasta MQL5\inlude\ (não o coloque em subpastas).
4. Coloque o arquivo KIB.mq5 na pasta MQL5\Experts\, abra-o no ME, compile-o e salve-o para que o Expert Advisor KIB.ex5 apareça no navegador MT5.
5. Carregue esse Expert Advisor no mesmo gráfico que o indicador KIB-source.mq5.
6. Depois disso, o arquivo do construtor KIB.mq5 no ME pode ser fechado. Ele não será mais necessário.


Tudo está pronto para funcionar.


1...91011121314151617181920212223...52
Novo comentário