Création d’interfaces graphiques avec GladeVCP

Tous les deux supportent la création de panneaux avec des widgets de HAL, des éléments utilisateur visuels tels que boutons, Leds, curseurs etc. dont les valeurs sont liées à des pins de HAL qui à leur tour, sont des interfaces pour le reste de LinuxCNC.

Pendant qu’Axis est en marche, explorons Afficher configuration de HAL dans lequel nous trouvons le composant de HAL gladevcp et dont nous pouvons observer la valeur des pins pendant l’interaction avec les widgets du panneau. La configuration de HAL peut être trouvée dans configs/gladevcp/manual-example.hal.

Usage des deux cadres en partie basse. Le panneau est configuré pour que, quand l’Arrêt d’Urgence est désactivé, le cadre Settings s’active et mette la machine en marche, ce qui active à son tour le cadre Commandes du dessous. Les widgets de HAL du cadre Settings sont liés aux Leds et labels du cadre Status ainsi qu’au numéros de l’outil courant et à celui de l’outil préparé. Les utiliser pour bien voir leur effet. L’exécution des commandes T<numéro d’outil> et M6 dans la fenêtre du MDI aura pour effet de changer les numéros de l’outil courant et de l’outil préparé dans les champs respectifs.

Les boutons du cadre Commandes sont des widgets d’action MDI. Les presser exécutera une commande MDI dans l’interpréteur. Le troisième bouton Execute Oword subroutine est un exemple avancé, il prends plusieurs pins de HAL du cadre Settings et leur passe comme paramètres, le sous-programme Oword. Les paramètres actuels reçus par la routine sont affichés par une commande (DEBUG, ). Voir configs/gladevcp/nc_files/oword.ngc pour le corps du sous-programme.

Pour voir comment le panneau est intégré dans Axis, voir la déclaration de [DISPLAY]GLADEVCP dans gladevcp_panel.ui, ainsi que les déclarations de [DISPLAY]EMBED et de [HAL]POSTGUI_HALFILE dans gladevcp_tab.ini, respectivement.

L’interface utilisateur est créée avec l'éditeur graphique de Glade. Pour l’essayer il faut avoir le pré-requis nécessaire, que glade soit installé. Pour éditer l’interface utilisateur, lancer la commande:

La zone centrale de la fenêtre montre l’apparence de l’interface en création. Tous les objets de l’interface et les objets supportés se trouvent dans la partie haute à droite de la fenêtre, où il est possible de choisir un widget spécifique (ou en cliquant sur lui au centre de la fenêtre). Les propriétés du widget choisi sont affichées et peuvent être modifiées, dans le bas à droite de la fenêtre.

Pour voir comment les commandes MDI sont passées depuis les widgets d’action MDI, explorer la liste des widgets sous Actions en haut à droite de la fenêtre, et dans le bas à droite de la fenêtre, sous l’onglet Général, les propriétés des commandes MDI.

Voici comment une fonction de rappel Python est intégrée dans l’exemple:

C'était juste pour toucher le concept du doigt. Le mécanisme de fonction de rappel sera détaillé plus en détails dans la section Programmation de GladeVCP.

Pour visualiser ou modifier les fichiers d’une interface Glade, Glade doit être installé. Ce n’est pas nécessaire pour seulement essayer un panneau GladeVCP. Si la commande glade est manquante, l’installer de la manière suivante:

Vérifier ensuite la version installée, qui doit être égale ou supérieure à 3.6.7:

glade3 3.6.7

Cette section souligne juste les étapes initiales spécifiques à LinuxCNC. Pour plus d’informations et un tutoriel sur Glade, voir http://glade.gnome.org. Certains trucs & astuces sur Glade, peuvent aussi être trouvés sur youtube.

Soit modifier une interface existante en lançant glade <fichier>.ui ou, démarrer une nouvelle en lançant juste la commande glade depuis un terminal.

Le résultat pourrait ressembler à cela:

Glade a tendance à écrire beaucoup de messages dans la fenêtre du terminal, la plupart peuvent être ignorés. Sélectionner Fichier → Enregistrer sous, donner lui un nom comme myui.ui et bien vérifier qu’il sera enregistré comme un fichier GtkBuilder (bouton radio en bas à gauche du dialogue d’enregistrement). GladeVCP peut aussi traiter correctement l’ancien format libglade mais il n’y a aucune raison de l’utiliser. Par convention, l’extension des fichier GtkBuilder est .ui.

Vous êtes maintenant prêt à faire un essai (avec LinuxCNC, par exemple Axis en marche) faites:

GladeVCP crée le composant de HAL portant le nom qui a été donné au fichier, par exemple, le très original myui.ui dans notre cas, à moins qu’il n’ait été surchargé pat l’option -c <nom du composant>. Si Axis est en marche, essayer de trouver le composant dans Afficher configuration de HAL et inspecter ses pins.

Vous vous demandez peut être pourquoi les widgets conteneurs comme HAL_Hbox ou HAL_Table apparaissent grisés (inactifs). Les conteneurs HAL ont une pin de HAL associée qui est désactivée par défaut, c’est ce qui cause ce rendu grisé des widgets conteneurs inactifs. Un cas d’utilisation courante pourrait être pour associer les pins de HAL du conteneur halui.machine.is-on ou un des signaux halui.mode., pour s’assurer que certains widgets n’apparaissent actifs que dans un certain état.

Pour activer un conteneur, exécuter la commande HAL setp gladevcp.<nom-du-conteneur> 1.

La voie suggérée pour lier les pins de HAL dans un panneau GladeVCP consiste à les collecter dans un fichier séparé portant l’extension .hal. Ce fichier est passé via l’option POSTGUI_HALFILE=, dans la section [HAL] du fichier de configuration.

ATTENTION: Ne pas ajouter le fichier de commandes HAL de GladeVCP à la section ini d’Axis [HAL]HALFILE=, ça n’aurait pas l’effet souhaité. Voir les sections suivantes.

Pour placer le panneau GladeVCP dans la partie droite d’Axis, ajouter les lignes suivantes dans le fichier ini:

Le nom de composant HAL d’une application GladeVCP lancé avec l’option GLADEVCP est toujours: gladevcp. La ligne de commande actuellement lancée par Axis dans la configuration ci-dessous est la suivante:

Ce qui veux dire que n’importe quelle option gladevcp, peut être ajoutée ici, tant qu’elle n’entre pas en collision avec les options des lignes de commande suivantes.

Pour cela, éditer le fichier .ini et ajouter dans les sections DISPLAY et HAL, les lignes suivantes:

Noter le halcmd loadusr pour charger la commande d’onglet, elle assure que POSTGUI_HALFILE ne sera lancé que seulement après que le composant de HAL ne soit prêt. Dans de rares cas, une commande pourrait être lancée ici, pour utiliser un onglet sans être associée à un composant de HAL. Une telle commande pourrait être lancée sans halcmd loadusr, ce qui indiquerait à Axis qu’il ne doit plus attendre un composant de HAL, puisqu’il n’existe pas.

Noter que quand le nom du composant est changé dans l’exemple suivant, les noms utilisés dans -Wn <composant> et -c <composant> doivent être identiques.

Essayer en lançant Axis, il doit avoir un nouvel onglet appelé GladeVCP demo à droite de l’onglet de la visu. Sélectionner cet onglet, le panneau de l’exemple devrait être visible, bien intégré à Axis.

Pour ajouter un onglet GladeVCP à Touchy, éditer le fichier .ini comme cela:

Noter les différences suivantes avec la configuration de l’onglet d’Axis:

La plupart des widgets HAL on une simple pin de HAL associée et portant le même nom que le widget (glade: Général→Nom).

Les exceptions à cette règle sont actuellement:

En règle générale, si une valeur doit être attribuée à la sortie d’un widget HAL depuis un code Python, le faire en appelant le setter Gtk sous-jacent (par exemple set_active(), set_value()), ne pas essayer de donner directement la valeur à la pin associée par un halcomp[nompin] = value, parce-que le widget ne verra jamais le changement!.

Il pourrait être tentant de fixer une pin d’entrée de widget HAL par programme. Noter que cela va à l’encontre du but premier d’une pin d’entrée. Elle devrait être attachée à un autre composant de HAL et réagir au signal qu’il génère. Bien qu’aucune protection, empêchant d'écrire sur les pins d’entrée HAL Python, ne soit présente actuellement, cela n’aurait aucun sens. Il faut utiliser setp nompin valeur dans un fichier Hal associé, pour les essais.

Il est par contre, parfaitement autorisé de mettre une valeur sur une pin de sortie de Hal avec halcomp[nompin] = valeur à condition que cette pin ne soit pas déjà associée avec un autre widget, ce qui aurait pu être créé par la méthode
hal_glib.GPin(halcomp.newpin(<nom>,<type>,<direction>). Voir la programmation de GladeVCP pour d’autres exemples.

La programmation événementielle signifie que l’interface graphique indique au code quand "quelque chose se produit", grâce à une fonction de rappel, comme quand un bouton est pressé, la sortie du widget HAL (ceux qui affichent la valeur des pins de HAL) comme une LED, une barre, une VBar, un indicateur à aiguille etc, supportent le signal hal-pin-changed qui peut provoquer une fonction de rappel dans le code Python quand une pin de HAL change de valeur. Cela veut dire qu’il n’est plus nécessaire d’interroger en permanence les pins de HAL dans le code pour connaitre les changements, les widgets font ça en arrière plan et le font savoir.

Voici un exemple montrant comment régler un signal hal-pin-changed pour une Hal Led, dans l'éditeur de Glade:

L’exemple dans configs/gladevcp/examples/complex montre comment c’est géré en Python.

Ce groupe de widgets est dérivé de divers boutons Gtk, ce sont les widgets HAL_Button, HAL_ToggleButton, HAL_RadioButton et CheckButton. Tous ont une seule pin de sortie BIT portant un nom identique au widget. Les boutons n’ont pas d’autres propriétés additionnelles, contrairement à leurs classes de base Gtk.

Case à cocher:

Boutons radio:

Bouton à bascule:

HAL_HScale et HAL_VScale sont respectivement dérivées de GtkHScale et GtkVScale. Elles ont une pin de sortie FLOAT portant le même nom que le widget. Les échelles n’ont pas de propriété additionnelle.

Pour créer une échelle fonctionnelle dans Glade, ajouter un Ajustement (Général→Ajustement→Nouveau ou existant) et éditer l’objet ajustement. Il défini les valeurs défaut/min/max/incrément. Fixer la Sensibilité de l’incrément de l’ajustement sur automatique pour éviter les warnings.

Exemple d'échelle (HAL_hscale):

La boîte d’incrément de HAL est dérivée de GtkSpinButton, elle a deux pins de sortie:

Pour être fonctionnelle, Spinbutton doit avoir une valeur d’ajustement comme l'échelle, vue précédemment.

Exemple de boîte d’incrément:

Le Label HAL est un simple widget basé sur GtkLabel qui représente la valeur d’une pin de HAL dans un format défini par l’utilisateur.

Comparés à leurs contreparties Gtk ils ont une pin d’entrée BIT qui contrôle si les enfants des widgets sont sensitifs ou non. Si la pin est basse, alors les widgets enfants sont inactifs, ce qui est le comportement par défaut.

La Led hal simule un vrai indicateur à Led. Elle a une seule pin d’entrée BIT qui contrôle son état: ON ou OFF. Les Leds ont quelques propriétés pour contrôler leur aspect:

Comme un widget d’entrée, la Led aussi supporte le hal-pin-changed signal. Si vous voulez avoir une notification dans votre code quand les pins des Leds HAL ont changé d'état, alors connectez ce signal au gestionnaire, par exemple on_led_pin_changed et passez ce qui suit au gestionnaire:

Ce code sera appelé à chaque front du signal et également au démarrage du programme pour reporter la valeur courante.

Exemple de Leds:

La HAL_ProgressBar est dérivée de gtk.ProgressBar et a deux pins d’entrée de HAL float:

Elle a les propriétés suivantes:

Exemple de barre de progression:

La comboBox HAL est dérivée de gtk.ComboBox. Elle valide le choix d’une valeur dans une liste déroulante.

Elle exporte deux pins de HAL:

Elle a la propriété suivante, qui est configurable dans Glade:

En mode par défaut, ces réglages du widget mettent les pins à la valeur d’index de l’entrée choisie dans la liste. Aussi, si le widget a trois labels, il peut seulement assumer les valeurs 0, 1 et 2.

En mode colonne (colonne > -1), la valeur reportée est choisie dans le tableau de stockage de liste défini dans Glade. Ainsi, typiquement la définition du widget devrait comprendre deux colonnes dans le tableau de stockage, une avec le texte affiché dans la liste déroulante, l’autre une valeur entière ou flottante correspondante au choix.

Il y a un exemple dans configs/gladevcp/by-widget/combobox/combobox.{py,ui} qui utilise le mode colonne pour prendre une valeur flottante dans un stockage de liste.

Si comme moi, vous êtes désorienté pour éditer une liste de stockage de ComboBox ou de CellRenderer, voyez http://www.youtube.com/watch?v=Z5_F-rW2cL8.

Les widgets HAL, HBar et VBar pour barres Horizontale et Verticale, représentent des valeurs flottantes. Elles ont une pin d’entrée de HAL FLOAT. Chaque barre a les propriétés suivantes:

Barre horizontale: Barre verticale:

L’indicateur est un widget similaire à celui de PyVCP, il représente une valeur flottante et a une pin d’entrée de HAL FLOAT. L’indicateur a les deux propriétés suivantes:

Exemples d’indicateurs:

Gremlin est un traceur de parcours d’outil similaire à celui d’Axis. Il demande un environnement LinuxCNC en fonctionnement, comme Axis ou Touchy. Pour se connecter à lui, inspecter la variable d’environnement INI_FILE_NAME. Gremlin affiche le fichiers .ngc courant. Si le fichier ngc est modifié, il doit être rechargé pour actualiser le tracé. Si il est lancé dans une application GladeVCP quand LinuxCNC n’est pas en marche, un message va être affiché parce-que le widget Gremlin ne trouve pas le statut de LinuxCNC, comme le nom du fichier courant.

Gremlin n’exporte aucune pin de HAL. Il a les propriétés suivantes:

Exemple:

Pour certaines applications, il est intéressant d’avoir une image de fond, comme un diagramme fonctionnel et positionner les widgets aux endroits appropriés dans le diagramme. Une bonne combinaison consiste à placer une image de fond comme un fichier .png, mettre la fenêtre GladeVCP en taille fixe, et utiliser Glade pour fixer la position du widget sur cette image.

Le code pour l’exemple ci-dessus peut être trouvé dans configs/gladevcp/animated-backdrop:

Les widgets LinuxCNC Action sont des widgets de type simple état. Ils implémentent une seule action par l’usage, d’un seul bouton, d’une option de menu, d’un bouton radio ou d’une case à cocher.

Ce sont des widgets double état. Ils implémentent deux actions ou utilisent un second état (habituellement, pressé) pour indiquer qu’une action est actuellement en cours. Les bascules action sont prévues pour être utilisées avec les boutons à bascule (ToggleButtons) et les boutons à bascule d’outil (ToggleToolButtons) ou encore, pour basculer les items de menu. Un exemple simple est le bouton à bascule d’Arrêt d’Urgence (EStop).

Actuellement, les widgets suivants sont disponibles:

Les bascules action suivantes ont seulement une commande associée et utilisent l'état pressé pour indiquer que l’opération demandée est lancée:

Ces widgets fournissent le moyen d’exécuter des commandes MDI. Le widget Action_MDI n’attends pas la complétion de la commande, comme le fait la bascule Action_MDI, qui reste elle, désactivée tant que la commande n’est pas terminée.

configs/gladevcp/mdi-command-example/whoareyou.ui est un fichier UI Glade qui transmet cette action basique:

L’ouvrir dans Glade et étudier comment il est fait. Lancer Axis puis dans un terminal faire: +gladevcp whoareyou.ui+. Voir l’action hal_action_mdi1 et les propriétés de MDI command qui exécute juste (MSG, "Hi, I’m an LinuxCNC_Action_MDI") ce qui ouvre un popup de message dans Axis, comme ci-dessous:

Noter que le bouton, associé à l’Action_MDI, est grisé si la machine est arrêtée, en A/U ou si l’interpréteur est déjà en marche. Il deviendra automatiquement actif quand la machine sera mise en marche donc, sortie de l’A/U (E-Stop), et que le programme est au repos.

Optionnellement, la chaine MDI command peut avoir des paramètres substitués avant d'être passée à l’interpréteur. Ces paramètres sont actuellement les noms des pins de HAL dans les composants GladeVCP. Voici comment cela fonctionne:

L’exemple de fichier UI est configs/gladevcp/mdi-command-example/speed.ui. Voici ce qui ce qui est obtenu en le lançant:

Il est parfaitement permis d’appeler un sous-programme O-word dans une commande MDI et passer la valeur des pins de HAL comme paramètres actuels. Un exemple de fichier UI est dans configs/gladevcp/mdi-command-example/owordsub.ui.

Placer configs/gladevcp/nc_files/oword.ngc de sorte qu’Axis puisse le trouver, et lancer gladevcp owordsub.ui depuis un terminal. Ce qui devrait ressembler à celà:

L’interpréteur de G-code de LinuxCNC dispose d’un simple jeu de variables globales, comme la vitesse travail, la vitesse broche, le mode relatif/absolu et autres. Si on utilise des commandes G-code ou des sous-programmes O-word, certaines de ces variables doivent être modifiées par la commande ou le sous-programme. Par exemple, un sous-programme de sonde a très probablement besoin de définir la vitesse d’avance à une valeur très faible. Sans autres précautions, le réglage de vitesse précédent serait écrasé par la valeur du sous-programme de sonde.

Pour faire avec ce surprenant, autant qu’indésirable effet de bord produit par un sous-programme O-word ou un G-code exécuté avec une bascule Action MDI, le gestionnaire pré-MDI et post-MDI doit être associé avec une bascule Action_MDI donnée. Ces gestionnaires sont optionnels et fournissent une voie pour sauver tous les états avant d’exécuter l’action MDI et pour les restaurer ensuite aux valeurs précédentes. Les noms de signaux sont mdi-command-start et mdi-command-stop, les noms de gestionnaire peuvent être fixés dans Glade comme tout autre gestionnaire.

Voici un exemple, montrant comment la valeur de la vitesse d’avance est sauvée puis restaurée par de tels gestionnaires, noter que la commande LinuxCNC et le statut des voies sont disponibles comme self.emc et self.stat à travers la classe LinuxCNC_ActionBase:

Seule le widget de la bascule Action_MDI, supporte ces signaux.

Beaucoup d’actions dépendent du statut de LinuxCNC, est-il en mode manuel, en mode MDI ou en mode auto ? Un programme est-il en cours d’exécution, est-il en pause ou au repos ? Il est impossible de lancer une commande MDI tant qu’un programme G-code est en cours d’exécution, cela doit donc être pris en compte. Beaucoup d’actions LinuxCNC prennent cela en compte d’elle même, les boutons et les options de menu sont désactivés quand leurs actions sont rendues impossibles.

Avec l’utilisation des gestionnaires d'événements Python, qui sont à un niveau inférieur aux Actions, on doit prendre soin de traiter les dépendances de statut soit-même. À cette fin, existe le widget LinuxCNC Stat, il associe les changements de statut de LinuxCNC avec les gestionnaires d'événements.

LinuxCNC Stat n’a pas de composant visible, il suffi de l’ajouter dans l'éditeur Glade. Une fois ajouté, vous pouvez associer des gestionnaires avec les signaux suivants:

La plupart des jeux de widgets, par le biais de l'éditeur Glade, supportent le concept de fonction de rappel, fonctions écrites par l’utilisateur, qui sont exécutées quand quelque chose arrive dans l’UI, événements tels que clics de souris, caractère tapé, mouvement de souris, événements d’horloge, fenêtre iconisée ou agrandie et ainsi de suite.

Les widgets de sortie HAL, typiquement, scrutent les événements de type entrée, tels qu’un bouton pressé, provoquant un changement de la valeur d’une pin HAL associée par le biais d’une telle fonction de rappel prédéfinie. Dans PyVCP, c’est réellement le seul type d'événement qui peut être défini à la main. Faire quelque chose de plus complexe, comme exécuter une commande MDI pour appeler un sous-programme G-code, n’est pas supporté.

Dans GladeVCP, les changement sur les pins de HAL sont juste un type de la classe générale d'événements (appelés signaux) dans GTK+. La plupart des widgets peuvent générer de tels signaux et l'éditeur de Glade supporte l’association de ces signaux avec une méthode Python ou nom de fonction.

Si vous décidez d’utiliser les actions définies par l’utilisateur, votre travail consistera à écrire un module Python dont la méthode, une fonction suffit dans les cas simples, peut être référencée à un gestionnaire d'événements dans Glade. GladeVCP fournit un moyen d’importer votre module au démarrage, il sera alors lié automatiquement au gestionnaire d'événements avec les signaux de widget comme un ensemble dans la description de l'éditeur Glade.

Ceci est juste un exemple minimal pour exprimer l’idée, les détails sont donnés dans le reste de cette section.

GladeVCP peut, non seulement manipuler ou afficher les pins de HAL, il est possible aussi d'écrire des gestionnaires d'événements en Python. Ce qui peut être utilisé, entre autre, pour exécuter des commandes MDI. Voici comment faire:

Écrire un module Python comme le suivant, et l’enregistrer sous le nom handlers.py

Dans Glade, définir un bouton ou un bouton HAL, sélectionner l’onglet Signal, et dans les propriétés GtkButton sélectionner la ligne pressed. Entrer on_button_press ici, puis enregistrer le fichier Glade.

Ensuite, ajouter l’option -u handlers.py à la ligne de commande de gladevcp. Si les gestionnaires d'événements son répartis sur plusieurs fichiers, ajouter de multiples options -u <pynomfichier>.

Maintenant, presser le bouton devrait modifier son label car il est défini dans la fonction de rappel.

Que fait le drapeau -u: toutes les fonctions Python dans ce fichier sont collectées et configurées comme des gestionnaires de fonction de rappel potentiels pour les widgets Gtk, ils peuvent être référencés depuis l’onglet Signaux de Glade. Le gestionnaire de fonction de rappel est appelé avec l’instance de l’objet particulier comme paramètre, comme l’instance du GtkButton précédente, ainsi, il est possible d’appliquer n’importe quelle méthode GtkButton depuis ici.

Ou faire des choses plus utiles, par exemple, appeler une commande MDI!

Les widgets d’entrée HAL, comme la Led, ont l'état de leur pin de HAL (on/off), automatiquement associé avec l’apparence optique du widget (Led allumée/éteinte).

Au delà de cette fonctionnalité primitive, on peut associer n’importe quelle pin de HAL avec une fonction de rappel, y compris les widgets de HAL prédéfinis. Cela correspond bien avec la structure événementielle de l’application typique du widget: chaque activité, qu’elle soit un simple clic de souris, une touche pressée, une horloge expirée ou le changement de valeur d’une pin de HAL, générera une fonction de rappel et sera gérée par le même mécanisme.

Pour les pins de HAL définies par l’utilisateur, non associées à un widget de HAL particulier, le nom du signal est value-changed. Voir la section Ajouter des pins de HAL pour plus de détails.

Les widgets HAL sont fournis avec un signal prédéfini appelé hal-pin-changed. Voir la section sur les Widgets HAL pour d’autres détails.

L’approche globale est la suivante:

Il est important de connaitre pour quoi faire, la fonction get_handlers() est appelée, et connaitre ce qui est sûr et ce qui ne l’est pas. Tout d’abord, les modules sont importés et initialisés dans leur ordre d’apparition sur la ligne de commande. Après le succès de l’importation, get_handlers() est appelé selon les étapes suivantes:

Après que tous les modules ont été importés et que les noms des méthodes ont été extraits, les étapes suivantes se produisent:

Ainsi, lorsque le gestionnaire de classe est initialisé, tous les widgets sont existants mais pas encore réalisés (affichés à l'écran). Et le composant de HAL n’est pas prêt non plus, de sorte qu’il n’est pas sûr d’accéder aux valeurs des pins dans la méthode init().

Si on doit avoir une fonction de rappel à exécuter au démarrage du programme mais, après qu’il soit sûr d’accéder aux pins de HAL, alors connecter un gestionnaire au signal de la fenêtre de niveau supérieur réalisée, window1 (qui pourrait être sa seule raison d'être). A ce point, GladeVCP en a terminé avec toutes les configurations, le halfile a bien été lancé et GladeVCP est sur le point d’entrer dans la boucle principale Gtk.

Dans une classe, les noms de méthode doivent être unique. Cependant, il est permis d’avoir de multiples instances de classe passées à GladeVCP par get_handlers() avec des méthodes portant le même nom. Lorsque le signal correspondant survient, les méthodes sont appelées dans l’ordre dans lequel elles ont été définies, module par module et dans un module, dans l’ordre des instances de classe retourné get_handlers().

Au lieu d'étendre GladeVCP à toutes les options concevables qui pourraient potentiellement être utilisées par un gestionnaire de classe, on peut utiliser le drapeau -U<useroption> (répétitivement si nécessaire). Ce drapeau collecte la liste des chaines de <useroption>. Cette liste est passée à la fonction get_handlers() (argument useropts). Le code est libre d’interpréter ces chaines comme bon lui semble. Un utilisation possible serait de les passer à la fonction exec de Python dans le get_handlers(), comme suit:

De cette façon, on peut passer des déclarations Python arbitraires au module grâce à l’option gladevcp -U, Par exemple:

Debug devrait être mis à 2, et confirmer ce que le module fait actuellement.

Un aspect gênant de GladeVCP dans sa forme initiale avec pyvcp est le fait qu’on peut changer les valeurs des pins de HAL au travers du texte saisi, curseurs, bouton tournant, bouton à bascule etc, mais leurs paramètres ne sont pas enregistrés ni restaurés à la prochaine exécution de LinuxCNC. Ils commencent aux valeurs par défaut fixées dans le panneau ou la définition du widget.

GladeVCP dispose d’un mécanisme facile à utiliser pour enregistrer et restaurer l'état des widgets de HAL, ainsi que les variables du programme (en fait, n’importe quel attribut d’instance de type int, float, bool ou string).

Ce mécanisme utilise le format du populaire fichier .ini pour enregistrer et recharger les attributs persistants.

Pour que tous les états des widgets Gtk, que toutes les valeurs des pins de sortie des widget HAL et/ou que tous les attributs de classe du gestionnaire de classe soient conservés entre les invocations, procéder comme suit:

Puis associer un fichier .ini avec ce descripteur:

Ensuite restore_state(), aura automatiquement les attributs définis si ce qui suit a été exécuté:

Noter que les types sont enregistrés et conservés lors de la restauration. Cet exemple suppose que le fichier .ini n’existe pas ou qu’il contient les valeurs par défaut depuis self.defaults.

Après cette incantation, on peut utiliser les méthodes IniFil suivantes:

Pour enregistrer le widget et/ou l'état des variables en quittant, connecter un gestionnaire de signal à la fenêtre de niveau supérieur window1, détruire l'événement:

La prochaine fois que l’application GladeVCP démarrera, les widgets doivent retrouver l'état qu’ils avaient à la fermeture de l’application.

Il est possible de faire cela, mais noter que les valeurs dans self.defaults écraseront votre édition si il y a erreur de frappe ou de syntaxe. Une erreur détectée, un message émis dans la console, donneront des indices sur ce qui s’est passé et le mauvais fichier ini sera renommé avec le suffixe .BAD. Après une mauvaise initialisation, les fichiers .BAD les plus anciens seront écrasés.

Si il faut des pins de HAL non associées avec un widget HAL, les ajouter comme ci-dessous:

Pour appeler une fonction de rappel quand la valeur de cette pin change il faut associer une fonction de rappel value-changed avec cette pin, ajouter pour cela:

et définir une méthode de fonction de rappel (ou une fonction, dans ce cas laisser tomber le paramètre self):

Depuis que GladeVCP utilise les widgets Gtk qui se rattachent sur les classes de base GObject, la totalité des fonctionnalités de la glib est disponible. Voici un exemple d' horloge de fonction de rappel:

Visiter linuxcnc/configs/gladevcp pour des exemples prêt à l’emploi et points de départ de vos propres projets.