Galleria di interfacce utente scritte in MQL - pagina 16

Nuovo commento
 
Nikolai Semko #:

Capisco, Peter.
Grazie. Naturalmente non è conveniente per uno sviluppatore.
C'è un sacco di codice inutile e di movimenti. Tuttavia, la variante con un puntatore a una funzione è molto meglio.

Perché è scomodo? Provatelo e poi trarrete le vostre conclusioni)).

1. Il costruttore stampa da solo tutti i gestori di elementi, basta collegarli.

2. Intellisense fornisce le funzioni necessarie, basta scegliere)))

3. Tutte le regole sono semplici, non è difficile da ricordare.

Solo l'editor visuale potrebbe essere più semplice, ma questo sarà il seguito.

P.S. Dopo una pausa di 4 anni ho completato il vostro compito in 10 minuti. Il resto del tempo ho cercato di capire perché la tua funzione non funzionava, e poi ho girato la gif. )))
 
Реter Konow #:
Perché è scomodo? Lo proverete e poi trarrete le conclusioni)).

1. Tutti i gestori di elementi sono stampati dal costruttore stesso, basta inserirli.

2. Intellisense fornisce le funzioni necessarie, basta sceglierne una)).

3. Tutte le regole sono semplici e facili da memorizzare.


Solo l'editor visivo potrebbe essere più semplice, ma questo è un punto successivo.

P.S. Dopo una pausa di 4 anni, ho completato il vostro compito in 10 minuti. Il resto del tempo ho cercato di capire perché la tua funzione non funzionava, e poi ho girato la gif. )))

Vedo che il file Internal_API.mqh che uno sviluppatore dovrà scrivere è piuttosto grande e complesso.



Quante righe di codice ci saranno in un'attività con un solo pulsante? È importante che uno sviluppatore sviluppi la sua GUI nel modo consueto, creando un oggetto. Ad esempio, ho un'attività come la seguente:

#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();
}

Tutto ciò che riguarda la creazione e la personalizzazione della GUI è evidenziato in giallo.
Ogni nuovo elemento della GUI è costituito da una riga di codice + una funzione di gestione degli eventi di questo elemento.



File:
SimplestGUI.mq5  7 kb
SimplestGUI.ex5  244 kb
 
Nikolai, ho già spiegato tutto.

1. Il file viene stampato automaticamente quando si salva la GUI costruita.

2. Nessuno lo scrive appositamente.

3. All'interno del file sono pronti i gestori dei controlli che l'utente ha dichiarato nel linguaggio di markup.

4.. I gestori ricevono gli eventi dell'interfaccia dal motore.

5. L'utente inserisce solo il suo codice nei gestori.

Questo è tutto. Non mi ripeterò, scusate.

 
Реter Konow controlli che l'utente ha dichiarato nel linguaggio di markup.

4.. I gestori ricevono gli eventi dell'interfaccia dal motore.

5. L'utente inserisce il proprio codice solo nei gestori.

Questo è tutto. Non mi ripeterò, scusate.



Ok, non hai fornito questo file, per questo ho fatto delle supposizioni. Aspettiamo la versione con tutti i file, in modo da poterla testare dal vivo.

 
Riguardo alla domanda su quante righe di codice.

Quando ho risolto il vostro problema, ho inserito 2 righe da intellisense nel gestore. Mostrate nell'immagine. Ho scritto solo il nome dei colori tra parentesi. E due righe di funzione (al posto della tua). Nient'altro.
 
Sto "ripulendo" il codice prima del rilascio, "ricostruendo" il motore, eliminando le cose inutili (se riesco a trovarle), ricordando allo stesso tempo come funzionava tutto.

In generale, lo pubblicherò presto.
 
Реter Konow # :
Sto "ripulendo" il codice prima del rilascio, "ricostruendo" il motore, rimuovendo le cose inutili (se riesco a trovarle), ricordando allo stesso tempo come funzionava tutto.

In generale, lo pubblicherò presto.

Aspetto con ansia il tuo rilascio, voglio capire le tue idee di codifica.

 
Nikolai Semko # :

Peter, non ti capisco. Non hai risposto alle domande.
Per i programmatori è importante sapere come interagire con la propria GUI durante il lavoro.
Ecco un esempio della mia GUI. Ho fatto clic sulla scorciatoia del tema chiaro/scuro e questo evento ha immediatamente attivato la funzione per cambiare i colori dello sfondo e le linee. Come si realizza questa interazione?


Che cosa significa "L'utente NON interagirà (in alcun modo) con il mio codice " ? "?
Il programmatore deve interagire non con il codice, ma con gli eventi che dovrebbero generare il codice.

Dopo tutto, la GUI non è un programma indipendente e separato. La GUI deve interagire con il programma principale dello sviluppatore. Che si tratti di un indicatore o di un EA.

La GUI che mostrate nelle vostre immagini è fantastica, potete dirci come l'avete realizzata?

 
hini #:

Attendo con ansia il tuo rilascio, voglio capire le tue idee di codifica.

Ok.

Farò una piccola precisazione sul rilascio. Dopo una pausa di 4 anni, l'ultima versione del motore è andata persa. Non è stato scoperto subito. La vecchia versione funziona, ma richiede un aggiornamento alla versione del costruttore. Per questo devo andare abbastanza a fondo nel codice, che avevo un po' dimenticato. Tuttavia, non è un grosso problema e sarà completato.

A causa del ritardo con il motore, ho deciso che la release sarà divisa in due parti. In primo luogo, mostrerò il costruttore. Chi lo desidera potrà familiarizzare con il linguaggio di markup e scrivere la GUI necessaria. Dopo qualche tempo renderò pubblico il motore aggiornato. Successivamente, aiuterò a collegare la GUI creata e a farla funzionare con Expert Advisor o indicatori personalizzati. In questo modo tutti impareranno i semplici principi di lavoro con il linguaggio di markup e i metodi per collegare l'interfaccia alle loro applicazioni.

È più facile fare una release in due parti, perché il costruttore è quasi pronto per essere rilasciato e il motore richiede una piccola modifica.

Naturalmente, insieme al rilascio del costruttore, fornirò esempi di codice di markup e istruzioni aggiuntive per la sua scrittura.

Aspettate il fine settimana).
 
Vorrei aggiungere una precisazione a quanto detto sopra: dopo il rilascio del designer, chi vuole progettare la propria GUI al volo direttamente da ME.

1. Per farlo, apriranno il file di inclusione "KIB-source.mqh" dalla build di rilascio.

2. Lo salveranno nella cartella degli indicatori e lo compileranno successivamente.

3. Di conseguenza, vedranno un nuovo indicatore chiamato "KIB-source.ex5" nei rami del navigatore MT5 e lo lanceranno su un grafico libero.

4. L'utente creerà nel navigatore MQL5 una cartella "Include"... per i file con il codice di markup.

Ad esempio, MQL5\include\My_GUI\Project_1\.....

In questa cartella vengono memorizzati i file con l'interfaccia dei progetti. In essa scriverà, modificherà, sperimenterà e progetterà l'interfaccia utente sul codice di markup.

5. È importante specificare che mentre si lavora con il linguaggio di markup e si costruisce l'interfaccia utente, il risultato viene visualizzato sul grafico MT5, dove si trovano l'indicatore "KIB-source.ex5" e l'Expert Advisor (costruttore) "KIB.ex5", che fornirò nella prima versione. Dovrebbero trovarsi entrambi sullo stesso grafico.

Inoltre (molto importante), durante la compilazione del file "KIB-source.mq5" aperto in parallelo in ME (insieme ai file del progetto GUI personalizzato), tutto il codice di markup viene inviato al costruttore sullo stesso grafico e ricostruisce completamente la GUI. Ci vogliono da 200 a 1000 ms, a seconda del numero di finestre ed elementi dell'interfaccia. L'utente vede immediatamente il risultato delle modifiche apportate. Tutto avviene molto rapidamente e quasi in tempo reale: si apportano modifiche al codice di markup, si compila "KIB-source.mq5" e in una frazione di secondo si vede il risultato sul grafico MT5. Pertanto, è auspicabile lavorare su due monitor. MT5 è aperto su uno e ME sull'altro.

6. La comodità del linguaggio di markup sta nella sua semplicità e nella possibilità di creare modelli di elementi e finestre che possono essere facilmente copiati tra finestre o progetti.

7. Vorrei aggiungere che il designer è open source nell'archivio. Pertanto, l'utente dovrà svolgere le seguenti operazioni:

1. Aprire l'archivio.
2. Posizionare la cartella KIB nella cartella MQL5include.
3. Inserire il file CONNECTION.mqh dall'archivio nella cartella MQL5include (non inserirlo in sottocartelle).
4. Inserite il file KIB.mq5 nella cartella MQL5\Experts\, apritelo in ME, compilatelo e salvatelo in modo che l'Expert Advisor KIB.ex5 appaia nel navigatore MT5.
5. Caricare questo Expert Advisor sullo stesso grafico dell'indicatore KIB-source.mq5.
6. Successivamente, il file del costruttore KIB.mq5 in ME può essere chiuso. Non sarà più necessario.


Tutto è pronto per funzionare.


1...91011121314151617181920212223...58
Nuovo commento