Galeria de UIs escritas em MQL - página 78

Novo comentário
 
Реter Konow #:
Não é fácil fazer algo assim. )

Até onde eu sei, na classe Ccanvas padrão não há funcionalidade para desenhar um gradiente de cor. Como você resolveu o problema com um gradiente em sua GUI?

Você se refere aos efeitos de luz? Bem, adicionei luz :D Conforme descrito, o CCanvas também é adaptado apenas em seus fundamentos e em sua estrutura, não em seus detalhes. 

//+------------------------------------------------------------------+
//| Macro to generate color                                          |
//+------------------------------------------------------------------+
#define XRGB(r,g,b)    (0xFF000000|(uchar(r)<<16)|(uchar(g)<<8)|uchar(b))
#define ARGB(a,r,g,b)  ((uchar(a)<<24)|(uchar(r)<<16)|(uchar(g)<<8)|uchar(b))
#define TRGB(a,rgb)    ((uchar(a)<<24)|(rgb))
#define GETRGB(clr)    ((clr)&0xFFFFFF)
#define GETRGBA(clr)   uchar((clr)>>24)
#define GETRGBR(clr)   uchar((clr)>>16)
#define GETRGBG(clr)   uchar((clr)>>8)
#define GETRGBB(clr)   uchar(clr)
#define COLOR2RGB(clr) (0xFF000000|(uchar(clr)<<16)|(uchar((clr)>>8)<<8)|uchar((clr)>>16))
#define RGB2COLOR(rgb) ((uchar(rgb)<<16)|(uchar((rgb)>>8)<<8)|uchar((rgb)>>16))


//+------------------------------------------------------------------+
//| Add light to rectangular area                                    |
//+------------------------------------------------------------------+
void CCanvasExt::AddLight(int x1, int y1, int x2, int y2, bool updown=true, double intensity=.5, int isoftedge=20, color lightcolor=C'255,255,255')
   {
   if (intensity==0)
      return;
      
   int tmp;
//--- sort vertexes
   if(x2<x1)
     {
      tmp=x1;
      x1 =x2;
      x2 =tmp;
     }
   if(y2<y1)
     {
      tmp=y1;
      y1 =y2;
      y2 =tmp;
     }
//--- out of screen boundaries
   if(x2<0 || y2<0 || x1>=m_width || y1>=m_height)
      return;
//--- stay withing screen boundaries
   if(x1<0)
      x1=0;
   if(y1<0)
      y1=0;
   if(x2>=m_width)
      x2=m_width -1;
   if(y2>=m_height)
      y2=m_height-1;


//--- calculate softedge
   isoftedge=MIN(100,isoftedge);
   int softedge=isoftedge>0 ? isoftedge*(y2-y1)/100 : 0;

//--- correct height
   y2-=(y2-y1)/2;
   y2+=(softedge/2);
   y2++;
   y2=MIN(m_height-1,y2);   
   
//--- prepare 
   COLOR_RGBA rgb=_ColorLumaMult(lightcolor,ABS(intensity));
   double r=(int)GETRGBR(rgb);
   double g=(int)GETRGBG(rgb);
   double b=(int)GETRGBB(rgb);  
   
   if (intensity<0)
      {
      r=0-r;
      g=0-g;
      b=0-b;
      }
   uint pixel;     
   int istart;
   int iend;
   int i;

//--- check direction
   if (updown)
      {
   //--- add main light   
      for(;y1<y2-softedge;y1++)
         {
         istart=y1*m_width+x1;
         iend=istart+(x2-x1);
         for (i=istart;i<=iend;i++)
            {
            pixel=m_pixels[i];
            m_pixels[i]=ARGB(GETRGBA(pixel),MIN(GETRGBR(pixel)+r,0xFF),MIN(GETRGBG(pixel)+g,0xFF),MIN(GETRGBB(pixel)+b,0xFF));// m_pixels[i]+=XRGB(r,g,b);
            //m_pixels[i]|=rgb;
            }
         }
      if (softedge==0)
         return;
   
   //-- Add soft edge 
      double decr=r/softedge;
      double decg=g/softedge;
      double decb=b/softedge;
   
   //--- Loop rows separate and adjust color each row   
      for (;y1<=y2;y1++)
         {
         r-=decr; r=MAX(0,r); 
         g-=decg; g=MAX(0,g); 
         b-=decb; b=MAX(0,b); 
         
         istart=y1*m_width+x1;
         iend=istart+(x2-x1);
         for (i=istart;i<=iend;i++)
            {
            pixel=m_pixels[i];
            m_pixels[i]=ARGB(GETRGBA(pixel),MIN(GETRGBR(pixel)+r,0xFF),MIN(GETRGBG(pixel)+g,0xFF),MIN(GETRGBB(pixel)+b,0xFF));// m_pixels[i]+=XRGB(r,g,b);
            }
         }
      }   
  }  
 
Doerk Hilger #: Você está se referindo aos efeitos de iluminação? Bem, luz adicional :D Como dito, o CCanvas também é adaptado apenas no básico e na estrutura, mas não nos detalhes.
Entendo, obrigado. )
 
Реter Konow #:
Entendo, obrigado. )

Fique à vontade para usá-lo :)
PS: o updown é realmente inútil, pelo que vejo. De qualquer forma, a luz geralmente vem de cima

 
Doerk Hilger #:

Fique à vontade para usá-lo :)
PS: o updown é, na verdade, inútil, pelo que vejo. De qualquer forma, a luz geralmente vem de cima.

Sim, você tem uma opção interessante, vou tentar :)

Eu tenho a distribuição de luz funcionando de forma inversa - de uma determinada cor de origem para uma mais clara. Deixe-me explicar: o próprio algoritmo de particionamento de cores funciona corretamente e grava 256 tons na matriz. Esse é o intervalo completo para cada cor que a função aceita. Mas o algoritmo de pintura coloca o gradiente nas superfícies dos elementos somente em uma direção. Há muito tempo eu queria adicionar recursos e fazer gradiente multidirecional, o que daria volume e elementos planos complexos. Em princípio, essa não é uma tarefa difícil. No entanto, há muitas tarefas mais importantes pela frente).

 
Amigo, se você puder descobrir como usar a GUI ao fazer o backtesting do seu EA, eu ficaria muito grato.
 
Реter Konow #:
Não é uma coisa fácil de fazer. )

Até onde sei, não há funcionalidade na classe Ccanvas padrão para desenhar um gradiente de cor. Como você resolveu o problema com um gradiente em sua GUI?
Tudo isso é resolvido por fórmulas no código
Arquivos anexados:
IMG_20240927_195954.jpg  3746 kb
 
Yu Zhang fazer o backtesting do seu EA, eu ficaria muito grato.

Não há nada mais fácil do que isso.

O núcleo descrito gerencia TODOS os eventos, não importa se o evento é um tick ou um evento de gráfico. Você pode simplesmente obter a posição do mouse etc. também em um tick, verificar se há alterações e, em seguida, acionar o OnEACylce() para o evento de gráfico. Você não está mais restrito a nada.

 
Amanhã publicarei uma atualização detalhada do status do desenvolvimento.

Hoje posso dizer que duas das seis bases do editor foram estabelecidas.
 

Status de desenvolvimento atual:

1. Muito trabalho foi feito para integrar centenas de propriedades de objetos, elementos, janelas e parâmetros em guias e tabelas no editor. Foi necessário separá-las e classificá-las. Cerca de 70% dessa tarefa foi concluída. Nem todas essas propriedades serão necessárias para o trabalho dos usuários, mas eu preciso delas para continuar o desenvolvimento do editor.

2- O mecanismo de rolagem foi depurado. Agora cada guia "lembra" a posição do controle deslizante e, quando você retorna, a tela é automaticamente rolada para o último local de visualização.

3) Correção de atrasos relacionados à rolagem. Por exemplo, durante a rolagem com a roda do mouse, os elementos interativos não reagem ao cursor no limite de velocidade especificado. Se a taxa de chegada dos eventos da roda for superior a 3 por segundo (300 ms entre os eventos), os elementos que estiverem sob o cursor não serão redesenhados. Além disso, agora somente o espaço da faixa e seus componentes são desenhados durante a rolagem. O restante do espaço da tela não é ignorado.

4. O trabalho dos elementos T_FOLDER - colapsos de tabela - foi ajustado. Isso pode ser visto claramente no vídeo.

5. Foram encontrados e corrigidos problemas com o fenômeno dos elementos.

6. O design da subjanela do editor foi melhor pensado. Foram encontradas soluções convenientes e estéticas. No entanto, ainda há muito trabalho a ser feito nesse sentido.


Os planos mais próximos:

1. Escrever as funções Get_property() e Set_property(). Elas permitirão editar instâncias copiadas de modelos. A primeira função obterá todas as propriedades (mais de 300) de cada elemento de uma só vez e as colocará nos elementos de edição nas guias do editor (as do vídeo). A segunda função enviará valores personalizados do elemento do editor para a propriedade da instância editável na tela principal (no centro).

2. Restaurar a funcionalidade de edição manual de elementos que funcionava bem há 4 anos.


 
Hoje é dia 21 de dezembro. Eu esperava que a versão mínima do editor estivesse pronta nos dez dias de dezembro, ou seja, antes do dia 20, e, em princípio, teria sido assim se eu tivesse restaurado a versão mínima anterior que funcionava antes, mas decidi criar uma versão completa do editor. É por isso que houve muito mais trabalho do que o esperado.

Anteriormente, falei sobre os 6 princípios básicos de um editor visual. Vou relembrá-los:

1. Clonagem de elementos/janelas.

Criação de novas instâncias de elementos copiando modelos e modificando suas propriedades.

2. Exclusão de elementos/janelas.

Apagar instâncias previamente clonadas do núcleo.


3. Recuperação de propriedades de janelas/elementos.

Os elementos do editor de propriedades devem recuperar os valores de propriedade das instâncias que estão no foco de edição.

4. Edição de propriedades de elementos/janelas.

Há duas maneiras de editar propriedades no total: (1) por meio de editores de elementos e (2) edição manual de instâncias. Por exemplo, ondular, mover, imprimir na superfície x etc.


5. Carregamento de modelos/projetos.

Funcionalidade que permite carregar modelos e projetos salvos dentro do editor para edição posterior.

6. Salvamento de modelos/projetos.

Funcionalidade que salva modelos e projetos de GUI concluídos em arquivos para posterior transferência para programas personalizados ou para uso como versões beta e recarregamento para edição ou cópia de partes.

Em geral, esses são os seis princípios básicos de um editor visual.

Como sétimo fundamento, eu acrescentaria uma interface gráfica de editor sem a qual ele não pode funcionar.


Antes do Ano Novo, espero implementar a clonagem, a exclusão e a edição visual com editores de elementos e no modo manual. Veremos o que posso fazer com o tempo.


1...71727374757677787980818283
Novo comentário