Connexion des signaux Glade avec les méthodes python

Pour faire cette connexion le plus simple est d'utiliser la méthode signal_autoconnect qui prend en argument un dictionnaire. Il faut donc construire un dictionnaire qui prend en cle le nom du signal défini dans Glade, et comme valeur la fonction qui doit être appelée lorsque l'événement est déclenché.

Exemple 1-2. Connexion des signaux

import libglade
import gtk

def on_exit(source=None, event=None):
    gtk.mainquit()

ui = libglade.GladeXML("fichier.glade")
dic = {}
dic["on_exit"] = on_exit
ui.signal_autoconnect(dic)
gtk.mainloop()
Ici on construit un dictionnaire dic, dans lequel un lien est créé entre le signal on_exit et la fonction on_exit. Cette méthode fait appelle à la fonction mainquit du module gtk qui permet de quitter la boucle de l'interface et ainsi de quitter le programme.

Bien que cette technique fonctionne elle peut être lourde à mettre en place si le nombre de signaux à connecter est grand. Pour éviter de créer ce dictionnaire est d'utiliser des fonctions python qui retourne un dictionnaire que l'on peut réutiliser directement dans signal_autoconnect comme par exemple globals qui retourne un dictionnaire qui comprend toutes les fonctions disponible dans le module. Bien sur pour que cette méthode fonctionne il faut donner à vos fonctions le même nom que les signaux Glade.

Exemple 1-3. Connexion des signaux avec globals

import libglade
import gtk

def on_exit(source=None, event=None):
    gtk.mainquit()

ui = libglade.GladeXML("fichier.glade")
ui.signal_autoconnect(globals())
gtk.mainloop()
Cette technique d'utilisation de globals ne fonctionne que si vous connectez vos signaux avec des fonctions. Mais pour connecter les signaux avec des méthodes d'objet cela ne fonctionne pas. Il faut alors recréer un dictionnaire, ou utiliser une autre technique.

Exemple 1-4. Connexion des signaux avec une classe

import libglade
import gtk

class ui:
    def __init__(self):
        self.ui = libglade.GladeXML("fichier.glade")
        dictionnaire_temporaire = {}
        for iteration in dir(self.__class__):
            dictionnaire_temporaire[iteration]= getattr(self,iteration)
        self.ui.signal_autoconnect(dictionnaire_temporaire)

    def on_exit(self, source=None, event=None):
        gtk.mainquit()

main = ui()
gtk.mainloop()
On utilise ici deux fonction python, la première dir qui retourne tous les éléments de la classe passé en paramètre sous forme de chaîne. La seconde getattr retourne l'élément véritable en fonction de son nom. Il nous faut alors avec une boucle charger notre dictionnaire pour le passer ensuite à signal_autoconnect.

On peut bien sur améliorer cette technique pour la mettre dans une classe, il nous faudra ensuite hériter de cette classe pour que nos objets aient la faculté de faire un connect de façon automatique.

Exemple 1-5. Connexion des signaux en utilisant une classe Connect

import libglade
import gtk

class Connect:    
    def cree_dico (self):
        dico = {} ## dico vide pour commencer
        self.cree_dico_pour_classe (self.__class__, dico)
        return dico

    def cree_dico_pour_classe (self, une_classe, dico):
        bases = une_classe.__bases__
        for iteration in bases:
            self.cree_dico_pour_classe (iteration, dico) ## Appel recursif
        for iteration in dir(une_classe):
            dico[iteration]=getattr(self,iteration)

    def connect(self):
        self.g.signal_autoconnect(self.cree_dico())

    def on_exit(self, source=None, event=None):
        gtk.mainquit()


class ui(Connect):
    def __init__(self):
        self.connect()

main = ui()
gtk.mainloop()
Notre classe ui hérite de la classe Connect et dans le constructeur nous appelons la méthode connect qui génère notre dictionnaire de fonction et le connecte aux widget de l'interface. On remarque que la méthode on_exit qui a beaucoup de chance d'exister dans tous nos projet est mise dans la classe Connect, ce qui nous évite de la réécrire pour chaque interface. Pour pouvoir réutiliser cette classe dans tous vos programme il vous faut la placer dans un répertoire que vous mettrez dans la variable d'environnement PYTHONPATH.