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

Nouveau commentaire
 
hini #:

Oui, il est important de publier d'abord un programme complet.

Je le ferai.
 
Une version de base entièrement fonctionnelle du moteur et du constructeur est un objectif valable et réalisable. Il nécessite un plan clair et une hiérarchisation des priorités. En retour, cela signifie la fin de l'ajout de tâches importantes aux plans et le début de la résolution des problèmes urgents.

Permettez-moi de faire une analogie avec la construction d'un immeuble de grande hauteur. Imaginons un projet dans lequel le contremaître ne sait pas exactement combien d'étages doivent être construits. Supposons qu'il n'ait pas été informé. Mais c'est un créateur dans l'âme, une personne créative. Il s'en moque. Plus c'est grand, mieux c'est. Il aime les grandes maisons et les gratte-ciel. Pendant qu'il travaille, la construction se poursuit, des étages sont ajoutés et le bâtiment s'élève vers le ciel. Mais les appartements ne peuvent pas être remis aux locataires, car les échafaudages n'ont pas été enlevés et l'espace habitable n'a pas été nettoyé. Même les portes ne sont pas posées. La maison est inachevée. Mais pour le contremaître, ce ne sont que des broutilles. Il regarde en l'air. Le ciel. Et les locataires attendent impatiemment, ils ont besoin d'appartements.

En général, il est temps pour le contremaître de "changer de firmware" et de se réorganiser mentalement. Arrêter de construire des étages et commencer à mettre des portes dans les ouvertures. Enfin, il faut commencer à nettoyer les lieux, à plâtrer les murs, à poser du parquet et à installer des lustres. ....

Permettez-moi de vous dire que, pour l'instant, les sols ne seront pas construits. En revanche, les sols déjà construits seront finis. Les travaux seront planifiés de manière à ce que la maison soit remise aux locataires le plus rapidement possible.

Après tout, la maison a été construite pour eux....


 

Bonjour à tous,

À la lumière des discussions récentes, je voudrais proposer que nous documentions les résultats et les progrès du projet de Peter Konow dans la "Codebase" plutôt que sur le forum. Le forum est excellent pour les discussions et les réactions immédiates, mais il manque de structure et de cohérence pour présenter l'image globale et les politiques cohérentes du projet.

En utilisant la base de code, nous pouvons nous assurer que toutes les informations pertinentes sont organisées, facilement accessibles et qu'elles fournissent une vue d'ensemble claire de l'état d'avancement du projet. Cela permettra non seulement de maintenir la clarté, mais aussi de faciliter la collaboration et la compréhension entre tous les membres de l'équipe et les parties prenantes.

Je vous serais reconnaissant de bien vouloir prendre en considération cette suggestion.

 
Yutaka Okamoto projet de Peter Konow soient documentés dans Codebase plutôt que sur le forum. Le forum est parfait pour les discussions et les réactions immédiates, mais il n'a pas la structure et la cohérence nécessaires pour présenter la vue d'ensemble et les politiques cohérentes du projet.

En utilisant un "Codebase", nous pouvons nous assurer que toutes les informations pertinentes sont organisées, facilement accessibles et qu'elles fournissent une image claire de l'état d'avancement du projet. Cela permettra non seulement de maintenir la clarté, mais aussi de promouvoir une meilleure coopération et une meilleure compréhension entre tous les membres de l'équipe et les parties prenantes.

Je vous serais très reconnaissant de bien vouloir examiner cette proposition.

C'est une suggestion très rationnelle, merci. Il ne fait aucun doute que la base de code est pratique pour publier des mises à jour et communiquer avec les utilisateurs. C'est un atout majeur pour le développement du projet. Bien que je n'aie guère utilisé la base de code dans le passé, je vois maintenant l'intérêt pratique d'explorer les termes et conditions et de s'adapter aux exigences. Pour me faire une idée des possibilités et des limites de cette plateforme, je vais me pencher sur les projets de membres bien connus de la communauté. En m'inspirant de leur exemple, je pourrai mener le projet dans la base de code de manière informative et compétente.

 

J'ai une version prévue pour aujourd'hui.

Cependant, j'ai décidé de suivre le conseil utile d'un membre du forum et de publier la nouvelle version dans la base de code. Pour bien faire, j'aurai besoin de quelques jours pour étudier des exemples de publications similaires, pour faire un plan de fonctionnement parallèle du projet sur le forum et là. Et aussi pour passer par la modération.

Quelques mots sur cette version :

1. Conceptualisation et implémentation d'un système d'interaction programmatique entre un programme utilisateur et son interface graphique.

Plus de détails :

  • Après avoir effectué des tests techniques et analysé les résultats, il a été décidé d'utiliser des fonctions d'enveloppement d' éléments au lieu de propriétés globales abstraites. Il s'agit de la variante la plus efficace et la plus simple du couplage des algorithmes avec l'environnement graphique.
  • Des ajouts ont été apportés aux fonctions d'enregistrement du projet et d'impression des fichiers UIDATA.mqh et API.mqh afin que chaque élément interactif de l'interface reçoive automatiquement une fonction d'enveloppe lors de l'enregistrement du projet.
  • En même temps, les fonctions d'habillage des éléments ont un corps très réduit et leur tâche principale est d'appeler la fonction centrale, en passant trois paramètres principaux - le numéro de l'élément, la valeur et la valeur de la propriété.
  • Lasimplicité externe des fonctions n'empêche pas la polyvalence de leur application :

1. Lorsqu'elles sont appelées avec des crochets vides, les fonctions renvoient la valeur du paramètre de l'élément avec l'un des trois types suivants : int, double, string selon le type de l'élément.

     int i    = w6_i_CHECKBOX_Some_checkbox(); //Элемент чекбокс. Буква i  после префикса означает что тип возвращаемого/устанавливаемого значения int.
     
     double d = w6_d_S_EDIT_Spin_the_value();  //Элемент поле ввода с кнопками. Буква d после префикса означает что тип возвращаемого/устанавливаемого значения double.

     string s = w7_s_EDIT_Comment_1();         //Элемент текстовое поле ввода. Буква s означает что тип возвращаемого/устанавливаемого значения string.

2. lorsqu'elles sont appelées avec une valeur entre parenthèses, les fonctions attribuent la valeur passée au paramètre de l'élément, puis le redessinent (la valeur est fixée à int, double ou string, en fonction du type de l'élément).

     int i    = w6_i_CHECKBOX_Some_checkbox(0/1/2/3); //Элемент чекбокс. Передача нуля,единицы, двойки или тройки для смены между нейтральным, активированным, нетр.блокир. и актив. блокир. состояниями элемента. 
                                                      //Тот же метод работает для всех кнопок.
     
     double d = w6_d_S_EDIT_Spin_the_value(653.89);   //Элемент поле ввода с кнопками. Передача значения параметра в функцию для установки его в элемент.

     string s = w7_s_EDIT_Comment_1("Any text");      //Элемент текстовое поле ввода. Передача текста для установки в поле ввода.   


3. Lorsqu'elles sont appelées avec la valeur par défaut du premier paramètre et un numéro de propriété (parmi les propriétés disponibles), les fonctions renvoient la valeur de cette propriété de l'élément (tous les numéros de propriété sont de type int, transmis dans le paramètre de propriété).

      int i = w6_i_BUTTON_Start(get_i,_A_COLOR); //Элемент Кнопка. Возврат значения цвета из свойства _A_COLOR. Может быть указано другое значение или другое свойство из списка доступных свойств.
                                                                  //Однако, данных тип функции принимает значения только типа int, но может приводить их к другим родственным типам (uint, short, bool...).
                                                                  //Значение первого параметра get_i говорит функции что не нужно принимать значение первого параметра в расчет, а лишь вернуть значение свойства _A_COLOR.


4 . Lorsqu'elles sont appelées avec lavaleur et la valeur dela propriété entre parenthèses, les fonctions fixent les valeurs transmises aux propriétés disponibles de l'élément. Lenuméro de la propriété est transmis dans le paramètre property , la valeur de la propriétéest transmise dans le paramètrevalue . 

     int i = w6_i_BUTTON_Start(C'255,0,0',_A_COLOR); //Элемент Кнопка. Передача и установка польз. значения цвета в свойство _A_COLOR. Может быть указано другое значение или другое свойство из списка доступных свойств.
                                                                      //Однако, тип функции этого элемента принимает значения только типа int, но может приводить их к другим родственным типам (uint, short, bool...).


Structure des noms de fonctions : w6_i_BUTTON_Start() ;

1. w est la lettre initiale de toutes les fonctions enveloppantes. Il s'agit d'une abréviation de " window" (fenêtre).

2. 6 (ou autre nombre) - le numéro de séquence de la fenêtre contenant l'élément.

3. i (soit d ou s) - désigne le type de la valeur renvoyée ou définie du paramètre de l'élément.

  • Peut être int: pour les boutons, les cases à cocher, les curseurs, les champs de saisie avec/sans boutons, les barres de progression, les barres de graphique, les boutons radio.
  • Peut être double: pour les curseurs, les champs de saisie avec/sans boutons.
  • Peut être une chaîne: pour les champs de saisie de texte, les éléments VALUE, les cellules de tableau, les listes déroulantes.


4) BOUTON - nom du type d'élément auquel appartient la fonction enveloppante. Il peut s'agir de n'importe quel autre élément.

5. début - nom d'un élément spécifique .


  • Toutes les fonctions enveloppantes ont une structure de noms identique.
  • Je le répète : toutes les fonctions sont imprimées automatiquement.

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

Application intelligente du système intellisense :

Il a été décidé d'utiliser un système de préfixes spécial qui permet de rechercher et de trouver rapidement les fonctions nécessaires - les wrappers de fenêtres et d'éléments. Voici un exemple :

Toutes les fonctions d'habillage de fenêtres et d'éléments ont la lettre w au début. Toutefois, si vous placez un tiret inférieur après w : _, une fenêtre d'intellisense s'ouvre avec une liste de noms de toutes les fonctions de fenêtre de l'interface utilisateur. Ensuite, vous devez trouver la fenêtre portant le nom que vous recherchez dans la liste, regarder son numéro (il est imprimé dans le nom de la fonction), effacer le tiret et placer ce numéro après w. La liste d'intellisense avec les noms des fonctions des éléments inclus dans la fenêtre apparaîtra immédiatement. Voici comment procéder :

Il s'agit d'un moyen simple de naviguer rapidement dans la liste des fonctions de l'enveloppe de l'élément. Il n'est même pas nécessaire de les imprimer.

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

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

Des modifications et des ajouts ont également été apportés au fichier API. L'utilisateur dispose désormais de plus d'informations sur l'élément et la fenêtre :

 switch(Element)
   {
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      BUTTON
//NAME:         Start
//PARAMETER:    int
//INIT STATE:   OFF
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   int w6_i_BUTTON_Start(int value = none, int Property = 0)      | PFX: w6
//=====================================================================================================================
  
case Settings_example_1___Start:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when button pressed or released?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case pressed:  Alert("BUTTON Start pressed!");   break;
  
                case released:  Alert("BUTTON Start released!");   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
  
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      CHECKBOX
//NAME:         Set an option
//PARAMETER:    int
//INIT STATE:   OFF
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   int w6_i_CHECKBOX_Set_an_option(int value = none, int Property = 0)      | PFX: w6
//=====================================================================================================================
  
case Settings_example_1___Set_an_option:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when checkbox checked or unchecked?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case checked:  Alert("CHECKBOX Set_an_option pressed!");   break;
  
                case unchecked:  Alert("CHECKBOX Set_an_option released!");   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
  
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      CHECKBOX
//NAME:         Set another option
//PARAMETER:    int
//INIT STATE:   OFF
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   int w6_i_CHECKBOX_Set_another_option(int value = none, int Property = 0)      | PFX: w6
//=====================================================================================================================
  
case Settings_example_1___Set_another_option:
  
               //------------------------------------------------------------------------------------------------------
               //What to do when checkbox checked or unchecked?
               //------------------------------------------------------------------------------------------------------
               switch((int)action)
               {
                case checked:  Alert("CHECKBOX Set_another_option pressed!");   break;
  
                case unchecked:  Alert("CHECKBOX Set_another_option released!");   break;
               }
               //------------------------------------------------------------------------------------------------------
               //Your comment:
               //------------------------------------------------------------------------------------------------------
               break;
  
//=====================================================================================================================
//WINDOW:       Settings example 1 | #: 6 | PFX: w_6 | GET/SET: int w_6_Settings_example_1(int value = get_i, int Property = 0)
//---------------------------------------------------------------------------------------------------------------------
//ELEMENT:      D_LIST
//NAME:         D_LIST 1
//PARAMETER:    string
//INIT OPTION:  L_ITEM  1
//LOCATION:     Location: Window's Main Frame
//---------------------------------------------------------------------------------------------------------------------
//GET/SET:   string w6_s_D_LIST_D_LIST_1(string value = get_s, int Property = 0)      | PFX: w6
//=====================================================================================================================
 
J'espère pouvoir tester ces fonctionnalités prochainement.
 
hini #:
J'espère pouvoir essayer ces fonctionnalités bientôt.
Je téléchargerai la nouvelle version sur codobase demain soir.
 
Sortie en fin de soirée.
 

Je présente une version du moteur interagissant de manière programmatique avec l'interface graphique.

J'ai fait beaucoup de choses. Il y a quelque chose à dire et à montrer.

Après les tests publics, je l'ajouterai à la base de code.

Une chose intéressante est apparue...

Plus de détails demain.

Dossiers :
4uh38_06.08.24.zip  1712 kb
 

Avec un peu d'avance, je peux dire que j'ai trouvé une solution très pratique pour les utilisateurs. Dans leur code, ils peuvent facilement naviguer à travers les fenêtres, les éléments et les propriétés. La solution leur permet de ne pas se souvenir des noms des éléments ou des propriétés, mais de les trouver facilement et de travailler avec eux. En même temps, chaque élément possède une liste de propriétés get/set disponibles uniquement pour lui et les éléments "apparentés". Le préfixe étant intégré dans le nom de la fonction de l'élément, l'utilisateur l'appelle et ne commet jamais l'erreur d'essayer de renvoyer ou de définir une propriété que l'élément ne possède pas.

Les fonctions enveloppantes se sont révélées si polyvalentes et si faciles à utiliser que j'en suis moi-même surpris. Elles renvoient la valeur d'un paramètre lorsque les parenthèses sont vides, la définissent lorsque la valeur est un, renvoient la valeur d'une propriété à partir d'une liste lorsque le premier paramètre est vide et que l'indice de la propriété se trouve dans le second. Ils attribuent une valeur à une propriété lorsque le premier paramètre contient une valeur et que l'index de la propriété se trouve dans le second. Elles renvoient également une notification de résultat sous la forme 1 en cas de succès et -1 en cas d'erreur (valeur ou propriété non valide). Les fonctions redessinent les éléments eux-mêmes. Vous n'avez pas besoin de vous en occuper.

Ce que vous pouvez faire avec les fonctions enveloppantes :

1. Obtenir la valeur du paramètre de l'élément.

2. Définir la valeur d'un paramètre d'élément.

3. Obtenir les valeurs des propriétés de l'élément à partir de la liste individuelle des propriétés appartenant à son type d'éléments (appelées par le préfixe écrit dans le nom de la fonction).

4. Définir les valeurs des propriétés d'un élément à partir de la même liste.

5. Définir l'état de l'élément : neutre, activé, (on/off), bloqué neutre, bloqué activé.

6. Renvoie l'état actuel de l'élément.


Dans le premier cas, la fonction renvoie la valeur du paramètre.

Dans le second cas, elle renvoie le résultat : succès ou erreur. L'erreur est consignée dans le journal.

Dans le troisième cas, la fonction renvoie la valeur de la propriété.

Dans le quatrième cas, elle renvoie le résultat : succès ou erreur de la définition de la propriété.

Dans le cinquième cas, il renvoie 1 ou -1.

Dans le sixième cas, elle renvoie l'indice d'état de l'élément (voir ci-dessous).


Tout est fait par une fonction enveloppante qui est imprimée automatiquement. Pour la trouver, tapez w_, la liste d'intellisense s'ouvrira, elle contient les noms des fenêtres. Dans l'une d'entre elles se trouve l'élément que vous recherchez. Vous devez vous rappeler à peu près dans quelle fenêtre il se trouve. Ensuite, effacez le diable et tapez le numéro de la fenêtre et sélectionnez celle dont vous avez besoin dans la liste des éléments. Pas de mémorisation.

Vous n'avez pas non plus besoin de vous souvenir des propriétés des éléments. Regardez le nom de l'élément, voyez le préfixe pour ouvrir une liste de propriétés individuelles. Tapez-le, ouvrez-le, sélectionnez la propriété. Vous n'avez pas besoin de vous souvenir de quoi que ce soit. Pas de saisie non plus. Intellisense fait tout.

Les Windows ont aussi leurs propres wrappers. Ils peuvent les ouvrir et les fermer. Le reste des fonctionnalités n'a pas encore été implémenté.


J'ai fait une grosse mise à jour du fichier API. Il contient maintenant une ÉNORME quantité d'informations utiles sur l'élément. A savoir : les préfixes, les propriétés individuelles, les prototypes de la fonction wrapper de l'élément et de sa fenêtre, l'emplacement exact de l'élément (tableau, canevas et onglet auquel l'élément appartient, le cas échéant), le type de son paramètre (int, double, string...), les propriétés de son paramètre (min.value, max.value, step, nombre de chiffres après la virgule) sont imprimés. Valeur initiale ou option sélectionnée (selon l'élément). Tout est conçu de manière très lisible et compréhensible.

J'ai partiellement testé la nouvelle fonctionnalité et j'en suis satisfait. Tout fonctionne comme prévu.

Demain, je le montrerai en pratique.

1...515253545556575859606162636465...71
Nouveau commentaire