Galleria di interfacce utente scritte in MQL - pagina 66

[Реter Konow]

Continuiamo con una nuova pagina.

[Реter Konow]

12. Ottenere/impostare programmaticamente i limiti di valore delcursore e del campo con i pulsanti (_V_MIN, _V_MAX, _V_STEP, _DIGITS).

1. Apriamo una finestra con gli elementi con i parametri di cui sopra:

int _OnInit()
  {
   //------------------------------------------------
   //Open the window "Settings example 1".
   //------------------------------------------------
   w_6_Settings_example_1();
   //------------------------------------------------

2. Scriviamo i valori di _V_MIN, _V_MAX, _V_STEP, _DIGITS e li pubblichiamo nel log:

   //------------------------------------------------
   //Get parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   int Min_value = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_V_MIN);
   int Max_value = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_V_MAX);
   int Step      = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_V_STEP);
   int digits    = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_DIGITS);
   //------------------------------------------------
   //Print the results:
   //------------------------------------------------
   Print("Min_value:  ",Min_value,"  Max_value:  ",Max_value,"  Step:  ",Step,"  digits:  ",digits);
   //------------------------------------------------

Risultato: i valori delle proprietà dei parametri del cursore vengono registrati.

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

3. Ripetiamo l'operazione con il campo con i pulsanti. A differenza dello slider, il campo ha altri confini numerici e il suo tipo di valore è double.

   //------------------------------------------------
   //Get parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   double _Min_value  =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_V_MIN);
   double _Max_value  =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_V_MAX);
   double _Step       =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_V_STEP);
   double _digits     =  w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_DIGITS);
   //------------------------------------------------
   Print("Min_value:  ",_Min_value,"  Max_value:  ",_Max_value,"  Step:  ",_Step,"  digits:  ",_digits);
   //------------------------------------------------ 

Risultato: ivalori delle proprietà dei parametri del campo con i pulsanti vengono visualizzati nel log.

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

4. Impostare altri limiti dell'intervallo dello slider (testato per la prima volta, il risultato è sconosciuto).

   //------------------------------------------------
   //Set parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP.
   //------------------------------------------------
   Min_value = -100;
   Max_value = 100;
   Step      = 1;
   //-----------------
   w6_i_p3_H_SLIDER_Roll_the_value(Min_value, p3_V_MIN);
   w6_i_p3_H_SLIDER_Roll_the_value(Max_value, p3_V_MAX);
   w6_i_p3_H_SLIDER_Roll_the_value(Step,      p3_V_STEP);
   //------------------------------------------------

Risultato: *trovato unproblema con l'intervallo in numeri negativi (risolto nella prossima versione).

Verifichiamo i limiti positivi dell'intervallo:

   //------------------------------------------------
   //Set parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP.
   //------------------------------------------------
   Min_value = 0;
   Max_value = 1000;
   Step      = 1;
   //-----------------
   w6_i_p3_H_SLIDER_Roll_the_value(Min_value, p3_V_MIN);
   w6_i_p3_H_SLIDER_Roll_the_value(Max_value, p3_V_MAX);
   w6_i_p3_H_SLIDER_Roll_the_value(Step,      p3_V_STEP);
   //------------------------------------------------

Risultato: i limiti dell'intervallo sono stati modificati con successo.

Punto principale: L'intervallo del cursore può essere modificato utilizzando la sua funzione.

**Importante:non è possibile modificare retroattivamente il tipo di valore del parametro da int a double o viceversa.

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

Eseguiamo un esperimento simile con il campo di input:

   //------------------------------------------------
   //Set NEW parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   double _Min_value  = -100.0;
   double _Max_value  =  100.0;
   double _Step       =  2.5;
   //-----------------
   //Set another default value---
   w6_d_p5_S_EDIT_Spin_the_value(50.5);
   //-----------------
   w6_d_p5_S_EDIT_Spin_the_value(_Min_value,p5_V_MIN);
   w6_d_p5_S_EDIT_Spin_the_value(_Max_value,p5_V_MAX);
   w6_d_p5_S_EDIT_Spin_the_value(_Step     ,p5_V_STEP);
   //------------------------------------------------

Risultato: funziona come previsto. Il campo con i pulsanti accetta l'intervallo e il passo specificati. Se l'intervallo viene superato, viene segnalato un errore nel log.

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

5. Infine, impostiamo il valore_DIGITS sul campo con i pulsanti (lo slider non funzionerà perché il suo tipo di parametro è int):

• Impostiamo il valore del passo con quattro cifre dopo il punto.
• La variabile cifre è impostata su 4 (quattro cifre decimali).

   //------------------------------------------------
   //Set parameter properties, such as: 
   //_V_MIN, _V_MAX, _V_STEP, _DIGITS
   //------------------------------------------------
   double _Min_value  = -100.0;
   double _Max_value  =  100.0;
   double _Step       =  2.5567;
          digits      =  4;
   //-----------------
   //Set another default value---
   w6_d_p5_S_EDIT_Spin_the_value(50.5);
   //-----------------
   w6_d_p5_S_EDIT_Spin_the_value(_Min_value,p5_V_MIN);
   w6_d_p5_S_EDIT_Spin_the_value(_Max_value,p5_V_MAX);
   w6_d_p5_S_EDIT_Spin_the_value(_Step     ,p5_V_STEP);
 
   //Set the new number of digits:
   w6_d_p5_S_EDIT_Spin_the_value(digits    ,p5_DIGITS);
   //------------------------------------------------

Risultato:

• All'inizio c'erano tre cifre dopo il punto decimale (il numero originale prima della modifica del software).

• Poi, la chiamata software ha aumentato la precisione a quattro cifre:

• Successivamente, a 7 cifre:

//Setting 7 digits after the decimal point:

w6_d_p5_S_EDIT_Spin_the_value(7,p5_DIGITS);

Risultati:

• È possibile reimpostare programmaticamente i limiti dell'intervallo di numeri originali del campo del pulsante e del cursore.

• È possibile modificare programmaticamente la precisione iniziale del valore doppio impostando un numero diverso di cifre decimali.
  

• Il cursore ha un problema con il calcolo dei valori entro i confini dei numeri negativi (verrà risolto).

• Non è possibile ripristinare il tipo originale del parametro dell'elemento.

Questo conclude l'argomento.

[Реter Konow]

13. Interrogazione dello stato degli elementi _GET_STATE.

Spesso si verificano situazioni in cui è necessario ottenere programmaticamente lo stato di uno o più elementi dell'interfaccia. Per risolvere questo problema viene creato l'identificatore _GET_STATE.

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

*Importante:la funzione request_GET_STATE restituisce l'indice dello stato corrente dell'elemento.

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

L'immagine seguente mostra l'elenco degli stati dell'elemento.

1. identificatori di stato :

(*nellaprossima release, il prefisso v_ sarà sostituito dal prefisso s_)

Indici inviati al log:

  v_NEUTRAL_STATE           15
  //-----------------------------
  v_ACTIVATED_STATE         62
  //-----------------------------
  v_NEUTRAL_BLOCKED         64
  //-----------------------------
  v_ACTIVATED_BLOCKED       65   
  //----------------------------- 
  v_NEUTRAL_HIGHLIGHTED     66  
  //-----------------------------
  v_ACTIVATED_HIGHLIGHTED   67

Proviamo a interrogare e recuperare gli stati degli elementi:

1. Aprire la finestra e ottenere lo stato iniziale del pulsante "Avvio":

int _OnInit()
  {
   //------------------------------------------------
   //Open the window "Settings example 1".
   //------------------------------------------------
   w_6_Settings_example_1();
   //------------------------------------------------
   //Get state of button "Start":
   //------------------------------------------------
   int Button_state = w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);
   //------------------------------------------------
   //Print out:
   //------------------------------------------------
   Print("Button state:  ",Button_state);
   //------------------------------------------------

Risultato: si ottiene il valore 15 corrispondente allo stato v_NEUTRAL_STATE.

2. Registriamo gli stati del pulsante alla pressione e al rilascio:

Per fare ciò:

• Individuiamo il pulsante nel file API.
• Scriviamo una richiesta _GET_STATE per entrambi i casi - premuto e rilasciato.

case Settings_example_1___Start:

               //------------------------------------------------------------------------------------------------------
               //What to do when the button is pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                //------------------------------------------------------------------------
                case pressed: 
                               {
                                //Get button's state when it pressed:
                                int Button_state =  w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);
                                
                                //Print out the result:
                                Print("Button state:  ",Button_state);
                               }
                break;
                //------------------------------------------------------------------------
                case released: 
                               {
                                //Get button's state when it released:
                                int Button_state =  w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);
                                
                                //Print out the result:
                                Print("Button state:  ",Button_state);
                               }
                break;
                //------------------------------------------------------------------------
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Risultato: sull'evento premuto/rilasciato, l'indice dello stato corrente viene stampato nel log.

Promemoria:

15 = v_NEUTRAL_STATE

62 = v_ACTIVATED_STATE

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

3. Ripetiamo la query con la casella di controllo.

1. Otteniamo lo stato della casella di controllo sull'evento di apertura della finestra:

   //------------------------------------------------
   //Open the window "Settings example 1".
   //------------------------------------------------
   w_6_Settings_example_1();
   //------------------------------------------------
   
   //Get the state of the checkbox when it checked:
   int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);
   
   //Print out the result:
   Print("Checkbox state:  ",Checkbox_state);
   //------------------------------------------------

Risultato: si ottiene il valore 15, corrispondente allo stato neutro v_NEUTRAL_STATE (dove si trova la casella di controllo).

2. Successivamente, interroghiamo gli stati della casella di controllo sull'evento di pressione e rilascio.

Per fare questo:

• Troviamo la casella di controllo"Imposta un'opzione" nel file API.
• Scriviamo la query _GET_STATE per entrambi i casi: checked e unchecked.

case Settings_example_1___Set_an_option:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the checkbox is checked or unchecked? 
               //------------------------------------------------------------------------------------------------------
                case checked: 
                               {
                                //Get checkbox state when it checked:
                                int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);
                                
                                //Print out the result:
                                Print("Checkbox state:  ",Checkbox_state);
                               }
                break;
                //------------------------------------------------------------------------
                case unchecked: 
                               {
                                //Get checkbox state when it unchecked:
                                int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);
                                
                                //Print out the result:
                                Print("Checkbox state:  ",Checkbox_state);
                               }
                break;
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Risultato: otteniamo i valori 66 (v_NEUTRAL_HIGHLIGHTED) e 67 (v_ACTIVATED_HIGHLIGHTED), che significano stato neutro evidenziato e stato premuto evidenziato.

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

Con questo si conclude la prima parte dell'argomento.

Nella seconda parte, verranno restituiti gli stati dell'elenco a discesa D_LIST, del cursore H_SLIDER e dei campi di input S_EDIT e EDIT.

[[Eliminato]]

Ho iniziato a utilizzare uno scambio di criptovalute chiamato coinsbitfx.com. Coins Bit FX affermava di essere registrato presso la National Futures Association per convincere gli utenti della sua legittimità. A un certo punto ho creduto che il mio conto fosse cresciuto di valore fino a 135.134 dollari. Ma quando ho cercato di prelevare fondi dal mio conto, la borsa mi ha detto che la transazione era "in fase di revisione". Da allora il residente non è stato in grado di contattare nessuno del sito web e non può accedere ai fondi investiti. Questo mi ha dato alla testa, così ho letto di RECOVERYCOINGROUP AT GMAIL DOT COM su un blog, ho fatto le mie ricerche e ho deciso di avvalermi dei loro servizi; in meno di 72 ore i miei fondi sono stati tutti recuperati, e come se non bastasse hanno recuperato anche i BTC dei miei amici. Quindi sono abbastanza coraggioso da far conoscere al mondo questi ragazzi. Sentitevi liberi di contattare il Recovery Coin Group oggi stesso e ringraziatemi in seguito !

[Реter Konow]

13. Richiesta di stato _GET_STATE.

Parte 2: Ottenere gli stati degli elementi D_LIST, H_SLIDER, EDIT, S_EDIT.

Nell'ultima parte abbiamo visto come restituire programmaticamente gli stati del pulsante BUTTON e della casella di controllo CHECKBOX . È stata utilizzata la query _GET_STATE ed è stato mostrato l'elenco dei nomi degli stati restituiti dalle funzioni. Ci sono sei nomi in tutto, ognuno dei quali inizia con il prefisso v_. (abbreviazione di value, che sarà sostituito da s_ - abbreviazione di state).

Ricordiamo gli indici di stato:

  v_NEUTRAL_STATE           15
  //-----------------------------
  v_ACTIVATED_STATE         62
  //-----------------------------
  v_NEUTRAL_BLOCKED         64
  //-----------------------------
  v_ACTIVATED_BLOCKED       65   
  //----------------------------- 
  v_NEUTRAL_HIGHLIGHTED     66  
  //-----------------------------
  v_ACTIVATED_HIGHLIGHTED   67

In questo caso, i numeri di indice specifici non sono importanti. Quando l'utente deve inserire un particolare stato in una condizione, utilizza un identificatore.

Esempio 1:

//Getting state of the first element:
int Button_state = w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);

//Getting state of the second element:
int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);


//Setting conditions for both elements when they're simultaneously ON:
if(Button_state == v_ACTIVATED_STATE)
  { 
   //Is the checkbox was already on:
    if(Checkbox_state == v_ACTIVATED_STATE)
      {
       Function_1();
      }
    //If the checkbox was the last pressed element and still highlighted:
    if(Checkbox_state == v_ACTIVATED_HIGHLIGHTED)
      {
       Function_2();
      }
  }

Esempio 2:

//Getting state of the first element:
int Button_state = w6_i_p1_BUTTON_Start(get_i,p1_GET_STATE);

//Getting state of the second element:
int Checkbox_state = w6_i_p7_CHECKBOX_Set_an_option(get_i,p7_GET_STATE);


//Setting conditions for one element being ON, while the other is OFF:
if(Button_state == v_ACTIVATED_STATE)
  { 
   //If the checkbox was already off:
    if(Checkbox_state == v_NEUTRAL_STATE)
      {
       Function_A();
      }
    //If the checkbox was just turned off and still highlighted:
    if(Checkbox_state == v_NEUTRAL_HIGHLIGHTED)
      {
       Function_B();
      }
  }

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

*Molto importante:

Vi spiego la differenza essenziale tra gli stati v_NEUTRAL_STATE e v_NEUTRAL_HIGHLIGHTED, e tra v_ACTIVATED_STATE e v_ACTIVATED_HIGHLIGHTED:

v_NEUTRAL_STATE - это нейтральное состояние в котором элемент находится неопределенное время.

v_NEUTRAL_HIGHLIGHTED - это нейтральное состояние в которое элемент перешел ТОЛЬКО ЧТО, после отжатия пользователя. Поэтому элемент подсвечен - HIGHLIGHTED. 

lo stesso vale per lo stato attivato:

v_ACTIVATED_STATE - это активированное состояние в котором элемент находится неопределенное время.

v_ACTIVATED_HIGHLIGHTED - это активированное состояние в которое элемент перешел ТОЛЬКО ЧТО, после нажатия пользователя. Поэтому элемент подсвечен - HIGHLIGHTED. 

Questa differenza fa la differenza.

Attualmente, il pulsante e alcuni altri elementi restituiscono solo v_NEUTRAL_STATE e v_ACTIVATED_STATE e non restituiscono gli stati HIGHLIGHTED come le caselle di controllo. Ciò significa che l'utente non ha modo di sapere se gli elementi sono stati cliccati/scliccati proprio ora o quando, un tempo indefinito. Tuttavia, nel file API l'utente può individuare il momento in cui sono stati premuti. Sì, ma questa funzione non è ancora disponibile nel resto del programma. Nella prossima versione, a tutti gli elementi interattivi verrà aggiunto il ritorno allo stato HIGHLIGHTED. In questo modo, da qualsiasi punto del programma, l'utente sarà in grado di sapere se un elemento è stato appena premuto/non premuto o se è rimasto nel suo stato per molto tempo.

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

Passiamo alla parte pratica:

• Apriamo due finestre con gli elementi D_LIST, H_SLIDER, EDIT e S_EDIT.
• Riportiamo gli stati degli elementi subito dopo l'apertura.

1. Aprire le finestre:

int _OnInit()
  {
   //------------------------------------------------
   //Open the windows "Settings example 1" and "Settings example 2".
   //------------------------------------------------
   w_6_Settings_example_1();
   w_7_Settings_example_2();
   //------------------------------------------------

2. Otteniamo gli stati degli elementi:

   //------------------------------------------------
   //Get the states of the elements S_EDIT, H_SLIDER, EDIT and D_LIST
   //------------------------------------------------
   //1. State index is type int, S_EDIT's function is double. Convert the types.
   int S_edit_state   = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d,p5_GET_STATE); 
   
   //2. Getting the slider's state. 
   int H_slider_state =      w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE);
   
   //3.State index is type int, EDIT's function is string. Convert the types. 
   int Edit_state     = (int)w7_s_p4_EDIT_Comment_3(get_s,p4_GET_STATE);
   
   //State index is type int, D_LIST's function is string. Convert the types.
   int D_list_state   = (int)w7_s_p6_D_LIST_D_LIST_1(get_s,p6_GET_STATE);
   //------------------------------------------------
   
   //Print out the results:
   Print("S_edit_state   = ",S_edit_state);
   Print("H_slider_state = ",H_slider_state);
   Print("Edit_state     = ",Edit_state);
   Print("D_list_state   = ",D_list_state);
   //------------------------------------------------

Risultato: tutti gli elementi del cnome D_LISThanno indice di stato 15 (stato neutro v_NEUTRAL_STATE). D_LIST ha restituito un errore (-1).

Motivo: la restituzione degli stati di questo elemento non è specificata nella funzione centrale. Difetto tecnico.Sarà corretto nella prossima versione.

Poiché la funzione D_LIST non restituisce ancora l'indice di stato, concentriamoci su tre elementi i cui stati sono stati ricevuti con successo: EDIT , S_EDIT e H_SLIDER.

Cosa controllare:

• Quali indici restituisce la funzione quando gli elementi vengono bloccati e cliccati.
• Se gli elementi dati hanno uno statoHIGHLIGHTED ( evidenziato). In altre parole, se è possibile sapere se l'elemento è stato appena cliccato o meno.

Abbiamo appena verificato che le funzioni EDIT, S_EDIT e H_SLIDER restituiscono un indice dello stato neutro all'apertura della finestra. Resta da verificare gli altri stati. Poiché questi tipi di elementi, in teoria, possono trovarsi solo negli stati neutro, bloccato ed evidenziato (a differenza di pulsanti e caselle di controllo, che hanno più stati), dobbiamo verificare i seguenti due possibili stati: bloccato ed evidenziato. Esiste anche un gruppo di stati"sotto il cursore", che non voglio ancora aggiungere per evitare confusione. Nelle prossime versioni creerò un prefisso speciale che aprirà un elenco individuale dei possibili stati di ogni tipo di elemento. Questo faciliterà il lavoro programmatico.

Come controlleremo il ritorno degli stati bloccati ed evidenziatiEDIT, S_EDIT e H_SLIDER:

• Troviamo la casella di controllo "Imposta un'opzione" nel file API.

• Scriviamo il blocco/sblocco degli elementi EDIT, S_EDIT e H_SLIDER all'interno della sua casella e stampiamo() gli stati degli elementi.

• Troviamo gli elementi EDIT, S_EDIT e H_SLIDER nel file API.

• Scriviamo un ritorno di stato in caso di inserimento di un valore in questi elementi.

• Stampiamo il risultato ottenuto con Print().

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

1. Individuare la casella di controllo "Imposta un'opzione" nel file API e scrivere il blocco/sblocco degli elementiEDIT, S_EDIT e H_SLIDER all'interno del suo caso.Quindi, produrre gli stati tramite Print().

case Settings_example_1___Set_an_option:
  
            switch((int)action)
               {
               //------------------------------------------------------------------------------------------------------
               //What to do when the checkbox is checked or unchecked? 
               //------------------------------------------------------------------------------------------------------
                case checked: 
                               {
                                //-----------------------------------------------
                                //Locking EDIT:
                                w7_s_p4_EDIT_Comment_1(p4_LOCK);
                                
                                //Locking H_SLIDER:
                                w6_i_p3_H_SLIDER_Roll_the_value(p3_LOCK);
                                
                                //Locking S_EDIT:
                                w6_d_p5_S_EDIT_Spin_the_value(p5_LOCK); 
                                
                                //-----------------------------------------------
                                //Getting state of EDIT:
                                int EDIT_state =  (int)w7_s_p4_EDIT_Comment_1(get_s, p4_GET_STATE);

                                //Getting state of H_SLIDER:
                                int H_SLIDER_state = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE); 

                                //Getting state of S_EDIT:
                                int S_EDIT_state = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d, p5_GET_STATE); 
                                //-----------------------------------------------
                                
                                //Printing results:
                                Print("EDIT_state      = ",EDIT_state);
                                Print("H_SLIDER_state  = ",H_SLIDER_state);
                                Print("S_EDIT_state    = ",S_EDIT_state);
                                //-----------------------------------------------
                               }
                break;
                //------------------------------------------------------------------------
                case unchecked: 
                               {
                                //-----------------------------------------------
                                //Unlocking the element EDIT:
                                w7_s_p4_EDIT_Comment_1(p4_UNLOCK);
                                
                                //Unlocking H_SLIDER:
                                w6_i_p3_H_SLIDER_Roll_the_value(p3_UNLOCK);
                                
                                //Unlocking S_EDIT:
                                w6_d_p5_S_EDIT_Spin_the_value(p5_UNLOCK);
                                
                                //-----------------------------------------------
                                //Getting state of EDIT:
                                int EDIT_state =  (int)w7_s_p4_EDIT_Comment_1(get_s, p4_GET_STATE);

                                //Getting state of H_SLIDER:
                                int H_SLIDER_state = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE); 

                                //Getting state of S_EDIT:
                                int S_EDIT_state = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d, p5_GET_STATE); 
                                //-----------------------------------------------
                                
                                //Printing results:
                                Print("EDIT_state      = ",EDIT_state);
                                Print("H_SLIDER_state  = ",H_SLIDER_state);
                                Print("S_EDIT_state    = ",S_EDIT_state);
                                //-----------------------------------------------
                               }
                break;
               } 
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Risultato:

• Quando si fa clic sulla casella di controllo, le funzioni dell'elemento restituiscono l'indice 64, che corrisponde allo stato v_NEUTRAL_BLOCKED (blocco neutro).
• Se si deseleziona la casella di controllo, le funzioni dell'elemento restituiscono l'indice 15, che corrisponde allo stato v_NEUTRAL_STATE (stato neutro).

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

[Реter Konow]

2. Secondo compito:

• Individuare gli elementiEDIT, S_EDIT, H_SLIDER nel file API e prescrivere di ottenere lo stato quando viene inserito un valore per vedere se le loro funzioni restituiscono un indice HIGHLIGHTED ( evidenziato).

Iniziare:

case Settings_example_2___Comment_1:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the text is entered?
               //------------------------------------------------------------------------------------------------------
               {
                //Getting state of EDIT:
                int EDIT_state =  (int)w7_s_p4_EDIT_Comment_1(get_s, p4_GET_STATE);
                                
                //Printing the results:
                Print("EDIT_state      = ",EDIT_state);
               } 
               //------------------------------------------------------------------------------------------------------
               //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:  75  |  Digits: Integer value
               //------------------------------------------------------------------------------------------------------
               {
                //Getting state of H_SLIDER:
                int H_SLIDER_state = w6_i_p3_H_SLIDER_Roll_the_value(get_i,p3_GET_STATE); 
                                
                //Printing results:
                Print("H_SLIDER_state  = ",H_SLIDER_state);
               }           
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

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
               //------------------------------------------------------------------------------------------------------
               {
                //Getting state of S_EDIT:
                int S_EDIT_state = (int)w6_d_p5_S_EDIT_Spin_the_value(get_d, p5_GET_STATE); 
                                
                //Printing results:
                Print("S_EDIT_state    = ",S_EDIT_state); 
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;

Risultato:

• EDIT: su un evento di interazione con l'utente, restituisce un indice di stato di 67, che significav_ACTIVATED_HIGHLIGHTED ( attivato, evidenziato).

• S_EDIT: su un evento di interazione con l'utente, restituisce un indice di stato di 67, che significav_ACTIVATED_HIGHLIGHTED ( attivato, evidenziato).

• H_SLIDER: su un evento di interazione dell'utente, restituisce alternativamente gli indici 66 e 67, che significanov_NEUTRAL_HIGHLIGHTED ( neutro, illuminato) ev_ACTIVATED_HIGHLIGHTED (attivato, illuminato).Bug. Correzione nella prossima versione.

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

Risultati:

In generale, i risultati possono essere valutati come soddisfacenti. Gli elementi restituiscono gli indici degli stati neutri e bloccati come previsto. Tuttavia, ci sono alcune carenze:

• La funzione elemento D_LIST non restituisce alcuno stato.

• La funzione H_SLIDER restituisce alternativamente gli indici degli stativ_NEUTRAL_HIGHLIGHTED ev_ACTIVATED_HIGHLIGHTED invece di un unico indice - v_ACTIVATED_HIGHLIGHTED(attivato, illuminato).

Conclusioni:

• È necessario correggere le carenze.
• È necessario creare un elenco di intellisense chiamato con un prefisso speciales_, in modo che l' utente possa sapere quali tipi di elementi hanno quali stati e utilizzarli facilmente nel codice.

Potenzialmente, è possibile aggiungere nuovi stati agli elementi. Ad esempio, Neutro puntato e Attivato puntato ( neutro sotto il cursore e attivato sotto il cursore), ma c'è una questione di praticità e di reale necessità dell'utente di avere queste caratteristiche. Finché non ci saranno queste esigenze, non aggiungerò nuovi stati.

Questo è il termine di questo argomento.

Passiamo ai seguenti argomenti.

[hini]

Ho passato l'ultima settimana a cercare come scrivere un'interfaccia utilizzando WinForm e incorporarla nei grafici MT5. Oggi l'ho finalmente realizzato.

[hini]

Caricare un video è più facile che caricare una gif e il file è più piccolo.

[Реter Konow]

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. Apertura di un elenco di elementi di finestra disponibili in modo programmatico.

4. Apertura di un elenco di proprietà dei singoli elementi.

5. Parsing del nome dell'elemento e della funzione wrapper della finestra.

6. Restituzione del valore di un parametro dell'elemento a una variabile del suo tipo.

7. Impostazione di valori per parametri di elementi di tipo diverso.

8. Restituzione, modifica e inoltro di valori tra parametri di elementi diversi. 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. Test per l'impostazione degli stati ON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK per diversi tipi di elementi.

11. Test di binding e sincronizzazione dei valori di modifica degli elementi: ad esempio, campo di input con pulsanti e cursori. In modo che quando il valore di un elemento (manuale o software) cambia, il valore del secondo elemento cambia di conseguenza.

12. Test dell'ottenimento/impostazione da parte del software dei limiti dell'intervallo dello slider e del campo con pulsanti (proprietà _V_MIN, _V_MAX, _V_STEP, _DIGITS).

13. Test del funzionamento dell'interrogazione sullo stato dell'elemento (_GET_STATE).

14. Collegamento dei colori del testo e dei bordi ai limiti dei valori distanziati.

15. Orientamento nel file API.

16.Implementazione di una semplice logica di programma per l'aspetto delle finestre di messaggio e di avviso.

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

Gli argomenti presi in considerazione sono evidenziati in giallo.

Per il momento ne rimangono alcuni da considerare:

14. Collegamento dei colori del testo e delle cornici ai limiti dei valori distanziati.

15. Orientamento nel file API.

16.Implementazione di una semplice logica di programma per l'aspetto delle finestre di messaggio e di avviso.

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

Suggerisco di collegare l'argomento 14 con l'argomento 16. Il superamento dei limiti impostati dei valori dei parametri causerà prima segnali sotto forma di cambiamento di colore di parti degli elementi (testo, base, cornice, striscia, ecc.), poi l'apertura di una finestra di dialogo e quindi di una finestra di avviso. Allo stesso tempo, la finestra di avviso bloccherà le modifiche ai valori degli elementi finché non verrà chiusa manualmente dall'utente.

Inoltre, vorrei aggiungere un tema all'elenco:

17. annullare le impostazioni inserite quando l'utente fa clic sul pulsante "Annulla".

Molto tempo fa è stata sviluppata e in parte testata la tecnologia che consente di annullare le impostazioni dell'utente facendo clic sul pulsante "Annulla". Al momento, non si sa quanto la precedente funzionalità funzioni. Pertanto, è necessario eseguire un test.

A causa della sovrapposizione di argomenti, l'ordine di revisione sarà il seguente:

14. Implementazione della protezione dei confini dei parametri sfalsati:

• Scrittura della logica per controllare le impostazioni all'interno dei confini prestabiliti e creazione di un sistema di avviso.

• Avviso 1: l'utente riceve un segnale sotto forma di cambiamento di colore di parti degli elementi.( Colleghiamo il colore del testo, delle basi, delle cornici e della barra di scorrimento ai confini dei valori).

• Avviso 2: 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"). )

• Avviso 3: apertura di una finestra di avviso che blocca ulteriori modifiche alle impostazioni e notifica all'utente l'esclusione di responsabilità, richiedendo la conferma manuale dell'utente. ( Verifichiamo il blocco delle finestre quando appare la finestra di avviso).

15. Esaminiamo in dettaglio la nuova stampa del file API.

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

Successivamente, raccoglierò tutti i bug o i difetti riscontrati e preparerò un elenco di attività per la prossima release.

Dopo la prossima versione con correzioni e aggiunte, mi concentrerò sulle tabelle, in cui vedo una delle principali direzioni di ulteriore sviluppo del motore.

[Реter Konow]

hini #:

Ho passato l'ultima settimana a imparare come scrivere un'interfaccia utilizzando WinForm e inserirla nei grafici MT5. Oggi ho finalmente capito come fare.

E come farete a far comunicare l'interfaccia con il vostro codice di programmazione?