Discussion :

[lvfek]

Bonjour, j'aurais besoin d'un coup de main pour démarrer en QT. En fait, j'ai 3 différente classe que j'ai crée en QT et je veut pouvoir gèrer mes interface pour les connecter entre elles et j'ai de la misere avec la gestion de ceux-ci. En gros, j'ai une page de base qui doit gèrer une bibliotheque. J'ai deux choix a la base soit j'ajoute un livre ou j'ajoute une reference.

J'ai donc sur une page principale deux bouton :

1 : le bouton ajouter livre et l'autre le bouton ajouter reference

Je voudrais que lorsque je clique sur le bouton Ajouter livre, il m'ouvre la deuxieme interface que j'ai créee pour préparer l'ajout d'un livre a ma bibliotheque. J'ai essayer de plusieurs manières mais je n'y arrive pas. Est-il mieux d'utiliser la commande exec ou la commande show ??

Bref voici en gros le code :

Dans mon interface de bases (GestionBibliotheque) j'ai la balise de connection suivante

Code :

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

1
2
3
4
5
6
7
8
9
GestionBibliotheque::GestionBibliotheque(QWidget *parent)
    : QWidget(parent)
{
	ui.setupUi(this);
	QObject::connect(ui.addarticle, SIGNAL(clicked()), this,
				SLOT(saisieArticle()));
 
 
}

J'ai aussi la fonction SaisieArticle qui se definit comme suit :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void GestionBibliotheque::saisieArticle()
{
          hide();
	/*ajouterarticle b(this); 
 
  // Le probleme se trouve ici je n'ai pas idée comment faire pour executer l'article j'obtiens des erreur du genre gestionbibliotheque.cpp:24: erreur: 'class ajouterarticle' has no member named 'exec'
 
	if (b.exec())*/
	{
		std::cout<<"Vous êtes maintenant dans l'outil d'ajout d'un Article"<<std::endl;
 
	}
}

Mon interface qui prepare lajout d'un article se nomme ajouterArticle.cpp et ajouterArticle.h

Voici en gros le GestionBibliotheque.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
 
class GestionBibliotheque : public QWidget
{
    Q_OBJECT
public:
    GestionBibliotheque(QWidget *parent = 0);
    ~GestionBibliotheque();
 
public slots :
		void saisieArticle();
 
private:
    Ui::GestionBibliothequeClass ui;
};

Mon but est simple je veut simplement que lorsque je clique sur le bouton (qui ici se nomme addarticle dans l'interface GestionBibliotheque) que la deuxieme interface s'ouvre et que la premiere reste en background (avec la fonction hide) cependant j'obtiens des erreur de compilation tels que b n'est pas defini ou la ne possede pas la fonction exec

Toute forme d'aide sera grandement apprécié!!!

Merci beaucoup

[allchimiste]

Bonjour a toi.

J'ai eu un soucis similaire et j'ai réussit a trouver la solution.
Un petit exemple rapide pour comprendre un peut le système. A adapter a ta situation :

Liste de mes fichiers :
AjouterLivre.h

AjouterLivre.cpp

AjouterLivre.ui

AjouterReference.h

AjouterReference.cpp

AjouterReference.ui

FenPrincipale.h

FenPrincipale.cpp

FenPrincipale.ui

main.cpp

Classes correspondantes :
AjouterLivre AjouterReference FenPrincipale

Maintenant un peut de code que j'ai essayer de commenter au maximum

AjouterLivre.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
#ifndef AJOUTERLIVRE_H
#define AJOUTERLIVRE_H
 
#include <QWidget>
#include "ui_AjouterLivre.h"
 
class AjouterLivre : public QWidget, private Ui_AjouterLivre
{
    Q_OBJECT
 
public:
    AjouterLivre();
 
private slots:
    void Retour();  // Fonction qui va permettre d'émettre un signal et fermer la fenêtre en cours.
 
signals:
    void EmettreRetour();       // Signal qui sera émit par la fenêtre et capturé par la fenêtre principale.
};
 
#endif // AJOUTERLIVRE_H

AjouterReference.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
#ifndef AJOUTERREFERENCE_H
#define AJOUTERREFERENCE_H
 
#include <QWidget>
#include "ui_AjouterReference.h"
 
class AjouterReference : public QWidget, private Ui_AjouterReference
{
    Q_OBJECT
 
public:
    AjouterReference();
 
private slots:
    void Retour();  // Fonction qui va permettre d'émettre un signal et fermer la fenêtre en cours.
 
signals:
    void EmettreRetour();       // Signal qui sera émit par la fenêtre et capturé par la fenêtre principale.
};
 
#endif // AJOUTERREFERENCE_H

FenPrincipale.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
#ifndef FENPRINCIPALE_H
#define FENPRINCIPALE_H
 
#include <QMainWindow>
#include "ui_FenPrincipale.h"
 
// Inclure les fichier de définition des deux autres interfaces
#include "AjouterLivre.h"
#include "AjouterReference.h"
 
// Inclure les définitions des interfaces graphiques
#include <QWidget>
 
// Include les définitions des "Messages Pop-Up"
#include <QMessageBox>
 
class FenPrincipale : public QMainWindow, private Ui_FenPrincipale
{
    Q_OBJECT
 
    // Définir deux objets qui ferons référence aux deux autres fenêtres.
    QWidget* FenAjouterLivre;
    QWidget* FenAjouterReference;
 
public:
    FenPrincipale();
 
private slots:
    void OuvrirAjouterLivre();          // Définir une fonction qui sera en charge d'afficher l'interface AjouterLivre.
    void OuvrirAjouterReference();      // Définir une fonction qui sera en charge d'afficher l'interface AjouterReference.
    void RetourAjouterLivre();          // Définir une fonction qui sera en charge de traiter le retour d'information de l'interface AjouterLivre.
    void RetourAjouterReference();      // Définir une fonction qui sera en charge de traiter le retour d'information de l'interface AjouterReference.
};
 
#endif // FENPRINCIPALE_H

------------------------------------------------------------------------------

AjouterLivre.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
#include "AjouterLivre.h"
 
AjouterLivre::AjouterLivre()
{
    setupUi(this);
 
    // Connexion entre le bouton "Retour" et la fonction chargée d'envoyer les informations de retour a l'interface principale.
    connect(B_Retour, SIGNAL(clicked()), this, SLOT(Retour()));
}
 
void AjouterLivre::Retour()
{
    // L'interface est fermée.
    this->close();
    // Le signal est émit.
    emit EmettreRetour();
}

AjouterReference.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
#include "AjouterReference.h"
 
AjouterReference::AjouterReference()
{
    setupUi(this);
 
    // Connexion entre le bouton "Retour" et la fonction chargée d'envoyer les informations de retour a l'interface principale.
    connect(B_Retour, SIGNAL(clicked()), this, SLOT(Retour()));
}
 
void AjouterReference::Retour()
{
    // L'interface est fermée.
    this->close();
    // Le signal est émit.
    emit EmettreRetour();
}

FenPrincipale.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
#include "FenPrincipale.h"
 
FenPrincipale::FenPrincipale()
{
    setupUi(this);
 
    // Création de l'objet, qui sera l'interface graphique "AjouterLivre".
    FenAjouterLivre = new AjouterLivre();
    // Fermeture de la fenêtre, pour éviter de voir la fenêtre s'afficher par défaut a l'ouverture du programme, avec la Fenêtre Principale.
    FenAjouterLivre->close();
 
    // Création de l'objet, qui sera l'interface graphique "AjouterReference".
    FenAjouterReference = new AjouterReference();
   // Fermeture de la fenêtre, pour éviter de voir la fenêtre s'afficher par défaut a l'ouverture du programme, avec la Fenêtre Principale.
    FenAjouterReference->close();
 
    // Connexion des deux boutons a des fonctions prévues pour afficher les interfaces.
    connect(B_AjouterLivre, SIGNAL(clicked()), this, SLOT(OuvrirAjouterLivre()));
    connect(B_AjouterReference, SIGNAL(clicked()), this, SLOT(OuvrirAjouterReference()));
 
    // Connexion des deux signaux de retour émis par les interfaces secondaires.
    connect(FenAjouterLivre, SIGNAL(EmettreRetour()), this, SLOT(RetourAjouterLivre()));
    connect(FenAjouterReference, SIGNAL(EmettreRetour()), this, SLOT(RetourAjouterReference()));
 
    // Connexion entre le bouton "Quitter" et la fonction native de fermeture du programme.
    connect(B_Quitter, SIGNAL(clicked()), this, SLOT(close()));
}
 
void FenPrincipale::OuvrirAjouterLivre()
{
    // L'interface secondaire est affichée.
    FenAjouterLivre->show();
    // L'interface principale est cachée.
    this->hide();
}
 
void FenPrincipale::OuvrirAjouterReference()
{
    // L'interface secondaire est affichée.
    FenAjouterReference->show();
    // L'interface principale est cachée.
    this->hide();
}
 
void FenPrincipale::RetourAjouterLivre()
{
    // L'interface principale est de nouveau visible.
    this->show();
    // Un petit message pour prouver qu'on est bien dans cette fonction.
    QMessageBox::information(this, tr("Information"), tr("Retour d'information(s) de l'interface graphique\n\tAjouterLivre"));
}
 
void FenPrincipale::RetourAjouterReference()
{
    // L'interface principale est de nouveau visible.
    this->show();
    // Un petit message pour prouver qu'on est bien dans cette fonction.
    QMessageBox::information(this, tr("Information"), tr("Retour d'information(s) de l'interface graphique\n\tAjouterReference"));
}

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "FenPrincipale.h"
#include <QApplication>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    FenPrincipale w;
    w.show();
 
    return a.exec();
}

------------------------------------------------------------------------------

IHM AjouterLivre :



IHM AjouterRefence :



IHM FenPrincipale :




Voilà, si ça peut t'aider.. Si tu as des questions n’hésite pas.
En pièce jointe le projet fait sous QtCreator pour l'exemple.