Galleria di interfacce utente scritte in MQL - pagina 65
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
Impostazione dellostatoON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK per diversi elementi
Come ottenere lo stato on/off di un pulsante?
Come ottenere lo stato on/off del pulsante?
Questo è il prossimo argomento. Lo affronteremo oggi.
Va aggiunto che gli elementi di questa GUI sono disegnati, quindi il metodo standard per ottenere lo stato ObjectGetInteger(0, "button1", OBJPROP_STATE); non funzionerà.
Inoltre, vorrei ricordare che gli eventi degli elementi, compresi i pulsanti, vengono inviati al file API.
Un elenco generale di argomenti da considerare:
1. Orientamento nell'elenco di intellisense e selezione della funzione della finestra giusta.
2. Apertura e chiusura programmatica delle finestre.
3. Orientarsi nell'elenco di intellisense e selezionare l'elemento giusto nella finestra giusta.
4. Navigare negli elenchi di proprietà dei singoli elementi.
5. Parsing del nome di un elemento e funzione wrapper della finestra.
6. restituzione del valore del parametro di un elemento selezionato a una variabile del suo tipo. Considerare tre tipi di elementi diversi.
7. Impostazione di valori nei parametri di diversi tipi di elementi. Vediamo come appariranno i valori nelle finestre dell'interfaccia di questi elementi.
8. Restituzione dei valori dei parametri di un elemento, modifica e inoltro del valore a un altro elemento. Considerare diversi tipi di elementi e valori e testare l'inoltro tra diversi tipi di elementi in diverse finestre.
9. Restituzione del valore precedente (_V_LAST). Quando e in quali casi è richiesto l'ultimo valore (da non confondere con il valore corrente).
10. Testare l'impostazione degli stati ON/OFF/LOCK_ON/LOCK_OFF/LOCK/UNLOCK per diversi tipi di elementi.
11. Proviamo a collegare e sincronizzare le modifiche dei valori di elementi di tipo diverso: ad esempio, campo di input con pulsanti e cursore. Supponiamo che quando il valore di un elemento (manuale o software) cambia, il valore del secondo elemento cambi di conseguenza.
12. Proviamo a reimpostare programmaticamente i confini dell'intervallo dello slider e del campo di input con pulsanti tramite funzioni wrapper. Non ho avuto il tempo di testarlo, ma qualcosa mi suggerisce che funzionerà. Comunque, vediamo.
13. Proviamo a restituire gli stati degli elementi tramite funzioni wrapper. È inclusa nella funzionalità, ma non ho avuto il tempo di testarla. Quindi vedremo... Il risultato è sconosciuto.
14. Otteniamo e impostiamo i colori per il testo e le basi degli elementi. Possiamo provare ad associare questi colori ad alcuni semplici eventi o confini di valori.
15. Vi spiegherò meglio come navigare e leggere la nuova stampa del file API.
//------------------------------------------
Gli argomenti già trattati sono evidenziati in giallo.
Oggi faremo un ripasso:
11. Sincronizzazione (collegamento) della modifica dei valori di elementi di tipo diverso: ad esempio, campo di input con pulsanti e cursore. In modo che quando si cambia il valore di un elemento (manuale o software), il valore del secondo elemento cambierà di conseguenza.
12. Proviamo a reimpostare programmaticamente i confini dell'intervallo del cursore e del campo di input con pulsanti tramite funzioni wrapper. Non ho avuto il tempo di testarlo, ma qualcosa mi suggerisce che funzionerà. Comunque, vediamo.
13. Proviamo a restituire gli stati degli elementi tramite funzioni wrapper. È inclusa nella funzionalità, ma non ho avuto il tempo di testarla. Quindi vedremo... Il risultato è sconosciuto.
11. Legame di parametri di elementi di tipo diverso.
Chi è attento ha notato che in una GUI a più finestre, elementi diversi sono spesso collegati da valori di parametri, proprietà e stati. Ad esempio:
//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
Si potrebbe pensare che ci sia una connessione invisibile tra elementi da qualche parte. E in effetti c'è. Ma è invisibile solo per un osservatore esterno. Per uno sviluppatore è abbastanza ovvio e oggi lo considereremo in dettaglio.
1. La connessione degli elementi ha due aspetti:
La realizzazione tecnica dei collegamenti è semplificata dalla presenza di un motore grafico.
Mi spiego meglio:
In un Expert Advisor convenzionale, ogni parametro viene inventato, nominato, memorizzato ed elaborato dall 'utente. Si tratta di un lavoro di routine che non può essere aggirato. Tuttavia, se si utilizza un motore grafico, gli elementi creati nel costruttore ricevono automaticamente il parametro insieme alla posizione di memorizzazione e alla funzione di elaborazione/ritorno. Inoltre, l'utente riceve le loro proprietà, come il tipo, l'intervallo, il valore passato, ecc. Questo semplifica notevolmente il lavoro. In teoria, è possibile utilizzare i parametri già pronti degli elementi della GUI come altri parametri utente, collegandoli direttamente alla logica di trading. Ad esempio, il lotto, il trailing stop, il take profit e altri ancora, non vengono ricavati dalle loro stesse variabili, ma dai campi di impostazione responsabili dei loro valori.
Alcune conclusioni generali:
1. La presenza di un controllo grafico in un programma = la presenza di un parametro del programma già pronto + le sue proprietà + la funzione di restituzione/impostazione del valore.
2. Più controlli sono collocati nelle finestre del programma di interfaccia, più parametri sono coinvolti nella logica di trading e nell'input/output delle informazioni di trading.
3. Maggiore è il numero di impostazioni e di finestre, maggiore è il controllo e lalarghezza di banda dell'output dei dati di mercato (fatta salva l'automazione).
4. Maggiore è il controllo e più ampia è la larghezza di banda dei dati di mercato in uscita, migliore è la consapevolezza del trader.
5. Consapevolezza moltiplicata per automazione e controllo = aumento delle opportunità per i trader.
Devo aggiungere che l'automazione è spesso contrapposta al controllo manuale. Si dice che avere un'interfaccia grafica significhi fare trading manuale. Ma non è così. L'interfaccia software non esclude ma espande l'automazione, aggiungendovi un "gradiente" - apre tre opzioni: controllo manuale, trading semiautomatico e modalità autonoma.
Tutto ciò che il trader deve fare è selezionare un'opzione.
Per carità, è facile creare una finestra a questo scopo.
//---------------------------------------------------------------------------------------------------
2. Passiamo all'implementazione tecnica dei parametri vincolanti dei controlli.
Consideriamo alcuni esempi pratici:
1. Apriamo una finestra di impostazioni già nota:
2. Apriamo il file API e troviamo gli elementi della finestra aperta all'interno della funzione On_Gui_Event():
Ricordiamo: tutti gli eventi di controllo entrano nella funzione On_Gui_Event();
A questo proposito, scriveremo alcuni dei collegamenti ai parametri all'interno di questa funzione e altri al di fuori del suo corpo.
1. Stabiliamo un collegamento tra il campo con i pulsanti (S_EDIT) "Gira il valore" e il cursore (H_SLIDER) "Gira il valore":
Risultato: cambiamo il valore del campo con i pulsanti e il cursore si muove da solo.
(*Importante: il cursore può muoversi solo all'interno del suo intervallo (in questo caso, da 0 a 100). In caso di superamento dell'intervallo, il valore non cambia, ma viene visualizzato un errore nel log).
//----------------------------------------------------------------------------------------------------------------
3. Invertiamo i ruoli. Il cursore controllerà il valore del campo di input:
Risultato: quando si sposta la maniglia del cursore, il campo con i pulsanti cambia il valore in modo sincrono.
//----------------------------------------------------------------------------------------------------------------
4. Scriviamo il controllo reciproco del cursore e del campo con pulsanti:
Risultato: il cursore e i campi di input si controllano a vicenda simultaneamente.
//---------------------------------------------------------------------------------------------------
Domani pubblicherò la seconda parte di questo tema con altri elementi.
Questo materiale è fantastico! Ho intenzione di controllare questo thread in modo più dettagliato con il tempo a disposizione. Pensavo che il mio lavoro stesse superando i limiti della GUI di mt4, ma il vostro lavoro è di livello superiore.
Questo è un materiale fantastico! Ho intenzione di approfondire questo argomento quando avrò tempo. Pensavo che il mio lavoro stesse superando i limiti della GUI di mt4, ma il vostro lavoro è di livello superiore.
Grazie mille per le tue gentili parole!
11. Parametri di vincolo di elementi di tipo diverso.
Continuazione dell'argomento.
Parte 2.
//--------------------------------------------------------------------------------------------------------------------------------
Vediamo se possiamo applicare il metodo di binding mostrato ad altri elementi. Ad esempio, alle caselle di controllo.
1. Facciamo in modo che la casella di controllo superiore si blocchi e sblocchi quella sottostante:
Per fare questo:
1. Troviamo la casella di controllo"Imposta un'opzione" nel file API.
2. Scriviamo una chiamata di funzione per la casella di controllo"Imposta un'altra opzione" che deve bloccare/sbloccare.
Risultato: la casella di controllo viene bloccata e sbloccata come previsto:
//--------------------------------------------------------------------------------------------------------------------------------
2. Ora facciamo in modo che la casella di controllo blocchi e sblocchi le due caselle di controllo sottostanti:
Risultato: la casella di controllo blocca e sblocca le due caselle di controllo sottostanti:
Ecco come è successo nella dinamica:
//--------------------------------------------------------------------------------------------------------------------------------
3. Ora risolviamo il problema mostrato nel diagramma seguente: le caselle di controllo devono bloccare e sbloccare gli elenchi a discesa di fronte a loro.
Per fare questo:
Risultato: le caselle di controllo bloccano gli elenchi a discesa e si bloccano con la casella di controllo principale:
//--------------------------------------------------------------------------------------------------------------------------------
4. Passiamo al compito successivo: gli elenchi a discesa devono tradurre il valore selezionato dall'utente in un campo di un'altra finestra.
Per fare questo:
*Risultato: entrambi gli elenchi a discesa inviano con successo i loro valori ai campi di input della finestra opposta:
//--------------------------------------------------------------------------------------------------------------------------------
5. Il seguente compito è mostrato in questo diagramma: è necessario che i pulsanti di opzione che vengono commutati inviino il loro nome ai campi di input di fronte.
Per fare questo:
*Nota importante: i pulsanti di opzione sono attivati perché l'operatore SWITCH è stato applicato ad essi nel codice KIB. Pertanto, hanno un parametro comune a tutti e si trovano nel file API nello stesso caso.
Risultato: la commutazione dei pulsanti provoca la modifica del testo nel campo di input. *C'è un piccolo problema tecnico con questa opzione. Sarà risolto nella prossima versione.
La seconda parte è stata completata.
Nella terza parte lavoreremo con la tabella.
La parte finale dell'argomento del binding dei parametri.
Passiamo i valori dei parametri degli elementi alle celle della tabella.
Schema:
Soluzione:
Risultato: i valori vengono inseriti in modo sicuro nelle celle di tabella selezionate.
Come si può vedere dagli esempi precedenti, abbiamo sviluppato una soluzione semplice e conveniente. Spero che la gente la trovi utile.
Questo conclude l'argomento del collegamento dei parametri degli elementi.
Restano da affrontare i seguenti argomenti:
12. Ottenere/impostare programmaticamente i limiti del valore del cursore e del campo del pulsante(_V_MIN, _V_MAX, _V_STEP, _DIGITS).
13. Interrogare lo stato degli elementi(_GET_STATE).
14. Collegamento dei colori del testo e della cornice ai limiti dei valori spaziati.
15. Orientamento nel file API.
Aggiunta di un tema:
16. Realizzazione della logica di programma per l'aspetto delle finestre di messaggio e di avviso.