Galleria di interfacce utente scritte in MQL - pagina 69
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
c'è un repository di qualcosa (che IMHO difficilmente può essere chiamato codice sorgente ) e la documentazione
Aggiunta la possibilità di modificare programmaticamente il colore delle cornici degli elementi e di associarle ai valori dei parametri. Si tratta di un indicatore informativo e utile che aiuta a rendersi conto rapidamente del livello di rischio dei valori inseriti. Si è rivelato pratico e chiaro. Inoltre, in caso di superamento dei limiti impostati, appaiono delle finestre di avviso.
Alcuni esempi:
Domani lo esamineremo con esempi e codice.
Prima di continuare con l'argomento dell'implementazione della protezione dei confini dei parametri scaglionati e delle avvertenze per l'utente, è necessario menzionare un altro argomento che lo precede direttamente. Si tratta della preimpostazione dei parametri.
Comincerò con il noto: la maggior parte dei programmi MQL ha variabili della categoria input. Esse sono dichiarate a livello globale e sono visibili in un'unica finestra di impostazione. La finestra appare all'inizio del programma e al suo interno l'utente può modificare i valori iniziali delle variabili "esterne", se necessario. Prima, però, l'utente inizializza le variabili esterne all'interno del programma. Il punto è che le preimpostazioni del programma non sono universali, ed è per questo che esiste una categoria di variabili che richiedono la possibilità di essere impostate a ogni avvio. È anche noto che qualsiasi tentativo di accedere manualmente alle variabili esterne durante l'esecuzione del programma è impossibile e richiede un riavvio. Con un'interfaccia grafica, questa necessità viene eliminata. Le impostazioni del programma possono essere aperte in fase di esecuzione.
Tuttavia, rimane la stessa necessità di impostare i valori iniziali dei parametri del programma all'inizio.
Se disponiamo di un'interfaccia grafica , non ha senso dichiarare variabili di tipo input, perché non abbiamo più bisogno della finestra delle impostazioni standard , ma l'essenza rimane la stessa: al posto delle variabili di input, dobbiamo impostare i valori iniziali dei parametri dei controlli.
All'inizializzazione del programma dovremmo chiamare una funzione che imposti i valori iniziali alle nostre finestre, non a quella standard. Come opzione, questo può essere fatto nel costruttore KIB, nella fase di costruzione dell'interfaccia, quando vengono impostati i valori V_CURRENT, o gli stati ON/OFF, eccetera, ma ora è possibile inizializzare gli elementi in modo programmatico. Ora è possibile combinare l'inizializzazione degli elementi nel costruttore e nel programma.
Per questo motivo, abbiamo bisogno di una funzione speciale chiamata da OnInit() per svolgere questo lavoro.
Cosa farà esattamente questa funzione:
Come si chiamerà la funzione?
Io la chiamerei Initialize(), ma ognuno può proporre una propria variante.
L'importante è che questa funzione sia presente in qualsiasi Expert Advisor dell'interfaccia. Può essere paragonata alla funzione OnTick() di un Expert Advisor o a OnCalculate() di un indicatore. È importante capire questo aspetto.
Quale valore restituirà la funzione?
La funzione sarà di tipo void. Non è necessario restituire un valore. Quando viene chiamata, apre le finestre necessarie, inizializza i parametri degli elementi ed eventualmente preimposta alcune proprietà. Questo è fondamentalmente tutto. In teoria, è possibile impostare i limiti dei parametri iniziali, ma penso che il controllo del valore sarà implementato in una funzione separata chiamata sugli eventi degli elementi dal file API e dal timer. Probabilmente nella prossima versione scriverò una stampa delle chiamate di controllo.
*È importantetenere presente che al momento il concetto di interfaccia Expert Advisors è appena nato e molte scoperte ci attendono.
Ecco un esempio della funzione di inizializzazione di un Expert Advisor di interfaccia nel contesto del progetto demo attuale:
1. Chiamata di funzione:
2. Implementazione della funzione:
Finora la struttura della funzione mi sembra la seguente. Una funzione molto semplice. Apre le finestre e invia i valori richiesti ai parametri degli elementi. È possibile modificare l'inizializzazione degli elementi e l'apertura delle finestre in alcuni punti, perché l'apertura delle finestre mostrerà immediatamente i valori richiesti degli elementi senza ulteriori ridisegni. Tuttavia, si tratta di aspetti secondari.
Passiamo quindi all'argomento principale: l'implementazione della protezione graduale dei parametri.
14.realizzazione della protezione a gradini dei limiti dei parametri:
//------------------------------------------------------------------------------------------------------------
Scrivere la logica di controllo delle impostazioni entro i limiti prestabiliti e creare un sistema di avviso:
//-----------------------------------------------------------------------------
Procediamo:
1. Impostare i valori iniziali dei parametri degli elementi selezionati e aprire le finestre necessarie. A tale scopo, scriviamo la funzioneInitialise() e richiamiamola nella funzione _OnInit().
Risultato: le finestre necessarie vengono aperte e i valori iniziali vengono impostati sugli elementi di destinazione.
2. Apriamo il file API e scriviamo la connessione degli elementi. Nel caso di ciascun elemento, scriviamo le chiamate e il passaggio del valore agli altri elementi di destinazione della catena:
3. Testare la connessione:
Risultato: i valori degli elementi sono collegati come previsto.
4. Scrivere una funzione per controllare i parametri del nostro gruppo di elementi: void Risk_management_group_1().
Chiamare la funzione Risk_management_group_1() dalla funzione _OnInit():
Risultato: funziona come previsto, ma quando si inserisce un valore nel campo di immissione, la finestra di avviso non ripristina il valore inserito quando appare(richiede un miglioramento).
(*Inoltre, l' impostazione del colore della cornice è stata aggiunta nell'aggiornamento, ma manca nella versione attuale).
Il prossimo compito è quello di considerare la possibilità di annullare i parametri inseriti premendo il pulsante "Annulla".
Si tratta di un compito molto difficile, ma l'ho già parzialmente implementato. Cercherò di ripristinare la funzionalità precedente.
Nell'ultima ripartizione ho mostrato come applicare l'indicazione a colori del rischio e come aprire finestre di blocco al superamento dei limiti dei parametri impostati. Tuttavia, sono stati riscontrati due problemi che non mi aspettavo.
1. La funzione di gestione del rischio apre la prima finestra di avviso al superamento di un livello pericoloso, ma se si tiene premuto il cursore sull'elemento in quel momento, il valore continua a crescere e raggiunge il livello condizionale successivo. - Critico.
2. Quando viene superato il valore critico, si apre l'ultima finestra di avviso, che però non interrompe la variazione del valore se l'utente continua a tenere premuto il tasto sinistro del mouse.
3. Se l'utente rilascia il pulsante del mouse e vuole chiudere le finestre di avviso, non può farlo. Per essere più precisi, non può farlo. Il motivo è che le due finestre di blocco iniziano a bloccarsi a vicenda. Quando una delle finestre di blocco è aperta, può essere chiusa facilmente, ma quando due finestre sono aperte contemporaneamente, non può funzionare nient'altro nell'interfaccia. Il programma si blocca, anche se continua a funzionare.
L'immagine qui sotto mostra come è successo:
Poi ho risolto i problemi di blocco reciproco delle finestre delle impostazioni e ora le finestre non interferiscono l'una con l'altra. Eseguono la funzione di blocco insieme senza entrare in conflitto l'una con l'altra.
Ora devo fare in modo che la finestra di avviso interrompa automaticamente le modifiche al valore del parametro, anche se il pulsante sinistro del mouse è premuto e l'elemento è attivo.