Discussion :

[Guillaume1701]

Bonjour,

J'essaye de réaliser un splashScreen affichant la progression d'une fonction d'initialisation.
J'ai fait un petit code pour illustrer ce que je veux faire.

Je comprendrais que le sleep bloque le programme mais on demande de redessiner la fenêtre entre temps.
Le contenu de la fonction load est juste pour l'exemple.

Merci d'avance pour votre aide.

main.cpp :

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
#include "mainwindow.h"
#include <QApplication>
#include "splashscreen.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    SplashScreen *splash = new SplashScreen(&a);
    MainWindow w(splash);
 
    splash->show();
    w.load();
    splash->finish(&w);
    w.show();
 
    return a.exec();
}

splashscreen.h

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
#ifndef SPLASHSCREEN_H
#define SPLASHSCREEN_H
 
#include <QSplashScreen>
#include <QApplication>
 
class SplashScreen : public QSplashScreen
{
    Q_OBJECT
public:
    explicit SplashScreen(QApplication *app, QWidget *parent = 0);
    int m_progress;
    QApplication *app;
 
public slots:
    void setProgress(int value)
    {
      m_progress = value;
      if (m_progress > 100)
        m_progress = 100;
      if (m_progress < 0)
        m_progress = 0;
      update();
    }
 
protected:
    void drawContents(QPainter *painter);
 
};
 
#endif // SPLASHSCREEN_H

splashscreen.cpp :

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
#include "splashscreen.h"
#include <QStyleOptionProgressBar>
 
SplashScreen::SplashScreen(QApplication *aApp, QWidget *parent) :
    QSplashScreen(parent), app(aApp), m_progress(0)
 
{
    this->setPixmap(QPixmap("C:/Users/T0181902/Downloads/ToolKit/inProgress/SplashScreen/SplashScreen/thales.png"));
    this->setCursor(Qt::BusyCursor);
}
 
void SplashScreen::drawContents(QPainter *painter)
{
  QSplashScreen::drawContents(painter);
 
  // Set style for progressbar...
  QStyleOptionProgressBar pbstyle;
  pbstyle.initFrom(this);
  pbstyle.state = QStyle::State_Enabled;
  pbstyle.textVisible = true;
  pbstyle.text = "Chargement en cours";
  pbstyle.minimum = 0;
  pbstyle.maximum = 100;
  pbstyle.progress = m_progress;
  pbstyle.invertedAppearance = false;
  pbstyle.rect = QRect(0, 265, 380, 19); // Where is it.
 
  // Draw it...
  style()->drawControl(QStyle::CE_ProgressBar, &pbstyle, painter, this);
}

mainwindow.h :

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
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include "splashscreen.h"
 
namespace Ui {
class MainWindow;
}
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    explicit MainWindow(SplashScreen *sp, QWidget *parent = 0);
    ~MainWindow();
    void load();
 
signals:
    void loadingUpdate(int progress, QString msg);
 
private:
    Ui::MainWindow *ui;
    SplashScreen *_sp;
};
 
#endif // MAINWINDOW_H

mainwindow.cpp :

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
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QThread>
 
MainWindow::MainWindow(SplashScreen *sp, QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    _sp(sp)
{
    ui->setupUi(this);
}
 
MainWindow::~MainWindow()
{
    delete ui;
}
 
void MainWindow::load()
{
    _sp->setProgress(20);
    QThread::sleep(2);
    _sp->setProgress(40);
    QThread::sleep(2);
    _sp->setProgress(60);
    QThread::sleep(2);
    _sp->setProgress(80);
    QThread::sleep(2);
    _sp->setProgress(100);
}

[Gojir4]

Bonjour,

Le problème est que lors de l'appel de MainWindow::load() dans main.cpp, la boucle d'événement n'est pas encore active, de ce fait les appels à drawContents() (généré pas l'appel de la fonction update()ne seront pas exécutés avant le lancement de la boucle d'événement avec a.exec().

Une solution consiste à appeler QApplication::processEvents() afin de forcer le traitement des événements.

Je pense que cela devrait fonctionner en remplaçant la ligne update() par app.processEvents() à la fin de l'implémentation de la fonction SplashScreen::setProgress().

Voici pour exemple un implémentation de splashcreen que j'avais codé il y a quelques temps. Par contre je ne dessine pas le contenu du splashcreen mais j'utilise des widgets et des layouts à la place. Mais le principe reste le même.

splashscreen.h:

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
#ifndef SPLASHSCREEN_H
#define SPLASHSCREEN_H
 
#include <QSplashScreen>
 
class QLabel;
class QProgressBar;
 
class SplashScreen : public QSplashScreen
{
    Q_OBJECT
    QApplication *m_app;
 
    QProgressBar *m_progressBar;
    QLabel *m_messageLabel;
    QLabel *m_versionLabel;
 
 
public:
    SplashScreen(QApplication *app, const QPixmap &pixmap = QPixmap());
 
public slots:
    void setVersion(const QString &version);
    void setMessage(const QString &message);
    void setProgressValue(int value);
    void setProgressMin(int min);
    void setProgressMax(int max);
    void onUpdate();
 
};
 
#endif // SPLASHSCREEN_H

splashscreen.cpp:

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
#include "splashscreen.h"
 
#include <QApplication>
#include <QLabel>
#include <QProgressBar>
#include <QStyleOptionProgressBarV2>
#include <QVBoxLayout>
 
SplashScreen::SplashScreen(QApplication *app, const QPixmap &pixmap) :
    QSplashScreen(pixmap)
{    
    m_progressBar = new QProgressBar;
    m_progressBar->setMinimumWidth(250);
    m_progressBar->setTextVisible(false);
    QPalette p;
    p.setBrush(QPalette::Highlight, QBrush(QColor("#0072A6")));
    m_progressBar->setPalette(p);
    m_versionLabel = new QLabel;
    m_messageLabel = new QLabel;
    p = QPalette();
    p.setBrush(QPalette::Foreground, QBrush(QColor(Qt::white)));
    m_versionLabel->setPalette(p);
    m_messageLabel->setPalette(p);
    m_versionLabel->setText("v" + app->applicationVersion());
 
    QVBoxLayout *layout = new QVBoxLayout;
    layout->setAlignment(Qt::AlignHCenter);
    layout->addStretch();
    layout->setSpacing(6);
    layout->addWidget(m_messageLabel, 0, Qt::AlignHCenter);
    layout->addWidget(m_progressBar, 0, Qt::AlignHCenter);
    layout->addWidget(m_versionLabel, 0, Qt::AlignRight);
    setLayout(layout);
}
 
void SplashScreen::setVersion(const QString &version)
{
    m_versionLabel->setText(version);
    onUpdate();
}
 
void SplashScreen::setMessage(const QString &message)
{
    m_messageLabel->setText(message);
    onUpdate();
}
 
void SplashScreen::setProgressValue(int value)
{
    m_progressBar->setValue(value);
    onUpdate();
}
 
void SplashScreen::setProgressMin(int min)
{
    m_progressBar->setMinimum(min);
    onUpdate();
}
 
void SplashScreen::setProgressMax(int max)
{
    m_progressBar->setMaximum(max);
    onUpdate();
}
 
void SplashScreen::onUpdate()
{
    m_app->processEvents();
}

utilisation:

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
SplashScreen splash(&a, QPixmap(":/img/splash.png"));
splash.show();
splash.setProgressMax(3);
 
splash.setMessage("Loading recent packages...");
loadRecentPackages("PackageData.json");
splash.setProgressValue(1);
 
splash.setMessage("Loading customers...");
loadCustomers("customers.json");
splash.setProgressValue(2);
 
splash.setMessage("Loading plugins...");
loadPlugins();
splash.setProgressValue(3);
 
MainWindow w;
splash.finish(&w);
w.show();