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

Nouveau commentaire
 
Maxim Kuznetsov projet?

Il y a un dépôt de quelque chose (que l'on peut difficilement qualifier de code source ) et de la documentation .

Pourquoi le cherches-tu, le cherches-tu, et tu ne le trouves pas)). Le projet se trouve sur les pages de la branche, avec les instructions d'installation. Je ne vous donnerai pas la page exacte, faites défiler vers l'arrière.

La prochaine version sera publiée dans kodobase. Si vous voulez, vous pouvez attendre un peu.
 

Ajout de la possibilité de modifier par programme la couleur des cadres des éléments et de les associer aux valeurs des paramètres. Il s'agit d'un indicateur informatif et utile qui permet de se rendre compte rapidement du niveau de risque des valeurs saisies. Il s'est avéré pratique et clair. En outre, en cas de dépassement des limites fixées, des fenêtres d'avertissement apparaissent.

Quelques exemples :


Demain, nous irons plus loin avec des exemples et du code.

 
Commençons par une nouvelle page.
 

Avant d'aborder la question de la mise en œuvre de la protection échelonnée des limites des paramètres et des avertissements à l'intention des utilisateurs, il convient d'évoquer un autre sujet qui la précède directement. Il s'agit de la présélection des paramètres.

Je commencerai par ce qui est bien connu : la plupart des programmes MQL ont des variables de la catégorie input. Elles sont déclarées au niveau global et sont visibles dans une seule fenêtre de paramétrage. Cette fenêtre apparaît au début du programme et l'utilisateur peut y modifier les valeurs initiales des variables "externes", si le besoin s'en fait sentir. Mais avant cela, l'utilisateur initialise les variables externes à l'intérieur du programme. Le fait est que les préréglages du programme ne sont pas universels, et c'est pourquoi il existe une catégorie de variables qui nécessitent la possibilité d'être paramétrées à chaque démarrage. On sait également que toute tentative d'accès manuel aux variables externes pendant l'exécution du programme est impossible et nécessite un redémarrage. Avec une interface graphique, cette nécessité est éliminée. Les paramètres du programme peuvent être ouverts au moment de l'exécution.

Cependant, il est toujours nécessaire de définir des valeurs initiales pour les paramètres du programme au début.

Si nous disposons d'une interface graphique , il est inutile de déclarer des variables de type entrée, car nous n'avons plus besoin de la fenêtre de paramétrage standard , mais l'essentiel reste le même : à la place des variables d'entrée, nous devons définir des valeurs initiales pour les paramètres des commandes.

Lors de l'initialisation du programme, nous devons appeler une fonction qui définit les valeurs initiales de nos propres fenêtres, et non de la fenêtre standard. En option, cela peut être fait dans le constructeur de KIB, au stade de la construction de l'interface, lorsque les valeurs V_CURRENT sont définies, ou les états ON/OFF, etc. Il est désormais possible de combiner l'initialisation des éléments dans le constructeur et dans le programme.

Par conséquent, nous avons besoin d'une fonction spéciale appelée OnInit() pour effectuer ce travail.

Ce que cette fonction fera exactement :

  • Ouvrir les fenêtres nécessaires au début du programme.
  • Définir des valeurs dans les contrôles cibles.

Quel sera le nom de cette fonction ?

Je l'appellerais Initialize(), mais chacun peut trouver sa propre variante.

L'essentiel est que cette fonction doit se trouver dans n'importe quelle interface Expert Advisor. Elle peut être comparée à la fonction OnTick() d'un Expert Advisor ou OnCalculate() d'un indicateur. Il est important de comprendre ceci.


Quelle valeur la fonction renverra-t-elle ?

La fonction est de type void. Il n'est pas nécessaire de renvoyer une valeur. Lorsqu'elle est appelée, elle ouvre les fenêtres nécessaires, initialise les paramètres des éléments et prédéfinit éventuellement certaines propriétés. C'est à peu près tout. Théoriquement, on peut y définir les limites initiales des paramètres, mais je pense que le contrôle des valeurs sera implémenté dans une fonction séparée appelée sur les événements d'éléments provenant du fichier API et de la minuterie. Je vais probablement écrire une impression des appels de contrôle dans la prochaine version.

*Il est important deprendre en compte le fait qu'à l'heure actuelle, le concept d'interface Expert Advisors n'en est qu'à ses débuts et que de nombreuses découvertes nous attendent.


Voici un exemple de la fonction d'initialisation d'une interface Expert Advisor dans le contexte du projet de démonstration actuel :

1. Appel de la fonction :

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


2. mise en œuvre de la fonction :

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


Jusqu'à présent, je vois la structure de la fonction comme suit. Une fonction très simple. Elle ouvre des fenêtres et envoie les valeurs requises aux paramètres des éléments. Il est possible de modifier l'initialisation des éléments et l'ouverture des fenêtres à certains endroits, car l'ouverture des fenêtres affichera immédiatement les valeurs requises des éléments sans redessin supplémentaire. Il s'agit toutefois de choses mineures.


Passons maintenant au sujet principal : la mise en œuvre de la protection des paramètres étape par étape.

1...6263646566676869
Nouveau commentaire