IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

PyQt Python Discussion :

[PyQt 5] Mise à jour d’une QProgressBar


Sujet :

PyQt Python

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éclairé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    Avril 2008
    Messages
    190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : Avril 2008
    Messages : 190
    Par défaut [PyQt 5] Mise à jour d’une QProgressBar
    Salut à tous !

    Je suis en train de travailler sur une application pour gérer mes entrées et sorties de modèle. Comme j’effectue des traitements un peu long, j’ai besoin de barre de progression.

    En m’inspirant de Progressbar2, j’ai réalisé une classe permettant d’utiliser la barre de progression à travers un itérable. Cependant, si une fenêtre s’ouvre bien, la barre de progression ne s’affiche jamais, comme le montre l’exemple minimum complet suivant (il utilise Python 3 et PyQt 5) :

    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
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
     
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
     
    """
    Exemple de classe permettant d’utiliser une QProgressBar avec un itérable.
     
    :module: iterableQProgressBar
    :author: Yoann LE BARS
    :version: 1.0
    :date: 16/08/2018
     
    Copyright © 2018 Le Bars, Yoann
     
    This program is distributed under CeCLL-B license, it can be copied and
    modified freely as long as initial author is cited. Complete text
    of CeCILL licence can be found on-line:
     
    <http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html>
    """
     
    import sys
    from PyQt5.QtWidgets import QWidget, QProgressBar, QApplication, QPushButton
     
    class ProgressBar (QWidget):
        """
        Class providing an easy way to use QProgressBar 
        """
     
        def __init__ (self, title, minValue = 0, maxValue = None):
            """
            Class initialiser.
            
            :param title: Window title.
            :param minValue: Minimum value in iteration.
            :param maxValue: Maximum value in iteration.
            """
     
            super().__init__()
            self.setWindowTitle(title)
            self.setGeometry(300, 300, 210, 35)
            # Actual progress bar.
            self._pbar = QProgressBar(self)
            self._pbar.setGeometry(30, 40, 200, 25)
            # Iterable through which iterate.
            self._iterable = None
            # Minimum iteration value.
            self._minValue = minValue
            self._pbar.setMinimum(self._minValue)
            # Maximum iteration value.
            self._maxValue = maxValue
            # Current iteration value.
            self._currValue = self._minValue
            # Whether or not iteration has started.
            self._started = False
     
        def __call__ (self, iterable, maxValue = None):
            """
            Use a ProgressBar to iterate through an iterable.
     
            
            :param iterable: The iterable through which iterate.
            :param maxValue: Maximum value in iteration.
            :return: A pointer to current instance.
            """
     
            if maxValue is None:
                self._maxValue = len(iterable)
            else:
                self._maxValue = maxValue
     
            self._pbar.setMaximum(self._maxValue)
            self._pbar.setValue(self._currValue)
            self._iterable = iter(iterable)
            self.show()
            return self
     
        def __iter__ (self):
            """
            Defines the class as iterable.
     
            :return: A pointer to current instance.
            """
     
            return self
     
        def __next__ (self):
            """
            What to be done every next iteration.
            """
     
            try:
                # New value in iteration.
                value = next(self._iterable)
                if self._started:
                    self._currValue = self._currValue + 1
                else:
                    self._started = True
                    self._currValue = self._minValue
                self._pbar.setValue(self._currValue)
                return value
            except StopIteration:
                raise
     
        def __exit__ (self, exc_type, exc_value, traceback):
            """
            What to do when exiting ProgressBar.
     
            :param exc_type: Type of execution.
            :param exc_value: Execution code.
            :param traceback: Execution trace.
            """
     
            pass
     
        def __enter__ (self):
            """
            What to do when entering ProgressBar.
     
            :return: A pointer to current instance.
            """
     
            return self
     
    class Exemple (QWidget):
        """
        Classe pour la fenêtre principale d’exemple.
        """
     
        def _realiseAction (self):
            """
            Que faire lorsque le bouton est appuyé.
            """
     
            # Iterable pour test.
            liste = [valeur for valeur in range(100000)]
     
            # Barre de progression indiquant l’état d’avancement dans le fichier.
            progression = ProgressBar('Lecture de la liste')
            for valeur in progression(liste):
                print(valeur)
     
        def __init__ (self):
            """
            Initialisation de la fenêtre.
            """
     
            super().__init__()
            self.setGeometry(300, 300, 280, 170)
            self.setWindowTitle('Test de la barre de progression.')
            # Bouton pour lancer l’activité.
            self._btn = QPushButton('Démarrer', self)
            self._btn.move(40, 80)
            self._btn.clicked.connect(self._realiseAction)
            self.show()
     
    if __name__ == '__main__':
        # Instance de l’application.    
        app = QApplication(sys.argv)
        # Fenêtre de test.
        ex = Exemple()
        sys.exit(app.exec_())
    Lorsque l’on appuie sur le bouton « Démarrer », on voit bien apparaître la fenêtre de la barre de progression, mais cette fenêtre est désespérément noire.

    Je pense faire une erreur idiote, mais je ne parviens pas à trouver où se situe le problème. Quelqu’un aurait-il une idée ?

  2. #2
    Expert confirmé

    Homme Profil pro
    Inscrit en
    Octobre 2008
    Messages
    4 307
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2008
    Messages : 4 307
    Par défaut
    Salut,

    Que veux-tu faire exactement ?
    Pourquoi ne pas utiliser simplement une QProgressBar et lui envoyer les valeurs au fur et à mesure plutôt que ce code inutile ?

  3. #3
    Expert confirmé
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 486
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 486
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    QProgressBar permet d'intégrer une barre de progression dans une fenêtre existante. Mais si on veut simplement une petite fenêtre qui ne contient que la barre de progression, ça existe déjà: QProgressDialog. Voir https://doc.qt.io/qt-5/qprogressdialog.html.

    Une fois ceci fait, le vrai problème est de savoir comment une tâche longue quelconque peut-elle mettre à jour la barre de progression, puisque sans précaution, la tâche longue monopolisera le CPU et bloquera donc le graphique. Une méthode très concise mais un peu brutale sera de forcer le rafraichissement du graphique avec QtCore.QCoreApplication.processEvents(). Mais la méthode que je préfère est de mettre la tâche longue dans un thread (QThread), et de lancer la mise à jour de la barre de progression grâce à des signaux (xxx.emit(...)). Il faut dans ce cas créer un signal pour la mise à jour et un signal pour la fin.

    A noter que la barre de progression nécessite de connaître l'évolution maxi de la valeur. Quand on ne la connait pas, on peut tout de même utiliser la barre de progression, mais en lui demandant d'afficher une "chenille" sans fin, qui ne sera arrêtée qu'à la fin de l'action. Cela permettra simplement d'indiquer à l'utilisateur que l'opération est en cours.

  4. #4
    Membre éclairé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    Avril 2008
    Messages
    190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : Avril 2008
    Messages : 190
    Par défaut
    Salut à tous*!

    Citation Envoyé par tyrtamos Voir le message
    Mais si on veut simplement une petite fenêtre qui ne contient que la barre de progression, ça existe déjà: QProgressDialog. Voir https://doc.qt.io/qt-5/qprogressdialog.html.
    Merci, j’avais réussi à complètement passer à côté. Ça m’a permis de réduire la quantité de code (voir plus bas), ce qui est toujours une bonne chose.

    Citation Envoyé par tyrtamos Voir le message
    Une fois ceci fait, le vrai problème est de savoir comment une tâche longue quelconque peut-elle mettre à jour la barre de progression, puisque sans précaution, la tâche longue monopolisera le CPU et bloquera donc le graphique. Une méthode très concise mais un peu brutale sera de forcer le rafraichissement du graphique avec QtCore.QCoreApplication.processEvents(). Mais la méthode que je préfère est de mettre la tâche longue dans un thread (QThread), et de lancer la mise à jour de la barre de progression grâce à des signaux (xxx.emit(...)). Il faut dans ce cas créer un signal pour la mise à jour et un signal pour la fin.
    Le code suivant a le comportement attendu. Cependant, il est peut-être possible de faire mieux (j’en parle après) :

    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
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
     
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
     
    """
    Exemple de classe permettant d’utiliser une QProgressBar avec un itérable.
     
    :module: iterableQProgressBar
    :author: Yoann LE BARS
    :version: 1.0
    :date: 16/08/2018
     
    Copyright © 2018 Le Bars, Yoann
     
    This program is distributed under CeCLL-B license, it can be copied and
    modified freely as long as initial author is cited. Complete text
    of CeCILL licence can be found on-line:
     
    <http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html>
    """
     
    import sys
    from PyQt5.QtWidgets import QWidget, QProgressDialog, QApplication, QPushButton
    from PyQt5 import QtCore
     
    class ProgressBar (QProgressDialog):
        """
        Class providing an easy way to use QProgressDialog.
        """
     
        def __init__ (self, title, minValue = 0, maxValue = None):
            """
            Class initialiser.
            
            :param title: Window title.
            :param minValue: Minimum value in iteration.
            :param maxValue: Maximum value in iteration.
            """
     
            super().__init__(title, None, minValue, 0)
    #        self.setWindowModality(QtCore.Qt.WindowModal)
            if maxValue is not None:
                self.setMaximum(maxValue)
            # Iterable through which iterate.
            self._iterable = None
            self.setValue(self.minimum())
            self.setWindowTitle('Progression')
            # Whether or not iteration has started.
            self._started = False
     
        def __call__ (self, iterable, maxValue = None):
            """
            Use a ProgressBar to iterate through an iterable.
     
            
            :param iterable: The iterable through which iterate.
            :param maxValue: Maximum value in iteration.
            :return: A pointer to current instance.
            """
     
            if maxValue is None:
                self.setMaximum(len(iterable))
            else:
                self.setMaximum(maxValue)
     
            self._iterable = iter(iterable)
            self.show()
            return self
     
        def __iter__ (self):
            """
            Defines the class as iterable.
     
            :return: A pointer to current instance.
            """
     
            return self
     
        def __next__ (self):
            """
            What to be done every next iteration.
            """
     
            try:
                # New value in iteration.
                iter = next(self._iterable)
                if self.wasCanceled():
                    raise StopIteration ()
                if self._started:
                    self.setValue(self.value() + 1)
                else:
                    self._started = True
                    self.setValue(self.minimum())
                QtCore.QCoreApplication.processEvents()
                return iter
            except StopIteration:
                self._started = False
                self.setValue(self.maximum())
                self.cancel()
                QtCore.QCoreApplication.processEvents()
                raise
     
        def __exit__ (self, exc_type, exc_value, traceback):
            """
            What to do when exiting ProgressBar.
     
            :param exc_type: Type of execution.
            :param exc_value: Execution code.
            :param traceback: Execution trace.
            """
     
            pass
     
        def __enter__ (self):
            """
            What to do when entering ProgressBar.
     
            :return: A pointer to current instance.
            """
     
            return self
     
        def reset (self, title, valMin = 0, valMax = None):
            """
            Reset progress bar.
     
            :param title: New window title.
            :param valMin: Minimum value during progress.
            :param valMax: Maximum value during progress.
            """
     
            super().reset()
            self.setLabelText(title)
            self.setMinimum(valMin)
            if valMax is not None:
                self.setMaximum(valMax)
            self.setValue(valMin)
            self._started = False
     
    class Exemple (QWidget):
        """
        Classe pour la fenêtre principale d’exemple.
        """
     
        def _realiseAction (self):
            """
            Que faire lorsque le bouton est appuyé.
            """
     
            # Barre de progression indiquant l’état d’avancement de l’activité.
            progression = ProgressBar('Création de la liste')
            # Iterable pour test.
            liste = [valeur for valeur in progression(range(100000))]
     
            progression.reset('Lecture de la liste')
            for valeur in progression(liste):
                print(valeur)
     
        def __init__ (self):
            """
            Initialisation de la fenêtre.
            """
     
            super().__init__()
            self.setGeometry(300, 300, 280, 170)
            self.setWindowTitle('Test de la barre de progression.')
            # Bouton pour lancer l’activité.
            self._btn = QPushButton('Démarrer', self)
            self._btn.move(40, 80)
            self._btn.clicked.connect(self._realiseAction)
            self.show()
     
    if __name__ == '__main__':
        # Instance de l’application.    
        app = QApplication(sys.argv)
        # Fenêtre de test.
        ex = Exemple()
        sys.exit(app.exec_())
    En l’espèce, ajouter une structure de processus léger me semble une complication inutile. En revanche, en lisant la documentation, il m’a semblé qu’en définissant la fenêtre en tant que « WindowModal », il n’était pas nécessaire de forcer le traitement des évènements. J’ai laissé ma tentative en commentaire pour montrer comment j’avais fait, mais ça n’a rien donné.

    Du coup, j’ai placé deux « processEvents ». Je ne sais pas si ça pose problème, je suis donc preneur de toutes remarques concernant la qualité du code.

    Citation Envoyé par VinsS Voir le message
    Que veux-tu faire exactement ?
    Confère les deux exemples dans la classe de test du code que j’ai posté : cela permet de créer simplement des barres de progressions au travers d’itérateurs. D’une part, dans la mesure où mon application est basée sur un modèle de greffons, cela permet à la fois d’harmoniser l’apparence dans l’application, mais également de permettre à chaque développeur de greffon d’utiliser facilement une barre de progression et donc de le faire, quelque soit son niveau de programmation et de connaissance de Qt.

    Par ailleurs, l’application utilise souvent des fonctions internes de Python, typiquement les fonctions d’interpolations. En passant par ce système qui est appelé automatiquement à chaque nouvelle itération, cela permet d’avoir une barre de progression efficace même avec une fonction qui est une boîte noire.

    À bientôt.

  5. #5
    Expert confirmé
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 486
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 486
    Billets dans le blog
    6
    Par défaut
    Citation Envoyé par Le Farfadet Spatial Voir le message
    En l’espèce, ajouter une structure de processus léger me semble une complication inutile
    Garde tout de même l'idée: tu y reviendras pour des raisons de qualité de fonctionnement.

  6. #6
    Membre éclairé
    Avatar de Le Farfadet Spatial
    Homme Profil pro
    En cours de précision…
    Inscrit en
    Avril 2008
    Messages
    190
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : En cours de précision…

    Informations forums :
    Inscription : Avril 2008
    Messages : 190
    Par défaut
    Salut à tous !

    J’ai fini par trouver comment déclarer la fenêtre de progression comme modale. Du coup, j’en suis au code suivant :

    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
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
     
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
     
    """
    Exemple de classe permettant d’utiliser une QProgressBar avec un itérable.
     
    :module: iterableQProgressBar
    :author: Yoann LE BARS
    :version: 1.0
    :date: 16/08/2018
     
    Copyright © 2018 Le Bars, Yoann
     
    This program is distributed under CeCLL-B license, it can be copied and
    modified freely as long as initial author is cited. Complete text
    of CeCILL licence can be found on-line:
     
    <http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html>
    """
     
    import sys
    from PyQt5.QtWidgets import QWidget, QProgressDialog, QApplication, QPushButton
    #from PyQt5 import QtCore
     
    class ProgressBar (QProgressDialog):
        """
        Class providing an easy way to use QProgressDialog.
        """
     
        def __init__ (self, title, minValue = 0, maxValue = None):
            """
            Class initialiser.
            
            :param title: Window title.
            :param minValue: Minimum value in iteration.
            :param maxValue: Maximum value in iteration.
            """
     
            super().__init__(title, None, minValue, 0)
            self.setMinimumDuration(0)
            self.setModal(True)
            if maxValue is not None:
                self.setMaximum(maxValue)
            # Iterable through which iterate.
            self._iterable = None
            self.setValue(self.minimum())
            self.setWindowTitle('Progression')
            # Whether or not iteration has started.
            self._started = False
     
        def __call__ (self, iterable, maxValue = None):
            """
            Use a ProgressBar to iterate through an iterable.
     
            
            :param iterable: The iterable through which iterate.
            :param maxValue: Maximum value in iteration.
            :return: A pointer to current instance.
            """
     
            if maxValue is None:
                self.setMaximum(len(iterable))
            else:
                self.setMaximum(maxValue)
     
            self._iterable = iter(iterable)
            self.show()
            return self
     
        def __iter__ (self):
            """
            Defines the class as iterable.
     
            :return: A pointer to current instance.
            """
     
            return self
     
        def __next__ (self):
            """
            What to be done every next iteration.
            """
     
            try:
                # New value in iteration.
                iter = next(self._iterable)
                if self.wasCanceled():
                    raise StopIteration ()
                if self._started:
                    self.setValue(self.value() + 1)
                else:
                    self._started = True
                    self.setValue(self.minimum())
    #            QtCore.QCoreApplication.processEvents()
                return iter
            except StopIteration:
                self._started = False
                self.setValue(self.maximum())
                self.cancel()
    #            QtCore.QCoreApplication.processEvents()
                raise
     
        def __exit__ (self, exc_type, exc_value, traceback):
            """
            What to do when exiting ProgressBar.
     
            :param exc_type: Type of execution.
            :param exc_value: Execution code.
            :param traceback: Execution trace.
            """
     
            pass
     
        def __enter__ (self):
            """
            What to do when entering ProgressBar.
     
            :return: A pointer to current instance.
            """
     
            return self
     
        def reset (self, title, valMin = 0, valMax = None):
            """
            Reset progress bar.
     
            :param title: New window title.
            :param valMin: Minimum value during progress.
            :param valMax: Maximum value during progress.
            """
     
            super().reset()
            self.setLabelText(title)
            self.setMinimum(valMin)
            if valMax is not None:
                self.setMaximum(valMax)
            self.setValue(valMin)
            self._started = False
     
    class Exemple (QWidget):
        """
        Classe pour la fenêtre principale d’exemple.
        """
     
        def _realiseAction (self):
            """
            Que faire lorsque le bouton est appuyé.
            """
     
            # Barre de progression indiquant l’état d’avancement de l’activité.
            progression = ProgressBar('Création de la liste')
            # Iterable pour test.
            liste = [valeur for valeur in progression(range(100000))]
     
            progression.reset('Lecture de la liste')
            for valeur in progression(liste):
                print(valeur)
     
        def __init__ (self):
            """
            Initialisation de la fenêtre.
            """
     
            super().__init__()
            self.setGeometry(300, 300, 280, 170)
            self.setWindowTitle('Test de la barre de progression.')
            # Bouton pour lancer l’activité.
            self._btn = QPushButton('Démarrer', self)
            self._btn.move(40, 80)
            self._btn.clicked.connect(self._realiseAction)
            self.show()
     
    if __name__ == '__main__':
        # Instance de l’application.    
        app = QApplication(sys.argv)
        # Fenêtre de test.
        ex = Exemple()
        sys.exit(app.exec_())
    Avec un tel code, je laisse le fonctionnement interne de Qt se charger de toute la mise à jour des fenêtres. De ce que j’ai pu trouver par ailleurs sur le web, cela semble être une façon assez standard de gérer une barre de progression dans une boucle simple – sachant que le code que je présente est pour gérer une barre de progression dans un itérateur, cela signifie que je ne me place que dans le cas de boucles simples.

    Citation Envoyé par tyrtamos Voir le message
    Garde tout de même l'idée: tu y reviendras pour des raisons de qualité de fonctionnement.
    Je suis tout prêt à le croire, mais avec le code que je présente dans ce message, je laisse Qt s’occuper des évènements en interne. Par ailleurs, sur l’application sur laquelle je travaille, typiquement l’utilisateur n’a aucun intérêt à interagir avec l’application tant que le traitement demandé n’est pas achevé. Il a même plutôt intérêt à ne pas interagir pour éviter de créer des artefacts.

    Par ailleurs, dans la mesure où ma classe est créée pour être utilisée dans les itérations d’un itérateur, cela veut dire qu’il faut que je me débrouille, dans la fonction « __init__ » de la classe « ProgressBar », pour placer les itérations dans un processus léger, sachant que je ne peux pas présumer autre chose sur ce processus qu’il s’agit d’itérations. Du coup, je ne vois pas comment faire.

    Si le mode modal existe dans Qt, c’est bien parce qu’il y a des cas où il est parfaitement approprié, non ? À l’inverse, les processus légers ne sont pas une panacée à utiliser quel que soit le cas, sans se demander s’ils sont bien ce qu’il faut pour une tâche précise.

    Bref : je suis disposé à croire que je sois dans un cas où les processus légers sont appropriés, mais j’ai besoin d’arguments l’indiquant. Par ailleurs, pour réaliser des processus légers à partir d’une classe itérable, j’ai besoin d’être guidé. Donc, s’il y a plus d’éléments sur la question, je suis preneur.

    À bientôt.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [MySQL] Mise à jour mysql avec une checkbox non checké
    Par lodan dans le forum PHP & Base de données
    Réponses: 2
    Dernier message: 24/08/2006, 16h45
  2. [Conception] mise à jour automatique d'une base de donné distante
    Par bipbip2006 dans le forum PHP & Base de données
    Réponses: 2
    Dernier message: 01/06/2006, 16h45
  3. Requête Mise à jour à partir d'une autre table
    Par temar dans le forum Access
    Réponses: 2
    Dernier message: 17/05/2006, 09h23
  4. Mise à jour automatique d'une table access via un .xls
    Par infratunes dans le forum Access
    Réponses: 4
    Dernier message: 05/04/2006, 18h33
  5. [VS2003][VB.NET]Mise à jour DataSet d'une grille (erreur)
    Par m-mas dans le forum Windows Forms
    Réponses: 2
    Dernier message: 08/02/2006, 10h41

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo