Galleria di interfacce utente scritte in MQL - pagina 69

Nuovo commento
 
Maxim Kuznetsov progetto?

c'è un repository di qualcosa (che IMHO difficilmente può essere chiamato codice sorgente ) e la documentazione

Perché lo cerchi, lo cerchi e non lo trovi))). Il progetto è nelle pagine del ramo, insieme alle istruzioni per l'installazione. Non vi dirò la pagina esatta, scorrete indietro.

La prossima versione sarà pubblicata su kodobase. Se volete, potete aspettare un po'.
 

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.

 
Cominciamo da una nuova pagina.
 

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:

  • Aprire le finestre necessarie all'inizio del programma.
  • Impostare i valori nei controlli di destinazione.

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:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int _OnInit()
  {
   //------------------------------------------------
   //Initializing program interface:
   //------------------------------------------------
   Initialize();
   //------------------------------------------------


2. Implementazione della funzione:

void Initialize()   
{
   //------------------------------------------------
   //Opening the windows:
   //------------------------------------------------
   //1. "Main Parameters". 

    w_14_Main_Parameters();
   //------------------------------------------------

   //------------------------------------------------
   //2. "Input parameters".

   w_10_Input_parameters();
   //------------------------------------------------

   //------------------------------------------------
   //3. "Setting example 1"

   w_6_Settings_example_1();
   //------------------------------------------------


  //------------------------------------------------
  //Initializing the elements:
  //------------------------------------------------
  
   w6_d_p5_S_EDIT_Spin_the_value(55);

   w6_i_p3_H_SLIDER_Roll_the_value(55);

   w14_i_p3_V_SLIDER_Vertical_slider(55);

   w14_s_p4_EDIT_Max("100");

   w14_s_p4_EDIT_Min("0");

   w14_s_p4_EDIT_Selected("55");

   w15_i_p2_P_BAR_P1(55);

   w15_s_p4_VALUE_V1("55");
  //------------------------------------------------
}


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:

  • 1. Scrittura della logica per il controllo delle impostazioni nei confini prestabiliti e creazione di un sistema di allarme.
  • 2. Ilprimo avviso: l'utente riceve un segnale sotto forma di modifica del colore di parti degli elementi responsabili delle impostazioni.( Colleghiamo il colore del testo, delle basi, delle cornici e della barradi scorrimento ai confini dei valori).
  • 3. Secondo avviso: apertura di una finestra di dialogo con una notifica di rischio e il suggerimento di tornare alle impostazioni originali.(Verifichiamo l'effettiva possibilità di tornare alle impostazioni precedenti facendo clic sul pulsante "Annulla").
  • 4. terzo avviso: apertura di una finestra di avviso che blocca l'ulteriore modifica delle impostazioni e richiede la conferma manuale dell'utente.(Verifichiamo il blocco delle finestre e degli elementi quando appare la finestra di avviso).

//------------------------------------------------------------------------------------------------------------

Scrivere la logica di controllo delle impostazioni entro i limiti prestabiliti e creare un sistema di avviso:

  • La prima parte dell'implementazione consiste nell'impostare i valori iniziali dei parametri degli elementi selezionati e nell'aprire le finestre richieste. A tale scopo, scriveremo la funzione Initialise() e la chiameremo nella funzione _OnInit().
  • La seconda parte dell'implementazione: apriamo il file API e scriviamo la connessione degli elementi. Nel caso di ogni elemento della catena comune, scriveremo le chiamate e passeremo il valore agli altri elementi di destinazione. Per esempio: sull'evento del campo con i pulsanti chiamiamo il cursore orizzontale e gli passiamo il valore. Poi, quando l'evento arriva al caso del cursore, lo passiamo nuovamente al campo con i pulsanti e, in aggiunta, al cursore verticale. Quest'ultimo, a sua volta, passa il valore ai campi di input vicini e alla finestra della barra di avanzamento.... In tutto, ci saranno sette elementi principali nella catena che passano il valore in diverse direzioni. Eccoli:"Esempio di impostazioni 1" con gli elementi"Gira il valore" e"Gira il valore","Parametri principali" con gli elementi"V_SLIDER", campo"Selezionato" e"Percentuale", e"Elaborazione dei dati..." con gli elementi VALORE e P_BAR .
  • Terza parte: testare la connessione.
  • Quarta parte: Scriviamo una funzione di controllo dei parametri con un nome condizionale: void Risk_management_group_1(). Il suo compito è quello di segnalare all'utente l'avvicinarsi ai limiti dei valori pericolosi all'interno di questo gruppo di elementi e di avvisare quando si superano i limiti consentiti. La funzione accetterà i valori dagli elementi correlati e li passerà attraverso i filtri impostati all'interno delle condizioni. L'avvertimento sarà implementato attraverso livelli di rischio appropriati, con modifiche al testo e al colore della cornice, e sarà inviato a tutti gli elementi della catena. Parallelamente, chiameremo le finestre di blocco che non consentono all'utente di continuare l'azione senza un'ulteriore conferma.
  • Quinta parte: testiamo il lavoro della funzione.

//-----------------------------------------------------------------------------

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().

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int _OnInit()
  {
   //------------------------------------------------
   //Initializing program interface:
   //------------------------------------------------
   Initialize();
   //------------------------------------------------
void Initialize()   
{
   //------------------------------------------------
   //Opening the windows:
   //------------------------------------------------
   //1. "Main Parameters". 
    w_14_Main_Parameters();

   //2. "Input parameters".
   w_10_Input_parameters();

   //3. "Setting example 1"
   w_6_Settings_example_1();

   //------------------------------------------------
  //Initializing the elements:
  //------------------------------------------------
   w6_d_p5_S_EDIT_Spin_the_value(55);
   w6_i_p3_H_SLIDER_Roll_the_value(55);
   w14_i_p3_V_SLIDER_Vertical_slider(55);
   w14_s_p4_EDIT_Max("100");
   w14_s_p4_EDIT_Min("0");
   w14_s_p4_EDIT_Selected("55");
   w15_i_p2_P_BAR_P1(55);
   w15_s_p4_VALUE_V1("55");
  //------------------------------------------------
}

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:

case Settings_example_1___Spin_the_value:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the value is set?
               //------------------------------------------------------------------------------------------------------
               //Min value:  NOT SET  |   Max value:  NOT SET  |   V_step:  1.7  |   Default value:  468.99  |  Digits: 3
               //------------------------------------------------------------------------------------------------------
               w6_i_p3_H_SLIDER_Roll_the_value((int)value);

               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
case Settings_example_1___Roll_the_value:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the slider's handle is moved?
               //------------------------------------------------------------------------------------------------------
               //Min value:  0  |   Max value:  100  |   V_step:  1  |   Default value:  55  |  Digits: Integer value
               //------------------------------------------------------------------------------------------------------
               //Transferring the value:
               w14_i_p3_V_SLIDER_Vertical_slider((int)value);

               w6_d_p5_S_EDIT_Spin_the_value((double)value);
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
case Main_Parameters___Vertical_slider:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the slider's handle is moved?
               //------------------------------------------------------------------------------------------------------
               //Min value:  0  |   Max value:  100  |   V_step:  1  |   Default value:  50  |  Digits: Integer value
               //------------------------------------------------------------------------------------------------------
               {
                //----------------------------------------------------- 
                //Transferring value to other destinations:
                //----------------------------------------------------- 
                w14_s_p4_EDIT_Percent(value);
                //-----------------------------------------------------
                w14_s_p4_EDIT_Selected(value);
                //-----------------------------------------------------
                w15_i_p2_P_BAR_P1((int)value);
                //-----------------------------------------------------
                w15_s_p4_VALUE_V1(value);
                //-----------------------------------------------------
                w6_i_p3_H_SLIDER_Roll_the_value((int)value);
                //-----------------------------------------------------
                w6_d_p5_S_EDIT_Spin_the_value((double)value);
                //-----------------------------------------------------
                w8_s_p4_CELL_Account_balance__Value(value);
                //------------------------------------------------------------------------------------------------------
                //Your comment:
                //------------------------------------------------------------------------------------------------------
               }
               break;


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().

void Risk_management_group_1(string value)
{
 uint Color = 0;
 //--------------------
 static uint This_color;
 static bool User_warned, Last_warning;
 //------------------------------------------------------------
 //Setting limit colors:
 //------------------------------------------------------------
 if((int)value < 25)                      Color = clrLightGreen;
 //------------------------------------------------------------
 if((int)value >= 25 && (int)value < 50)  Color = clrLimeGreen;
 //------------------------------------------------------------
 if((int)value >= 50 && (int)value < 70)  Color = clrGreen;
 //------------------------------------------------------------
 if((int)value >= 70 && (int)value < 85)  Color = clrDarkGreen;
 //------------------------------------------------------------
 if((int)value >= 85 && (int)value < 90)  Color = clrBrown;
 //------------------------------------------------------------
 if((int)value >= 90 && (int)value < 95)  Color = C'170,0,0';
 //------------------------------------------------------------
 if((int)value >= 95 && (int)value <=100) Color = clrRed;
 //------------------------------------------------------------  

 //------------------------------------------------------------ 
 //Changing colors when the limits are passed:
 //------------------------------------------------------------
 if(This_color != Color)
   {
    w14_s_p4_EDIT_Percent((string)Color, p4_COLOR_base); 
    //-----------------------------------------------------
    w14_s_p4_EDIT_Selected((string)Color, p4_COLOR_base); 
    //-----------------------------------------------------
    w15_i_p2_P_BAR_P1(Color, p2_COLOR_bar);
    w15_i_p2_P_BAR_P1(Color, p2_COLOR_frame);
    w15_s_p4_VALUE_V1((string)Color, p4_COLOR_frame);
                   
    w8_s_p4_CELL_Account_balance__Value((string)Color, p4_COLOR_text);
    w8_s_p4_CELL_Account_balance__Value((string)Color, p4_COLOR_frame);
    //-----------------------------------------------------
    w14_i_p3_V_SLIDER_Vertical_slider(Color,p3_COLOR_bar);
    //-----------------------------------------------------
    w15_s_p4_VALUE_V1((string)Color, p4_COLOR_text);
    //-----------------------------------------------------
    w6_i_p3_H_SLIDER_Roll_the_value(Color,p3_COLOR_bar);
    //-----------------------------------------------------
    w6_d_p5_S_EDIT_Spin_the_value((double)Color, p5_COLOR_text);
    //-----------------------------------------------------
    w6_d_p5_S_EDIT_Spin_the_value((double)Color, p5_COLOR_frame);
    //-----------------------------------------------------
    w14_i_p1_BUTTON_BUY_OFF(Color, p1_N_COLOR_frame);
    w14_i_p1_BUTTON_BUY_OFF(Color, p1_A_COLOR_frame);
    //-----------------------------------------------------
    w14_i_p1_BUTTON_SELL_OFF(Color, p1_N_COLOR_frame);
    w14_i_p1_BUTTON_SELL_OFF(Color, p1_A_COLOR_frame);
    //-----------------------------------------------------
    w7_s_p4_EDIT_Comment_1(Color, p4_COLOR_frame);
    //-----------------------------------------------------
    This_color = Color;
    //-----------------------------------------------------
   }   
 //-----------------------------------------------------
 //Opening warning window 1:
 //-----------------------------------------------------
 if((int)value >= 85 && (int)value < 95 && !User_warned)
   { 
    //---------------------------------
    //Opening dialog window:
    //---------------------------------
    w_13_Risky_managment(); 
    //---------------------------------
    //Setting flag of warning 1:
    //---------------------------------
    User_warned = true;
    //---------------------------------
   }
 //-----------------------------------------------------
 if((int)value < 85)User_warned = false;
 //-----------------------------------------------------
 //Opening warning window 2:
 //-----------------------------------------------------
 if((int)value >= 96 && !Last_warning)
   { 
    //---------------------------------
    //Calling blocking window:
    //---------------------------------
    w_17_Last_warning();
    //---------------------------------
    //Setting flag of warning 2:
    //---------------------------------
    Last_warning = true;
    //---------------------------------
   }
 //-----------------------------------------------------
 if((int)value < 95)Last_warning = false;                
 //-----------------------------------------------------                 
}

Chiamare la funzione Risk_management_group_1() dalla funzione _OnInit():

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int _OnInit()
  {
   //------------------------------------------------
   //Initializing program interface:
   //------------------------------------------------
   Initialize();
   //----------------------------------------------------------
   //Checking default value of the parameters in the group:  
   //----------------------------------------------------------
   Risk_management_group_1();
   //----------------------------------------------------------
 

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.

1...6263646566676869
Nuovo commento