blognote-info.com

J'ai bossé un moment la dessus, j'ai fouillé le net, rien trouvé qui me transcandait, donc j'ai mis les mains dans le camboui et je vous ai concocté quelque chose de sympa ... bon j'avoue ça me rend vachement service du coup je l'ai fais plus pour moi que pour vous mais je partage ;)

J'en avais un peu marre de me taper les initialisations de toutes mes tables, les ListStore, les Model, et surtout j'avais besoin de construire des tables sans connaitre a l'avance le nombre de colonnes que ces tables devaient avoir ... par exemple, afficher le résultat brut d'une requete de base de donnée, requiert un nombre variable de colonnes ...

Allons y progressivement... on crée le constructeur d'une classe qui logiquement va admettre en paramètre un treeview et l'initialiser sommairement avec un ListStore:

class TreeView:
    
    def __init__(self,treeview):
        self.treeview = treeview
        self.store = gtk.ListStore(object)
        self.treeview.set_model(self.store)

L'idée c'est de pouvoir dire "bon j'ai tant de colonnes et elle s'appellent comme ça" Voici une fonction qui fait ça :

    def setColumns(self,columns):
        for column in columns:
            cell = gtk.CellRendererText()
            col = gtk.TreeViewColumn(column, cell)
            self.treeview.append_column(col)
            col.set_cell_data_func(cell, TreeObject, column)

Voila un rendu texte sur chaque colonne, j'étofferai par la suite ... J'ai introduit la notion de TreeObject et l'appel a une fonction particulière ... Cette fonction permet d'overloader (surcharger pardon ;)) la fonction de mapping par défaut ... Dans la mesure ou notre ListStore utilise un seul élément qui est un object et non une suite de str, il faut lui dire comment il va afficher les données qu'il y a dans chaque colonnes et surtout comment il va y accéder dans l'objet en question ...

L'objet de mapping je l'ai construit en cherchant les entêtes avec des prints enfin j'ai mis un peu de temps mais j'en suis arrivé a ça :

def TreeObject(column, renderer, model, iter, data):
    item = model.get_value(iter, 0)
    if item == None:
        return
    attr = getattr(item,data)
    if callable(attr):
        attr = attr()
    renderer.set_property('text', attr)

en gros: on cherche le label demandé data dans l'objet contenu dans le model à la position iter de la colonne column et on lui applique un renderer de type text ...

Du coup on est a la fin ... on peut faire quelques fonctions de convenance du genre :

    def append(self,object):
        self.store.append([object])
    
    def clear(self):
        self.store.clear()

mais aussi getPosition et bien d'autres mais ça je vous laisse le soin d'agrémenter l'objet a vos besoins ...

Comment on s'en sert ??? Ben en fait rien de plus simple ... par exemple on veut afficher des utilisateurs, nom, prénom et age dans une table. On définit une classe utilisateur comme ceci :

class TreeObjectPerson:
    def __init__(self,nom,prenom,age):
        self.Nom = nom
        self.Prenom = prenom
        self.Age = age

Et pour construire sa liste (et vous allez voir c'est simplicime, eeeeeeenfin ...)

        #on s'arrange pour retrouver le widget (perso j'utilise glade et GLObject (j'ai posté dessus ...))
        tree = self.widgets.get_widget('treePersons')
        self.tree = TreeView(tree)
        self.tree.setColumns(['Nom','Prenom','Age'])
 
        #on rempli la table (persons est une liste d'objets de type TypeObjectPerson
        self.tree.clear()
        for person in persons:
            self.tree.append(person)

Evidemment c'est perfectible ... on pourrait redéfinir une fonction de mapping qui prend en compte les accents, qui se sert d'une fonction get pour interfacer le truc au sein de lobjet ... enfin a vous de voir tout ça ;)