Galleria di interfacce utente scritte in MQL - pagina 78

Nuovo commento
 
Реter Konow #:
Non è facile realizzare qualcosa di simile. )

Per quanto ne so, nella classe Ccanvas standard non c'è alcuna funzionalità per disegnare un gradiente di colore, come hai risolto il problema con un gradiente nella tua GUI?

Intendi gli effetti di luce? Beh, ho aggiunto la luce :D Come descritto, anche CCanvas è adattato solo nelle sue basi e nella sua struttura, non nei suoi dettagli. 

//+------------------------------------------------------------------+
//| 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 #: Intendi gli effetti di luce? Beh, luce aggiunta :D Come detto, anche CCanvas è adattato solo nelle basi e nella struttura, ma non nei dettagli.
Capisco, grazie. )
 
Реter Konow #:
Capisco, grazie. )

Sentiti libero di usarlo :)
PS: l'updown è in realtà inutile, come vedo. Comunque, la luce viene dall'alto di solito

 
Doerk Hilger #:

Sentitevi liberi di usarlo :)
PS: l'updown è in realtà inutile, per quanto ne so. In ogni caso, la luce di solito proviene dall'alto.

Sì, hai un'opzione interessante, la proverò :)

La distribuzione della luce funziona al contrario: da un determinato colore originale a uno più chiaro. Mi spiego: l'algoritmo di suddivisione dei colori funziona correttamente e scrive 256 tonalità nell'array. Cioè l'intera gamma di colori accettata dalla funzione. Ma l'algoritmo di pittura inserisce il gradiente sulle superfici degli elementi solo in una direzione. Per molto tempo ho voluto aggiungere delle caratteristiche e realizzare un gradiente multidirezionale, che desse volume ed elementi piani complessi. In linea di principio, questo non è un compito difficile. Tuttavia, ci sono molti compiti più importanti da svolgere).

 
amico, se riesci a capire come utilizzare la GUI durante il backtesting del tuo EA, te ne sarei grato.
 
Реter Konow #:
Non è una cosa facile da fare. )

Per quanto ne so, non esiste una funzionalità nella classe Ccanvas standard per disegnare un gradiente di colore, come avete risolto il problema con un gradiente nella vostra GUI?
È tutto risolto con formule nel codice
File:
IMG_20240927_195954.jpg  3746 kb
 
Yu Zhang backtesting del tuo EA, te ne sarei grato.

Non c'è niente di più facile.

Il nucleo descritto gestisce TUTTI gli eventi, non importa se si tratta di un tick o di un evento grafico. Si può semplicemente ottenere la posizione del mouse ecc. anche in un tick, controllare le modifiche e poi lanciare l'OnEACylce() per l'evento grafico. Non si è più vincolati a nulla.

 
Domani pubblicherò un aggiornamento dettagliato sullo stato di sviluppo.

Oggi posso dire che sono state gettate due delle 6 fondamenta dell'editor.
 

Stato di sviluppo attuale:

1. È stato fatto molto lavoro per integrare centinaia di proprietà di oggetti, elementi, finestre e parametri in schede e tabelle dell'editor. È stato necessario separarle e ordinarle. Circa il 70% di questo compito è stato completato. Non tutte queste proprietà saranno necessarie agli utenti nel loro lavoro, ma mi servono per l'ulteriore sviluppo dell'editor.

2- Il meccanismo di scorrimento è stato messo a punto. Ora ogni scheda "ricorda" la posizione del cursore e quando si torna indietro la tela viene automaticamente fatta scorrere fino all'ultimo punto di visualizzazione.

3. Sono stati corretti i ritardi legati allo scorrimento. Ad esempio, durante lo scorrimento con la rotellina del mouse, gli elementi interattivi non reagiscono al cursore alla soglia di velocità specificata. Se la velocità di arrivo degli eventi della rotella è superiore a 3 al secondo (300 ms tra gli eventi), gli elementi che cadono sotto il cursore non vengono ridisegnati. Inoltre, ora solo lo spazio della striscia e i suoi componenti vengono disegnati durante lo scorrimento. Il resto dello spazio della tela non viene ignorato.

4. Il lavoro degli elementi T_FOLDER - collassatori di tabelle - è stato regolato. È possibile vederlo chiaramente nel video.

5. Trovati e risolti problemi con il fenomeno degli elementi.

6. Il design della sottofinestra dell'editor è stato pensato meglio. Sono state trovate soluzioni comode ed estetiche. Tuttavia, c'è ancora molto lavoro da fare in questa direzione.


I progetti più vicini:

1. Scrivere le funzioni Get_property() e Set_property(). Permetteranno di modificare le istanze copiate dai modelli. La prima funzione otterrà tutte le proprietà (più di 300) di ogni elemento in una volta sola e le metterà negli elementi di modifica nelle schede dell'editor (quelle nel video). La seconda funzione invierà i valori personalizzati dall'elemento dell'editor alla proprietà dell'istanza modificabile sul canvas principale (al centro).

2. Ripristinare la funzionalità di modifica manuale degli elementi che funzionava bene 4 anni fa.


 
Oggi è il 21 dicembre. Mi aspettavo che la versione minima dell'editor sarebbe stata pronta nei dieci giorni di dicembre, cioè prima del 20, e in linea di principio sarebbe andata così se avessi ripristinato la precedente versione minima che funzionava prima, ma ho deciso di creare una versione completa dell'editor. Ecco perché c'è stato molto più lavoro del previsto.

Prima ho parlato delle 6 basi di un editor visuale. Permettetemi di ricordarle:

1. Clonazione di elementi/finestre.

Creare nuove istanze di elementi copiando i modelli e modificandone le proprietà.

2. Eliminazione di elementi/finestre.

Cancellazione delle istanze precedentemente clonate dal nucleo.


3. Recupero delle proprietà di finestre/elementi.

Gli elementi dell'editor delle proprietà devono recuperare i valori delle proprietà delle istanze che rientrano nel focus di modifica.

4. Modifica delle proprietà di elementi/finestre.

Esistono due modi per modificare le proprietà in totale: (1) tramite gli editor di elementi e (2) la modifica manuale delle istanze. Ad esempio, increspatura, spostamento, stampa sulla superficie x, ecc.


5. Caricamento di modelli/progetti.

Funzionalità che consente di caricare modelli e progetti salvati all'interno dell'editor per ulteriori modifiche.

6. Salvataggio di modelli/progetti.

Funzionalità che salva i modelli e i progetti GUI finiti in file per trasferirli successivamente a programmi personalizzati o per utilizzarli come versioni beta e ricaricarli per modificare o copiare parti.

In generale, queste sono le sei basi di un editor visuale.

Come settima base, aggiungerei l'interfaccia grafica dell'editor, senza la quale non può funzionare.


Prima del nuovo anno, prevedo di implementare la clonazione, la cancellazione e l'editing visuale sia con gli editor di elementi che in modalità manuale. Vedremo cosa riuscirò a fare nel tempo.


1...71727374757677787980818283
Nuovo commento