0/5 (2 avis)
Snippet vu 8 421 fois - Téléchargée 20 fois
# -*- Encoding: Latin-1 -*- # Exemple de code rafraichissant à travers le multithread # une progressbar. Celà évite les problèmes de fonctions bloquantes # qui ne rendent pas la main et qui ne rafraichissent pas les # widgets. #Module pygtk et gtk import pygtk, gtk #Modules pour le multithreading import thread,threading #Important : Initialisation pour l'utilisation de threads gtk.gdk.threads_init() #Options du comportement du widget(cf.doc), pas important ici twidget = gtk.EXPAND | gtk.FILL | gtk.SHRINK #Notre classe principal de gestion class demo(): def __init__(self): #Ce verrou servira à rendre une variable modifiable uniquement par un seul processus. self.lock=threading.Lock() #On crée l'instance de notre fenetre self.win = gtk.Window(gtk.WINDOW_TOPLEVEL) #On modifie le titre de la fenetre self.win.set_title("Démonstration du multithread avec pygtk") #On la positionne au millieu self.win.set_position(gtk.WIN_POS_CENTER) #On règle la taille : 300x100 self.win.set_default_size(300, 100) #On appel la méthode "panel" qui va créer les widgets self.panel() #On lie l'évènement destroy (quitter), à la fonction gtk.main_quit self.win.connect("destroy", gtk.main_quit) #On affiche tous les widgets de la fenêtre win créés. self.win.show_all() def panel(self): #Table d'organisation des widgets self.table = gtk.Table(2, 2, True) # 2 cellules horizontables, 2 verticales # True = les cellules de la table ont la même taille. #Fenetre # 0_____1____2 # 1| | # 2|___________| #Bouton Exit self.Bexit = gtk.Button(stock='gtk-quit') #On l'attaque à la fonction de fermeture self.Bexit.connect("clicked", gtk.main_quit) #On attribue l'emplacement du bouton sur la table. self.table.attach(self.Bexit, 0, 1, 0, 1, twidget, twidget, 5, 5) #A gauche (0, 1), en haut (0, 1)... Pensez au jeu du touché coulé! #Bouton Start self.Bconvert = gtk.Button("Start") #On l'attaque à la fonction up_progressbar self.Bconvert.connect("clicked", self.init_thread) self.table.attach(self.Bconvert, 1, 2, 0, 1, twidget, twidget, 5, 5) #A droite (1, 2), en haut (0, 1)... Pensez au jeu du touché coulé! #Barre de chargement self.progressbar = gtk.ProgressBar(None) self.progressbar.set_text("En attente...") self.table.attach(self.progressbar, 0, 2, 1, 2, twidget, twidget, 5, 5) #De gauche à droite(0, 2), en bas (1, 2)... Pensez au jeu du touché coulé! #On joint la table notre fenetre self.win.add(self.table) def init_thread(self, parent): #Lancement du thread t = thread.start_new_thread(self.up_progressbar, ()) def up_progressbar(self): #On prends le lock, aucun autre processus ne pourra accéder/altérer aux informations. self.lock.acquire() count = 0.00 #Boucle qui ne rend pas la main while(1): count = count + 1 if count >= 0 and count <= 3000: self.progressbar.set_text("Initialisation...") elif count >= 3000 and count <= 30000: self.progressbar.set_text("Traitement en cours...") elif count >= 30000: self.progressbar.set_text("Traitement terminé!") #On libère le verrou. self.lock.release() return(0) #On update la progressbar self.progressbar.set_fraction(count / 30000) def idle(self): gtk.main() #Vérifier qu'il n'y a pas d'autres mains if __name__ == '__main__': example = demo() example.idle()
27 févr. 2008 à 03:29
Tout d'abord, merci d'avoir commenter ma source :)
J'ai changé gobject.threads_init(), par gtk.gdk.threads_init(), car il est vrai que celà est plus logique. Ca permet de retirer le module gobject dans le header.
Ensuite, j'ai également utilisé thread.start_new_thread qui est plus simple, et explicite.
Finalement, j'ai opté pour le verrou, au lieu d'utiliser gtk.gdk.threads_enter() ou gtk.gdk.threads_leave().
En effet, on pouvait constater (si on appuyait plusieurs fois sur "start"), que des accès concurrentiels se faisaient sur la progressbar! Pour ceux que ca interresse, retirez simplement les verrous, et vous verrez la progress bar s'incrémenter à divers endroits, c'est le fruit de plusieurs processus qui incrémente dans chacun d'eux la variable count, et la mettent à jour dans le progressbar.
25 févr. 2008 à 13:13
- gobject.threads_init() permet de déclarer l'initialisation du thread gtk car en fait gtk descend de gdk qui lui même descend de gobject, il est donc possible de le remplacer par gtk.gdk.threads_init(). Je trouve que c'est plus logique !!
- ensuite pour lancer la fonction c'est plus facile en passant par thread.start_new_thread(mafonction, (tuple de paramètres)). Ce n'est pas mieux que ce que tu propose mais pour les débutants je trouve que c'est plus explicite
- enfin et c'est ce point que je ne comprennez pas il faut préciser à gtk qu'il reprend la main lors de la fonction de mise à jour de notre progressbar par gtk.gdk.threads_enter() notre code et enfin gtk.gdk.threads_leave() pour rendre la main à notre thread fils. Je trouve cette méthode plus facile à utiliser que le gobject.add car dans nos petites têtes on comprend bien ce qu'il se passe.
Voila je tenais à ajouter ces quelques lignes qui m'ont pris bien d'heures à chercher...
Bonne continuation
Vive PyGtk
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.