QProgressDialog simple usage

Version imprimable

Salut,
J'expérimente avec QProgressDialog:
Code:

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 #include <QtGui> #include <QProgressDialog> int main(int argc, char *argv[]) { QApplication app(argc, argv); QProgressDialog progressDialog("Dumping", "Abort", 0, 3, 0); progressDialog.setMinimumDuration(0); progressDialog.setVisible(true); progressDialog.setLabelText("init..."); progressDialog.setValue(0); progressDialog.setLabelText("0..."); sleep(5); progressDialog.setValue(1); progressDialog.setLabelText("1..."); sleep(5); progressDialog.setValue(2); progressDialog.setLabelText("2..."); sleep(5); progressDialog.setValue(3); progressDialog.setLabelText("3..."); sleep(5); return app.exec(); }
Le texte "init..." n'est pas écrit instamment (on attend quelques secondes), puis "0..." est écrit après quelques secondes, et enfin "2..." est écrit et l'application se termine à la fois.
Je ne comprends pas pourquoi les textes "1..." et "3..." ne sont pas écrits pas du tout? J'ai lit les documents de QProgressDialog et de setMinimumDuration(), mais pas de conclusion.
Merci et pardon de mon mauvais français.

18/01/2010, 10h04
cayou66

Salut,
je te dirais que faire des sleeps n'est pas la meilleure façon de tester, j'aurais plutôt fait un QTimer, relié à un slot qui incrémente une valeur, laquelle tu affiche dans la processDialog. Le QTimer fonctionne comme un QThread ;)
18/01/2010, 17h03
Fabllot

Bonjour,

Citation:

Envoyé par karastojko

Le texte "init..." n'est pas écrit instamment (on attend quelques secondes), puis "0..." est écrit après quelques secondes, et enfin "2..." est écrit et l'application se termine à la fois.
Je ne comprends pas pourquoi les textes "1..." et "3..." ne sont pas écrits pas du tout?

Parce-que l'affichage sur les widgets Qt, ou leurs rafraichissements s'effectuent dans la boucle d'événements Qt qui est ...

Code:

app.exec();

donc à la fin de ton code...

En gros ce que tu fais signifie que tu demandes à la barre de progression de changer de valeur mais sans qu'elle puisse se redessiner. Et quand le programme arrive enfin à la boucle d'événement, ta barre de progression est déjà rendue à ton étape "3"...

Ce que dis karastojko est correct... Il faut que tu passes par un QTimer ou un QThread, pour avoir des résultats visuels corrects.

Merci pour la réponse.
La même chose se passe avec le programme complet, voilà un fragment arraché d'une fonction d'une MainWindow classe:
Code:

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 QProgressDialog progressDialog(this); progressDialog.setRange(0, 3); progressDialog.setLabelText("Dumping"); DatabaseDumpDialog* dlg = new DatabaseDumpDialog(this); short res = dlg->exec(); progressDialog.setVisible(true); progressDialog.setValue(0); if (res == 1) { // ... progressDialog.setValue(1); if (dlg->readGzip()) { // ... progressDialog.setValue(2); } if (status != -1 && dlg->readEmail() != "") { // ... } progressDialog.setValue(3); progressDialog.setVisible(false); }
Le programme utilise QApplication, QMainWindow et les autres Qt widgets, mais le progress dialog se redessine pas comme je desirerais. Donc, est-ce que le progress dialog est à la boucle d'événement? Est-ce qu'il est placé dans un autre thread?

18/01/2010, 23h05
yan

IL y as deux façon d'utiliser QProgressDialog.
http://qt.developpez.com/doc/4.6-sna...ialog/#details
http://qt.developpez.com/doc/4.6-sna...og/#value-prop

tois cela devrais correspondre à une QProgressDialog qui va appeler l'evntloop à chaque setValue.
Sinon, regarde
http://qt.developpez.com/faq/?page=qt4Gui#de-geler-ihm
20/01/2010, 20h24
karastojko

Merci pour cet example, il marche comme supposé, mais ceci de moi ne marche pas, même avec QCoreApplication::processEvents(). Evidemment elle se redessine pas, mais j'en vois aucune façon de la forcer de se redessiner.:(

Voilà un petit exemple très simple d'utilisation d'une QProgressBar qui pourra t'aider... Inspire toi de cet exemple et n'hésite pas à poser des questions.

Tout d'abord, un petit thread qui va simuler un traitement...

Code:

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
// "Fichier Process.h
#include <QProgressDialog>
#include <QThread>
class Process : public QThread {
	Q_OBJECT
private:
	bool m_stop;
public:
	Process () {};
	~Process () {};
	// Méthode du processus...
	void run () {
		m_stop = false;
		for (int i=0; !m_stop && i<=10; i++) {
			// Emission des signaux pour la progress bar 
			emit progressValue (i*10);
			emit newText ("Etape " + QString::number (i));
			sleep (1);
		}
	};
signals:
	void progressValue (const int);
	void newText(const QString&);
public slots:
	void cancel () {
		m_stop = true;
	};
};

Et ici le main qui initialise tout le monde...

Code:

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
// Fichier main.cpp
#include <QtGui/QApplication>
#include "Process.h"
 
int main (int argc, char *argv[]) {
	QApplication a (argc, argv);	
	Process process;
 
	// Initialisation de la progress bar
	QProgressDialog dlg;
	dlg.setWindowTitle ("Test du QProgressDialog");
	dlg.setRange (0, 100);
 
	// Connexion entre la progress bar et le thread
	QObject::connect (&process, 
		SIGNAL(progressValue(int)), &dlg, SLOT(setValue(int)));
	QObject::connect (&process, 
		SIGNAL(newText(QString)), &dlg, SLOT(setLabelText(QString)));
	QObject::connect (&dlg, 
		SIGNAL(canceled()), &process, SLOT(cancel())) ;
 
	// On affiche la progress bar
	dlg.show ();
	// On lance le thread
	process.start ();
 
	// On lance la boucle d'événements de l'application qui va transmettre
	// les signaux entre la progress bar et le thread
	return a.exec ();
}

Merci pour cet exemple, il marche bien, mais j'essayerais de construire un exemple quand le dialog est construit quelque part ailleurs, pas dans la main(). Ici, f() simule une fonction qui crée le dialog de progrès:
Code:

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 #include <QProgressDialog> #include <QtGui/QApplication> #include "Process.h" void f() { Process process; QProgressDialog dlg; dlg.setWindowTitle("Test du QProgressDialog"); dlg.setRange(0, 100); QObject::connect(&process, SIGNAL(progressValue(int)), &dlg, SLOT(setValue(int))); QObject::connect(&process, SIGNAL(newText(QString)), &dlg, SLOT(setLabelText(QString))); QObject::connect(&dlg, SIGNAL(canceled()), &process, SLOT(cancel())) ; dlg.show(); process.start(); } int main (int argc, char *argv[]) { QApplication a(argc, argv); f(); return a.exec(); }
Ca ne marcherait pas, parce que f() finit et le dialog est detruit. Donc, je peux essayer placer
Code:

1 2 process.wait();
au fin de f(). Mais ca ne marcherait non plus, parce qu'on n'arrive pas jusqu'à a.exec() et on ne redessine jamais le dialog. Donc, quoi faire dans la situation comme celle-ci?

En fait avec les QProgressBar il vaut mieux faire de la programmation objet (C++) que de l'impérative (C)...

Ton objet QProgressBar doit exister quelque part le temps que le processus s'exécute, et d'ailleurs lui aussi (l'objet de la classe Process) doit exister tant le processus n'est pas terminé, sinon ça risque de faire mal...

Dans certains cas ceci peut fonctionner (programmation impérative)
Code:

1 2 3 4 5 6 7 8 f () { Process process; QProgressDialog dlg; // [...] dlg.show (); dlg.exec (); // C'est une boucle d'évènements intermédiaire qui ici peut suffire process.wait (); // A ne pas oublier, pour que le thread est le temps de totalement se terminer avant d'être détruit...
Une autre manière, plus dans un esprit "C++ / Objet" serait :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class MyClass : public QWidget { private: Process* process; QProgressDialog* dlg; MyClass () : process (0), dlg (0) {}; ~MyClass () {}; void launch () { process = new process (this); dlg = new QProgressBar (this); dlg->setWindowTitle("Test du QProgressDialog"); dlg->setRange(0, 100); QObject::connect(process, SIGNAL(progressValue(int)), dlg, SLOT(setValue(int))); QObject::connect(process, SIGNAL(newText(QString)), dlg, SLOT(setLabelText(QString))); QObject::connect(dlg, SIGNAL(canceled()), process, SLOT(cancel())) ; dlg->show(); process->start(); }; };
Et bien sûr en rajoutant des contrôles, pour éviter de lancer un process alors qu'un autre tourne déjà, pour pouvoir en arrêter un, etc...

26/01/2010, 19h26
karastojko

Ca marche comme j'ai désiré , merci beacoup.