qelectrotech-source-mirror/qetapp.cpp

#include "qetapp.h"
#include "schemavue.h"
#include "schema.h"
#include "panelappareils.h"
#include "aboutqet.h"

/**
	constructeur
	@param parent le widget parent de la fenetre principale
 */
QETApp::QETApp(QWidget *parent) : QMainWindow(parent) {
	// mise en place de l'interface MDI au centre de l'application
	setCentralWidget(&workspace);
	
	// mise en place du signalmapper
	connect(&windowMapper, SIGNAL(mapped(QWidget *)), &workspace, SLOT(setActiveWindow(QWidget *)));
	
	// recupere les arguments passes au programme
	QStringList args = QCoreApplication::arguments();
	
	// recupere les chemins de fichiers parmi les arguments
	QStringList fichiers;
	for (int i = 1 ; i < args.size() ; ++ i) {
		if (QFileInfo(args.at(i)).exists()) fichiers << args.at(i);
	}
	
	// si des chemins de fichiers valides sont passes en arguments
	QList<SchemaVue *> schema_vues;
	if (fichiers.size()) {
		// alors on ouvre ces fichiers
		foreach(QString fichier, fichiers) {
			SchemaVue *sv = new SchemaVue(this);
			if (sv -> ouvrir(fichier)) schema_vues << sv;
			else delete sv;
		}
	}
	
	// si aucun schema n'a ete ouvert jusqu'a maintenant, on ouvre un nouveau schema
	if (!schema_vues.size()) schema_vues << new SchemaVue(this);
	
	// ajout de tous les SchemaVue necessaires
	foreach (SchemaVue *sv, schema_vues) addSchemaVue(sv);
	
	// titre de la fenetre
	setWindowTitle(tr("QElectroTech"));
	
	// icone de la fenetre
	setWindowIcon(QIcon(":/ico/qet.png"));
	
	// barre de statut de la fenetre
	statusBar() -> showMessage(tr("QElectrotech"));
	
	// ajout du panel d'Appareils en tant que QDockWidget
	qdw_pa = new QDockWidget(tr("Panel d'appareils"), this);
	qdw_pa -> setAllowedAreas(Qt::AllDockWidgetAreas);
	qdw_pa -> setFeatures(QDockWidget::AllDockWidgetFeatures);
	qdw_pa -> setMinimumWidth(160);
	qdw_pa -> setWidget(pa = new PanelAppareils(qdw_pa));
	addDockWidget(Qt::LeftDockWidgetArea, qdw_pa);
	
	// mise en place des actions
	actions();
	
	// mise en place de la barre d'outils
	toolbar();
	
	// mise en place des menus
	menus();
	
	// systray de l'application
	if (QSystemTrayIcon::isSystemTrayAvailable()) {
		qsti = new QSystemTrayIcon(QIcon(":/ico/qet.png"), this);
		qsti -> setToolTip(tr("QElectroTech"));
		connect(qsti, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), this, SLOT(systray(QSystemTrayIcon::ActivationReason)));
		menu_systray = new QMenu(tr("QElectroTech"));
		menu_systray -> addAction(masquer_appli);
		menu_systray -> addAction(quitter_qet);
		qsti -> setContextMenu(menu_systray);
		qsti -> show();
	}
	
	// la fenetre est maximisee par defaut
	setMinimumWidth(500);
	setMinimumHeight(350);
	setWindowState(Qt::WindowMaximized);
	
	// connexions signaux / slots pour une interface sensee
	connect(&workspace, SIGNAL(windowActivated(QWidget *)), this, SLOT(slot_updateActions()));
	connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(slot_updateActions()));
}

/**
	Gere les evenements relatifs au QSystemTrayIcon
	@param raison un entier representant l'evenement survenu sur le systray
*/
void QETApp::systray(QSystemTrayIcon::ActivationReason raison) {
	if (!QSystemTrayIcon::isSystemTrayAvailable()) return;
	switch(raison) {
		case QSystemTrayIcon::Context:
			// affichage du menu
			(qsti -> contextMenu()) -> show();
			break;
		case QSystemTrayIcon::DoubleClick:
		case QSystemTrayIcon::Trigger:
			// reduction ou restauration de l'application
			if (isVisible()) systrayReduire(); else systrayRestaurer();
			break;
		case QSystemTrayIcon::Unknown:
		default: // ne rien faire
		break;
	}
}

/**
	Reduit l'application dans le systray
*/
void QETApp::systrayReduire() {
	// on sauvegarde la position et les dimensions de l'application
	wg = saveGeometry();
	// on cache l'application
	hide();
	// on ajoute le menu "Restaurer" et on enl<6E>ve le menu "Masquer"
	menu_systray -> insertAction(masquer_appli, restaurer_appli);
	menu_systray -> removeAction(masquer_appli);
}

/**
	Restaure l'application reduite dans le systray
*/
void QETApp::systrayRestaurer() {
	// on restaure la position et les dimensions de l'application
	restoreGeometry(wg);
	// on affiche l'application
	show();
	// on ajoute le menu "Masquer" et on enl<6E>ve le menu "Restaurer"
	menu_systray -> insertAction(restaurer_appli, masquer_appli);
	menu_systray -> removeAction(restaurer_appli);
}

/**
	Permet de quitter l'application lors de la fermeture de la fenetre principale
	@param qce Le QCloseEvent correspondant a l'evenement de fermeture
*/
void QETApp::closeEvent(QCloseEvent *qce) {
	quitter(qce);
}

/**
	Gere la sortie de l'application
	@param e Le QCloseEvent correspondant a l'evenement de fermeture
*/
void QETApp::quitter(QCloseEvent *e) {
	// quitte directement s'il n'y a aucun schema ouvert
	if (!schemaEnCours()) qApp -> quit();
	else {
		// sinon demande la permission de fermer chaque schema
		bool peut_quitter = true;
		foreach(QWidget *fenetre, workspace.windowList()) {
			if (qobject_cast<SchemaVue *>(fenetre)) {
				workspace.setActiveWindow(fenetre);
				if (!fermer()) {
					peut_quitter = false;
					if (e != NULL) e -> ignore();
					break;
				}
			}
		}
		if (peut_quitter) qApp -> quit();
	}
}

/**
	Fait passer la fenetre du mode plein ecran au mode normal et vice-versa
*/
void QETApp::toggleFullScreen() {
	setWindowState(windowState() ^ Qt::WindowFullScreen);
}

/**
	Active ou desactive l'antialiasing sur le rendu graphique du Schema
*/
void QETApp::toggleAntialiasing() {
	SchemaVue *sv = schemaEnCours();
	if (!sv) return;
	sv -> setAntialiasing(!sv -> antialiased());
	toggle_aa -> setText(sv -> antialiased() ? tr("D\351sactiver l'&antialiasing") : tr("Activer l'&antialiasing"));
}

/**
	Dialogue <EFBFBD> A propos de QElectroTech <EFBFBD>
	Le dialogue en question est cree lors du premier appel de cette fonction.
	En consequence, sa premiere apparition n'est pas immediate. Par la suite,
	le dialogue n'a pas a etre recree et il apparait instantanement. Il est
	detruit en meme temps que son parent (ici, la QETApp).
*/
void QETApp::aPropos() {
	static AboutQET *apqet = new AboutQET(this);
	apqet -> exec();
}

/**
	Mise en place des actions
*/
void QETApp::actions() {
	// icones et labels
	nouveau_fichier   = new QAction(QIcon(":/ico/new.png"),        tr("&Nouveau"),                       this);
	ouvrir_fichier    = new QAction(QIcon(":/ico/open.png"),       tr("&Ouvrir"),                        this);
	fermer_fichier    = new QAction(QIcon(":/ico/fileclose.png"),  tr("&Fermer"),                        this);
	enr_fichier       = new QAction(QIcon(":/ico/save.png"),       tr("&Enregistrer"),                   this);
	enr_fichier_sous  = new QAction(QIcon(":/ico/saveas.png"),     tr("Enregistrer sous"),               this);
	importer          = new QAction(QIcon(":/ico/import.png"),     tr("&Importer"),                      this);
	exporter          = new QAction(QIcon(":/ico/export.png"),     tr("E&xporter"),                      this);
	imprimer          = new QAction(QIcon(":/ico/print.png"),      tr("Imprimer"),                       this);
	quitter_qet       = new QAction(QIcon(":/ico/exit.png"),       tr("&Quitter"),                       this);
	
	annuler           = new QAction(QIcon(":/ico/undo.png"),       tr("Annu&ler"),                       this);
	refaire           = new QAction(QIcon(":/ico/redo.png"),       tr("Re&faire"),                       this);
	couper            = new QAction(QIcon(":/ico/cut.png"),        tr("Co&uper"),                        this);
	copier            = new QAction(QIcon(":/ico/copy.png"),       tr("Cop&ier"),                        this);
	coller            = new QAction(QIcon(":/ico/paste.png"),      tr("C&oller"),                        this);
	sel_tout          = new QAction(                               tr("Tout s\351lectionner"),           this);
	sel_rien          = new QAction(                               tr("D\351s\351lectionner tout"),      this);
	sel_inverse       = new QAction(                               tr("Inverser la s\351lection"),       this);
	supprimer         = new QAction(QIcon(":/ico/delete.png"),     tr("Supprimer"),                      this);
	pivoter           = new QAction(QIcon(":/ico/pivoter.png"),    tr("Pivoter"),                        this);
	
	toggle_aa         = new QAction(                               tr("D\351sactiver l'&antialiasing"),  this);
	zoom_avant        = new QAction(QIcon(":/ico/viewmag+.png"),   tr("Zoom avant"),                     this);
	zoom_arriere      = new QAction(QIcon(":/ico/viewmag-.png"),   tr("Zoom arri\350re"),                this);
	zoom_adapte       = new QAction(QIcon(":/ico/viewmagfit.png"), tr("Zoom adapt\351"),                 this);
	zoom_reset        = new QAction(QIcon(":/ico/viewmag.png"),    tr("Pas de zoom"),                    this);
	
	mode_selection    = new QAction(QIcon(":/ico/select.png"),     tr("Mode Selection"),                 this);
	mode_visualise    = new QAction(QIcon(":/ico/move.png"),       tr("Mode Visualisation"),             this);
	
	entrer_pe         = new QAction(QIcon(":/ico/entrer_fs.png"),  tr("Passer en &mode plein \351cran"), this);
	sortir_pe         = new QAction(QIcon(":/ico/sortir_fs.png"),  tr("Sortir du &mode plein \351cran"), this);
	configurer        = new QAction(QIcon(":/ico/configure.png"),  tr("&Configurer QElectroTech"),       this);
	
	f_mosaique        = new QAction(                               tr("&Mosa\357que"),                   this);
	f_cascade         = new QAction(                               tr("&Cascade"),                       this);
	f_reorganise      = new QAction(                               tr("Arranger les fen\352tres r<>duites"),this);
	f_suiv            = new QAction(                               tr("Fen\352tre suivante"),            this);
	f_prec            = new QAction(                               tr("Fen\352tre pr\351c\351dente"),    this);
	
	a_propos_de_qet   = new QAction(QIcon(":/ico/qet.png"),        tr("\300 &propos de QElectroTech"),   this);
	a_propos_de_qt    = new QAction(QIcon(":/ico/qt.png"),         tr("\300 propos de &Qt"),             this);
	
	masquer_appli     = new QAction(QIcon(":/ico/masquer.png"),    tr("&Masquer"),                       this);
	restaurer_appli   = new QAction(QIcon(":/ico/restaurer.png"),  tr("&Restaurer"),                     this);
	
	// info-bulles
	masquer_appli     -> setToolTip(tr("Reduire QElectroTech dans le systray"));
	restaurer_appli   -> setToolTip(tr("Restaurer QElectroTech"));
	
	// raccourcis clavier
	nouveau_fichier   -> setShortcut(QKeySequence::New);
	ouvrir_fichier    -> setShortcut(QKeySequence::Open);
	fermer_fichier    -> setShortcut(QKeySequence::Close);
	enr_fichier       -> setShortcut(QKeySequence::Save);
	importer          -> setShortcut(QKeySequence(tr("Ctrl+Shift+I")));
	exporter          -> setShortcut(QKeySequence(tr("Ctrl+Shift+X")));
	imprimer          -> setShortcut(QKeySequence(QKeySequence::Print));
	quitter_qet       -> setShortcut(QKeySequence(tr("Ctrl+Q")));
	
	annuler           -> setShortcut(QKeySequence::Undo);
	refaire           -> setShortcut(QKeySequence::Redo);
	couper            -> setShortcut(QKeySequence::Cut);
	copier            -> setShortcut(QKeySequence::Copy);
	coller            -> setShortcut(QKeySequence::Paste);
	sel_tout          -> setShortcut(QKeySequence::SelectAll);
	sel_rien          -> setShortcut(QKeySequence(tr("Ctrl+Shift+A")));
	sel_inverse       -> setShortcut(QKeySequence(tr("Ctrl+I")));
	supprimer         -> setShortcut(QKeySequence::Delete);
	pivoter           -> setShortcut(QKeySequence(tr("P")));
	
	zoom_avant        -> setShortcut(QKeySequence::ZoomIn);
	zoom_arriere      -> setShortcut(QKeySequence::ZoomOut);
	zoom_adapte       -> setShortcut(QKeySequence(tr("Ctrl+9")));
	zoom_reset        -> setShortcut(QKeySequence(tr("Ctrl+0")));
	
	entrer_pe         -> setShortcut(QKeySequence(tr("Ctrl+Shift+F")));
	sortir_pe         -> setShortcut(QKeySequence(tr("Ctrl+Shift+F")));
	
	// affichage dans la barre de statut
	nouveau_fichier   -> setStatusTip(tr("Cr\351e un nouveau sch\351ma"));
	ouvrir_fichier    -> setStatusTip(tr("Ouvre un sch\351ma existant"));
	fermer_fichier    -> setStatusTip(tr("Ferme le sch\351ma courant"));
	enr_fichier       -> setStatusTip(tr("Enregistre le sch\351ma courant"));
	enr_fichier_sous  -> setStatusTip(tr("Enregistre le sch\351ma courant avec un autre nom de fichier"));
	importer          -> setStatusTip(tr("Importe un sch\351ma dans le sch\351ma courant"));
	exporter          -> setStatusTip(tr("Exporte le sch\351ma courant dans un autre format"));
	imprimer          -> setStatusTip(tr("Imprime le sch\351ma courant"));
	quitter_qet       -> setStatusTip(tr("Ferme l'application QElectroTech"));
	
	annuler           -> setStatusTip(tr("Annule l'action pr\351c\351dente"));
	refaire           -> setStatusTip(tr("Restaure l'action annul\351e"));
	couper            -> setStatusTip(tr("Transf\350re les \351l\351ments s\351lectionn\351s dans le presse-papier"));
	copier            -> setStatusTip(tr("Copie les \351l\351ments s\351lectionn\351s dans le presse-papier"));
	coller            -> setStatusTip(tr("Place les \351l\351ments du presse-papier sur le sch\351ma"));
	sel_tout          -> setStatusTip(tr("S\351lectionne tous les \351l\351ments du sch\351ma"));
	sel_rien          -> setStatusTip(tr("D\351s\351lectionne tous les \351l\351ments du sch\351ma"));
	sel_inverse       -> setStatusTip(tr("D\351s\351lectionne les \351l\351ments s\351lectionn\351s et s\351lectionne les \351l\351ments non s\351lectionn\351s"));
	supprimer         -> setStatusTip(tr("Enl\350ve les \351l\351ments s\351lectionn\351s du sch\351ma"));
	pivoter           -> setStatusTip(tr("Pivote les \351l\351ments s\351lectionn\351s"));
	
	toggle_aa         -> setStatusTip(tr("Active / d\351sactive l'antialiasing pour le rendu du sch\351ma courant"));
	zoom_avant        -> setStatusTip(tr("Agrandit le sch\351ma"));
	zoom_arriere      -> setStatusTip(tr("R\351tr\351cit le sch\351ma"));
	zoom_adapte       -> setStatusTip(tr("Adapte la taille du sch\351ma afin qu'il soit enti\350rement visible"));
	zoom_reset        -> setStatusTip(tr("Restaure le zoom par d\351faut"));
	
	mode_selection    -> setStatusTip(tr("Permet de s\351lectionner les \351l\351ments"));
	mode_visualise    -> setStatusTip(tr("Permet de visualiser le sch\351ma sans pouvoir le modifier"));
	
	entrer_pe         -> setStatusTip(tr("Affiche QElectroTech en mode plein \351cran"));
	sortir_pe         -> setStatusTip(tr("Affiche QElectroTech en mode fen\352tr\351"));
	configurer        -> setStatusTip(tr("Permet de r\351gler diff\351rents param\350tres de QElectroTech"));
	
	f_mosaique        -> setStatusTip(tr("Dispose les fen\352tres en mosa\357que"));
	f_cascade         -> setStatusTip(tr("Dispose les fen\352tres en cascade"));
	f_reorganise      -> setStatusTip(tr("Aligne les fen\352tres r<>duites"));
	f_suiv            -> setStatusTip(tr("Active la fen\352tre suivante"));
	f_prec            -> setStatusTip(tr("Active la fen\352tre pr\351c\351dente"));
	
	a_propos_de_qet   -> setStatusTip(tr("Affiche des informations sur QElectroTech"));
	a_propos_de_qt    -> setStatusTip(tr("Affiche des informations sur la biblioth\350que Qt"));
	
	// traitements speciaux
	mode_selection    -> setCheckable(true);
	mode_visualise    -> setCheckable(true);
	mode_selection    -> setChecked(true);
	
	QActionGroup *grp_visu_sel = new QActionGroup(this);
	grp_visu_sel -> addAction(mode_selection);
	grp_visu_sel -> addAction(mode_visualise);
	grp_visu_sel -> setExclusive(true);
	
	// connexion a des slots
	connect(quitter_qet,      SIGNAL(triggered()), this,       SLOT(quitter())                  );
	connect(sel_tout,         SIGNAL(triggered()), this,       SLOT(slot_selectAll())           );
	connect(sel_rien,         SIGNAL(triggered()), this,       SLOT(slot_selectNothing())       );
	connect(sel_inverse,      SIGNAL(triggered()), this,       SLOT(slot_selectInvert())        );
	connect(supprimer,        SIGNAL(triggered()), this,       SLOT(slot_supprimer())           );
	connect(pivoter,          SIGNAL(triggered()), this,       SLOT(slot_pivoter())             );
	connect(entrer_pe,        SIGNAL(triggered()), this,       SLOT(toggleFullScreen())         );
	connect(sortir_pe,        SIGNAL(triggered()), this,       SLOT(toggleFullScreen())         );
	connect(mode_selection,   SIGNAL(triggered()), this,       SLOT(slot_setSelectionMode())    );
	connect(mode_visualise,   SIGNAL(triggered()), this,       SLOT(slot_setVisualisationMode()));
	connect(a_propos_de_qet,  SIGNAL(triggered()), this,       SLOT(aPropos())                  );
	connect(a_propos_de_qt,   SIGNAL(triggered()), qApp,       SLOT(aboutQt())                  );
	connect(masquer_appli,    SIGNAL(triggered()), this,       SLOT(systrayReduire  ())         );
	connect(restaurer_appli,  SIGNAL(triggered()), this,       SLOT(systrayRestaurer())         );
	connect(zoom_avant,       SIGNAL(triggered()), this,       SLOT(slot_zoomPlus())            );
	connect(zoom_arriere,     SIGNAL(triggered()), this,       SLOT(slot_zoomMoins())           );
	connect(zoom_adapte,      SIGNAL(triggered()), this,       SLOT(slot_zoomFit())             );
	connect(zoom_reset,       SIGNAL(triggered()), this,       SLOT(slot_zoomReset())           );
	connect(imprimer,         SIGNAL(triggered()), this,       SLOT(dialogue_imprimer())        );
	connect(exporter,         SIGNAL(triggered()), this,       SLOT(dialogue_exporter())        );
	connect(enr_fichier_sous, SIGNAL(triggered()), this,       SLOT(dialogue_enregistrer_sous()));
	connect(enr_fichier,      SIGNAL(triggered()), this,       SLOT(enregistrer())              );
	connect(nouveau_fichier,  SIGNAL(triggered()), this,       SLOT(nouveau())                  );
	connect(ouvrir_fichier,   SIGNAL(triggered()), this,       SLOT(ouvrir())                   );
	connect(fermer_fichier,   SIGNAL(triggered()), this,       SLOT(fermer())                   );
	connect(couper,           SIGNAL(triggered()), this,       SLOT(slot_couper())              );
	connect(copier,           SIGNAL(triggered()), this,       SLOT(slot_copier())              );
	connect(coller,           SIGNAL(triggered()), this,       SLOT(slot_coller())              );
	connect(toggle_aa,        SIGNAL(triggered()), this,       SLOT(toggleAntialiasing())       );
	connect(f_mosaique,       SIGNAL(triggered()), &workspace, SLOT(tile()));
	connect(f_cascade,        SIGNAL(triggered()), &workspace, SLOT(cascade()));
	connect(f_reorganise,     SIGNAL(triggered()), &workspace, SLOT(arrangeIcons()));
	connect(f_suiv,           SIGNAL(triggered()), &workspace, SLOT(activateNextWindow()));
	connect(f_prec,           SIGNAL(triggered()), &workspace, SLOT(activatePreviousWindow()));
}

/**
	Mise en place des menus
*/
void QETApp::menus() {
	QMenu *menu_fichier   = menuBar() -> addMenu(tr("&Fichier"));
	QMenu *menu_edition   = menuBar() -> addMenu(tr("&\311dition"));
	QMenu *menu_affichage = menuBar() -> addMenu(tr("Afficha&ge"));
	QMenu *menu_outils    = menuBar() -> addMenu(tr("O&utils"));
	QMenu *menu_config    = menuBar() -> addMenu(tr("&Configuration"));
	menu_fenetres         = menuBar() -> addMenu(tr("Fe&n\352tres"));
	QMenu *menu_aide      = menuBar() -> addMenu(tr("&Aide"));
	
	// tear off feature rulezz... pas ^^ mais bon...
	menu_fichier   -> setTearOffEnabled(true);
	menu_edition   -> setTearOffEnabled(true);
	menu_affichage -> setTearOffEnabled(true);
	menu_outils    -> setTearOffEnabled(true);
	menu_config    -> setTearOffEnabled(true);
	menu_aide      -> setTearOffEnabled(true);
	
	// menu Fichier
	menu_fichier -> addAction(nouveau_fichier);
	menu_fichier -> addAction(ouvrir_fichier);
	menu_fichier -> addAction(enr_fichier);
	menu_fichier -> addAction(enr_fichier_sous);
	menu_fichier -> addAction(fermer_fichier);
	menu_fichier -> addSeparator();
	menu_fichier -> addAction(importer);
	menu_fichier -> addAction(exporter);
	menu_fichier -> addSeparator();
	menu_fichier -> addAction(imprimer);
	menu_fichier -> addSeparator();
	menu_fichier -> addAction(quitter_qet);
	
	// menu Edition
	menu_edition -> addAction(annuler);
	menu_edition -> addAction(refaire);
	menu_edition -> addSeparator();
	menu_edition -> addAction(couper);
	menu_edition -> addAction(copier);
	menu_edition -> addAction(coller);
	menu_edition -> addSeparator();
	menu_edition -> addAction(sel_tout);
	menu_edition -> addAction(sel_rien);
	menu_edition -> addAction(sel_inverse);
	menu_edition -> addSeparator();
	menu_edition -> addAction(supprimer);
	menu_edition -> addAction(pivoter);
	
	// menu Affichage > Afficher
	QMenu *menu_aff_aff = new QMenu(tr("Afficher"));
	menu_aff_aff -> setTearOffEnabled(true);
	menu_aff_aff -> addAction(barre_outils -> toggleViewAction());
	barre_outils -> toggleViewAction() -> setStatusTip(tr("Affiche ou non la barre d'outils"));
	menu_aff_aff -> addAction(qdw_pa -> toggleViewAction());
	qdw_pa -> toggleViewAction() -> setStatusTip(tr("Affiche ou non le panel d'appareils"));
	
	// menu Affichage
	menu_affichage -> addMenu(menu_aff_aff);
	menu_affichage -> addSeparator();
	menu_affichage -> addAction(toggle_aa);
	menu_affichage -> addSeparator();
	menu_affichage -> addAction(zoom_avant);
	menu_affichage -> addAction(zoom_arriere);
	menu_affichage -> addAction(zoom_adapte);
	menu_affichage -> addAction(zoom_reset);
	
	// menu Outils
	menu_outils -> addAction(mode_selection);
	menu_outils -> addAction(mode_visualise);
	
	// menu Configuration
	menu_config -> addAction(entrer_pe);
	menu_config -> addAction(configurer);
	
	// menu Fen<65>tres
	slot_updateMenuFenetres();
	
	// menu Aide
	menu_aide -> addAction(a_propos_de_qet);
	menu_aide -> addAction(a_propos_de_qt);
}

/**
	Mise en place de la barre d'outils
*/
void QETApp::toolbar() {
	barre_outils = new QToolBar(tr("Outils"), this);
	
	// Modes selection / visualisation
	barre_outils -> addAction(mode_selection);
	barre_outils -> addAction(mode_visualise);
	barre_outils -> addSeparator();
	barre_outils -> addAction(annuler);
	barre_outils -> addAction(refaire);
	barre_outils -> addSeparator();
	barre_outils -> addAction(couper);
	barre_outils -> addAction(copier);
	barre_outils -> addAction(coller);
	barre_outils -> addSeparator();
	barre_outils -> addAction(supprimer);
	barre_outils -> addAction(pivoter);
	barre_outils -> addSeparator();
	barre_outils -> addAction(zoom_avant);
	barre_outils -> addAction(zoom_arriere);
	barre_outils -> addAction(zoom_adapte);
	barre_outils -> addAction(zoom_reset);
	
	// ajout de la barre d'outils a la fenetre principale
	addToolBar(Qt::TopToolBarArea, barre_outils);
}

/**
	gere l'impression
*/
void QETApp::dialogue_imprimer() {
	QPrinter *qprin = new QPrinter();
	QPrintDialog *qpd = new QPrintDialog(qprin, this);
	qpd -> exec();
}

/**
	Gere l'export de schema vers un autre format (PNG pour le moment)
*/
void QETApp::dialogue_exporter() {
	// demande un nom de fichier
	QString nom_fichier = QFileDialog::getSaveFileName(
		this,
		tr("Exporter vers le fichier"),
		QDir::homePath(),
		tr("Image PNG (*.png)")
	);
	// exporte le schema
	if (nom_fichier != "") {
		if (!nom_fichier.endsWith(".png", Qt::CaseInsensitive)) nom_fichier += ".png";
		QFile fichier(nom_fichier);
		Schema *sc = schemaEnCours() -> scene;
		sc -> setAffichageGrille(false);
		QImage image = sc -> toImage();
		sc -> setAffichageGrille(true);
		image.save(&fichier, "PNG");
		fichier.close();
	}
}

/**
	Methode enregistrant le schema dans le dernier nom de fichier connu.
	Si aucun nom de fichier n'est connu, cette methode appelle la methode enregistrer_sous
	@return true si l'enregistrement a reussi, false sinon
*/
bool QETApp::enregistrer() {
	if (!schemaEnCours()) return(false);
	return(schemaEnCours() -> enregistrer());
}

/**
	Cette methode demande un nom de fichier a l'utilisateur pour enregistrer le schema
	Si aucun nom n'est entre, elle renvoie faux.
	Si le nom ne se termine pas par l'extension .qet, celle-ci est ajoutee.
	Si l'enregistrement reussit, le nom du fichier est conserve et la fonction renvoie true.
	Sinon, faux est renvoye.
	@return true si l'enregistrement a reussi, false sinon
	@todo detecter le chemin du bureau automatiquement
*/
bool QETApp::dialogue_enregistrer_sous() {
	if (!schemaEnCours()) return(false);
	return(schemaEnCours() -> enregistrer_sous());
}

/**
	Cette methode cree un nouveau schema.
	@return true si tout s'est bien passe ; false si vous executez cette fonction dans un univers non cartesien (en fait y'a pas de return(false) :p)
*/
bool QETApp::nouveau() {
	addSchemaVue(new SchemaVue(this));
	return(true);
}

/**
	Cette fonction demande un nom de fichier a ouvrir a l'utilisateur
	@return true si l'ouverture a reussi, false sinon
*/
bool QETApp::ouvrir() {
	// demande un nom de fichier a ouvrir a l'utilisateur
	QString nom_fichier = QFileDialog::getOpenFileName(
		this,
		tr("Ouvrir un fichier"),
		QDir::homePath(),
		tr("Schema QelectroTech (*.qet);;Fichiers XML (*.xml);;Tous les fichiers (*)")
	);
	if (nom_fichier == "") return(false);
	
	// verifie que le fichier n'est pas deja ouvert
	QString chemin_fichier = QFileInfo(nom_fichier).canonicalFilePath();
	foreach (QWidget *fenetre, workspace.windowList()) {
		SchemaVue *fenetre_en_cours = qobject_cast<SchemaVue *>(fenetre);
		if (QFileInfo(fenetre_en_cours -> nom_fichier).canonicalFilePath() == chemin_fichier) {
			workspace.setActiveWindow(fenetre);
			return(false);
		}
	}
	
	// ouvre le fichier
	SchemaVue *sv = new SchemaVue(this);
	int code_erreur;
	if (sv -> ouvrir(nom_fichier, &code_erreur)) {
		addSchemaVue(sv);
		return(true);
	} else {
		QString message_erreur;
		switch(code_erreur) {
			case 1: message_erreur = tr("Ce fichier n'existe pas."); break;
			case 2: message_erreur = tr("Impossible de lire ce fichier."); break;
			case 3: message_erreur = tr("Ce fichier n'est pas un document XML valide."); break;
			case 4: message_erreur = tr("Une erreur s'est produite lors de l'ouverture du fichier."); break;
		}
		QMessageBox::warning(this, tr("Erreur"), message_erreur);
		delete sv;
		return(false);
	}
}

/**
	Ferme le document courant
	@return true si la fermeture du fichier a reussi, false sinon
	@todo detecter les modifications et ne demander que si besoin est
*/
bool QETApp::fermer() {
	SchemaVue *sv = schemaEnCours();
	if (!sv) return(false);
	bool fermeture_schema = sv -> close();
	if (fermeture_schema) delete sv;
	return(fermeture_schema);
}

/**
	@return Le SchemaVue qui a le focus dans l'interface MDI
*/
SchemaVue *QETApp::schemaEnCours() {
	return(qobject_cast<SchemaVue *>(workspace.activeWindow()));
}

/**
	Effectue l'action "couper" sur le schema en cours
*/
void QETApp::slot_couper() {
	if(schemaEnCours()) schemaEnCours() -> couper();
}

/**
	Effectue l'action "copier" sur le schema en cours
*/
void QETApp::slot_copier() {
	if(schemaEnCours()) schemaEnCours() -> copier();
}

/**
	Effectue l'action "coller" sur le schema en cours
*/
void QETApp::slot_coller() {
	if(schemaEnCours()) schemaEnCours() -> coller();
}

/**
	Effectue l'action "zoom avant" sur le schema en cours
*/
void QETApp::slot_zoomPlus() {
	if(schemaEnCours()) schemaEnCours() -> zoomPlus();
}

/**
	Effectue l'action "zoom arriere" sur le schema en cours
*/
void QETApp::slot_zoomMoins() {
	if(schemaEnCours()) schemaEnCours() -> zoomMoins();
}

/**
	Effectue l'action "zoom arriere" sur le schema en cours
*/
void QETApp::slot_zoomFit() {
	if(schemaEnCours()) schemaEnCours() -> zoomFit();
}

/**
	Effectue l'action "zoom par defaut" sur le schema en cours
*/
void QETApp::slot_zoomReset() {
	if(schemaEnCours()) schemaEnCours() -> zoomReset();
}

/**
	Effectue l'action "selectionner tout" sur le schema en cours
*/
void QETApp::slot_selectAll() {
	if(schemaEnCours()) schemaEnCours() -> selectAll();
}

/**
	Effectue l'action "deselectionenr tout" sur le schema en cours
*/
void QETApp::slot_selectNothing() {
	if(schemaEnCours()) schemaEnCours() -> selectNothing();
}

/**
	Effectue l'action "inverser la selection" sur le schema en cours
*/
void QETApp::slot_selectInvert() {
	if(schemaEnCours()) schemaEnCours() -> selectInvert();
}

/**
	Effectue l'action "supprimer" sur le schema en cours
*/
void QETApp::slot_supprimer() {
	if(schemaEnCours()) schemaEnCours() -> supprimer();
}

/**
	Effectue l'action "pivoter" sur le schema en cours
*/
void QETApp::slot_pivoter() {
	if(schemaEnCours()) schemaEnCours() -> pivoter();
}

/**
	Effectue l'action "mode selection" sur le schema en cours
*/
void QETApp::slot_setSelectionMode() {
	if(schemaEnCours()) schemaEnCours() -> setSelectionMode();
}

/**
	Effectue l'action "mode visualisation" sur le schema en cours
*/
void QETApp::slot_setVisualisationMode() {
	if(schemaEnCours()) schemaEnCours() -> setVisualisationMode();
}

/**
	gere les actions ayant besoin d'un document ouvert
*/
void QETApp::slot_updateActions() {
	SchemaVue *sv = schemaEnCours();
	bool document_ouvert = (sv != 0);
	
	// actions ayant juste besoin d'un document ouvert
	fermer_fichier   -> setEnabled(document_ouvert);
	enr_fichier      -> setEnabled(document_ouvert);
	enr_fichier_sous -> setEnabled(document_ouvert);
	importer         -> setEnabled(document_ouvert);
	exporter         -> setEnabled(document_ouvert);
	imprimer         -> setEnabled(document_ouvert);
	sel_tout         -> setEnabled(document_ouvert);
	sel_rien         -> setEnabled(document_ouvert);
	sel_inverse      -> setEnabled(document_ouvert);
	zoom_avant       -> setEnabled(document_ouvert);
	zoom_arriere     -> setEnabled(document_ouvert);
	zoom_adapte      -> setEnabled(document_ouvert);
	zoom_reset       -> setEnabled(document_ouvert);
	toggle_aa        -> setEnabled(document_ouvert);
	
	// actions ayant aussi besoin d'un historique des actions
	annuler          -> setEnabled(document_ouvert);
	refaire          -> setEnabled(document_ouvert);
	
	// actions ayant aussi besoin d'elements selectionnes
	bool elements_selectionnes = document_ouvert ? (sv -> scene -> selectedItems().size() > 0) : false;
	couper           -> setEnabled(elements_selectionnes);
	copier           -> setEnabled(elements_selectionnes);
	supprimer        -> setEnabled(elements_selectionnes);
	pivoter          -> setEnabled(elements_selectionnes);
	
	// action ayant aussi besoin d'un presse-papier plein
	bool peut_coller = QApplication::clipboard() -> text() != QString();
	coller           -> setEnabled(document_ouvert && peut_coller);
	
	// actions ayant aussi besoin d'un document ouvert et de la connaissance de son mode
	if (!document_ouvert) {
		mode_selection   -> setEnabled(false);
		mode_visualise   -> setEnabled(false);
	} else {
		switch((int)(sv -> dragMode())) {
			case QGraphicsView::NoDrag:
				mode_selection -> setEnabled(false);
				mode_visualise -> setEnabled(false);
				break;
			case QGraphicsView::ScrollHandDrag:
				mode_selection -> setEnabled(true);
				mode_visualise -> setEnabled(true);
				mode_selection -> setChecked(false);
				mode_visualise -> setChecked(true);
				break;
			case QGraphicsView::RubberBandDrag:
				mode_selection -> setEnabled(true);
				mode_visualise -> setEnabled(true);
				mode_selection -> setChecked(true);
				mode_visualise -> setChecked(false);
				break;
		}
	}
	
	// actions ayant besoin de la connaissance de son mode
	if (document_ouvert) toggle_aa -> setText(sv -> antialiased() ? tr("D\351sactiver l'&antialiasing") : tr("Activer l'&antialiasing"));
	
	slot_updateMenuFenetres();
}

/**
	Ajoute un schema dans l'espace de travail
	@param sv L'objet SchemaVue a ajouter a l'espace de travail
*/
void QETApp::addSchemaVue(SchemaVue *sv) {
	if (!sv) return;
	SchemaVue *s_v = schemaEnCours();
	bool maximise = ((!s_v) || (s_v -> windowState() & Qt::WindowMaximized));
	QWidget *p = workspace.addWindow(sv);
	connect(sv, SIGNAL(selectionChanged()), this, SLOT(slot_updateActions()));
	connect(sv, SIGNAL(modeChanged()),      this, SLOT(slot_updateActions()));
	if (maximise) p -> showMaximized();
	else p -> show();
}

/**
	met a jour le menu "Fenetres"
*/
void QETApp::slot_updateMenuFenetres() {
	// nettoyage du menu
	menu_fenetres -> clear();
	
	// actions de fermeture
	menu_fenetres -> addAction(fermer_fichier);
	//menu_fenetres -> addAction(closeAllAct);
	
	// actions de reorganisation des fenetres
	menu_fenetres -> addSeparator();
	menu_fenetres -> addAction(f_mosaique);
	menu_fenetres -> addAction(f_cascade);
	menu_fenetres -> addAction(f_reorganise);
	
	// actiosn de deplacement entre les fenetres
	menu_fenetres -> addSeparator();
	menu_fenetres -> addAction(f_suiv);
	menu_fenetres -> addAction(f_prec);
	
	// liste des fenetres
	QList<QWidget *> fenetres = workspace.windowList();
	if (!fenetres.isEmpty()) menu_fenetres -> addSeparator();
	for (int i = 0 ; i < fenetres.size() ; ++ i) {
		SchemaVue *sv = qobject_cast<SchemaVue *>(fenetres.at(i));
		QString sv_titre = sv -> windowTitle().left(sv -> windowTitle().length() - 3);
		QAction *action  = menu_fenetres -> addAction(sv_titre);
		action -> setStatusTip(tr("Active la fen\352tre ") + sv_titre);
		action -> setCheckable(true);
		action -> setChecked(sv == schemaEnCours());
		connect(action, SIGNAL(triggered()), &windowMapper, SLOT(map()));
		windowMapper.setMapping(action, sv);
	}
}

/**
	Renvoie le dossier des elements communs, c-a-d le chemin du dossier dans
	lequel QET doit chercher les definitions XML des elements de la collection QET.
	@return Le chemin du dossier des elements communs
*/
QString QETApp::commonElementsDir() {
	return(QDir::current().path() + "/elements/");
}

/**
	Renvoie le dossier des elements de l'utilisateur, c-a-d le chemin du dossier
	dans lequel QET chercher les definitions XML des elements propres a
	l'utilisateur.
	@return Le chemin du dossier des elements persos
*/
QString QETApp::customElementsDir() {
#ifdef Q_OS_WIN32
	return(QETApp::configDir() + "elements\\");
#else
	return(QETApp::configDir() + "elements/");
#endif
}

/**
	Renvoie le dossier de configuration de QET, c-a-d le chemin du dossier dans
	lequel QET lira les informations de configuration et de personnalisation
	propres a l'utilisateur courant. Ce dossier est generalement
	C:\Documents And Settings\utilisateur\Application Data\qet sous Windows et
	~/.qet sous les syst<EFBFBD>mes type UNIX.
	@return Le chemin du dossier de configuration de QElectroTech
*/
QString QETApp::configDir() {
#ifdef Q_OS_WIN32
	return(QDir::homePath() + "\\Application Data\\qet\\");
#else
	return(QDir::homePath() + "/.qet/");
#endif
}