Discussion :

[FolDeDol]

Bonjour à vous tous,

Je débute avec PyQt et je rencontre un problème pour afficher les valeurs issues d'un simple compteur. J'ai créé sous le Qt Designer un QlineEdit et un Bouton.

En appuyant sur le bouton OK, j'obtiens le résultat 19 dans le QlineEdit alors que je souhaiterais voir 1,2,3,4... défiler un peu à la manière de la console python.

J'ai essayé d'effacer à chaque incrémentation le QlineEdit et d'ajouter une pause à chaque itération pour afficher la nouvelle valeur mais rien ne se passe.

Pourriez-vous m'aider à résoudre ce problème ?

Cordialement,

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
import sys
from ThirdApp import *
 
class MyForm(QtGui.QDialog) :
    def __init__(self, parent = None) :
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        QtCore.QObject.connect(self.ui.OkButton, QtCore.SIGNAL('clicked()'),self.compteur)
 
    def compteur(self):
        a = 1
        while a < 20 :
            self.ui.LineResultat.setText(str(a))
            a = a + 1
 
if __name__ == "__main__" :
    app = QtGui.QApplication(sys.argv)
    myapp = MyForm()
    myapp.show()
    sys.exit(app.exec_())

[fred1599]

Essaie un truc comme ça, pas testé...

Code :

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

1
2
3
4
5
6
7
8
def compteur(self):
    liste = []
    a = 1
    while a < 20 :
        liste.append(a)
        a = a + 1
    st = ','.join(liste)
    self.ui.LineResultat.setText(st)

[tyrtamos]

Bonjour,

Il y a 2 choses à faire:
- ralentir la boucle, même de peu (5/100 s)
- forcer l'affichage en demandant l'application des tâches en attente

Voilà comment (après "from time import sleep"):

Code :

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

1
2
3
4
5
6
7
    def compteur(self):
        a = 1
        while a < 20 :
            self.lineEdit.setText(str(a))
            sleep(0.05) # <= ralentir la boucle
            QtCore.QCoreApplication.processEvents() #<= forcer l'affichage
            a = a + 1

[wiztricks]

Meilleurs vœux tyrtamos et fred1599.

Tant que le callback (compteur) s’exécute l'affichage ne sera pas mis a jour... .processEvents() resoud le problème pose par le sleep.
Si l'attente est "petite" ça peut passer... mais dans la pratique, on évite car le GUI se bloque et l'interaction avec l'utilisateur sera problématique.
note: quand Windows rame, vous ne savez plus trop sur quoi vous avez clique et c'est désagréable...

Comment faire? Avec Qt tous les QObjects ont un "timer" integre. Il suffit de le demarrer et de mettre a jour compteur et affichage lorsqu'il expire:

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
from PyQt4.QtGui import QApplication, QLineEdit
 
class Counter(QLineEdit):
    _timer_id = None
    def start(self, count=5):
        assert self._timer_id is None
        self._count = count + 1
        self.timerEvent()
        self._timer_id = self.startTimer(500)
 
    def timerEvent(self, event=None):
        self._count -= 1
        self.setText(str(self._count))
        if self._count <= 0:
            self.stop()
 
    def stop(self):
        assert self._timer_id 
        self.killTimer(self._timer_id)        
        self._timer_id = None
 
if __name__ == '__main__':
    app = QApplication([])
    counter = Counter()
    counter.show()
    counter.start(5)
    app.exec()

- W

[tyrtamos]

Bonjour,

Meilleurs voeux aussi, merci wiztricks!

Intéressant le timerEvent. Mais il ne concerne que l'affichage du compteur, et pour l'utiliser avec Designer, il faudra créer un "customwidget" du QLineEdit, accompagné de son code plugin: possible, mais pas simple.

Je rencontre souvent ce problème d'affichage avec du texte, par exemple avec un QTextEdit qui doit afficher des infos au fur et à mesure du déroulement du programme. Si je ne fais rien, il n'affiche que le texte final ce qui n'est ni beau ni intéressant. La seule solution que j'ai trouvée, c'est d'utiliser QtCore.QCoreApplication.processEvents().

J'ai aussi essayé de récuper le signal "textChanged", afin de n'afficher le texte suivant que quand ce signal a bien été activé par le texte précédent. Mais ça n'évite pas le ".processEvents()".

Et il faut avoir conscience que si tout le texte (ici la boucle) est émis en 0.01s, même si l'affichage était très très rapide, les yeux humains, eux, ne seraient pas assez! D'où le sleep dans la boucle pour ralentir l'exécution.

Si tu as une solution pour résoudre ce problème général de façon plus élégante pour l'affichage de textes, je suis très intéressé!

[wiztricks]

Salut,

Intéressant le timerEvent. Mais il ne concerne que l'affichage du compteur, et pour l'utiliser avec Designer, il faudra créer un "customwidget" du QLineEdit, accompagné de son code plugin: possible, mais pas simple.

Si le PO prend la peine de comprendre l'exemple d'utilisation avec les timer, il peut aussi l’intégrer dans son code modulo les meme redirections.

Code :

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

1
2
3
4
5
6
7
8
class MyForm(QtGui.QDialog) :
    ...
    def timerEvent(self, event=None):
        self._count -= 1
        self.ui.LineResultat.setText(str(self._count))
        if self._count <= 0:
            self.stop()
    ...

Si tu as une solution pour résoudre ce problème général de façon plus élégante pour l'affichage de textes, je suis très intéressé!

Le cas général est de s'appliquer a ce que l’exécution d'un callback soit rapide. Les cas particuliers sont quand les traitements effectues dans un callback sont trop longs: il faut alors arbitrer entre des appels a .processEvents() ou la création d'un thread sépare.
Cela s'applique a tous les GUI classiques Qt, Tk, GTk, Wx,...

Dans le cas présent, ce n'est la durée des traitements est raisonnable mais on souhaite que les différentes valeurs du décompte s'affichent assez longtemps pour que l'utilisateur voie les mises a jour successives.
C'est une animation et "assez longtemps" doit être supérieur a une durée de 1/20 - 1/50 de secondes. Si le temps de calcul de la valeur suivante est "petit" vs. cette durée, inutile de créer un thread.

Ce ne sont pas des "règles" mais des "principes". Ils sont bases sur comment sont construits les GUI et l'ordonnancement coopératif entre callbacks utilisateurs et event-loop.

Je rencontre souvent ce problème d'affichage avec du texte, par exemple avec un QTextEdit qui doit afficher des infos au fur et à mesure du déroulement du programme.

Postez un exemple.

- W

[FolDeDol]

Bonjour à vous,

Meilleurs voeux pour cette année 2014.
Je vous remercie pour vos réponses.

Je ne connaissais pas la notion de QtCore.QCoreApplication.processEvents().

Je rebondis sur les propos de Tyrtamos :

Je rencontre souvent ce problème d'affichage avec du texte, par exemple avec un QTextEdit qui doit afficher des infos au fur et à mesure du déroulement du programme. Si je ne fais rien, il n'affiche que le texte final ce qui n'est ni beau ni intéressant. La seule solutihttp://www.developpez.net/forums/images/smilies/icon_redface.gifon que j'ai trouvée, c'est d'utiliser QtCore.QCoreApplication.processEvents()

Je pense que je vais rencontrer un peu ce type de problème car j'aime bien suivre l'affichage des informations au fur et à mesure du script (je debugge encore au print ).

Tout comme Tyrtamos, si tu as une solution plus élégante Wiztricks je suis également preneur.

En tout cas, merci pour votre aide.

Cordialement,