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

Nouveau commentaire
 
Aujourd'hui, je vais publier la suite du sujet sur l'indication en couleur des valeurs des paramètres - le clignotement des éléments. La tâche s'est avérée un peu plus compliquée que je ne le pensais, c'est pourquoi j'ai tardé à m'y atteler. En fin de compte, la solution a justifié le temps passé. À mon avis, en tout cas.
 
Vous pouvez le comprendre.
 
Jin Rong Xia #:
Vous pouvez le comprendre.
Oui, je peux vous comprendre. Le traducteur fonctionne bien.
 

Thème 14.3 : Indication des valeurs dangereuses par le clignotement de parties d'éléments (cadres, bases, texte, curseurs et tableaux de curseurs).

Le clignotement des éléments est un excellent complément à l'indication en couleur signalant la transition des paramètres dans la zone des valeurs dangereuses. La mise en œuvre de la nouvelle solution est similaire à la précédente, mais si l'indication de couleur fonctionne selon le principe que plus la valeur est proche de la valeur critique, plus la couleur est vive, le clignotement ne fait qu'augmenter la fréquence de changement de la couleur initiale avec la couleur définie pour le clignotement. L'utilisateur peut régler par programmation le délai de clignotement, en le diminuant progressivement jusqu'à 25 ms ou en l'augmentant jusqu'à 2,5 secondes. Dans ce cas, les deux mécanismes peuvent être utilisés simultanément. La couleur passe du vert clair au rouge vif et au bordeaux, et le clignotement s'accélère. Un mécanisme n'interfère pas avec le second. Nous allons ensuite détailler des exemples pratiques.

*Important: le clignotement est activé indépendamment des fonctions d'indication des couleurs. Les deux mécanismes ne sont pas techniquement liés et peuvent fonctionner en parallèle ou séparément.

Pour mettre en œuvre le clignotement, de nouvelles propriétés ont été ajoutées aux éléments interactifs :

  • pn_BLINK_frame -. Clignotement du cadre Ajouté à tous les contrôles qui ont un cadre. Les éléments suivants sont exclus : H_SLIDER, V_SLIDER, VALUE , R_BUTTON, CHECKBOX.
  • pn_ BLINK_text -. Texte clignotant Ajouté à tous les éléments comportant du texte. Sont exclus les éléments : P_BAR, D_BAR, H_SLIDER, V_SLIDER.
  • pn_BLINK_base - Base du clignotement Ajouté à tous les éléments qui ont une base. Les éléments suivants sont exclus : CHECKBOX, R_BUTTON, D_LIST, C_LIST, VALUE.
  • pn_BLINK_bar -Barre clignotante Ajouté aux éléments comportant une barre : P_BAR , D_BAR,H_SLIDER, V_SLIDER.
  • pn_BLINK_handle - Clignotement du curseur. Ajouté aux curseurs H_SLIDER, V_SLIDER.


De nouvelles propriétés ont été ajoutées pour contrôler la vitesse et l'arrêt du clignotement :

  • pn_BLINK_DELAY - Délai de clignotement. Ajouté à tous les éléments principaux sans exception. * Important : le délai est défini pour toutes les parties clignotantes de l'élément et ne peut différer d'une partie à l'autre. Toutes les parties de l'élément dont le clignotement est activé par le logiciel (il peut y en avoir plusieurs) clignoteront de manière synchrone . Toutefois, la vitesse de clignotement peut varier d'un élément à l'autre, ce qui est entièrement laissé à la discrétion de l'utilisateur.
  • pn_BLINK_STOP Commande qui arrête complètement le clignotement de tous les composants de l'élément.
  • Au stade actuel, il est possible d'activer le clignotement du cadre de la fenêtre de paramétrage. Pour ce faire, vous devez appeler la fonction window et lui transmettre l'identifiant de la propriété pn_BLINK_frame. Et la couleur. Tout est exactement le même que pour les éléments.

Résumons ce qui précède :

  • Le délai de clignotement pn_BLINK_DELAY est défini par programme et s'applique à toutes les parties clignotantes de l'élément en même temps. Elles clignotent de manière synchrone.
  • La propriété pn_BLINK_DELAY a une valeur par défaut. Sauf spécification explicite de l'utilisateur, le délai de clignotement sera de 20, soit un peu plus d'une seconde (20*25ms).
  • Un élément peut avoir un clignotement de plusieurs parties à la fois, ou d'une partie à la fois. La décision est prise par l'utilisateur.
  • Au cours du processus de clignotement, il est possible de modifier la couleur et d'ajuster la vitesse de manière programmée. Les fonctions de clignotement sont abordées ci-dessous.
  • Pour faire clignoter une autre partie de l'élément, vous devez appeler la fonction et lui transmettre l'identifiant de la partie de l'élément et la couleur. Mais si, par exemple, un cadre clignote et que l'utilisateur souhaite que le texte clignote à la valeur souhaitée, et que le cadre s'arrête de clignoter, il est nécessaire de désactiver complètement le clignotement à l'aide de la commande pn_BLINK_STOP, puis d'activer le clignotement du texte par un appel de programme.
  • À la demande de l'utilisateur, les composants de l'élément peuvent clignoter dans différentes couleurs. Par exemple, le texte peut clignoter en vert, le cadre en bleu et la base en rouge. Différentes variantes sont disponibles. Mais permettez-moi de vous rappeler que la vitesse de clignotement de toutes les parties d'un élément est la même.
  • Si une fenêtre est réduite et que son onglet se trouve sur la barre des tâches, et qu'il y a des éléments clignotants dans la fenêtre, l'onglet sélectionnera automatiquement l'élément clignotant le plus rapide dans la fenêtre fermée (il n'y a pas de redessin réel lorsque la fenêtre est fermée) et s'adaptera à sa fréquence et à sa couleur. En d'autres termes, les onglets de la barre des tâches clignotent à la couleur et à la vitesse de l'élément clignotant le plus rapide dans leur fenêtre. Mais si des éléments modifient leur vitesse de clignotement pendant qu'ils reçoivent des valeurs, l'onglet se reconstruit automatiquement en trouvant un autre élément et en modifiant sa vitesse de clignotement et sa couleur.
  • En cas de désactivation complète du clignotement des éléments de la fenêtre, l'onglet s'arrête de clignoter automatiquement.

Demain, nous passerons à des exemples pratiques.

Aujourd'hui, une petite démo pour comprendre de quoi nous parlons.



Malheureusement, il y a des décalages lors de l'enregistrement. Le processeur est chargé. Mais la démo montre que les éléments clignotent de manière asynchrone et à des vitesses différentes. Différentes parties des éléments clignotent également. Tout cela est programmé. L'onglet de la barre des tâches a automatiquement trouvé l'élément qui clignote le plus rapidement et est devenu bleu. Puis, lorsque l'élément a commencé à clignoter moins souvent, il a trouvé l'autre élément qui clignotait le plus rapidement et est devenu rouge.

Nous étudierons cela plus en détail demain.

P.S. Nous discuterons également des options d'utilisation de ces fonctionnalités très utiles.

 


Suite du sujet d'hier...

Aujourd'hui, nous allons résumer conceptuellement et terminer le sujet du clignotement des éléments.

Hier, je n'ai abordé le clignotement que dans le contexte de la signalisation des valeurs dangereuses, mais l'application peut être beaucoup plus large que cela. Voici un exemple :

Imaginons un conseiller expert multidevises analysant la situation de plusieurs places de marché. Supposons qu'il sélectionne les points d'entrée et de sortie optimaux en fonction d'un ensemble de critères complexes. L'Expert Advisor fonctionne en mode semi-automatique et le trader ne peut ou ne veut pas programmer toute la logique de la stratégie de trading. Son robot surveille les marchés, recueille des données et informe sur les points importants. Le travail de l'expert se limite à l'analyse et à l'affichage des résultats dans des tableaux et des diagrammes. La décision finale sur les transactions est prise par une personne.

Dans cette variante, l'activité commerciale consiste à observer des flux de données en temps réel et à regrouper les séries de valeurs courantes dans des paramètres personnalisés. Ces derniers permettent d'améliorer la connaissance de la situation.

Cependant, l'engagement en direct exige des décisions en temps opportun. Le problème se pose lorsque les résultats de l'analyse sont affichés dans différentes fenêtres par le biais de multiples vues graphiques. La quantité d'informations à prendre en compte augmente et la focalisation de l'attention se divise. En conséquence, la perspective du marché s'obscurcit dans l'esprit du trader et l'efficacité de son travail diminue. La fatigue s'installe.

Dans ce cas, les éléments clignotants sont d'une grande aide :

  • Ils signalent l'urgence de prendre des décisions ou d'agir.
  • Ils informent sur la vitesse des changements à venir.
  • Ils indiquent la pertinence des événements observés.
  • Il informe sur la signification des résultats obtenus : chiffres, différences, fourchettes, sommes, limites, etc.

En résumé :
  • Le clignotement peut rappeler, avertir, informer, signaler ou indiquer.
  • Le clignotement concentre l'attention et augmente la concentration du trader.
  • La fréquence et la couleur déterminent l'urgence des décisions ou des actions.
  • Combiné à un changement de couleur, le clignotement augmente l'interactivité de l'interface graphique et l'efficacité du trader.

Passons maintenant à l'analyse pratique des nouvelles fonctionnalités :

  • 1. Prescrivons l'ordre des actions préparatoires.
  • 2. Activons le clignotement du cadre du bouton lorsque l'on appuie et désactivons le clignotement lorsque l'on désappuie.
  • 3. Activons le clignotement du texte du bouton.
  • 4. Activons le clignotement de la base du bouton.
  • 5. Relions plusieurs autres éléments au clignotement du bouton : un champ avec des boutons, un curseur, une case à cocher et d'autres.
  • 6. Déclenchons le clignotement du cadre de la fenêtre.
  • 7. Relions la vitesse de clignotement des éléments à la valeur du curseur et du champ de boutons.

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

1. Ordre des actions préparatoires :

  • Commençons par écrire les wrappers des fonctions Blink_start() et Blink_stop(), qui doivent activer et désactiver le clignotement des éléments lorsqu'elles sont appelées.
  • La fonction Blink_start() sera responsable de l'activation. Elle sera appelée lors de l'événement "press". La fonction Blink_stop() est responsable de la désactivation du clignotement. Elle sera appelée lorsque le bouton "Start" sera pressé .
  • Trouvons le bouton dans le fichier API et écrivons l'appel de la fonction Blink_start() lors de l'appui sur le bouton et l'appel de la fonction Blink_stop() lors de l' appui sur le bouton . 
//-----------------------------------------------------
//This function will start the blinking of the elements.
//-----------------------------------------------------
void Blink_start()
{

}
//-----------------------------------------------------
//This function will stop the blinking of the elements.
//-----------------------------------------------------
void Blink_stop()
{

}


Maintenant, trouvons le cas du bouton "Start" dans le fichier API et écrivons les appels des fonctions Blink_start() et Blink_stop() sur l'événement de pression et d'appui sur le bouton :

case Settings_example_1___Start:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when the button is pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case pressed:    Blink_start();  break;
  
                case released:   Blink_stop();   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Passons maintenant au remplissage des fonctions avec du contenu :

1. Nous avons besoin que le cadre du bouton "Start" clignote. Écrivons un appel pour le clignotement du cadre comme indiqué dans le code ci-dessous. L'identifiant de la propriété de clignotement du cadre du bouton est p1_BLINK_frame. Spécifiez la couleur du clignotement et l'objet du clignotement.

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
}


2) Mettons maintenant en œuvre la désactivation du clignotement lorsque le bouton est relâché. L'identifiant p1_BLINK_STOP est responsable de la désactivation du clignotement . Vous n'avez pas besoin de mettre quoi que ce soit entre parenthèses à part cet identifiant.

void Blink_stop()
{
 //Stopping the blinking of all of the parts of the element all together:
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
}


Vérifions le résultat :



3. Activons le clignotement du texte du bouton au lieu de celui du cadre. L'identifiant de la propriété pn_BLINK_text est responsable du clignotement du texte :

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
}

Résultat : le texte du bouton clignote en bleu et s'arrête de clignoter lorsque l'on appuie sur le bouton.



4. Activons le clignotement de la base du bouton. L'identificateur de la propriété pn_BLINK_base est responsable de la base:

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_base);
}

Résultat : la base du bouton clignote en rouge et s'arrête de clignoter lorsqu'on appuie dessus.



Combinons maintenant le clignotement du cadre du bouton et de son texte :

void Blink_start()
{
 //Setting the blinking of the frame and the text of the button
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 w_6_Settings_example_1((int)clrRed,p8_BLINK_text);
}

Résultat : lecadre et le texte du bouton clignotent de manière synchronisée dans des couleurs différentes, comme prévu.


5. Relions d'autres éléments de cette fenêtre au clignotement : 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Écrivons également la désactivation du clignotement dans la fonction Blink_stop( ) : 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Résultat : les nouveaux éléments sont inclus dans Blink_start() et Blink_stop() et clignotent comme prévu.


6. Faisons en sorte que le cadre de la fenêtre clignote lorsque l'on clique sur le bouton. (Désactivons temporairement le clignotement des éléments en retard).

void Blink_start()
{
//Setting the blinking of the frame of the window:
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
}

void Blink_stop()
{
//Stopping the blinking of the frame of the window:
 w_6_Settings_example_1(p8_BLINK_STOP);
}


Résultat : le cadre de la fenêtre clignote comme il se doit.


*Important : tous les éléments considérés et le cadre de la fenêtre clignotent à la vitesse par défaut.

Par la suite, nous réglerons la vitesse de clignotement des éléments avec la poignée du curseur et le champ avec les boutons.


7. Lions la vitesse de clignotement à la valeur du champ avec les boutons et le curseur. Tous les éléments et le cadre de la fenêtre clignoteront simultanément, et la vitesse de clignotement sera réglée manuellement par ces éléments.

Je vous rappelle que la vitesse de clignotement dépend du délai pn_BLINK_DELAY.

  • Le délai minimum possible est de 1, le maximum de 99.
  • Pour calculer le délai de clignotement, il faut multiplier sa valeur par 25 (ms).
  • Par défaut, le délai est égal à 20, soit 500 millisecondes (20*25ms).

Pour résoudre le problème, procédons comme suit :

  • 1. Rétablissons le clignotement de tous les éléments lors de l'appui ou du relâchement d'un bouton et ajoutons-y le clignotement de la fenêtre d'appel/d'arrêt.
  • 2. Écrire une nouvelle fonction Blink_delay() dans laquelle nous placerons les appels qui établissent une pause dans le clignotement. La fonction acceptera la valeur du délai.
  • 3. Écrivons un appel à la fonction Blink_delay() à partir des cas d'éléments de curseur et de champ de saisie dans le fichier API, en transmettant la valeur actuelle.

N ous avons ajouté le clignotement du cadre de la fenêtre dans la fonction Blink_start(): . 

void Blink_start()
{
 //Setting the color and the part of the element that is suppoused to blink.
 //-------------------------------------------------------------
 w_6_Settings_example_1((int)clrRed,p8_BLINK_frame);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start((int)clrLimeGreen,p1_BLINK_frame);
 w6_i_p1_BUTTON_Start((int)clrRed,p1_BLINK_text);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_frame);
 w6_d_p5_S_EDIT_Spin_the_value((int)C'255,50,0',p5_BLINK_text);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_handle);
 w6_i_p3_H_SLIDER_Roll_the_value((int)C'255,50,0',p3_BLINK_bar);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option((int)C'255,50,0',p7_BLINK_text);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1((int)C'255,50,0',p6_BLINK_frame);
 //-------------------------------------------------------------
}

Nous avons ajouté la désactivation du clignotement du cadre de la fenêtre dans la fonction Blink_stop(): 

void Blink_stop()
{
 //Stopping the blinking
 //-------------------------------------------------------------
 w_6_Settings_example_1(p8_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p1_BUTTON_Start(p1_BLINK_STOP);
 //-------------------------------------------------------------
 w6_d_p5_S_EDIT_Spin_the_value(p5_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p3_H_SLIDER_Roll_the_value(p3_BLINK_STOP);
 //-------------------------------------------------------------
 w6_i_p7_CHECKBOX_Set_an_option(p7_BLINK_STOP);
 //-------------------------------------------------------------
 w6_s_p6_D_LIST_D_LIST_1(p6_BLINK_STOP);
 //-------------------------------------------------------------
}

Écriture de la fonction Blink_delay():

Appeler la fonction Blink_delay() sur l'événement du curseur et des éléments du champ de saisie, et lui transmettre la valeur actuelle des éléments :

void Blink_delay(uint delay)
{
 if(delay > 0 && delay < 100)
   {
    //-------------------------------------------------------------
    w_6_Settings_example_1(delay,p8_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p1_BUTTON_Start(delay,p1_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_d_p5_S_EDIT_Spin_the_value(delay,p5_BLINK_DELAY);
    //-------------------------------------------------------------
    w6_i_p3_H_SLIDER_Roll_the_value(delay,p3_BLINK_DELAY);
    //-------------------------------------------------------------
   }
else Print("Wrong value!");
}

*Note importante : il s'est avéré qu'il est impossible de modifier la vitesse de clignotement des cases à cocher et des listes déroulantes. Cette vitesse est toujours égale à 20 (une demi-seconde). Cela a été fait intentionnellement, mais je le modifierai probablement à l'avenir. Les autres éléments peuvent modifier la vitesse de clignotement.

Écrivons un appel à la fonction Blink_delay() à partir de l'événement de l'élément "Spin_the_value" (le champ avec les boutons). Le champ est connecté au curseur, il n'est donc pas nécessaire de placer l'appel dans le cas du curseur. La connexion fonctionnera et le curseur, sans appel direct, modifiera la vitesse de clignotement par l'intermédiaire du champ avec boutons :

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);
              
               //Сalling the blinking delay function
               Blink_delay((int)value);
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;


Résultat : le champ avec boutons et le curseur modifient la vitesse de clignotement des éléments de la fenêtre.



Résultats :

  • Grâce au clignotement des éléments, l'interface est beaucoup plus interactive et informative qu'auparavant.
  • Les méthodes permettant d'activer, de contrôler et de désactiver le clignotement des éléments sont très simples et sont décrites en détail dans deux articles de cette page.
  • Les méthodes sont énumérées et démontrées à l'aide d'exemples de code et de vidéos.
  • Il est probable que certaines nuances puissent être affinées ou ajoutées à l'avenir, mais dans l'ensemble, les fonctions de clignotement de base ont déjà été ajoutées et ne nécessitent pas de changements majeurs.
  • Vous pouvez changer la couleur du clignotement tout en modifiant la valeur du paramètre de l'élément.

Je considère que ce sujet est épuisé.


Le prochain point sur la liste est l'annulation des valeurs saisies en appuyant sur le bouton "Annuler".

 
La prochaine version sera publiée lundi ou mardi de la semaine prochaine. La mise à jour inclura les fonctionnalités présentées ci-dessus, ainsi que l'annulation/confirmation de l'entrée des paramètres dans les fenêtres de réglage. En outre, les catalogues seront traduits en anglais et le code sera amélioré et corrigé à partir de la liste des problèmes identifiés.
 
Реter Konow #:
La prochaine version sera publiée lundi ou mardi de la semaine prochaine. La mise à jour inclura les fonctionnalités présentées ci-dessus, ainsi que l'annulation/confirmation de l'entrée des paramètres dans les fenêtres de réglage. En outre, les catalogues seront traduits en anglais et le code fera l'objet d'ajustements et de corrections à partir d'une liste compilée de problèmes identifiés.
Avec un peu de chance, à temps.
 
Le travail est négligé, ou vous avez simplement une "saison de velours", des vacances ? C'est sacré.
 
Edgar Akhmadeev #:
Le travail est négligé, ou vous avez simplement une "saison de velours", des vacances ? Eh bien, c'est sacré.
Le travail n'est pas terminé, mais les priorités ont été restructurées. Je continuerai peut-être, s'il y a une demande du public. De toute façon, j'ai besoin de tableaux dynamiques et générés. Et des graphiques aussi. Je les ferai certainement. Le reste - tel qu'il se présente.
 
Реter Konow #:
Je continuerai peut-être s'il y a une demande de la part du public.

Il y a une demande. Le fait que la plupart des gens soient silencieux sur le sujet est normal. Les gens rôdent et attendent. Jusqu'à présent, aucun grand projet n'a été réalisé. Il est toujours difficile de le mener à bien seul et sans financement. Jusqu'à présent, je ne connais qu'un seul projet mené à bien par une seule personne - "VLADIK BRUTAL" sur Steam.

1...636465666768697071
Nouveau commentaire