Discussion :

[Caxton]

Bonjour,

Hier, je me suis décidé à reprendre le principe d'une application. Pas que j'en abandonne totalement mes projets !

J'ai fait une sorte de lanceur de Dé. Jusque là, c'est assez facile.

Pièce jointe 123656

J'ai trouver le code qui permettrait de lancer une classe qui elle se chargerais de fournir un résultat aléatoire. Et d'ailleurs, je me prépare à en écrire son algorithme.

Code dans le slot du bouton, qui, pour le moment ne sert qu'à démontrer que la sélection se fait correctement.

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
 
//Slot Bouton Lancer les Dés.
void MainWindow::on_pushButton_clicked()
{
    //Si c'est le dé 4 qui est sélectionné
    if(ui->radioButton_4->isChecked()) {
        //Debug -> Afficher 4
        ui->lcdNumber->display(4);
    }
 
    //Si c'est le dé 6 qui est sélectionné
    if(ui->radioButton_6->isChecked()) {
        //Debug -> Afficher 6
        ui->lcdNumber->display(6);
    }
 
    //Si c'est le dé 8 qui est sélectionné
    if(ui->radioButton_8->isChecked()) {
        //Debug -> Afficher 8
        ui->lcdNumber->display(8);
    }
 
    //Si c'est le dé 10 qui est sélectionné
    if(ui->radioButton_10->isChecked()) {
        //Debug -> Afficher 10
        ui->lcdNumber->display(10);
    }
 
    //Si c'est le dé 12 qui est sélectionné
    if(ui->radioButton_12->isChecked()) {
        //Debug -> Afficher 12
        ui->lcdNumber->display(12);
    }
 
    //Si c'est le dé 20 qui est sélectionné
    if(ui->radioButton_20->isChecked()) {
        //Debug -> Afficher 20
        ui->lcdNumber->display(20);
    }
 
    //Si c'est le dé 100 qui est sélectionné
    if(ui->radioButton_100->isChecked()) {
        //Debug -> Afficher 4
        ui->lcdNumber->display(100);
    }
}

Voilà ce que je compte faire. A la suite de tout ces if, j'aurais fait une sorte d'appel de classe tel que:

Code :

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

1
2
3
4
5
 
dice = new dice();           //Créer un objet dice
dice.setFaces(int faces);  //Initialise le nombre de faces
dice.throw();                  //Lancer les dés
ui->lcdNumber->display(dice.out());

Dans ma classe, il faudra un constructeur. Il initialisera le nombre d'affichage intermédiaire tel que:

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
 
//Conctructeur
   //Initialiser 6 affichages intermédiaire
 
//setFace (int faces)
   //Place le nombre de face dans une variable
 
//throw ()
   //boucle for int i = int 6 affichages intermédiaire
      //Aléatoire entre 1 et int faces
      //Afficher sur le lcdNumber->display(résiltat intermédiaire)
      //Refresh (repaint ?)
      //Attendre 1 seconde
      //Boucler
 
   //Aléatoire entre 1 et int faces
   //Placer dans une variable int out
 
//out()
   //Return int out

Je pense que j'ai la base théorique. Il ne me reste plus, si je ne me suis pas tromper qu'à implémenter cela

[Caxton]

Plop !

Alors, dans un souci de clarté... j'ai commencer ma classe externe. Un fichier dice.h et un fichier dice.cpp.

Voyons ce que j'ai fait et ce qui reste à faire

Au niveau de dice.h j'ai fait ceci:

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
 
#ifndef DICE_H
#define DICE_H
 
#include <QMainWindow>
 
class dice : public QMainWindow
{
    Q_OBJECT
public:
    explicit dice(QWidget *parent = 0);
    void setFaces(int faces);               //Déclaration de la méthode setFaces
    void throwDice();                       //Opère un lancement de dé
 
private:
    int nbAff;                              //Nombre d'affichage intermédiaire
    int F;                                  //Nombre de face dans la classe
 
    int randN(int n);                       //Methode permettant de retourner un nombre aléatoire entre 1 et n
 
signals:
 
public slots:
 
};
 
#endif // DICE_H

Et au niveau de dice.cpp cela:

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
 
#include "dice.h"
#include <qDebug>
#include <qglobal.h>
 
//Conctructeur de la classe dice
dice::dice(QWidget *parent) :
    QMainWindow(parent)
{
    nbAff = 6;  //Initialise le nombre d'affichage intermédiaire
}
 
//Setter le nombre de faces
void dice::setFaces(int faces)
{
    F = faces;  //Initialise le nombre de face avec ce qui est setté
}
 
//Lancer les dés
void dice::throwDice()
{
    //Boucler pour x affichages intermédiaires
    for (int i = 1; i < nbAff; i++)
    {
        //Lancer un rand
        //Afficher (mainwindow : ui->lcdNumber->display(resultatRandIntermediaire); donc en dehors de la classe
        //Attendre 1seconde (sleep(1000) ?) 
 
        qDebug() << "Attention" << i;
    }
 
 
 
    qDebug() << "NB Faces" << F << "Random" << randN(F);
}
 
//Random pour n faces
int dice::randN(int n)
{
    int partSize = 1 + (n == RAND_MAX ? 0 : (RAND_MAX - n) / (n + 1));
    int maxUserFull = partSize * n + (partSize -1);
    int draw;
 
    do
    {
        draw = rand();
    }
    while (draw > maxUserFull);
 
    return (draw / partSize) + 1;
}
 
//Mon code pour setter
//qDebug() << faces;

Enfin l'appel de fonction dans le slot du mainwindow.cpp qui permet de tester sur l'appuie d'un bouton

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
 
//Slot Bouton Lancer les Dés.
void MainWindow::on_pushButton_clicked()
{
    int nbFaces;  //Le nombres de faces
 
    //Si c'est le dé 4 qui est sélectionné
    if(ui->radioButton_4->isChecked())
    {
        nbFaces = 4;    //Charger un nombre de face
    }
 
    //Si c'est le dé 6 qui est sélectionné
    if(ui->radioButton_6->isChecked())
    {
        nbFaces = 6;    //Charger un nombre de face
    }
 
    //Si c'est le dé 8 qui est sélectionné
    if(ui->radioButton_8->isChecked())
    {
        nbFaces = 8;    //Charger un nombre de face
    }
 
    //Si c'est le dé 10 qui est sélectionné
    if(ui->radioButton_10->isChecked())
    {
        nbFaces = 10;    //Charger un nombre de face
    }
 
    //Si c'est le dé 12 qui est sélectionné
    if(ui->radioButton_12->isChecked())
    {
        nbFaces = 12;    //Charger un nombre de face
    }
 
    //Si c'est le dé 20 qui est sélectionné
    if(ui->radioButton_20->isChecked())
    {
        nbFaces = 20;    //Charger un nombre de face
    }
 
    //Si c'est le dé 100 qui est sélectionné
    if(ui->radioButton_100->isChecked())
    {
        nbFaces = 21;    //Charger un nombre de face
    }
 
    dice D;                 //Initialisation d'un Dés D
    D.setFaces(nbFaces);    //Set le nombre de face du dé à jetter
    D.throwDice();          //Jetter les dés
 
}

Un grand merci à WinJerome pour son aide sur le randum disponible en VP: http://c.developpez.com/faq/?page=alea#RANDOM_runif_a_b

J'ai juste eu à modifier et a débugger avec EpiTouille. A la fin je rajoute +1 car je ne veux pas tomber à "0".

Ensuite, il reste, pour moi un mystère que je pense contourner. J'ai dans ma boucle for, dans ma classe, mis du commentaire. A cette endroit, j'aimerais faire ce qui est commenté (algo..). Sauf que le LCD est externe et est dépendant de mainwindows.cpp et mainwindows.h via l'ui.

Donc soit c'est faisable par une écoute de la classe (via un slot) qui toutes les secondes affiche un résultat partiel, soit ce n'est pas faisable et c'est virer de la classe pour être exécuter dans le main.

En espérant avoir pas trop fait un code trop mal.

Merci pour vos aides

[Caxton]

Bonjour,

Finalement, j'ai retirer mon système intermédiaire

Cela ne servais pas à grand chose dans le code à part l'alourdir inutilement pour faire une geekerie inutile au final.

Je vais donc poursuivre mon application

Jeter les dés fonctionne mais seulement localement. Dans la réalité, j'aimerais me servir de cette application avec d'autres en temps réel. Imaginon une partie de RPG (à l'ancienne, papier.... crayon... règles... musique d'ambiance...) si je suis joueur, je dois jeter les dés, je peux pas montrer aux autres, à distance le jet que j'ai fait. C'est là qu'il faudra donc mettre en place un système de client / serveur.

Plusieurs cas sont en prendre en ligne de compte.
A/ Cas de l'application orienté Master
1/ Si je suis MJ (Maître des jeux), j'ai certains jets de dés qui sont invisible. Donc pas besoin de montrer aux autres.
2/ Si je suis MJ et que je veux montrer aux autres mes jets.

B/ Cas de l'application orienté Joueur
1/ Tous mes jets doivent être visible de tous

La même application pouvant servir pour les deux cas, je pense faire un système d'onglet basculant. C'est à dire repeindre l'interface, selon que l'on choisit MJ ou Joueur.

Deuxièmement. N'est pas MJ qui veut ! Ce qui veut dire qu'un seul des participant peut avoir en même temps la zone MJ. Il faudra gérer le cas ou plusieurs MJ, dans chacun de leur jeu ai une interface identique. Là, je pense que la partie client / serveur, sera donc lancé à la main.

Exemple :
Onglet Connexion
Btn -> Créer serveur (si MJ)
Btn -> Se connecter à un serveur (si Joueur)

Mais pas les deux à la fois.

Bon, si je fais une deadline, je dirais que:
1/ Je refais une application neuve.
2/ Je crée le système de basculement de fenêtre. Via un bouton en haut ou par le menu déroulant. Pour les tests, ça sera par menu déroulant -> schecked
3/ Placer deux boutons ou deux textes pour tester le basculement.
4/ Implémenter la zone outils -> dès et outils -> Connexion
5/ Implémenter les paramètres.

Pour le moment, je vais me cantonner à l'interface si vous me permettez d'être réducteur ! Et de ne pas compter sur le reste de ma deadline tant que j'ai pas terminer avec celle-ci.

Comment je pourrait créer le basculement d'écran, sans avoir d'onglets par exemple ?

[Caxton]

Alors voilà !

J'ai pris mon courage à deux mains et j'ai fini par trouver une solution satisfaisante.

Je vais disposer dans la QToolBar, en haut, deux icônes. Une pour l'affichage Joueur, une pour l'affichage Master.

Par défaut, seule l'icône joueur est active. l'autre est bleue mais cliquable.
Si je clique sur la seconde, ça grise l'autre et ainsi de suite.

Comment donc faire cela dans le designer de Qt sachant que j'ai créer mes deux action dans l'éditeur d'action ?

Merci

[Caxton]

Bonjour,

Maintenant, au démarrage, j'ai besoin de proposer des choix. En effet, j'ai deux onglets dans mon application qui doivent pas être mise en marche en même temps. Du coup, je me dit:

1/ Au démarrage, l'application se lance.
2/ Immédiatement ensuite, une fenêtre MODALE (bloquante quoi), viens avec un choix du type:
2 bis -> Voulez-vous activer l'espace PJ ou l'espace MJ ?
3/ Si clic sur l'espace PJ, on viendra grisé et désactiver l'espace MJ, sinon, l'inverse.

A noter que je vais avoir besoin d'une variable particulière dans toute l'application. Elle permettra entre autre de changer la configuration de la connexion. Client en mode PJ, Serveur en mode MJ.

Donc, si je synthétise, il faut (démarrer l'apply et la bloquer. Faire ouvrir une popup et afficher les choix. Selon le choix fermer la popup, mettre a jour une variable locale, travailler sur les grisés ou non en fonction du choix.

Merci beaucoup pour votre aide.

Edit:

J'ai créer une nouvelle fenêtre que j'ai nommé dialogstart avec:
dialogstart.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
 
#ifndef DIALOGSTART_H
#define DIALOGSTART_H
 
#include <QDialog>
 
namespace Ui {
class DialogStart;
}
 
class DialogStart : public QDialog
{
    Q_OBJECT
 
public:
    explicit DialogStart(QWidget *parent = 0);
    ~DialogStart();
 
private:
    Ui::DialogStart *ui;
};
 
#endif // DIALOGSTART_H

dialogstart.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
 
#include "dialogstart.h"
#include "ui_dialogstart.h"
 
DialogStart::DialogStart(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DialogStart)
{
    ui->setupUi(this);
}
 
DialogStart::~DialogStart()
{
    delete ui;
}

Et bien sûr un ui pour générer tout ça.

Maintenant, j'aimerais faire en sorte que ça soit modale. On m'a parler de QSplashScreen, il semble adapté à une image. Ors, là, j'ai une boite de dialogue en quelque-sorte.

Du coup, j'essaie de faire cela:
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 <QSplashScreen>
#include "dialogstart.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
 
    QSplashScreen dialogStart;
    //dialogStart -> ouvrir en modale dislogstart.cpp fenêtre de choix de début
 
 
    w.show();
 
    return a.exec();
}

Je ne suis pas certain de la validité du concept.

[Caxton]

Bon, voyant que j'avance à rien, je vais changer mon fusil d'épaule

Voila ce que j'avais conçu comme fenêtre au démarrage. A priori incompatible avec QSplashScreen. En plus QSplashScreen n'est là que pour attendre que le reste ce charge. Ce qui n'est pas mon cas !

Pièce jointe 123840

A partir de là, j'avais donc cherché à faire apparaître d'abord la popup avant de faire apparaître l'application en elle-même.

Ma question est donc, comment faire pour que , j'ouvre bien cette popup au départ ? Ensuite en fonction du choix, j'écoute les deux boutons qui font ceci :
Fermer la popup
Enregistrer le choix (je pense à un QSettings mais il faudra l'effacer à la fin pour qu'au prochain redémarrage on ai a nouveau le choix)
Faire apparaître la fenêtre et grisé tout sauf ce qui est choisi par le choix.

Merci.

[LittleWhite]

Il faut repasser au C++ (coté code). Afin de faire deux classes, une pour la popup, chargeant son UI associé et une pour le reste de l'interface.
La première classe proposera un get, pour récupérer le choix de l'utilisateur. Ce choix sera passé au constructeur de la seconde classe.

Ça devrait pas mal le faire, je pense.
Le designer est là, pour dessiner les interfaces (les créer). Le code C++ est toujours présent pour faire la logique, les liens entre les interfaces.

[Caxton]

Oui, je crois que je commence à comprendre !

Tu veux donc que je modifie main.cpp afin qu'il : Affiche la fenêtre de choix, et écoute le bouton qui lui mettra a jour les infos de l'apply.

A tu un bref exemple de ce que je peux faire.

Là, je ne suis pas sur mon poste de programmation ; difficile de te faire un copier / coller de ce que j'ai déjà réalisé.

[Caxton]

Bonsoir,

Ça avance lentement !

J'ai fait un peu de code, beaucoup aider pour comprendre le concept des enum que je n'avais jamais utilisé en c++

Il se passe une chose étrange, au démarrage de mon application, j'ouvre une boite de dialogue QDialog, nommé DialogStart. Et là, en théorie, je dois attendre l'action de l'utilisateur. Soit il clique sur le bouton 1 -> énum chargé avec la valeur DS_FLAG_PJ, soit c'est le second bouton, alors il est chargé avec DS_FLAG_MJ.

Mais voila, à l'endroit de mes tests, on attends pas que l'utilisateur appuie sur l'un des boutons, on prends la valeur par défaut et basta ! Et ça c'est pas bon

Voila dans l'ordre logique mon code:
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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include "mainwindow.h"
#include <QApplication>
#include <QSplashScreen>
#include "dialogstart.h"
#include <qDebug>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    //Première fenêtre
    DialogStart fenStart;
        //fenStart.setModal(true);
        fenStart.show();
 
        if(fenStart.getStartFlag() == DialogStart::DS_FLAG_PJ)
        {
            qDebug() << "PJ";
        }
        if(fenStart.getStartFlag() == DialogStart::DS_FLAG_MJ)
        {
            qDebug() << "MJ";
        }
 
        //qDebug() << "Test Enum" << fenStart.getStartFlag();
        //qDebug() << "Comparaison PJ" << DialogStart::DS_FLAG_PJ;
        //qDebug() << "Comparaison MJ" << DialogStart::DS_FLAG_MJ;
 
    //MainWindow w;
    //w.show();
 
    return a.exec();
}

dialogstart.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
33
34
35
36
37
38
39
40
41
 
#ifndef DIALOGSTART_H
#define DIALOGSTART_H
 
#include <QDialog>
 
namespace Ui {
class DialogStart;
}
 
class DialogStart : public QDialog
{
    Q_OBJECT
 
public:
    explicit DialogStart(QWidget *parent = 0);
    ~DialogStart();
 
    //Défini une enum de type DialogStart_FLAG
        //Le DS_FLAG_PJ si PJ choisi
        //Le DS_FLAG_PJ si MJ choisi
    enum DialogStart_FLAG
    {
        DS_FLAG_PJ,
        DS_FLAG_MJ
    };
 
    //Méthode getStartFlag qui renvoie un DialogStart_FLAG
    DialogStart::DialogStart_FLAG getStartFlag();
 
private slots:
    void on_pushButton_Joueur_clicked();    //Bouton joueur
    void on_pushButton_Mj_clicked();        //Bouton MJ
 
private:
    Ui::DialogStart *ui;
 
    DialogStart_FLAG FLAG_F; //Crée un atribut FLAG_F
};
 
#endif // DIALOGSTART_H

dialogstart.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
 
#include "dialogstart.h"
#include "ui_dialogstart.h"
 
DialogStart::DialogStart(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DialogStart)
{
    ui->setupUi(this);
    FLAG_F = DS_FLAG_PJ;          //Assigne au flag la valeur DS_FLAG_PJ
}
 
DialogStart::~DialogStart()
{
    delete ui;
}
 
//Si bouton joueur
void DialogStart::on_pushButton_Joueur_clicked()
{
    FLAG_F = DS_FLAG_PJ;          //Assigne au flag la valeur DS_FLAG_PJ
}
 
//Si bouton Mj
void DialogStart::on_pushButton_Mj_clicked()
{
    FLAG_F = DS_FLAG_MJ;          //Assigne au flag la valeur DS_FLAG_MJ
}
 
//Methode qui renvoie l'état de la sélection utilisateur
DialogStart::DialogStart_FLAG DialogStart::getStartFlag()
{
    return FLAG_F;
}

Voila si quelqu'un à une idée.

Merci.

[Caxton]

Finalement, j'y suis arrivé

Mon application se lance parfaitement.

Maintenant, j'ai un autre souci à gérer:
dans ma QDialog,, oui, toujours la même ! J'ai un bouton qui apparaît en haut à droite et qui dit (fermer la popup). J'aimerais faire en sorte que, n'ayant pas de quoi accéder à ce bouton invisible en mode ui, cela ferme l'application avec quit();

Comment donc repéré un bouton inconnu ? Et comment le connecté à la commande quit(); sous Qt 5.

Voila, ça sera tout pour le moment

[arnolddumas]

Ca ne fonctionne pas en faisant :

Code :

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

QObject::connect(myPushButton, &QPushButton::clicked, this, &QDialog::close);

Et sinon, c'est quoi cette histoire de bouton invisible dans le designer ?

[Caxton]

Bon, alors, deux screen s'impose

Dans mon designer:
Pièce jointe 124021

Dans la réalité (suivre la flèche rouge) tadaaaaa !
Pièce jointe 124022

EDIT:

Ok, je teste cette technique

Sans succès...


merci

[arnolddumas]

Je ne sais toujours pas sûr de ce que tu veux faire. En gros, tu voudrait appeler un slot quand l'utilisateur clique sur la croix de fermeture de ta QDialog ?

Sinon, le code que j'ai donné n'était pas fait pour être directement copié collé, il faut adapter le nom du QPushButton, ici myPushButton, mais il aura sûrement un autre nom dans ton code.

PS : tu peux pré-visualiser le rendu de ta fênetre en ouvrant le .ui dans le designer et en appuyant sur Ctrl+R.

[Caxton]

Oui, ça j'avais compris qu'il fallait adapté. Et c'est pas tant ça que je demande. C'est comment retrouver le nom du bouton incriminé

Sinon, y a la solution bâtarde de cacher le bouton de la croix et de se créer un bouton à la main qui lui fera le job. Mais j'aimerais éviter cette dernière qu'en cas de dernier recours !

[Caxton]

Bonjour,

Je me suis amusé ce matin à intégré une redéfinition et je trouve cela exaltant de pouvoir reconstruire une fonction. Je pense poursuivre dans cette voie pour ce problème là.

Voila en réalité ce qui se passe. J'ai pas bien le choix, il va y avoir une tartine de code. C'est peut-être pour ça que du coup, ça compile, le quit(); s'exécute mais l'autre fenêtre s'ouvre quand même !

Dans l'ordre d'exécution -> 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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
#include "mainwindow.h"
#include <QApplication>
#include <QSplashScreen>
#include "dialogstart.h"
#include <qDebug>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
        //Première fenêtre
        DialogStart fenStart;
            fenStart.exec();
 
            if(fenStart.getStartFlag() == DialogStart::DS_FLAG_PJ)
            {
                qDebug() << "PJ";
            }
 
            if(fenStart.getStartFlag() == DialogStart::DS_FLAG_MJ)
            {
                qDebug() << "MJ";
            }
 
            /* Pour plus tard */
            //qDebug() << "Test Enum" << fenStart.getStartFlag();
            //qDebug() << "Comparaison PJ" << DialogStart::DS_FLAG_PJ;
            //qDebug() << "Comparaison MJ" << DialogStart::DS_FLAG_MJ;
 
        //Programme principal
        MainWindow w;
            w.show();
 
    return a.exec();
}

QDialog -> dialogstart.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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#ifndef DIALOGSTART_H
#define DIALOGSTART_H
 
#include <QDialog>
#include <QCloseEvent>
 
namespace Ui {
class DialogStart;
}
 
class DialogStart : public QDialog
{
    Q_OBJECT
 
public:
    explicit DialogStart(QWidget *parent = 0);
    ~DialogStart();
 
    //Défini une enum de type DialogStart_FLAG
        //Le DS_FLAG_PJ si PJ choisi
        //Le DS_FLAG_PJ si MJ choisi
    enum DialogStart_FLAG
    {
        DS_FLAG_PJ,
        DS_FLAG_MJ
    };
 
    //Méthode getStartFlag qui renvoie un DialogStart_FLAG
    DialogStart::DialogStart_FLAG getStartFlag();
 
 
private slots:
    void on_pushButton_Joueur_clicked();    //Bouton joueur
    void on_pushButton_Mj_clicked();        //Bouton MJ
 
 
private:
    Ui::DialogStart *ui;
    DialogStart_FLAG FLAG_F; //Crée un atribut FLAG_F
 
public slots:
    void closeEvent(QCloseEvent *);     //Redéfinir la méthode close event
};
 
#endif // DIALOGSTART_H

QDialog -> dialogstart.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
 
#include "dialogstart.h"
#include "ui_dialogstart.h"
#include <qDebug>
#include <QCloseEvent>
 
DialogStart::DialogStart(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::DialogStart)
{
    ui->setupUi(this);
    FLAG_F = DS_FLAG_PJ;          //Assigne au flag la valeur DS_FLAG_PJ
 
    /*
     * !!! ANCIEN CODE A L' ETUDE !!! */
    //Slot bouton close de QDialog
    //connect(this, SIGNAL(QDialog::close()), qApp, SLOT(quit()));
    /* Préférer la redéfinition de la méthode closeEvent */
}
 
DialogStart::~DialogStart()
{
    delete ui;
}
 
//Si bouton joueur
void DialogStart::on_pushButton_Joueur_clicked()
{
    FLAG_F = DS_FLAG_PJ;    //Assigne au flag la valeur DS_FLAG_PJ
    close();                //Ferme la fenêtre et poursui l'exécution du programme
}
 
//Si bouton Mj
void DialogStart::on_pushButton_Mj_clicked()
{
    FLAG_F = DS_FLAG_MJ;    //Assigne au flag la valeur DS_FLAG_MJ
    close();                //Ferme la fenêtre et poursui l'exécution du programme
}
 
//Methode qui renvoie l'état de la sélection utilisateur
DialogStart::DialogStart_FLAG DialogStart::getStartFlag()
{
    return FLAG_F;
}
 
//Redéfinir la méthode closeEvent
void DialogStart::closeEvent(QCloseEvent *event) {
    qDebug() << "Quit application required by user !";
    qApp->quit();
    event->accept();
}

Ensuite, j'ai la mainwindow qui apparaît et qui ne dois apparaître que si je clique sur l'un des deux boutons de validation, donc pas la croix en haut. Si c'est faisable.

En tout cas, merci pour votre aide.

[arnolddumas]

La tu instancie ta MainWindow même si l'utilisateur appuie sur la croix de fermeture de ta QDialog. Le souci se situe dans main.cpp au niveau des conditions avec les drapeaux, ou plutôt juste après.

[Caxton]

Bonsoir,

Hypothèse intéressante et même logique en effet.

Étant débutant en cpp, j'aimerait si possible savoir comment je pourrait faire pour revoir la portion de code concerne.


Merci.

[Caxton]

Bonjour,

Début de piste dans le main.cpp

Faites pas gaffe à ce qui est commenté, j''ai garder pour l'instant, le temps de trouver la bonne parade au bug. Tout ça disparaîtra quand j'aurais résolu le souci du bouton de la QDialog.

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
 
#include "mainwindow.h"
#include <QApplication>
#include <QSplashScreen>
#include "dialogstart.h"
#include <qDebug>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
        //Première fenêtre
        DialogStart fenStart;
            //fenStart.exec();
 
            //Si on a cliquer sur la croix de fermeture
            if(fenStart.exec() == QDialog::Rejected)
            {
                qDebug() << "Rejected ?";
                return 0;   //Renvoie 0 car il faut quitter l'application
            }
 
            if(fenStart.getStartFlag() == DialogStart::DS_FLAG_PJ)
            {
                qDebug() << "PJ";
            }
 
            if(fenStart.getStartFlag() == DialogStart::DS_FLAG_MJ)
            {
                qDebug() << "MJ";
            }
 
            /* Pour plus tard */
            //qDebug() << "Test Enum" << fenStart.getStartFlag();
            //qDebug() << "Comparaison PJ" << DialogStart::DS_FLAG_PJ;
            //qDebug() << "Comparaison MJ" << DialogStart::DS_FLAG_MJ;
 
        //Programme principal
        MainWindow w;
            w.show();
 
    return a.exec();
}

Si je comprends bien, on passe tout le temps sur rejected même avec les boutons. Et du coup, ça ferme l'application à chaque fois que l'utilisateur fait quelque-chose.

[LittleWhite]

Cela dépend du code de la boite de Dialogue, car il y a un moment, c'est elle qui indique ce qui est retournée.

[Caxton]

Justement, pourquoi elle enverrais directement Rejected qui, je le rappel est due à l'emploie de la fermeture de la QDialog et non sur les boutons qui, eux, renvoie Accepted.

Il y a là, un souci de renvoie manifeste de la bonne valeur par la boite de dialog. Ok. Mais le pourquoi, là, c'est à se cogner la tête contre les murs

Une idée, par hasard, il n'existe pas un moyen avec qDebug() de savoir ce que fait la boite de dialog ? Tester son event me paraît être une piste. Mais comment lettre ça en oeuvre ?