Bonjour a tous, et ... help !

Je crée une fenêtre munie d'un bouton "ajouter", et un objet regroupant plusieurs boutons (avec une "class").

Je voudrai qu'à chaque click sur le bouton, il apparaisse dans ma fenêtre une nouvelle instance de cet objet, en plus de celles existant déjà. seulement voilà, ça ne fonctionne pas, je ne comprend pas pourquoi. J'avais fais la même chose avec tkinter sans problème particulier.

voici mon code :

#! /usr/bin/python3
# -*- coding : utf-8 -*-

from gi.repository import Gtk

count=0
dico={}

win=Gtk.Window(title="Ajouter des objets à chaque click")
winbox=Gtk.VBox()

class MyBox(Gtk.Box):

    def __init__(self):
        Gtk.Box.__init__(self)

        self.box = Gtk.Box(spacing=6)
        self.add(self.box)

        self.button1 = Gtk.Button(label="Hello")
        self.button1.connect("clicked", self.on_button1_clicked)
        self.box.pack_start(self.button1, True, True, 0)

        self.button2 = Gtk.Button(label="Goodbye")
        self.button2.connect("clicked", self.on_button2_clicked)
        self.box.pack_start(self.button2, True, True, 0)

    def on_button1_clicked(self, widget):
        print("Hello")

    def on_button2_clicked(self, widget):
        print("Goodbye")

def f_new(bouton,data=None):
    """cree une nouvelle instance de MyBox"""
    global count
    global dico
    count+=1
    dico[count]=MyBox()
    winbox.add(dico[count])
    print("Pourtant je clique ! la preuve :  "+str(dico.keys())) # verifie le call back en console



bouton=Gtk.Button(label="Ajouter")
bouton.connect("clicked",f_new)
winbox.pack_start(bouton,True,True,0)

f_new(bouton) # preuve que la callback fonctionne !
f_new(bouton)

win.add(winbox)


win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()

 La fonction callback est pourtant bien appelée par le bouton, mais n'affiche rien dans la fenêtre, alors que là ou j'appelle la fonction directement dans le code, mes objets se retrouvent bien présents... quel est ce mystère ???

J'ai l'impression qu'il me manque quelque chose pour rafraichir la fenêtre, que la fonction interagisse dynamiquement ou je ne sais quoi...

-
Edité par Byoso 3 mars 2016 à 20:14:48

J'ai bien fouiné et enfin trouvé par moi-même, c'est une erreur de débutant (que je suis !) toute bête, je détaille donc, pour que ça serve peut-être à d'autres.

Il existe en Gtk deux genre de containers, ceux descendant de Gtk.Bin, qui n'acceptent qu'un seul et unique enfant en leur sein, et ceux descendant de Gtk.Container, qui en acceptent une quantité illimitée.

Hors, une Gtk.Window() descend de Gtk.Bin, l'astuce est donc de lui donner un enfant issu de Gtk.Container, comme par exemple Gtk.VBox que j'aime bien, et lui pourra par contre avoir plusieurs enfants.

Voici mon code de test :

#! /usr/bin/python3
# -*- coding : utf-8 -*-

from gi.repository import Gtk


win=Gtk.Window()
win.connect("delete-event",Gtk.main_quit)
box=Gtk.VBox()


class WinGrid (Gtk.Grid):
    """Objet qui se multipi dans la fenetre"""
    compte=0
    dico={}
    
    def __init__(self):
        Gtk.Grid.__init__(self)

        self.texte=Gtk.Label("Des choses ici")
        self.attach(self.texte,0,0,1,1)

        self.bouton_plus=Gtk.Button(label="Ajouter")
        self.bouton_plus.connect("clicked",f_new)
        self.attach(self.bouton_plus,1,0,1,1)

        box.add(self)
        self.show_all()

def f_new(bouton):
    """cree une nouvelle instance de WinGrid, s'appelle soit par le
    bouton plus soit par le bouton ajouter"""
    
    WinGrid.dico[WinGrid.compte]=WinGrid()
    WinGrid.compte+=1

bouton=Gtk.Button(label="Plus")
bouton.connect("clicked",f_new)
box.add(bouton)
        
#start=WinGrid() # optionnel, pour creer une première instance de WinGrid

win.add(box)
win.show_all()
Gtk.main()

Et voilou ! je passe donc mon bref topic en résolut