Galerie d'interfaces utilisateur écrites en MQL - page 65
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Définir l'étatON, OFF, LOCK_ON, LOCK_OFF, LOCK, UNLOCK pour différents éléments
Comment obtenir l'état activé/désactivé d'un bouton ?
Comment obtenir l'état activé/désactivé d'un bouton ?
C'est le sujet suivant. Nous l'examinerons aujourd'hui.
Je dois ajouter que les éléments de cette interface graphique sont dessinés, de sorte que la méthode standard d'obtention de l'état ObjectGetInteger(0, "button1", OBJPROP_STATE) ; ne fonctionnera pas.
Permettez-moi également de vous rappeler que les événements des éléments, y compris les boutons, sont envoyés au fichier API.
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 programmées des fenêtres.
3. l'orientation dans la liste d'intellisense et la sélection du bon élément dans la bonne fenêtre
4. naviguer dans des listes de propriétés d'éléments individuels.
5. Analyse du nom d'un élément et d'une fonction d'enveloppe de fenêtre.
6. le renvoi de la valeur du paramètre d'un élément sélectionné à une variable de son type. Considérer trois types d'éléments différents.
7. Définition de valeurs dans les paramètres de différents types d'éléments. Voyons comment les valeurs apparaîtront dans les fenêtres d'interface de ces éléments.
8. Renvoyer les valeurs des paramètres d'un élément, modifier et transmettre cette valeur à un autre élément. Considérons différents types d'éléments et de valeurs, et testons la transmission entre différents types d'éléments dans différentes fenêtres.
9. Retour 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. Tester le réglage des états ON/OFF/LOCK_ON/LOCK_OFF/LOCK/UNLOCK pour différents types d'éléments.
11. Essayons de lier et de synchroniser les changements de valeurs d'éléments de différents types : par exemple, un champ de saisie avec des boutons et un curseur. Supposons que lorsque la valeur d'un élément (manuel ou logiciel) change, la valeur du second élément change en conséquence.
12. Essayons de réinitialiser par programme les limites de la plage du curseur et du champ de saisie avec boutons au moyen de fonctions d'enveloppe. Je n'ai pas eu le temps de le tester, mais quelque chose me laisse penser que cela fonctionnera. Cependant, voyons ce qu'il en est.
13. Essayons de renvoyer les états des éléments via des fonctions wrapper. C'est inclus dans la fonctionnalité, mais je n'ai pas eu le temps de le tester. Nous verrons bien... Le résultat est inconnu.
14. Obtenons et définissons des couleurs pour le texte et les bases des éléments. Nous pouvons essayer d'associer ces couleurs à des événements simples ou à des limites de valeurs.
15. Je vous en dirai plus sur la manière de naviguer et de lire le nouveau fichier API imprimé.
//------------------------------------------
Les sujets que nous avons déjà abordés sont surlignés en jaune.
Aujourd'hui, nous allons passer en revue :
11. Synchronisation (liaison) de la modification des valeurs d'éléments de types différents : par exemple, un champ de saisie avec des boutons et un curseur. Ainsi, lorsque l'on modifie la valeur d'un élément (manuel ou logiciel), la valeur du second élément change en conséquence.
12. Essayons de réinitialiser par programme les limites de la plage du curseur et du champ de saisie avec boutons via des fonctions d'enveloppe. Je n'ai pas eu le temps de le tester, mais quelque chose me laisse penser que cela fonctionnera. Cependant, voyons ce qu'il en est.
13. Essayons de renvoyer les états des éléments via des fonctions wrapper. C'est inclus dans la fonctionnalité, mais je n'ai pas eu le temps de le tester. Nous verrons bien... Le résultat est inconnu.
11. Liaison des paramètres d'éléments de différents types.
L'observateur a remarqué que dans une interface graphique multifenêtre, différents éléments sont souvent liés par des valeurs de paramètres, des propriétés et des états. En voici un exemple :
//-------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------
On pourrait croire qu'il existe une connexion invisible entre les éléments. Et c'est bien le cas. Mais elle n'est invisible que pour un observateur extérieur. Pour un développeur, c'est tout à fait évident et aujourd'hui nous allons l'examiner en détail.
1. La connexion des éléments a deux aspects :
La réalisation technique des connexions est simplifiée par la présence d'un moteur graphique.
Je m'explique :
Dans un Expert Advisor classique, chaque paramètre est inventé, nommé, stocké et traité par l'utilisateur. Il s'agit d'un travail de routine qui ne peut être contourné. Toutefois, dans le cas de l'utilisation d'un moteur graphique, les éléments créés dans le constructeur reçoivent automatiquement le paramètre ainsi que l'emplacement de stockage et la fonction de traitement/retour. En outre, l'utilisateur obtient leurs propriétés telles que le type, la plage, la valeur passée, etc. Cela simplifie grandement le travail. En théorie, il est possible d'utiliser les paramètres prêts à l'emploi des éléments de l'interface graphique comme d'autres paramètres utilisateur, en les reliant directement à la logique de négociation. Par exemple, lot, trailing stop, take take profit et autres, non pas à partir de leurs propres variables, mais à partir des champs de paramétrage responsables de leurs valeurs.
Quelques conclusions générales :
1. La présence d'un contrôle graphique dans un programme = la présence d'un paramètre de programme prêt à l'emploi + ses propriétés + la fonction de retour/réglage de la valeur.
2. Plus il y a de contrôles dans les fenêtres du programme d'interface, plus il y a de paramètres impliqués dans la logique de négociation et l'entrée/sortie des informations de négociation.
3) Plus il y a de paramètres et de fenêtres, plus le contrôle est élevé et plus la largeur de bande de la sortie des données du marché est importante(sans préjudice de l'automatisation).
4. Plus le contrôle est élevé et plus la bande passante des données de marché est large, plus le trader est conscient de la situation.
5. Conscience multipliée par l'automatisation et le contrôle = multiplication des opportunités pour le trader.
Je dois ajouter que l'automatisation est souvent opposée au contrôle manuel. On dit que le fait d'avoir une interface graphique signifie que l'on négocie manuellement. Mais ce n'est pas le cas. L'interface logicielle n'exclut pas l'automatisation mais l'étend, en lui ajoutant un "gradient" - elle ouvre trois options : lecontrôle manuel, la négociation semi-automatique et le mode autonome.
Il suffit au trader de sélectionner une option.
Il est facile de créer une fenêtre à cet effet.
//---------------------------------------------------------------------------------------------------
2. Passons maintenant à la mise en œuvre technique des paramètres de liaison des contrôles.
Examinons quelques exemples pratiques :
1) Ouvrons une fenêtre de paramétrage familière :
2. ouvrons le fichier API et trouvons les éléments de la fenêtre ouverte dans la fonction On_Gui_Event() :
Rappel : tous les événements de contrôle entrent dans la fonction On_Gui_Event() ;
À cet égard, nous écrirons certains des liens de paramètres à l'intérieur de cette fonction et d'autres à l'extérieur de son corps.
1. Établissons un lien entre le champ avec boutons (S_EDIT) "Tourner la valeur" et le curseur (H_SLIDER) "Rouler la valeur" :
Résultat: nous modifions la valeur du champ à l'aide des boutons, et le curseur se déplace de lui-même.
(*Important - le curseur ne peut se déplacer qu'à l'intérieur de sa plage (dans ce cas, de 0 à 100). En cas de dépassement, la valeur ne change pas, mais une erreur est affichée dans le journal).
//----------------------------------------------------------------------------------------------------------------
3. Inversons les rôles. Le curseur contrôlera la valeur du champ de saisie :
Résultat : lorsque vous déplacez la poignée du curseur, le champ avec les boutons change de valeur de manière synchrone.
//----------------------------------------------------------------------------------------------------------------
4. Écrivons le contrôle mutuel du curseur et du champ avec boutons :
Résultat : le curseur et les champs de saisie se contrôlent mutuellement et simultanément.
//---------------------------------------------------------------------------------------------------
Demain, je publierai la deuxième partie de ce thème avec d'autres éléments.
C'est génial ! J'ai l'intention de consulter ce fil de discussion plus en détail si j'en ai le temps. Je pensais que mon travail repoussait les limites de l'interface graphique de mt4, mais votre travail est d'un niveau supérieur.
Il s'agit là d'un matériel impressionnant ! J'ai l'intention d'explorer ce sujet plus en détail quand j'aurai le temps. Je pensais que mon travail repoussait les limites de l'interface graphique de mt4, mais votre travail est d'un niveau supérieur.
Merci beaucoup pour vos aimables paroles !
11. Paramètres de liaison des éléments de différents types.
Suite du sujet.
Partie 2.
//--------------------------------------------------------------------------------------------------------------------------------
Voyons si nous pouvons appliquer la méthode de liaison présentée à d'autres éléments. Par exemple, aux cases à cocher.
1. Faisons en sorte que la case à cocher du haut verrouille et déverrouille la case à cocher du bas :
Pour ce faire, procédez comme suit
1. Trouvons la case à cocher"Set an option" dans le fichier API.
2. Écrivons un appel de fonction pour la case à cocher"Définir une autre option" qui doit se verrouiller/déverrouiller.
Résultat : la case à cocher est verrouillée et déverrouillée comme prévu :
//--------------------------------------------------------------------------------------------------------------------------------
2) Maintenant, faisons en sorte que la case à cocher verrouille et déverrouille les deux cases à cocher situées en dessous d'elle :
Résultat : la case à cocher verrouille et déverrouille les deux cases à cocher situées en dessous d'elle :
Voici comment cela s'est passé dans la dynamique :
//--------------------------------------------------------------------------------------------------------------------------------
3) Résolvons maintenant le problème illustré dans le diagramme ci-dessous : les cases à cocher doivent verrouiller et déverrouiller les listes déroulantes situées en face d'elles.
Pour ce faire, nous devons trouver ces cases à cocher :
Résultat : les cases à cocher verrouillent les listes déroulantes et se verrouillent elles-mêmes avec la case à cocher principale:
//--------------------------------------------------------------------------------------------------------------------------------
4. Passons à la tâche suivante: les listes déroulantes doivent traduire la valeur sélectionnée par l'utilisateur dans un champ d'une autre fenêtre.
Pour ce faire, il est nécessaire de trouver la liste déroulante :
*Résultat : les deux listes déroulantes envoient avec succès leurs valeurs aux champs de saisie de la fenêtre opposée:
//--------------------------------------------------------------------------------------------------------------------------------
5. La tâche suivante est illustrée dans ce diagramme : vous devez faire en sorte que les boutons radio qui sont activés envoient leur nom aux champs de saisie de la fenêtre opposée.
Pour ce faire, il faut que les boutons radio qui sont activés envoient leur nom aux champs de saisie situés en face :
*Note importante: les boutons radio sont activés parce que l'opérateur SWITCH leur a été appliqué dans le code KIB. Par conséquent, ils ont un paramètre commun à tous et se trouvent dans le fichier API dans le même cas.
Résultat : la commutation des boutons entraîne une modification du texte dans le champ de saisie. *Il ya un petit problème technique avec cette option. Ilsera corrigé dans la prochaine version.
La deuxième partie est terminée.
Dans la troisième partie, nous travaillerons avec le tableau.
Dernière partie du thème de la liaison des paramètres.
Transmettons les valeurs des paramètres de l'élément aux cellules du tableau.
Schéma :
Solution :
Résultat : les valeurs sont placées en toute sécurité dans les cellules de tableau sélectionnées.
Comme vous pouvez le voir dans les exemples ci-dessus, nous avons développé une solution simple et pratique. J'espère que les gens la trouveront utile.
Ceci conclut le sujet de la liaison des paramètres d'éléments.
Les sujets suivants restent à traiter :
12. Obtention/réglage programmatique des limites de valeur du curseur et du champ du bouton(_V_MIN, _V_MAX, _V_STEP, _DIGITS).
13. Interroger l'état des éléments(_GET_STATE).
14. Lier les couleurs du texte et du cadre aux limites des valeurs espacées.
15. Orientation dans le fichier API.
Ajout d'un thème :
16. Réalisation de la logique de programme de l'apparence des fenêtres de message et d'avertissement.