Galerie d'interfaces utilisateur écrites en MQL - page 66

[Реter Konow]

Poursuivons avec une nouvelle page.

[Реter Konow]

12. Obtention/réglage par programme des limites de valeur ducurseur et du champ avec boutons (_V_MIN, _V_MAX, _V_STEP, _DIGITS).

1. ouvrons une fenêtre contenant des éléments avec les paramètres ci-dessus :

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

2. Écrivons les valeurs de _V_MIN, _V_MAX, _V_STEP, _DIGITS et affichons-les dans le journal :

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat : les valeurs des propriétés des paramètres du curseur sont enregistrées.

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

3. Répétons l'opération avec le champ à boutons. Contrairement au curseur, le champ a d'autres limites numériques et son type de valeur est 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);
   //------------------------------------------------ 

Résultat : lesvaleurs des propriétés des paramètres du champ avec boutons sont affichées dans le journal.

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

4. Définir d'autres limites de la plage du curseur (testé pour la première fois, le résultat est inconnu).

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat : *J'ai trouvé unproblème avec la plage des nombres négatifs (correction dans la prochaine version).

Vérifions avec des limites de plage positives :

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat : les bornes de la plage ont été modifiées avec succès.

Point principal : La portée du curseur peut être modifiée à l'aide de sa fonction.

**Important :il n'est pas possible de modifier rétroactivement le type de valeur du paramètre de int à double ou vice versa.

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

Réalisons une expérience similaire avec le champ de saisie :

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat : tout fonctionne comme prévu. Le champ avec les boutons accepte la plage et le pas spécifiés. Si la plage est dépassée, une erreur est signalée dans le journal.

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

5. Enfin, définissons la valeur_DIGITS pour le champ avec boutons (le curseur ne fonctionnera pas car son type de paramètre est int) :

• Définissons la valeur du pas avec quatre chiffres après le point.
• La variable digits est fixée à 4 (quatre décimales).

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat :

• Au début, il y avait trois chiffres après la virgule (le nombre original avant la modification du logiciel).

• Ensuite, l'appel au logiciel a augmenté la précision à quatre chiffres :

• Ensuite, à 7 chiffres :

//Setting 7 digits after the decimal point:

w6_d_p5_S_EDIT_Spin_the_value(7,p5_DIGITS);

Résultats :

• Il est possible de réinitialiser par programme les limites de la plage de nombres d'origine du champ du bouton ainsi que du curseur.

• Il est possible de modifier par programme la précision initiale de la valeur double en définissant un nombre différent de décimales.
  

• Le curseur présente un problème de calcul des valeurs dans les limites des nombres négatifs (ce problème sera résolu).

• Le type original du paramètre de l'élément ne peut pas être réinitialisé.

Ceci conclut ce sujet.

[Реter Konow]

13. Interroger l'état des éléments _GET_STATE.

Il arrive souvent qu'il soit nécessaire d'obtenir par programme l'état de l'un ou l'autre élément de l'interface. Pour résoudre ce problème, l'identificateur _GET_STATE est créé.

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

*Important :à la demande de _GET_STATE, la fonction renvoie l'index de l'état actuel de l'élément.

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

L'image ci-dessous montre la liste des états de l'élément.

1. identifiants d'état :

(*dans laprochaine version, le préfixe v_ sera remplacé par le préfixe s_)

Indices affichés dans le journal :

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

Testons l'interrogation et la récupération des états d'un élément :

1. ouvrons la fenêtre et obtenons l'état initial du bouton "Start" :

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);
   //------------------------------------------------

Résultat : la valeur 15 correspondant à l'état v_NEUTRAL_STATE est obtenue .

2. Enregistrons les états du bouton à l'appui et au relâchement :

Pour ce faire :

• Trouvons le bouton dans le fichier API.
• Écrivons une requête _GET_STATE pour les deux cas - pressé et relâché.

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;

Résultat : lors de l'événement pressé/relâché, l'index de l'état actuel est imprimé dans le journal.

Rappel :

15 = v_NEUTRAL_STATE

62 = v_ACTIVATED_STATE

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

3. Répétons la requête avec la case à cocher.

1. Obtenons l'état de la case à cocher lors de l'ouverture de la fenêtre :

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat : on obtient la valeur 15, correspondant à l'état neutre v_NEUTRAL_STATE (où se trouve la case à cocher).

2. Ensuite, interrogeons les états de la case à cocher sur l'événement d'appui et de relâchement.

Pour ce faire :

• Trouvons la case à cocher"Set an option" dans le fichier API.
• Écrivons la requête _GET_STATE pour les deux cas - coché et non coché.

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;

Résultat : nous obtenons les valeurs 66 (v_NEUTRAL_HIGHLIGHTED) et 67 (v_ACTIVATED_HIGHLIGHTED), ce qui signifie que l'état neutre et l'état enfoncé sont mis en évidence.

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

Ceci conclut la première partie du sujet.

Dans la deuxième partie, nous renverrons les états de la liste déroulante D_LIST, du curseur H_SLIDER et des champs de saisie S_EDIT et EDIT.

[[Supprimé]]

J'ai commencé à utiliser un échange d'actifs cryptographiques appelé coinsbitfx.com. Coins Bit FX prétendait être enregistré auprès de la National Futures Association pour convaincre les utilisateurs de sa légitimité. À un moment donné, j'ai cru que la valeur de mon compte avait augmenté pour atteindre 135 134 dollars. Mais lorsque j'ai essayé de retirer des fonds de mon compte, la bourse m'a dit que la transaction était "en cours d'examen". Depuis, le résident n'a pu contacter personne sur le site web et n'a pas accès aux fonds investis. Cela m'a mis la puce à l'oreille et j'ai lu sur un blog l'existence de RECOVERYCOINGROUP AT GMAIL DOT COM, j'ai fait mes recherches et j'ai décidé de faire appel à leurs services ; en moins de 72 heures, mes fonds ont été récupérés, et comme si cela ne suffisait pas, ils ont également récupéré les BTC de mes amis. Je suis donc assez audacieux pour faire connaître ces gars au monde entier. N'hésitez pas à contacter le Recovery Coin Group aujourd'hui et remerciez-moi plus tard !

[Реter Konow]

13. Demande d'état _GET_STATE.

Partie 2 : Obtenir les états des éléments D_LIST, H_SLIDER, EDIT, S_EDIT.

Dans la dernière partie, nous avons étudié la possibilité de renvoyer par programme les états du bouton BUTTON et de la case à cocher CHECKBOX . La requête _GET_STATE a été utilisée et la liste des noms d'états renvoyés par les fonctions a été affichée. Il y a six noms en tout, chacun commençant par le préfixe v_. (abréviation de value, qui sera remplacée par s_ - abréviation de state).

Rappelons les indices d'état :

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

Dans ce cas, les numéros d'index spécifiques ne sont pas importants. Lorsque l'utilisateur a besoin de placer un état particulier dans une condition, il utilise un identifiant.

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

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

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

*Très important :

Permettez-moi d'expliquer la différence essentielle entre les états v_NEUTRAL_STATE et v_NEUTRAL_HIGHLIGHTED, et entre v_ACTIVATED_STATE et v_ACTIVATED_HIGHLIGHTED:

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

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

il en va de même pour l'état activé :

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

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

Cette différence fait toute la différence.

Actuellement, le bouton et certains autres éléments ne renvoient que v_NEUTRAL_STATE et v_ACTIVATED_STATE, et ne renvoient pas d' état HAUTE LUMIERE comme une case à cocher. Cela signifie que l'utilisateur n'a aucun moyen de savoir si les éléments ont été cliqués/décliqués à l'instant même, ou quand, il y a un temps indéfini. Toutefois, l'utilisateur peut connaître le moment où il a appuyé sur l'élément dans le fichier API. Oui, mais cette fonctionnalité n'est pas encore disponible dans le reste du programme. Dans la prochaine version, le retour d'état en surbrillance sera ajouté à tous les éléments interactifs. Ainsi, de n'importe quel endroit du programme, l'utilisateur pourra savoir si un élément vient d'être appuyé/désappuyé, ou s'il est dans son état depuis longtemps.

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

Passons à la partie pratique :

• Ouvrons deux fenêtres avec les éléments D_LIST, H_SLIDER, EDIT et S_EDIT.
• Renvoyons les états des éléments immédiatement après l'ouverture.

1. ouvrons les fenêtres

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

2. Obtenons les états des éléments :

   //------------------------------------------------
   //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);
   //------------------------------------------------

Résultat : tous les éléments du cnome D_LISTont l' indice d'état 15 (état neutre v_NEUTRAL_STATE). D_LIST a renvoyé une erreur (-1).

Motif : le retour des états de cet élément n'est pas spécifié dans la fonction centrale. Défaut technique.Il sera corrigé dans la prochaine version.

Puisque la fonction D_LIST ne renvoie pas encore l'indice d'état, concentrons-nous sur trois éléments dont les états ont été reçus avec succès: EDIT , S_EDIT et H_SLIDER.

Ce qu'il faut vérifier :

• Les indices renvoyés par la fonction lorsque les éléments sont verrouillés et cliqués.
• Si les éléments donnés ont un étatHIGHLIGHTED ( mis en évidence). En d'autres termes, il est possible de savoir si l'élément vient d'être cliqué ou non.

Nous venons de vérifier que les fonctions EDIT, S_EDIT et H_SLIDER renvoient un index de l'état neutre à l'ouverture de la fenêtre. Il reste à vérifier les autres états. Comme ces types d'éléments ne peuvent théoriquement se trouver que dans les états neutre, verrouillé et en surbrillance (contrairement aux boutons et aux cases à cocher, qui ont plus d'états), nous devons vérifier les deux états possibles suivants : verrouillé et en surbrillance. Il existe également un groupe d'états"sous le curseur", que je ne souhaite pas encore ajouter pour éviter toute confusion. Dans les prochaines versions, je créerai un préfixe spécial qui ouvrira une liste individuelle des états possibles de chaque type d'élément. Cela facilitera le travail de programmation.

Comment allons-nous vérifier le retour des étatsEDIT, S_EDIT et H_SLIDER bloqués et mis en évidence ?

• Trouvons la case à cocher "Définir une option" dans le fichier API.

• Écrivons le verrouillage/déverrouillage des éléments EDIT, S_EDIT et H_SLIDER dans son cas et imprimons() les états des éléments à cet endroit.

• Trouvons les éléments EDIT, S_EDIT et H_SLIDER dans le fichier API.

• Ecrivons un retour d'état sur l'événement d'entrée d'une valeur dans ces éléments.

• Affichons le résultat obtenu via Print().

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

1. Trouvez la case à cocher "Définir une option" dans le fichier API et écrivez le verrouillage/déverrouillage des élémentsEDIT, S_EDIT et H_SLIDER dans son cas.Produisez ensuite les états à l'aide de 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;

Résultat :

• Lorsque l'on clique sur la case à cocher, les fonctions de l'élément renvoient l'index 64, qui correspond à l'état v_NEUTRAL_BLOCKED (verrouillé neutre).
• En cas de décochage de la case, les fonctions d'élément renvoient l'indice 15, qui correspond à l'état v_NEUTRAL_STATE (état neutre).

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

[Реter Konow]

2. Deuxième tâche :

• Trouver les élémentsEDIT, S_EDIT, H_SLIDER dans le fichier API et prescrire l'obtention de l'état lorsqu'une valeur est saisie pour voir si leurs fonctions renvoient un index HIGHLIGHTED (en surbrillance).

Commencez :

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;

Résultat :

• EDIT: Lors d'un événement d'interaction avec l'utilisateur, renvoie un indice d'état de 67, ce qui signifiev_ACTIVATED_HIGHLIGHTED ( activé, mis en évidence).

• S_EDIT: Lors d'une interaction avec un utilisateur, renvoie un index d'état de 67, ce qui signifiev_ACTIVATED_HIGHLIGHTED ( activé, en surbrillance).

• H_SLIDER: En cas d'interaction avec l'utilisateur, renvoie alternativement les indices 66 et 67, ce qui signifiev_NEUTRAL_HIGHLIGHTED ( neutre, éclairé) etv_ACTIVATED_HIGHLIGHTED (activé, éclairé).Bogue. Correction dans la prochaine version.

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

Résultats :

En général, les résultats peuvent être évalués comme satisfaisants. Les éléments renvoient les indices des états neutre et verrouillé comme prévu. Cependant, il y a quelques lacunes :

• La fonction de l'élément D_LIST ne renvoie aucun état.

• La fonction H_SLIDER renvoie alternativement les indices des étatsv_NEUTRAL_HIGHLIGHTED etv_ACTIVATED_HIGHLIGHTED au lieu d' un seul indice 67 - v_ACTIVATED_HIGHLIGHTED(activé, illuminé).

Conclusions :

• Il faut corriger les lacunes.
• Il est nécessaire de créer une liste d'intellisense appelée par un préfixe spécials_ afin que l' utilisateur puisse savoir quels types d'éléments ont quels états et les utiliser facilement dans le code.

Potentiellement, il est possible d'ajouter de nouveaux états d'éléments. Par exemple, Neutre pointé et Activé pointé ( neutre sous le curseur et activé sous le curseur), mais il y a une question de praticité et de besoin réel de l'utilisateur de disposer de ces caractéristiques. Tant que ces exigences ne seront pas satisfaites, je n'ajouterai pas de nouveaux états.

C'est la fin de ce sujet.

Pour plus d'informations, voir les sujets suivants.

[hini]

J'ai passé la semaine dernière à chercher comment écrire une interface en utilisant WinForm et l'intégrer dans les graphiques MT5. Aujourd'hui, je l'ai enfin réalisé.

[hini]

Le téléchargement d'une vidéo est plus facile que celui d'un gif et le fichier est plus petit.

[Реter Konow]

Une liste générale de sujets à prendre en considération :

1. l'orientation dans la liste d'intellisense et la sélection de la fonction de la bonne fenêtre.

2. Ouverture et fermeture de fenêtres par programmation.

3. l'ouverture d'une liste d'éléments de fenêtre disponibles par programme

4. ouverture d'une liste de propriétés d'éléments individuels

5. Analyse du nom de l'élément et de la fonction d'enveloppe de la fenêtre.

6. renvoi de la valeur d' un paramètre d'élément à une variable de son type

7. Définition de valeurs pour des paramètres d'éléments de types différents.

8. Renvoyer, modifier et transmettre des valeurs entre les paramètres de différents éléments. Considérer différents types d'éléments et de valeurs, et tester la transmission entre différents types d'éléments dans différentes fenêtres.

9. Renvoi de la valeur précédente (_V_LAST). Quand et dans quels cas la dernière valeur est requise (à ne pas confondre avec la valeur actuelle).

10. Test de réglage des états ON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK pour différents types d'éléments.

11. test de liaison et de synchronisation des valeurs changeantes des éléments : par exemple, champ de saisie avec boutons et curseur. Ainsi, lorsque la valeur d'un élément (manuel ou logiciel) change, la valeur du second élément change en conséquence.

12) Test de l'obtention/du réglage par le logiciel des limites de la plage du curseur et du champ avec boutons (propriétés _V_MIN, _V_MAX, _V_STEP, _DIGITS).

13. Test du fonctionnement de l'interrogation sur l'état de l'élément (_GET_STATE).

14. Lier les couleurs du texte et de la bordure aux limites des valeurs espacées.

15. Orientation dans le fichier API.

16.mise en œuvre d'une logique de programme simple pour l'apparence des fenêtres de message et d'avertissement.

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

Les sujets qui ont été examinés sont surlignés en jaune.

Pour l'instant, il en reste encore quelques-uns à examiner :

14. Lier les couleurs du texte et du cadre aux limites des valeurs espacées.

15. Orientation dans le fichier API.

16.mise en œuvre d'une logique de programme simple pour l'apparence des fenêtres de message et d'avertissement.

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

Je suggère de lier le sujet 14 au sujet 16. Le dépassement des limites fixées pour les valeurs des paramètres entraînera d'abord des signaux sous la forme d'un changement de couleur de certaines parties des éléments (texte, base, cadre, bande, etc.), puis l'ouverture d'une fenêtre de dialogue, et enfin d'une fenêtre d'avertissement. En même temps, la fenêtre d'avertissement bloquera les changements de valeurs dans les éléments jusqu'à ce qu'elle soit fermée manuellement par l'utilisateur.

J'aimerais également ajouter un thème à la liste :

17. l'annulation des paramètres saisis lorsque l'utilisateur clique sur le bouton "Annuler".

Il y a longtemps que la technologie permettant d'annuler les paramètres de l'utilisateur en cliquant sur le bouton "Annuler" a été développée et, dans une certaine mesure, testée. À l'heure actuelle, on ne sait pas dans quelle mesure l'ancienne fonctionnalité fonctionne. Un test est donc nécessaire.

En raison du chevauchement des sujets, l'ordre d'examen sera le suivant :

14. Mise en œuvre d'une protection échelonnée des limites des paramètres :

• Écrire une logique pour contrôler les paramètres à l'intérieur de limites prédéfinies et créer un système d'avertissement.

• Avertissement 1 : l'utilisateur reçoit un signal sous la forme d'un changement de couleur de certaines parties des éléments.( Lions la couleur du texte, des bases, des cadres et de la barre de défilement aux limites des valeurs).

• Avertissement 2 : ouverture d'une boîte de dialogue contenant une notification de risque et une suggestion de retour aux paramètres d'origine. ( Testons la possibilité réelle de revenir aux paramètres précédents en cliquant sur le bouton "Annuler". )

• Avertissement 3 : ouverture d'une fenêtre d'avertissement bloquant toute modification ultérieure des paramètres et informant l'utilisateur de la clause de non-responsabilité, ce qui nécessite une confirmation manuelle de la part de l'utilisateur. ( Testons le blocage des fenêtres lorsque la fenêtre d'avertissement apparaît).

15. Examinons en détail l'impression du nouveau fichier API.

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

Ensuite, je rassemblerai tous les bogues ou défauts trouvés et dresserai une liste de tâches pour la prochaine version.

Après la prochaine version avec les corrections et les ajouts, je me concentrerai sur les tables, dans lesquelles je vois l'une des principales directions de développement du moteur.

[Реter Konow]

hini #:

J'ai passé la semaine dernière à apprendre comment écrire une interface à l'aide de WinForm et à l'intégrer dans les graphiques MT5. Aujourd'hui, j'ai enfin trouvé comment le faire.

Et comment allez-vous faire pour que l'interface communique avec votre code de programmation ?