Classe qui fait cesser de fonctionner mon programme

Bonjour à tous.

Je viens vous demander un peu d'aide car mon programme utilisant Qt compile bien mais cesse de fonctionner.

J'ai une classe FenetrePrincipale qui correspond à la fenêtre de mon programme, et deux classes PageMenuPrincipal et PageOptions qui sont deux "écrans" différents qui peuvent être affichés dans la fenêtre.

Voici le code :
PageMenuPrincipal.hpp :

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
31
#ifndef _PAGEMENUPRINCIPAL
#define _PAGEMENUPRINCIPAL
 
#include <QApplication>
#include <QPushButton>
#include <QVBoxLayout>
 
#include "FenetrePrincipale.hpp"
#include "PageOptions.hpp"
 
class PageOptions;
class FenetrePrincipale;
 
class PageMenuPrincipal : public QWidget
{
	Q_OBJECT
 
	public :
		PageMenuPrincipal(FenetrePrincipale* fenetrePrincipale);
 
	public slots :
		void afficherMenuSolo();
		void afficherMenuMultijoueur();
		void afficherPageOptions();
 
	private :
		FenetrePrincipale *m_fenetrePrincipale;
		PageOptions *m_pageOptions;
};
 
#endif

PageMenuPrincipale.cpp :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "PageMenuPrincipal.hpp"
 
PageMenuPrincipal::PageMenuPrincipal(FenetrePrincipale* fenetrePrincipale) :
	QWidget(),
	m_fenetrePrincipale(fenetrePrincipale)
{
	// layout principal
	QPushButton *menuSolo = new QPushButton("Solo");
	menuSolo->setObjectName("Menu");
	QPushButton *menuMultijoueur = new QPushButton("Multijoueur");
	menuMultijoueur->setObjectName("Menu");
	QPushButton *menuOptions = new QPushButton("Options");
	menuOptions->setObjectName("Menu");
	QPushButton *menuQuitter = new QPushButton("Quitter");
	menuQuitter->setObjectName("Menu");
 
	QVBoxLayout *layoutPrincipal = new QVBoxLayout;
	layoutPrincipal->setAlignment(Qt::AlignCenter);
	layoutPrincipal->addWidget(menuSolo);
	layoutPrincipal->addWidget(menuMultijoueur);
	layoutPrincipal->addWidget(menuOptions);
	layoutPrincipal->addWidget(menuQuitter);
 
	setLayout(layoutPrincipal);
 
	connect(menuSolo, SIGNAL(clicked()), this, SLOT(afficherMenuSolo()));
	connect(menuMultijoueur, SIGNAL(clicked()), this, SLOT(afficherMenuMultijoueur()));
	connect(menuOptions, SIGNAL(clicked()), this, SLOT(afficherPageOptions()));
	connect(menuQuitter, SIGNAL(clicked()), m_fenetrePrincipale, SLOT(close()));
 
 
	// autres pages
	m_pageOptions = new PageOptions(m_fenetrePrincipale);
	m_fenetrePrincipale->ajouterPage(this, 0);
}
 
void PageMenuPrincipal::afficherMenuSolo()
{
}
 
void PageMenuPrincipal::afficherMenuMultijoueur()
{
}
 
void PageMenuPrincipal::afficherPageOptions()
{
	m_fenetrePrincipale->afficherPage(1);
}

PageOptions.hpp :

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
31
32
33
34
35
#ifndef _PAGEOPTIONS
#define _PAGEOPTIONS
 
#include <QWidget>
#include <QComboBox>
#include <QCheckBox>
#include <QPushButton>
#include <QFormLayout>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QSettings>
#include <QFile>
 
#include "FenetrePrincipale.hpp"
 
class FenetrePrincipale;
 
class PageOptions : public QWidget
{
	Q_OBJECT
 
	public :
		PageOptions(FenetrePrincipale* fenetrePrincipale);
 
	public slots :
		void enregistrerOptions();
 
	private :
		QSettings m_fichierOptions;
		FenetrePrincipale *m_fenetrePrincipale;
		QComboBox *m_listeStyle;
		QCheckBox *m_casePleinEcran;
};
 
#endif

PageOptions.cpp :

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
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
#include "PageOptions.hpp"
 
PageOptions::PageOptions(FenetrePrincipale* fenetrePrincipale) :
	QWidget(),
	m_fichierOptions("Options", QSettings::IniFormat),
	m_fenetrePrincipale(fenetrePrincipale)
{
	// layout des options
	m_listeStyle = new QComboBox;
	m_listeStyle->addItem("Defaut Noir");
	m_listeStyle->addItem("Defaut Blanc");
	m_casePleinEcran = new QCheckBox;
	parentWidget()->isFullScreen() ? m_casePleinEcran->setChecked(true) : m_casePleinEcran->setChecked(false);
 
	QFormLayout *layoutFormulaireOptions = new QFormLayout;
	layoutFormulaireOptions->addRow("Style :", m_listeStyle);
	layoutFormulaireOptions->addRow("Plein écran :", m_casePleinEcran);
 
 
	// layout des boutons
	QPushButton *boutonAppliquer = new QPushButton("Appliquer");
	QPushButton *boutonAnnuler = new QPushButton("Retour");
 
	QHBoxLayout *layoutBoutons = new QHBoxLayout;
	layoutBoutons->addWidget(boutonAppliquer);
	layoutBoutons->addWidget(boutonAnnuler);
 
	connect(boutonAppliquer, SIGNAL(clicked()), this, SLOT(enregistrerOptions()));
	connect(boutonAnnuler, SIGNAL(clicked()), this, SLOT(afficherPageMenuPrincipal()));
 
 
	// layout principal
	QVBoxLayout *layoutPrincipal = new QVBoxLayout;
	layoutPrincipal->setAlignment(Qt::AlignCenter);
	layoutPrincipal->addLayout(layoutFormulaireOptions);
	layoutPrincipal->addLayout(layoutBoutons);
 
	setLayout(layoutPrincipal);
 
	m_fenetrePrincipale->ajouterPage(this, 1);
}
 
void PageOptions::enregistrerOptions()
{
	// enregistrement des options
	m_fichierOptions.setValue("Style", m_listeStyle->currentText());
	m_fichierOptions.setValue("PleinEcran", m_casePleinEcran->isChecked());
 
	// application des options
	QFile fichierStyle("Styles/" + m_listeStyle->currentText() + "/" + m_listeStyle->currentText() + ".css");
	fichierStyle.open(QIODevice::ReadOnly);
	m_fenetrePrincipale->setStyleSheet(fichierStyle.readAll());
 
	m_casePleinEcran->isChecked() ? parentWidget()->showFullScreen() : parentWidget()->showNormal();
 
	m_fenetrePrincipale->afficherPage(0);
}

FenetrePrincipale.hpp :

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
#ifndef _FENETREPRINCIPALE
#define _FENETREPRINCIPALE
 
#include <QWidget>
#include <QStackedLayout>
#include <QFile>
#include <QSettings>
#include <QCloseEvent>
 
#include "PageMenuPrincipal.hpp"
 
class FenetrePrincipale : public QWidget
{
	Q_OBJECT
 
	public :
		FenetrePrincipale();
		void closeEvent(QCloseEvent *event);
		void ajouterPage(QWidget* page, int numeroPage);
		void afficherPage(int page);
 
	private :
		QSettings m_fichierOptions;
		QString m_style;
		bool m_pleinEcran;
		QStackedLayout *layoutPrincipal;
};
 
#endif

FenetrePrincipale.cpp :

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include "FenetrePrincipale.hpp"
 
FenetrePrincipale::FenetrePrincipale() :
	QWidget(),
	m_fichierOptions("Options", QSettings::IniFormat),
	m_style(m_fichierOptions.value("Style", "Defaut Noir").toString()),
	m_pleinEcran(m_fichierOptions.value("PleinEcran", true).toBool())
{
	// affichage de la fenêtre
	QFile fichierStyle("Styles/" + m_style + "/" + m_style + ".css");
	fichierStyle.open(QIODevice::ReadOnly);
	setStyleSheet(fichierStyle.readAll());
 
	resize(m_fichierOptions.value("LargeurFenetre", 600).toInt(), m_fichierOptions.value("HauteurFenetre", 400).toInt());
	m_fichierOptions.value("PleinEcran", true).toBool() ? showFullScreen() : showNormal();
 
 
	// affichage du menu principal
	layoutPrincipal = new QStackedLayout;
	setLayout(layoutPrincipal);
 
	PageMenuPrincipal *menuPrincipal = new PageMenuPrincipal(this);
	afficherPage(0);
}
 
void FenetrePrincipale::closeEvent(QCloseEvent *event)
{
	// enregistrement de la taille de la fenêtre
	if (!isFullScreen())
	{
		m_fichierOptions.setValue("LargeurFenetre", width());
		m_fichierOptions.setValue("HauteurFenetre", height());
	}
 
	event->accept();
}
 
void FenetrePrincipale::ajouterPage(QWidget* page, int numeroPage)
{
	layoutPrincipal->insertWidget(numeroPage, page);
}
 
void FenetrePrincipale::afficherPage(int numeroPage)
{
	layoutPrincipal->setCurrentIndex(numeroPage);
}

Si je retire la classe PageOptions du projet, le programme s'exécute correctement et sans planter. Autrement j'ai un "a cessé de fonctionner" lors du lancement du programme.

Pourriez vous me dire d'où vient l'erreur ?
Merci d'avance.

PS : je doute que le problème vienne de là, mais voici le main.cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
#include <QApplication>
#include "GUI/FenetrePrincipale.hpp"
 
int main(int argc, char *argv[])
{
	QApplication application(argc, argv);
 
	FenetrePrincipale fenetrePrincipale;
	fenetrePrincipale.show();
 
	return application.exec();
}