Discussion :

[Ovopâck]

Bonjour, à tous!

Je viens vers vous car je n'arrive pas à résoudre un problème.

Je souhaiterais créer une interface graphique constituée d'un bouton quitté et d'un canevas qui affiche un défillement d'images se trouvant dans le même dossier (toutes les secondes, via time.sleep(1) ).

Les images étant du JPG, j'utilise PIL mais pour la fenêtre j'aurrais vraiment une préférence pour wxpython ou encore PyQt parce que Tkinter... c moyen niveau qualité graphique.

Une autre petite question : Pour les captures d'écran avec PIL, je peux choisir le format d'enregistrement via l'extension mais peut t-on choisir la qualité ou la résolution? (je voudrais une inférieure)

Voila, j'espère avoir de vos nouvelles rapidement, Merci BCP!!!!

[nyko77]

Bonjour,
C'est facilement réalisable avec wxpython. (avec pyqt aussi, mais je suis moins à l'aise).
Il ne faut pas utiliser time.sleep(1) car cela bloque le mainloop (à moins d'utiliser un thread).
il existe wx.Timer prévu à cet effet.
Voici un exemple:
Je ne sais pas exactement quelle traitement tu veux effectuer avec pil, ici je redimensionne simplement l'image. Si tu ne veux pas faire de traitement Pil est inutile ici.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# -*- coding: utf-8 -*-
 
import wx, os
from PIL import Image
 
class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None)
        self.pathImg = "./"
        #liste des images
        self.listPathImg = self.getImgsPath()
        #pour récupérer l'image en cours d'affichage
        self.photoEnCours = 0
        sizer = wx.BoxSizer(wx.VERTICAL)
        #taille des images
        self.widthImg = 800
        self.heightImg = 600
 
        btnQuit = wx.Button(self, -1, "quitter")
        self.canvas = wx.StaticBitmap(self, -1, wx.EmptyBitmap(self.widthImg, self.heightImg))
 
        sizer.Add(self.canvas)
        sizer.Add(btnQuit)
        self.SetSizerAndFit(sizer)
 
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.onTimer, self.timer)
        self.Bind(wx.EVT_BUTTON, self.onQuit, btnQuit)
        self.timer.Start(1000)
 
        self.Show()
 
    #retourne la liste des *.jpg présent dans le dossier
    def getImgsPath(self):
        listPath = []
        for img in os.listdir(self.pathImg):
            if os.path.splitext(img)[1].lower() == ".jpg":
                listPath.append(os.path.join(self.pathImg, img))
        return listPath
 
    #redimmentionne l'image et retourne un wx.Bitmap
    def resize(self, pathImg):
        im = Image.open(pathImg)
        im.thumbnail((self.widthImg, self.heightImg), Image.ANTIALIAS)
 
        image = wx.EmptyImage(im.size[0], im.size[1])
        image.SetData(im.convert('RGB').tostring())
 
        return image.ConvertToBitmap()
 
 
    #méthode appelée toutes les seconde, et affiche la nouvelle image
    def onTimer(self, event):
        if self.photoEnCours == len(self.listPathImg):
            self.photoEnCours = 0
        self.canvas.SetBitmap(self.resize(self.listPathImg[self.photoEnCours]))
        self.photoEnCours += 1
 
    def onQuit(self, event):
        self.timer.Stop()
        self.Destroy()        
 
 
app = wx.App(0)
MyFrame()
app.MainLoop()

[Ovopâck]

Ah merci beaucoup niko, je bloquait surtout sur le défilement de l'image : je savait en faire apparaître une mais pas en changer. Ton script correspond très bien à ce que je cherche, merci bcp!!!

Par contre, je ne l'aurais pas fait de cette manière, est-t-il possible d'avoir un thread de traitement (script, fichier, etc....) et un thread qui ne gère que l'interface? Parce que je ne comprend pas pourquoi tu as mi le loop à la fin et non dans une fonction.

Perso j'utilise cette méthode pour les threads :

monthread1=threading.Thread(None, mafonction1, None)
monthread2=threading.Thread(None, mafonction2, None)
monthread1.start()
monthread2.start()

Pour une utilisation directe ca ne me pose pas de problème mais si je le compile, une fois la fin du programme atteinte il se termine même si des threads sont encore ouverts, je suis donc obligé de mettre une boucle pour autoriser la fermeture.

[nyko77]

heu...
c'est bizarre comme façon de faire (enfin je trouve).

Je ne vois pas l'intérêt de mettre 2 threads.
Le coté graphique est ton programme principale, donc pas besoin de le mettre dans un thread. D'où le mainloop en dehors d'une fonction ou d'un thread (ça commence à être tordu sinon). ça fait une boucle infini qui vérifie les évènements, c'est déjà une sorte de thread.
Ensuite le wx.Timer est aussi un thread, c'est une juste une façon plus pratique dans ton cas que les thread standard de python.

Pour une utilisation directe ca ne me pose pas de problème mais si je le compile

Qu'appels tu "compile"?

je suis donc obligé de mettre une boucle pour autoriser la fermeture

Avec le wx.Timer je pense pas que tu aies ce problème(je suis vraiment pas sûr). As tu essayé?
Si c'est le cas, comme tu le dis, il suffira de mettre une boucle dans le onQuit pour vérifier que la fonction est bien terminer.

Dans l'exemple que j'ai donnée, il faut juste faire attention que le traitement ne dur pas plus longtemps que l'appel du Timer (1000ms). C'est déjà pas mal pour le traitement d'une photo.

De plus c'est souvent compliqué d'utiliser les thread avec wxpython, car ça rentre en conflit avec le mainloop.

Ensuite, j'ai peut-être pas bien compris ce que tu veux faire. Je pourrais t'en dire plus, si tu me convaincs que wx.Timer ne fonctionne dans ton cas .

[Ovopâck]

Accroche toi xD!

Alors pour les threads, j'ai toujours pris l'habitude de séparer les fonctions de mes programmes dans des threads différents, par exemple :

En ce moment je suis sur un gros projet avec un gestion client serveur. Mon programme a quasiment 20 fonctions chacune dans un thread différent. Et les 20 ne sont pour qu'un client... après il faut les multiplier par le nombre de connexion....

Cependant, pour que certaines fonctions puissent fonctionner, d'autre doivent être arrété c'est pour cela que j'utilise beaucoup de thread + un autre pour la gestion de ces derniers.

Fonctionnement du thread de gestion:

Le contrôle se fait par variable global (3 variables pour chaques thread) :
1 - Thread demarré
2 - Contrôle du bon fonctionnement périodique. (détection du changement de valeur indique que le thread fonctionne toujours)
3 - Demande d'arret (l'arret c'est le thread concerné qui l'éxécute en testant la valeur de la variable)

Il y a 2 autres variables mais celles-ci sont plus pour optimiser le tout.

Donc pour revenir, oui j'ai besoin que l'interface soit dans un thread car je pourrais avoir besoin d'en créer des copies pour chaque client (par ex une fenêtre s'ouvre avec des info a chaque fois qu'un client se connecte).

De cette facon, j'ai juste a démarrer le même thread pour chaque client avec un argument qui identifie le numéro du client.

Il y a aussi un problème pour les connexions réseau : mon serveur doit pouvoir gérer un grand nombre de connexion et pour chacune d'entre elles, 20 fonctions utilisent le réseau... Ya vraiment intérêt à ce qu'il y ai un contrôle de thread parce que si tout ce petit monde envoi ses infos en même temps.... Pour l'instant j'ai pas encore trouvé d'autre solutions mais elle me convient très bien.

Pour "compiler" je veux en réalité dire en faire un exécutable portable. Et donc le problème est dans la cas où mon programme est "compilé", si jamais il atteint la fin du prog, il s'arrette (même si d'autre thread son encore en cours....). Pour résoudre a ca, je met mon contrôle de thread dans le corps du programme et comme il est dans une boucle (normal vu qu'il est censé contrôler en permanence), le programme n'arrive jamais à la fin.

Pour le wx.Timer, je n'est pas essayé puisque selon ma méthode de gestion avec les thread, il ne bloque que le thread concerné et non les autres, ce qui est doublement mieu.

Je me suis apercu très récement que les méthodes des autre programmeur ne me convenait pas. C'est peut-être la pensé de tout les programmeurs.... Tout ca pour dire que cette facon d'utiliser les threads me permet une bonne gestion des taches à effectuer en même temps et de facon séquentielle même si cela peut paraîte étrange!

++

[nyko77]

Bon d'accord.
Et ça fonctionne comme tu le souhaites alors?

[Ovopâck]

Oui, avec ton code que j'ai un peu modifié pour qu'il puisse être prit en compte par la gestion de thread, il fonctionne à merveille.

Dumoins, je n'ai fait que des tests avec 3 faut client, il me faut encore terminer tout mon projet et vérifier qu'il n'y ai pas de problème avec quelques dixaines de connexion.

Merci!!!

[Ovopâck]

Recoucou, c'est encore moi.

J'ai un autre petit problème avec mon interface graphique. Je poste ici car le titre convient aussi à ce nouveau.

Je vient de me lancer dans Pyqt (je sais que tu n'es pas très alaise mais j'essaye quand même). J'utilise QT designer pour faire mon interface graphique et j'ai fait quelque chose de pas mal du tout. Maintenant mon problème est que je ne sais pas comment faire pour faire "communiquer" l'interface à mon prog.

Ex : J'ai un bouton. Qu'elle est la commande pour qu'il change une variable une fois que jai appuyé dessus?

Connaîtrais tu des tutoriels qui explique cela?

Merci!

[VinsS]

Hello, ça n'a rien de compliqué, mais peux-tu nous montrer un exemple simplifié de code ?

Est-ce que tu bloque sur le signal-slot ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
QtCore.QObject.connect(self.mon_bouton, QtCore.SIGNAL(
                                "clicked()"), self.update_viewer)

dans cet exemple update_viewer est dans la même classe, mais cela ne change rien.

vincent

[Ovopâck]

Oula oula, là ca y est : JE SUIS PAUMER!!!

Bon alors, programmer en python aucun problème, gestion réseau aucun problème... mais niveau graphique, je sais :

f=Tk()

faire des label, des canvas, ....

f.mainloop()

Et voila (surtout que ca, c'était du tkinter)

La je débute en Qt parce que je trouve ca déjà bien mieu fait et qu'après QT designer je gagne des journées en temps de programmation.

Donc, pour mon interface graphique, rien de très compliqué :

Titre, entry, liste, case à cochées, etc....

J'enregistre en .ui, je compile avec pyuic, je copie le texte dans le thread graphique de mon prog et c'est ici que je bloque.

Comment faire apparaître le contenue de variables global dans cadres graphique et comment modifier des variables avec des pushboutons ou encore enregistrer le contenu d'un texte dans un entry dans une variable?

[VinsS]

Je ne saisis pas très bien, ton thread n'est pas isolé du reste du monde, il peut toujours traiter des arguments qui ne sont pas dans son propre espace de nom et même des arguments d'une autre classe. Je dirais presque que c'est l'enfance de l'art.

Les entry sont encore plus facile à utiliser

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
QtCore.QObject.connect(self.mon_entry, QtCore.SIGNAL(
                                "textChanged (const QString&)"), foo.ma_fonction)

où ma_fonction récupérera la nouvelle valeur de l'entry du moment que foo soit accessible.

vincent

[Ovopâck]

Rolala, je suis coulé!

C'est quoi foo?

Et mon interface peut être considérée comme isolée sauf qu'elle "communique" aux aux thread via des variables globales et des boucles.

Quand la fonction sera-t-elle exécutée? A chaques changements du contenue de l'entry?

[VinsS]

Montre nous un exemple simplifié, parce que j'ai du mal à imaginer l'architecture de ton appli.

Elle n'avait pas d'interface graphique avant ? Si c'est le cas, et que tu veux faire l'interface avec Qt, instancie-la au démarrage de ton appli et non dans un thread, ça n'a pas de sens.

Ou alors, cette interface n'est qu'un accessoire à ton appli qui n'apparaît que contextuellement et dans ce cas cela s'appelle une boite de dialogue.

Quel rapport avec le défilé d'images de ton premier post ?

vincent

Ah oui,

[ame="http://fr.wikipedia.org/wiki/Foo"]http://fr.wikipedia.org/wiki/Foo[/ame]

[nyko77]

J'enregistre en .ui, je compile avec pyuic, je copie le texte dans le thread graphique de mon prog et c'est ici que je bloque.

Je n'ai pas beaucoup utilisé qt designer, mais je pense que tu peux étendre ta classes avec celle de la classe créée par le pyuic, ou comme dit VinsS, l'instancier au démarrage. ça dépend comment tu procèdes.

Programmes-tu en objet? je vois que tu parles de variables globales...

instancie-la au démarrage de ton appli et non dans un thread, ça n'a pas de sens.

Il n'y a pas que moi qui trouve ta façon de faire bizarre.

C'est pratique d'utiliser un RAD, ça fait gagner du temps, mais il faut tout de même connaitre un minimum la library que tu utilises, sinon ça deviens vite compliqué.

C'est vrai qu'un bout de code permettrait d'y voir plus clair.

Si tu es plus à l'aise avec wxpython, tu peux utiliser wxFormBuilder. C'est un peu moins performant que qt designer, mais ça reste très convenable.

[Ovopâck]

Je vais avoir beaucoup de mal à vous donner un code simplifier de mon programme puisse qu'il doit faire dans les 1000 lignes... D'où mon intention de bien organiser mon programme en thread. D'ailleurs j'ai mi une semaine entière rien que pour organiser mon programme avec des logiciels comme DIA.

Auparavant, mon programme n'avait que la console basique de python avec de temps en temps des print dessus et c'était tout. Là mon but est de cacher cette console et la remplacer par une vrai interface graphique qui me permet d'interagir avec mon prog. Ce n'est absolument pas une simple boite de dialogue.

Il n'y a pas vraiment de rapport avec ma première question sauf que le domaine était le même (Qt) ... Sans compter que tu m'avait déjà répondu à ma première question, et qu'il y avait plus de chance que la réponse à la deuxième soit plus claire vu le contexte.

Pour le défilement d'image, une fonction de mon soft est l'administration a distance. D'où le fait de télécharger les screens client toutes les secondes et de les afficher dans un canvas. Je suis aussi en train de travailler sur PIL pour n'envoyer par socket que les modifications par rapport à l'image précédente qui limiterai le temps de transfert et la bande passante.

En ce qui concerne ma méthode pour inclure une interface graphique dans mon programme déjà éxistant, j'ai choisi le thread et les variables globales pour les raisons suivantes :

- C'est limite mission impossible de ce retrouver dans mon programme d'où l'envie de mettre la fonction qui gère l'interface graphique dans un thread, bien séparé des autres.

- De plus, pour chaques threads existant, il y a une multitude de variables globales qui renseignent sur son état et sur ce qu'il doit faire. Voila pourquoi je pensait tout simplement ajouter un thread graphique qui irait directement piquer les infos sur les globales...

J'espère qu'avec ces compléments d'informations, vous comprenez mieux ma façon de procéder, qui je l'avoue, dans pour un programme basique, serait totalement bizarre.

Pour wxpython, j'en suis au même point qu'avec QT : je sais faire l'interface graphique sur le logiciel mais je ne sais pas comment faire pour récupérer, afficher les globales et les modifier en fonction des events dans l'interface.

[VinsS]

J'ai l'impression que tu travailles de façon empirique.

- C'est limite mission impossible de ce retrouver dans mon programme d'où l'envie de mettre la fonction qui gère l'interface graphique dans un thread, bien séparé des autres.

Quelques règles de bases:

-Ton interface principale doit être instanciée au démarrage de l'apply, elle sera disponible pour tous les constituants de ton programme.

-Les variables globales sont interdites depuis l'édit de Nantes.

-Place les connections de tous tes widgets dans l'application principale et non dans le code de l'interface parce que tu auras surement à les modifier plus tard.

-Trop de threads tue le thread, n'oublie pas que ton apply ne fontionne pas plus vite avec des threads, cela permet simplement à l'utilisateur de pouvoir continuer son traitement pendant qu'une autre tâche s'accomplit en arrière-plan, un processeur ne fait qu'une chose à la fois.

-Si tu veux aussi traiter des images, le format optimisé pour l'écran est le pixmap et il est impossible de traiter les pixmap en dehors du thread principal (main loop).

Les conseils que nous te donnons, ici, vont dans le sens d'une simplification réelle de ton travail, il ne faut pas craindre de revoir totalement le concept de base, tu y gagneras beaucoup de temps plus tard.

Quitte à tout réécrire, qui ne l'a jamais fait ?

vincent

[Ovopâck]

AAAaaa j'le crois pas, je ne pensait pas avoir de réponse vu que je n'ai pas recu d'e-mail et je ne faisait que passer par la....

Donc pardon pour mon retard

J'ai l'impression que tu travailles de façon empirique.

Oh non justement, j'ai tellement de fonction que je suis obligé de faire ca pour les séparer, ne pas être bloqué par des scripts bloquant, etc....

Mon prog est un client/serveur fonctionnant sur 10 ports :
1 port pour la commande (ordre)
les 9 restants pour les transferts et autres.....

1 ordre arrive sur le thread de connexion, il est interprété, le thread de connexion lance le thread de fonction avec en argument le port donné par le serveur après l'ordre. le thread de fonction se connecte a un thread tout juste créer qui est sur le serveur via le port donné.

Là je ne voit pas comment je pourrais me passer de threads...

-Ton interface principale doit être instanciée au démarrage de l'apply, elle sera disponible pour tous les constituants de ton programme.

La je n'est pas besoin de cela. Elle doit juste afficher des variables globales et en modifier...

-Les variables globales sont interdites depuis l'édit de Nantes.

Gné?

-Place les connections de tous tes widgets dans l'application principale et non dans le code de l'interface parce que tu auras surement à les modifier plus tard.

Impossible a cause des script bloquant. Il doit pouvoir faire plusieurs transfert en même temps + réception et retour des ordres sur le port de commande.

-Trop de threads tue le thread, n'oublie pas que ton apply ne fontionne pas plus vite avec des threads, cela permet simplement à l'utilisateur de pouvoir continuer son traitement pendant qu'une autre tâche s'accomplit en arrière-plan, un processeur ne fait qu'une chose à la fois.

OOOooo oui, niveau thread je suis tout a fait à la page. Mon but n'est que de développer bien séparément des fonctions indépendantes

-Si tu veux aussi traiter des images, le format optimisé pour l'écran est le pixmap et il est impossible de traiter les pixmap en dehors du thread principal (main loop).

Je ne connait pas le pixmap, j'utilise PIL mais je suppose qu'il doit s'en occupé en arrière plan.

Les conseils que nous te donnons, ici, vont dans le sens d'une simplification réelle de ton travail, il ne faut pas craindre de revoir totalement le concept de base, tu y gagneras beaucoup de temps plus tard.

Quitte à tout réécrire, qui ne l'a jamais fait ?

J'en suis déjà à ma 4eme réécriture de mon apply faute d'organisation des taches et depuis que j'utilise les threads, tout va nettement mieu.

Pour revenir là où je bloque toujours :

J'ai des variables globales, comment les afficher dans une interface et comment les modifier via des entry, ..... + bouton

Voila, merci!

PS: J'ai fait un modèle pour prévoir à l'avance à quoi mon interface va ressembler (simple image bmp). N'empêche qu'elle paraît vraiment réaliste. Si ca peut aider (elle n'est pas fini). Voir pièce jointe

[VinsS]

Ah, le gothique c'est chic,

Je te met un exemple de connexions basiques, tu devrais t'en sortir avec ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# -*- coding: utf-8 -*-
 
from PyQt4 import QtCore, QtGui
 
class MainWin(object):
    def setup(self, MainWindow):
        MainWindow.resize(452, 331)
        MainWindow.setWindowTitle("Signal-slot")
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.verticalLayout_3 = QtGui.QVBoxLayout()
        self.verticalLayout_2 = QtGui.QVBoxLayout()
        self.horizontalLayout = QtGui.QHBoxLayout()
        self.text_edit = QtGui.QPlainTextEdit(self.centralwidget)
        self.horizontalLayout.addWidget(self.text_edit)
        self.verticalLayout = QtGui.QVBoxLayout()
        self.line = QtGui.QLineEdit(self.centralwidget)
        self.verticalLayout.addWidget(self.line)
        self.combo = QtGui.QComboBox(self.centralwidget)
        self.verticalLayout.addWidget(self.combo)
        self.spinbox = QtGui.QSpinBox(self.centralwidget)
        self.spinbox.setSingleStep(10)
        self.spinbox.setProperty("value", QtCore.QVariant(50))
        self.verticalLayout.addWidget(self.spinbox)
        self.btn_click = QtGui.QToolButton(self.centralwidget)
        self.btn_click.setText("Cliquez-moi")
        self.verticalLayout.addWidget(self.btn_click)
        self.horizontalLayout.addLayout(self.verticalLayout)
        self.verticalLayout_2.addLayout(self.horizontalLayout)
        self.horizontalLayout_2 = QtGui.QHBoxLayout()
        self.radiobtn = QtGui.QRadioButton(self.centralwidget)
        self.radiobtn.setText("La Une")
        self.horizontalLayout_2.addWidget(self.radiobtn)
        self.radiobtn_1 = QtGui.QRadioButton(self.centralwidget)
        self.radiobtn_1.setText("La Deux")
        self.horizontalLayout_2.addWidget(self.radiobtn_1)
        self.verticalLayout_2.addLayout(self.horizontalLayout_2)
        self.verticalLayout_3.addLayout(self.verticalLayout_2)
        self.horizontalLayout_3 = QtGui.QHBoxLayout()
        spacerItem = QtGui.QSpacerItem(278, 20, QtGui.QSizePolicy.Expanding, 
                                        QtGui.QSizePolicy.Minimum)
        self.horizontalLayout_3.addItem(spacerItem)
        self.btn_quit = QtGui.QToolButton(self.centralwidget)
        self.btn_quit.setText("Quitter")
        self.horizontalLayout_3.addWidget(self.btn_quit)
        self.verticalLayout_3.addLayout(self.horizontalLayout_3)
        self.gridLayout.addLayout(self.verticalLayout_3, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
        cl = ["Alpha", "Beta", "Gamma", "Delta"]
        self.combo.addItems(cl)
 
        QtCore.QObject.connect(self.btn_quit, QtCore.SIGNAL("clicked()"), sys.exit)
        QtCore.QObject.connect(self.line, QtCore.SIGNAL("editingFinished()"), l_edit)
        QtCore.QObject.connect(self.combo, QtCore.SIGNAL("currentIndexChanged(const QString&)"), c_edit)
        QtCore.QObject.connect(self.spinbox, QtCore.SIGNAL("valueChanged (int)"), s_edit)
        QtCore.QObject.connect(self.btn_click, QtCore.SIGNAL("clicked()"), click)        
        QtCore.QObject.connect(self.radiobtn, QtCore.SIGNAL("toggled(bool)"), radio)
 
def l_edit():
    txt = unicode(gui.line.text()) 
    gui.text_edit.appendPlainText(txt)
 
def c_edit(val):
    gui.text_edit.appendPlainText(val)
 
def s_edit(val):
    gui.text_edit.appendPlainText(str(val)) 
 
def click():
    gui.text_edit.appendPlainText("Clicked")
    print "\a"
 
def radio(b):
    if b:
        gui.text_edit.appendPlainText("Bouton radio La Une")
    else:
        gui.text_edit.appendPlainText("Bouton radio La Deux")
 
 
if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    gui = MainWin()
    gui.setup(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

tu remarqueras que j'ai mis les fonctions qui reçoivent les signaux ainsi que la gestion du plainTextEdit hors de la classe de l'interface pour te montrer qu'elle peut-être gérée de "l'exterieur".

Enjoy, vincent

[Ovopâck]

Hé non pas Gothic mais Celtique!!!

Je ne suis pourtant pas très doué pour tout ce qui est graphisme mais je ne suis pas mécontent de moi, surtout sous paint xD!!!

Merci pour cette portion de code, je vais potasser ca, je vous tient au courant.

Merci encore, a bientôt!!!

PS : je met en résolu car je considère que le plus gros a été fait.

[Ovopâck]

10 minutes plus tard....

MAGNIFIQUE!!!!!
C'est ce que je cherchais!!!!
Maintenant, je n'est plus qu'à ajouter, dans les fonctions, le changement des variables globales!!!

MERCI MERCI MERCI

Et pour ce qui en est de l'affichage d'une variable dans un Label, comment faire?