//! \file    MainWindow.cpp
//! \brief   Implementation of the main Visual_YAO code.
//! \version 2010
//! \author  MAYAKI Abdouramane
/*
  Nom du Fichier: MainWindow.cpp
  Nom de classe: MainWindow
  Role: Outre son role de fichier d'implémentation des méthodes, ce fichier gère toutes les fenêtres graphiques.
  Nombre de methodes: 50
  Nombre d'attributs: 81
  */

#include "include/MainWindow.hpp"
#include<iostream>

using namespace std;
//using namespace antlr;
using namespace yao;

//! \class MainWindow(QWidget *parent) : QMainWindow(parent)
//! \brief Implementation of the Main window for visual_YAO.

/*!
 * \fn MainWindow(MainWindowController *mwc, QWidget *parent) 
 * \brief Constructor of the class MainWindow().
 *
 * \param MainWindowController *mwc, QWidget *parent.
 * \return void.
 */
/**************************************** Implementation of the constructor MainWindow() *************************************************************/
/*
  Implementation du constructeur de la classe MainWindow

*/

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_constantWindow(NULL), m_hatnameWindow(NULL), m_contextWindow(NULL), m_trajectoryWindow(NULL), m_spaceWindow(NULL), m_operaWindow(NULL), m_netwardWindow(NULL), m_modulWindow(NULL), m_ctinWindow(NULL), m_orderWindow(NULL), m_insertFCTWindow(NULL), m_newProjectWindow(NULL), m_newProjectName(""), theConstantTablePt(theConstantTable), contextTest(false), iw(NULL), confirmationFlag(false)     
{

	setWindowTitle(" Visual YAO "); 	//Gives a title to the mainwindow.
	pt_espace = new QWorkspace;    				//Crée un espace de travail. Ici, ça serait notre zone centrale
		pt_espace = &espace;
	fv  = new FilesViewer(); 			//Création d'un espace montrant l'arborescence des fichiers sur le disque dûr.
	
	fenetreProjet                 = new QDockWidget("Aperçu des projets: ", this);	// Réservation de l'espace pour la fenêtre projet
		fenetreProjet->setFeatures(QDockWidget::NoDockWidgetFeatures); 	//La fenêtre projet ne pourra être ni deplacée ni fermée.
		fenetreProjet->setWidget(fv); 			// L'arborescence des fichiers est incluse dans la fenêtre projet. 
        QDockWidget *dock2            = new QDockWidget("", this);
        addDockWidget(Qt::LeftDockWidgetArea, fenetreProjet); //Positionnement de la fenêtre projet à gauche dans la QMainWindow.
	addDockWidget(Qt::LeftDockWidgetArea, dock2);
	
    	setCentralWidget(pt_espace); 	//Ici, se précise la zone centrale de la QMainWindow.
	
	// Appel des differentes méthodes crées.
    	createActions(); 		//Appel de la methode createActions(), voir le code ci-après.
    	createMenus();  			// Appel de la méthode creerMenu(), voir le code ci-après.
    	createToolBar();             //Cree la barre d'outils
     	barreEtat = statusBar(); 	//Affiche la barre d'état.
	
	QDockWidget *dock3            = new QDockWidget("Résultats", this);/////////////////////////////////
    		dock3->setAllowedAreas(Qt::BottomDockWidgetArea | Qt::RightDockWidgetArea); 
	addDockWidget(Qt::BottomDockWidgetArea, dock3);

    	tabWidget = new QTabWidget(dock3);//(this);
    	dock3->setWidget(tabWidget);  
	page1 = new QWidget();
	tabWidget->addTab(page1, "          Compilation               ");
	page2 = new QWidget();
	tabWidget->addTab(page2, "                 Exécution          ");
	
	//Editor *edit = new Editor;
	//pt_espace->addWindow(editor); 
	//editor->show();

	connect(this, SIGNAL(WindowTitleChanged()), this, SLOT(setTitle()));
	this->showMaximized(); // Maximise toujours la fenetre principale.
		
	
}

/*************************************** Implementation of the contructor MainWindow(Table <Constant> aConstant) *********************************/
MainWindow::MainWindow(Table <Constant> aConstantTable): theConstantTablePt(aConstantTable)
{
	theConstantTablePt = aConstantTable;
	//theConstantTable;			
}

/******************************************* Implementation of the method setTitle() *****************************************************************/
void MainWindow::setTitle() {

	QWidget::setWindowTitle(tr("%1[*]  %2").arg("Projet:").arg(QString(getProjectName().c_str())));

}

/************************************ Implementation of the method createMenus() *******************************************************************/
void MainWindow::createMenus() {

	menuFichier = menuBar()->addMenu(tr("&Fichier"));
		menuFichier->addAction(actionNouveauProjet);
		menuFichier->addAction(actionOuvrirProjet);
		menuFichier->addAction(actionOuvrirProjetsRecents);
		menuFichier->addSeparator(); // Met une ligne horizontale entre les menus
		//menuFichier->addAction(actionImporterProjet);
		menuFichier->addSeparator();
		menuFichier->addAction(actionSaveProject);
		menuFichier->addAction(actionSaveAsProject);
		menuFichier->addSeparator();
		menuFichier->addAction(actionSortieProjet);
	menuEdition = menuBar()->addMenu("&Edition");
		//menuEdition->addAction(actionFichierDescription);
		//menuEdition->addAction(actionFichierHat);
		//nouveau->addAction(actionModule);
		menuEdition->addAction(actionFichierInstruction);
		menuEdition->addAction(actionGrapheModulaire);
		//menuEdition->addAction(actionInfosProjet);

	menuAffichage = menuBar()->addMenu("&Affichage");
		menuAffichage->addAction(actionCacherBarreOutils);

		menuAffichage->addAction(actionCacherFenetreApercu);
		menuAffichage->addAction(actionCacherFenetreProjet);
		menuAffichage->addAction(actionCacherFenetreDialog);
	menuExecution = menuBar()->addMenu("&Exécution");
		menuExecution->addAction(actionGenerationD);
		menuExecution->addAction(actionGenerationI);
		menuExecution->addAction(actionCompilation);
		menuExecution->addAction(actionExecution);
		
	menuConfig    = menuBar()->addMenu("&Configuration");
		menuConfig->addAction(actionEditeur);
	menuAide = menuBar()->addMenu(tr("&Aide"));
		menuAide->addAction(actionDocYao);
		menuAide->addAction(actionRapport);

}

/******************************** Implementation of the method Implémentation de la methode createActions() ****************************************/
void MainWindow::createActions()  {

	
	QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
	// Les actions du menu fichier
	actionNouveauProjet = new QAction(tr("&Nouveau projet"), this);
		actionNouveauProjet->setIcon(QIcon("Images/icons/newfile.png"));
		actionNouveauProjet->setStatusTip("Créer un nouveau projet");
		actionNouveauProjet->setShortcut(tr("Ctrl+N"));

		//connect(actionNouveauProjet, SIGNAL(triggered()), this, SLOT(activateToolBarButtons()));
		connect(actionNouveauProjet, SIGNAL(triggered()), this, SLOT(createNewProjectWindow()));
		connect(actionNouveauProjet, SIGNAL(triggered()), this, SLOT(montrerActionGenererD()));

	actionOuvrirProjet = new QAction(tr("&Ouvrir un projet"), this);
		actionOuvrirProjet->setIcon(QIcon("Images/icons/openfile.png"));
		actionOuvrirProjet->setShortcut(tr("Ctrl+O"));
		actionOuvrirProjet->setStatusTip("Ouvrir un projet existant");

		connect(actionOuvrirProjet, SIGNAL(triggered()), this, SLOT(openProject()));
		//connect(actionOuvrirProjet, SIGNAL(triggered()), this, SLOT(montrerActionCompilation()));

	actionOuvrirProjetsRecents = new QAction(tr("Ouvrir projets recents"), this);
		//compilAction->setIcon(QIcon(""));
		actionOuvrirProjetsRecents->setShortcut(tr("Ctrl+P"));
		actionOuvrirProjetsRecents->setStatusTip("Projets recemment ouverts");
		//connect(compilAction, SIGNAL(triggered()), this, SLOT());
	//actionImporterProjet = new QAction(tr("&Importer"), this);
		//runAction->setIcon(QIcon(""));
		//  actionImporterProjet->setShortcut(tr("Ctrl+E"));
		//  actionImporterProjet->setStatusTip("Importer un projet");

		//connect(runAction, SIGNAL(triggered()), this, SLOT());
	actionSaveProject = new QAction(tr("Enregi&strer"), this);
		actionSaveProject->setIcon(QIcon("Images/icons/save.png"));
		actionSaveProject->setEnabled(false); // Option désactivée par défaut.
		actionSaveProject->setStatusTip("Pour sauvegarder le projet en cours");
		connect(actionSaveProject, SIGNAL(triggered()), this, SLOT(save()));

	actionSaveAsProject = new QAction(tr("Enregistrer sous"), this);
		actionSaveAsProject->setIcon(QIcon("Images/icons/saveas.png"));
		actionSaveAsProject->setEnabled(false); // Option désactivée par défaut.
		actionSaveAsProject->setStatusTip("En le projet sous un autre nom");
		connect(actionSaveAsProject, SIGNAL(triggered()), this, SLOT(saveAs()));
	actionImprimerProjet = new QAction(tr("Imprimer"), this);
		actionImprimerProjet->setStatusTip("Options d'impression");
	actionSortieProjet = new QAction(tr("&Sortir"), this);
		actionSortieProjet->setIcon(QIcon("Images/icons/exit.png"));
		actionSortieProjet->setShortcut(tr("Ctrl+Q"));
		actionSortieProjet->setStatusTip("Fermer le programme");

		connect(actionSortieProjet, SIGNAL(triggered()), this, SLOT(close()));

     // Les actions du menu Edition
	//actionFichierDescription = new QAction(tr("Fichier de description (.d)"), this);

		//connect(actionFichierDescription, SIGNAL(triggered()), this, SLOT(generateDFile()));

	//actionFichierHat = new QAction(tr("Fichier  (.h)"), this);
		//actionModule = new QAction(tr("Modul"), this);
	actionFichierInstruction = new QAction(tr("Fichier d'instruction (.i)"), this);
		connect(actionFichierInstruction, SIGNAL(triggered()), this, SLOT(instructionFileManager()));
	actionGrapheModulaire = new QAction(tr("Graphe modulaire"), this);
	//actionInfosProjet = new QAction(tr("Edition infos projet"), this);

     // Les actions du menu Affichage
	actionCacherBarreOutils = new QAction(tr("Cacher la barre d'outils"), this);
		actionCacherBarreOutils->setCheckable(true);

	      // connect(actionCacherBarreOutils, SIGNAL(triggered()), this, SLOT(cacherBarreOutils()));
	actionCacherFenetreApercu = new QAction(tr("Cacher la fenetre apercu"), this);
		actionCacherFenetreApercu->setCheckable(true);
	actionCacherFenetreProjet = new QAction(tr("Cacher la fenetre Projet"), this);
		actionCacherFenetreProjet->setCheckable(true);
	actionCacherFenetreDialog = new QAction(tr("Cacher la fenetre dialog"), this);
		actionCacherFenetreDialog->setCheckable(true);
	//actionPleinEcran = new QAction(tr("Plein ecran"), this);
		//actionPleinEcran->setCheckable(true);

     // Les actions du menu Execution
	actionGenerationD = new QAction(this);
		actionGenerationD->setEnabled(false);
		actionGenerationD->setText("Générer le fichier .d");

		connect(actionGenerationD, SIGNAL(triggered()), this, SLOT(callGenerateDFile()));
		//connect(actionGenerationD, SIGNAL(triggered()), this, SLOT(information()));

	actionGenerationI = new QAction(this);
		actionGenerationI->setEnabled(false);
		actionGenerationI->setText("Générer le fichier .i"); 
		connect(actionGenerationI, SIGNAL(triggered()), this, SLOT(generateIFile()));

	actionCompilation = new QAction(tr("Compilation"), this);
		actionCompilation->setEnabled(false);
	actionExecution = new QAction(this);
		actionExecution->setEnabled(false);
		actionExecution->setText("Exécution");

     // Les actions du menu Configuration
	actionEditeur = new QAction(tr("Editeur par defaut"), this);

     // Les actions du menu Aide
	actionDocYao = new QAction(tr("Doc Yao"), this);
	actionRapport = new QAction(tr("Rapport"), this);
	//aproposYao = new QAction(tr("A propos de Yao"), this);

     // Les actions de la barre d'outils

	toolBarActions(espace);

}

/********************************* Implementation of the enableIAction() method ***************************************************************************/
void MainWindow::enableIAction() {

	actionGenerationI->setEnabled(true);

}

/********************************* Implementation of the createToolBar() method ****************************************/
void MainWindow::createToolBar() {

	yaoToolBar = addToolBar(tr("&YaoToolbar"));

		yaoToolBar->addWidget(m_constantButton);
		yaoToolBar->addWidget(m_hatNameButton);
		yaoToolBar->addWidget(m_contextButton);
		yaoToolBar->addWidget(m_trajButton);
		yaoToolBar->addWidget(m_spaceButton);
		yaoToolBar->addWidget(m_operaButton);
		yaoToolBar->addWidget(m_netwardButton);
		yaoToolBar->addWidget(m_modulButton);
		yaoToolBar->addWidget(m_ctinButton);
		yaoToolBar->addWidget(m_orderButton);
		yaoToolBar->addWidget(m_insertFCTButton);
		yaoToolBar->addSeparator();
		yaoToolBar->addAction(actionSortieProjet);

}

/******************************** Implementation of the cacherBarreOutils() method ***************************************/
void MainWindow::cacherBarreOutils() {

	yaoToolBar->hide();
	barreEtat->showMessage(tr("La barre des outils est cachée!"), 2000);

}

/********************************** Implementation of the toolBarActions() method ****************************************/
void MainWindow::toolBarActions(QWorkspace &espace) 
{

	m_constantButton    = new QPushButton(tr("Defval"), this);
		//m_constantButton->setToolTip("Bouton désactivé. Vous devez d'abord creer un nouveau projet ou en ouvrir un.");
		connect(m_constantButton, SIGNAL(clicked()), this, SLOT(createDefvalWindow()));
		connect(m_constantButton, SIGNAL(clicked()), this, SLOT(changeColorConstantButton()));
    	
	m_hatNameButton   = new QPushButton(tr("Hatname"), this);
		connect(m_hatNameButton, SIGNAL(clicked()), this, SLOT(createHatNameWindow()));
		connect(m_hatNameButton, SIGNAL(clicked()), this, SLOT(changeColorHatButton()));
 
	m_contextButton    = new QPushButton(tr("Option"), this);
		connect(m_contextButton, SIGNAL(clicked()), this, SLOT(createContextWindow()));
		connect(m_contextButton, SIGNAL(clicked()), this, SLOT(changeColorContextButton()));

	m_trajButton      = new QPushButton(tr("Trajectory"), this);
		connect(m_trajButton, SIGNAL(clicked()), this, SLOT(createTrajectoryWindow()));
		connect(m_trajButton, SIGNAL(clicked()), this, SLOT(changeColorTrajButton()));
	m_spaceButton     = new QPushButton(tr("Space"), this);
		connect(m_spaceButton, SIGNAL(clicked()), this, SLOT(createSpaceWindow()));
		connect(m_spaceButton, SIGNAL(clicked()), this, SLOT(changeColorSpaceButton()));
	m_operaButton     = new QPushButton(tr("Operator"), this);
		connect(m_operaButton, SIGNAL(clicked()), this, SLOT(createOperaWindow()));
		connect(m_operaButton, SIGNAL(clicked()), this, SLOT(changeColorOperaButton()));
	m_netwardButton   = new QPushButton(tr("Netward"), this);
		connect(m_netwardButton, SIGNAL(clicked()), this, SLOT(createNetwardWindow()));
		connect(m_netwardButton, SIGNAL(clicked()), this, SLOT(changeColorNetwardButton()));
	m_modulButton     = new QPushButton(tr("Modul"), this);
		connect(m_modulButton, SIGNAL(clicked()), this, SLOT(createModulWindow()));
		connect(m_modulButton, SIGNAL(clicked()), this, SLOT(changeColorModulButton()));
	m_ctinButton      = new QPushButton(tr("Connection"), this);
		connect(m_ctinButton, SIGNAL(clicked()), this, SLOT(createCtinWindow()));
		connect(m_ctinButton, SIGNAL(clicked()), this, SLOT(changeColorCtinButton()));
	m_orderButton     = new QPushButton(tr("Order"), this);
		connect(m_orderButton, SIGNAL(clicked()), this, SLOT(createOrderWindow()));
		connect(m_orderButton, SIGNAL(clicked()), this, SLOT(changeColorOrderButton()));
	m_insertFCTButton = new QPushButton(tr("Insert_fct"), this);
		connect(m_insertFCTButton, SIGNAL(clicked()), this, SLOT(createInsertFCTWindow()));
		connect(m_insertFCTButton, SIGNAL(clicked()), this, SLOT(changeColorInsertFCTButton()));

	desactivateToolBarButtons(); // Désactive tous les boutons de la barre d'outils
}

/*********************************************** Implementation of the createDefvalWindow() method *************************************************/
void MainWindow::createDefvalWindow() 
{

	if (m_constantWindow == NULL) { //to test if the object is already created.

		m_constantWindow = new ConstantWindow(&theConstantTable, &theHeaderList, &the_mwc); //Then create the object and initialize it.
		espace.addWindow(m_constantWindow)->move(0, 0); //Put the object in the workspace (here, espace is the QWorkspace's object.)
		m_constantWindow->show();// shows the object. 
	}

	connect(m_constantWindow, SIGNAL(rowIsAdded()), this, SLOT(hatUpdate()));
	connect(m_constantWindow, SIGNAL(rowIsDeleted(QString )), this, SLOT(hatUpdate(QString )));
	connect(m_constantWindow, SIGNAL(rowIsAdded()), this, SLOT(trajUpdate()));
	//connect(m_constantWindow, SIGNAL(rowIsAdded()), this, SLOT(contextUpdate()));
	connect(m_constantWindow, SIGNAL(rowIsAdded()), this, SLOT(mainWindowIsModified()));
	connect(m_constantWindow, SIGNAL(windowIsClosed(int )), this, SLOT(initializeWindow(int )));// The signal is in the ConstantWindow.hpp file.
	//connect(m_constantWindow, SIGNAL(clicked(bool )), , SLOT(hatUpdate()));

}

/******************************************** Implementation of the createHatNameWindow() method ***************************************************/
void MainWindow::createHatNameWindow() {

	if (m_hatnameWindow == NULL) { //to test if the object is already created.

		m_hatnameWindow = new HatNameWindow(&theHeaderList, &theConstantTable); //Then create the object and initialize it.
		espace.addWindow(m_hatnameWindow)->move(350, 0); //Put the object in the workspace (here, espace is the QWorkspace's object.)
		m_hatnameWindow->show();// shows the object. 
	}

	connect(m_hatnameWindow, SIGNAL(hatWindowIsClosed(int)), this, SLOT(initializeWindow(int)));// The signal is in the HatNameWindow.hpp file.
}

/********************************************* Implementation of the method createContextWindow() *************************************************/
void MainWindow::createContextWindow() {

	if (m_contextWindow == NULL) { //to test if the object is already created.

		m_contextWindow = new ContextWindow(&theContext, &theConstantTable, &theContextData); //mwc.getContext();
		espace.addWindow(m_contextWindow)->move(5, 0);
		m_contextWindow->show();
		contextTest = true;
	}

	connect(m_contextWindow, SIGNAL(contextWindowIsClosed(int)), this, SLOT(initializeWindow(int)));
}

/********************************************* Implementation of the method createTrajectoryWindow() ************************************************/
void MainWindow::createTrajectoryWindow() {

	if (m_trajectoryWindow == NULL) { //to test if the object is already created.

		m_trajectoryWindow = new TrajectoryWindow(&theTrajectoryTable, &theConstantTable); //mwc.getTraj();
		espace.addWindow(m_trajectoryWindow)->move(30, 10);
		m_trajectoryWindow->show(); 

	}

	connect(m_trajectoryWindow, SIGNAL(trajectoryWindowIsClosed(int)), this, SLOT(initializeWindow(int)));
	connect(m_trajectoryWindow, SIGNAL(trajRowIsAdded(bool)), m_spaceButton, SLOT(setEnabled(bool)));
	connect(m_trajectoryWindow, SIGNAL(trajRowIsAdded(bool)), m_operaButton, SLOT(setEnabled(bool)));
}

/********************************************* Implementation of the method createSpaceWindow() ************************************************/
void MainWindow::createSpaceWindow() {

	if (m_spaceWindow == NULL) { //to test if the object is already created.
	
		m_spaceWindow = new SpaceWindow(&theSpaceTable, &theTrajectoryTable, &theConstantTable); //mwc.getSpace();
		espace.addWindow(m_spaceWindow)->move(30, 20);
		m_spaceWindow->show(); 
	}

	connect(m_spaceWindow, SIGNAL(spaceWindowIsClosed(int)), this, SLOT(initializeWindow(int)));
	connect(m_spaceWindow, SIGNAL(spaceRowIsAdded(bool)), m_modulButton, SLOT(setEnabled(bool)));
}

/********************************************* Implementation of the method createOperaWindow() ************************************************/
void MainWindow::createOperaWindow() {

	if (m_operaWindow == NULL) { //to test if the object is already created.
		m_operaWindow =  new OperaWindow(&theOperaTable, &theTrajectoryTable, &theConstantTable); //mwc.getOpera();
		espace.addWindow(m_operaWindow)->move(5, 8);
		m_operaWindow->show(); 
	}

	connect(m_operaWindow, SIGNAL(operaWindowIsClosed(int )), this, SLOT(initializeWindow(int )));
	//connect(m_operaWindow, SIGNAL(operaRowIsAdded(bool)), m_modulButton, SLOT(setEnabled(bool)));
}

/********************************************* Implementation of the method createNetwardWindow() ************************************************/
void MainWindow::createNetwardWindow() {

	if (m_netwardWindow == NULL) { //to test if the object is already created.
		m_netwardWindow = new NetwardWindow(&theNeuronTable, &theConstantTable); //mwc.getNetward();
		espace.addWindow(m_netwardWindow)->move(5, 15);
		m_netwardWindow->show();
	}
        connect(m_netwardWindow, SIGNAL(netwardWindowIsClosed(int )), this, SLOT(initializeWindow(int )));
        //connect(m_netwardButton, SIGNAL(clicked()), this, SLOT(changeColorNetwardButton()));
}

/********************************************* Implementation of the method createModulWindow() ************************************************/
void MainWindow::createModulWindow() {

	if (m_modulWindow == NULL) { //to test if the object is already created.
		m_modulWindow = new ModulWindow(&theModulTable, &theSpaceTable, &theOperaTable, &theConstantTable, &the_mwc, &m_newProjectName, &m_projectPath); //mwc.getModul();
		espace.addWindow(m_modulWindow)->move(30, 15);
		m_modulWindow->show(); 
	}

	connect(m_modulWindow, SIGNAL(modulWindowIsClosed(int)), this, SLOT(initializeWindow(int)));
	connect(m_modulWindow, SIGNAL(modulRowIsAdded(bool)), m_ctinButton, SLOT(setEnabled(bool)));
}

/********************************************* Implementation of the method createCtinWindow() ************************************************/
void MainWindow::createCtinWindow() {

	if (m_ctinWindow == NULL) { //to test if the object is already created.
		m_ctinWindow = new ConnectionWindow(&theConnectionTable, &theModulTable, &theConstantTable); //mwc.getCtin();
		espace.addWindow(m_ctinWindow)->move(0, 0);
		m_ctinWindow->show();
	}

	connect(m_ctinWindow, SIGNAL(ctinWindowIsClosed(int)), this, SLOT(initializeWindow(int)));
	connect(m_ctinWindow, SIGNAL(ctinRowIsAdded(bool)), m_orderButton, SLOT(setEnabled(bool)));
}

/********************************************* Implementation of the method createOrderWindow() ************************************************/
void MainWindow::createOrderWindow() {

	if (m_orderWindow == NULL) { //to test if the object is already created.
		m_orderWindow = new OrderWindow(&theTrajectoryTable, &theSpaceTable, &theOperaTable, &theModulTable, &theOrderTable); //mwc.getOrder();
		espace.addWindow(m_orderWindow)->move(2, 0);
		m_orderWindow->show();
	}

	connect(m_orderWindow, SIGNAL(orderWindowIsClosed(int)), this, SLOT(initializeWindow(int)));

}

/********************************************* Implementation of the method createInsertFCTWindow() ************************************************/
void MainWindow::createInsertFCTWindow() {

	if (m_insertFCTWindow == NULL) { //to test if the object is already created.
		m_insertFCTWindow = new InsertFCTWindow(&theFunctionTable); //mwc.getInsertFCT();
		espace.addWindow(m_insertFCTWindow)->move(30, 20);
		m_insertFCTWindow->show();
	}

	connect(m_insertFCTWindow, SIGNAL(insertFCTWindowIsClosed(int)), this, SLOT(initializeWindow(int)));

}

/********************************************* Implementation of the method directivesManage() *****************************************************/
void MainWindow::directivesManager() {

	theHeaderList.push_back(getProjectName() + ".h") ; 
	
}

/*********************************** Implementation of the method activateToolBarButtons() *********************************************************/
void MainWindow::activateToolBarButtons() {

	m_constantButton->setEnabled(true);
	m_hatNameButton->setEnabled(true);
	m_contextButton->setEnabled(true);
	m_trajButton->setEnabled(true);
	 theSpaceTable.empty() == true ? m_spaceButton->setEnabled(false): m_spaceButton->setEnabled(true);//The button will be enabled/disabled depending on the structure's status (empty or not).
	 theOperaTable.empty() == true ? m_operaButton->setEnabled(false): m_operaButton->setEnabled(true);
	m_netwardButton->setEnabled(true);
	 theModulTable.empty() == true ? m_modulButton->setEnabled(false): m_modulButton->setEnabled(true);
	
	m_ctinButton->setEnabled(false);
	 theModulTable.empty() == true ? m_ctinButton->setEnabled(false): m_ctinButton->setEnabled(true);
	m_orderButton->setEnabled(true);
	 //theModulTable.empty() == true ? m_orderButton->setEnabled(false): m_orderButton->setEnabled(true);
	m_insertFCTButton->setEnabled(true);
}

/********************************** Implementation of the method desactivateToolBarButtons() *******************************************************/
void MainWindow::desactivateToolBarButtons() {

        m_constantButton->setEnabled(false);
        m_hatNameButton->setEnabled(false);
        m_contextButton->setEnabled(false);
        m_trajButton->setEnabled(false);
        m_spaceButton->setEnabled(false);
        m_operaButton->setEnabled(false);
        m_netwardButton->setEnabled(false);
        m_modulButton->setEnabled(false);
        m_ctinButton->setEnabled(false);
        m_orderButton->setEnabled(false);
        m_insertFCTButton->setEnabled(false);
}

/**************************************** Implementation of the method nouveauProjet (SLOT) *******************************************************/
void MainWindow::createNewProjectWindow() 	{ // Affiche la fenetre nouveau projet lorsqu'elle est appelée.

	//clearAllStructures();
	espace.closeAllWindows(); 
	m_newProjectWindow = new NewProjectWindow(espace);//The new project window will be appeared in the workspace.
	m_newProjectName = m_newProjectWindow->getProjectName();//Gets the current project's name.
	m_projectPath = m_newProjectWindow->getProjectPath();
	if (!m_newProjectName.empty()) {
		clearAllStructures();// To eraze Yao structure before creating the new project.
		theHeaderList.push_back(m_newProjectWindow->getProjectName() + ".h");
		emit WindowTitleChanged(); //Emits the signal to change the window's title. 
		emit newProjectIsCreated();//Emits the signal that the project is created.
		activateToolBarButtons(); // To active the toolbar buttons.
		actionSaveAsProject->setEnabled(true); // Option désactivée par défaut.
	}
	fv->updateTheView(); //Permet de mettre à jour automatiquement la liste des fichiers visibles dans filesviewer.
	//connect(m_newProjectWindow, SIGNAL(newProjectIsCreated()), this, SLOT(activateToolBarButtons()));
	//	connect(m_newProjectWindow, SIGNAL(projectDone()), this, SLOT(clearAllStructures()));
}

/*************************************** Implementation of the method clearAllStrutures() *********************************************************/
void MainWindow::clearAllStructures() {


	theConstantTable.clear();//Erase data from Table <Constant>
	theHeaderList.clear();
	theTrajectoryTable.clear();
	theSpaceTable.clear();
	theOperaTable.clear();
	theNeuronTable.clear();
	theModulTable.clear();
	theConnectionTable.clear();
	theFunctionTable.clear();	
	
	//To restaure all buttons original color
	for (int i=1; i<=11; i++) {

		switch (i) {
			case 1:	m_constantButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 2:	m_hatNameButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 3:	m_contextButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 4:	m_trajButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 5:	m_spaceButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 6:	m_operaButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 7:	m_netwardButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 8:	m_modulButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 9:	m_ctinButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 10:m_orderButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
			case 11:m_insertFCTButton->setStyleSheet("background-color: rgb(255, 255, 255)"); 
		}
	}

	
}
/**************************************** Implementation of the method mainWindowIsModified() (SLOT) ************************************************/
void MainWindow::mainWindowIsModified() {

	setWindowModified(true);
	actionSaveProject->setEnabled(true);
	actionSaveAsProject->setEnabled(true);

}
/**************************************** Implementation of the method save() (SLOT) *******************************************************/
void MainWindow::save() {
	
	generateDFile();
	setWindowModified(false);

}

/**************************************** Implementation of the method callgenerateDFile() (SLOT) *******************************************************/
void MainWindow::callGenerateDFile() {
	
	generateDFile();
	QMessageBox::about(this, "Avis", "Le fichier <B>"+ QString(getProjectName().c_str()) + ".d</B> a été généré avec succès.");

}
/**************************************** Implementation of the method saveAs() (SLOT) *******************************************************/
void MainWindow::saveAs() {
	
	
	m_newProjectWindow = new  NewProjectWindow ;
	//m_newProjectWindow->setWindowTitle("testhj");
	m_newProjectName = m_newProjectWindow->getProjectName();
	m_projectPath = m_newProjectWindow->getProjectPath();
	theHeaderList.push_back(m_newProjectWindow->getProjectName() + ".h");
	fv->updateTheView(); //To refresh the view from FileViewer class.
	//connect(m_newProjectWindow, SIGNAL(newProjectIsCreated()), this, SLOT(activateToolBarButtons()));
	activateToolBarButtons();
	emit WindowTitleChanged();
	emit newProjectIsCreated();

 	//QFileDialog *dialog = new QFileDialog(this); //Crée une boite de dialogue
	//dialog->setFileMode(QFileDialog::Directory);
	//QString cheminFichier = dialog->getExistingDirectory(this, tr("Enregistrement d'un projet."), "."); 
	//m_newProjectName = cheminFichier.toStdString();
	generateDFile(m_projectPath + "/");
	//cout << cheminFichier.toStdString() << endl;
	
	actionGenerationD->setEnabled(true);

}
/**************************************** Implementation of the method nouveauProjet (SLOT) *******************************************************/
void MainWindow::openProject() 	{ // Affiche la fenetre nouveau projet lorsqu'elle est appelée.


 	QFileDialog *dialogue = new QFileDialog(this); //Crée une boite de dialogue

	QString cheminFichier = dialogue->getOpenFileName(this, tr("Ouverture d'un project existant."), QDir::homePath(), tr("*.d *.i *.txt")); //Retourne le chemin du fichier.
	FilePath localName(cheminFichier.toStdString());
	setProjectName(localName.getTitle());
	setProjectPath(localName.getLocation());
	setTitle();
	QProcess builder;//To lanch an external command. Example: "ls -l"
	QString test("");
	builder.setProcessChannelMode(QProcess::MergedChannels);
	builder.start("Yao9Generator " + cheminFichier);//Will execute the linux command 
	if (!builder.waitForFinished())
		qDebug() << "Make failed:" << builder.errorString();
	else {
		test = builder.readAll();//the results are saved in a string format.
		istringstream iss(test.toStdString()); //To have each word that compose the string.
		FilePath aString, theShape, name, parent, aType, boot, offset, step, size, netname, indegree, outdegree, modname, arg;
		vector <int> theShapeVector;

		while ( getline(iss, aString, '\n' ) ) // Here we notified that the words in the string are separated by "\n"
			{
				//For DEFVAL
				if (aString.getExtension() == ".def1")//
				{			
					//cout << aString.getTitle() << endl;
					name = aString;
				}
			    	if (aString.getExtension() == ".def2" && name.getExtension() == ".def1")
				{
					Constant aConstant(name.getTitle(), aString.getTitle());	
					theConstantTable.push_back(aConstant);
				}
				//For HATNAME
				if (aString.getExtension() == ".h")
				{
				//	cout << aString << endl;
					theHeaderList.push_back(aString);	
				}
				//For TRAJ
				if (aString.getExtension() == ".traj1"){
					name = aString.getTitle();
				//	cout << name << endl;
				}
				if (aString.getExtension() == ".traj2"){
					aType = aString.getTitle();
				//	cout << aType << endl;
				}
				if (aString.getExtension() == ".traj3") {
					boot = aString.getTitle();
				//	cout << boot << endl;
				}
				if (aString.getExtension() == ".traj4"){
					offset = aString.getTitle();	
				//	cout << offset << endl;
				}
				if (aString.getExtension() == ".traj5"){
					step = aString.getTitle();
				//	cout << step << endl; 
				}
				if (aString.getExtension() == ".traj6")
				{
					size = aString.getTitle();
				//	cout << size << endl;
					Trajectory localTrajectory(name, m_trajectoryWindow->toInt(boot), m_trajectoryWindow->toDouble(size), m_trajectoryWindow->toDouble(step), m_trajectoryWindow->toInt(offset), 'M');//Trajectory object.
					theTrajectoryTable.push_back(localTrajectory); //Trajectory vector (contents many objects)   
					//if (m_trajectoryWindow->isTrajectoryTableEmpty()) 

				}		//theConstantTable.push_back(aString.getTitle());
				//For SPACE
				if (aString.getExtension() == ".sp1")//{
					name = aString.getTitle();
					//cout << name << endl;
				//}
				if (aString.getExtension() == ".sp2"){
					aType = aString.getTitle();	
					istringstream aShape1(aType); 
					while ( getline(aShape1, theShape, ' ' )){
						theShapeVector.push_back(m_spaceWindow->toInt(theShape));
						//cout << aType << endl;
					}
				}
				if (aString.getExtension() == ".sp3") {
					parent = aString.getTitle(); 
					//cout << parent << endl;
					Space espace(name, theTrajectoryTable.find(parent), theShapeVector);
					theSpaceTable.push_back(espace);
					theShapeVector.clear();
					
				}
				//For NETWARD	
				if (aString.getExtension() == ".nw1") {
					netname = aString.getTitle(); 
				}

				if (aString.getExtension() == ".nw2") {
					indegree = aString.getTitle(); 
				}

				if (aString.getExtension() == ".nw3") {
					outdegree = aString.getTitle(); 
					theNeuronTable.push_back(Neuron(netname, m_netwardWindow->toInt(indegree), m_netwardWindow->toInt(outdegree)));
				}
				//For MODUL
				if (aString.getExtension() == ".mod1") {
					modname = aString.getTitle(); 
					
				}
				if (aString.getExtension() == ".mod2") {
					aType = aString.getTitle(); 
					
				}
				if (aString.getExtension() == ".mod3") {
					parent = aString.getTitle(); 
					
					Modul mod1(modname, theSpaceTable.find(parent), true);
					theModulTable.push_back(mod1);	
				}
				//For CONNECTION
				/*if (aString.getExtension() == ".mod1") {
					parent = aString.getTitle(); 
					//cout << parent << endl;
					Space espace(name, theTrajectoryTable.find(parent), theShapeVector);
					theSpaceTable.push_back(espace);
					theShapeVector.clear();
					
				}*/

				//For INSERTFCT	
				if (aString.getExtension() == ".fct1") {
					arg = aString.getTitle(); 
					//cout << parent << endl;
				}
				if (aString.getExtension() == ".fct2") {
					bool aBool;
					parent = aString.getTitle();
					aBool = arg.empty() ? false : true ; 
					theFunctionTable.push_back(Function(parent, aBool));
					//cout << parent << endl;
				}
			}
			
				//m_spaceButton->setEnabled(true);
		
	}
	if (!cheminFichier.isEmpty() && !test.isEmpty()) {
			activateToolBarButtons();
			//actionSaveProject->setEnabled(true);
			actionSaveAsProject->setEnabled(true);
		}
	
	
	
	//connect(m_trajectoryWindow, SIGNAL(trajRowIsAdded(bool)), m_spaceButton, SLOT(setEnabled(bool)));
	//connect(m_trajectoryWindow, SIGNAL(trajRowIsAdded(bool)), m_operaButton, SLOT(setEnabled(bool)));

	
}

/**************************************** Implementation of the method hatUpdate() ****************************************************************/
void MainWindow::hatUpdate() {
	
	if (m_hatnameWindow != NULL) //Teste si l'objet n'est pas déjà crée. S'il n'est pas 
		{ 
			delete m_hatnameWindow;
			m_hatnameWindow = new HatNameWindow(&theHeaderList, &theConstantTable); //Crée un autre objet.
			espace.addWindow(m_hatnameWindow)->move(350, 0);
			m_hatnameWindow->show();
			espace.setActiveWindow(m_constantWindow);
			//m_hatnameWindow->update();

			connect(m_hatnameWindow, SIGNAL(hatWindowIsClosed(int)), this, SLOT(initializeWindow(int)));// The signal is in the HatNameWindow.hpp file.
		}

	else
		return;
}

/******************************************* Implementation of the method hatUpdate(QString choix) **************************************************/
void MainWindow::hatUpdate(QString choix) {

	if (m_hatnameWindow != NULL) //Teste si l'objet n'est pas déjà crée.
		{ 
			m_hatnameWindow->deleteARow(choix.toStdString()); 
			delete m_hatnameWindow;
			m_hatnameWindow = new HatNameWindow(&theHeaderList, &theConstantTable); //Crée un autre objet.
			espace.addWindow(m_hatnameWindow)->move(350, 0);
			m_hatnameWindow->show();
			espace.setActiveWindow(m_constantWindow);
			//m_hatnameWindow->update();

			connect(m_hatnameWindow, SIGNAL(hatWindowIsClosed(int)), this, SLOT(initializeWindow(int)));// The signal is in the HatNameWindow.hpp file.
	
			//delete m_hatnameWindow;
			//cout << "Voici la chaine supprimée: " + choix.toStdString() << endl;
			//m_hatnameWindow = new HatNameWindow(&theHeaderList, &theConstantTable); //Crée un autre objet.
			//espace.addWindow(m_hatnameWindow)->move(350, 0);
			//m_hatnameWindow->show();
			//espace.setActiveWindow(m_constantWindow);

			//connect(m_hatnameWindow, SIGNAL(hatWindowIsClosed(int)), this, SLOT(initializeWindow(int)));// The signal is in the HatNameWindow.hpp file.
		}
	else
		return;
}

/******************************************* Implementation of the method contextUpdate(QString choix) ************************************************/
/*void MainWindow::contextUpdate() {

	if (m_contextWindow != NULL) //Teste si l'objet n'est pas déjà crée.
		{ 
			delete m_contextWindow ;
			m_contextWindow = new ContextWindow(&theContext, &theConstantTable); //mwc.getContext();
			espace.addWindow(m_contextWindow)->move(350, 0);
			m_contextWindow->show();
			espace.setActiveWindow(m_constantWindow);
			//m_contextWindow->update(); 

			connect(m_contextWindow, SIGNAL(contextWindowIsClosed(int)), this, SLOT(initializeWindow(int)));

		}
	else
		return;
}*/

/******************************************* Implementation of the method trajUpdate() **************************************************/
void MainWindow::trajUpdate() {

	if (m_trajectoryWindow != NULL) //Teste si l'objet n'est pas déjà crée.
		{ 
			delete m_trajectoryWindow ;
			m_trajectoryWindow = new TrajectoryWindow(&theTrajectoryTable, &theConstantTable); //mwc.getTraj();
			espace.addWindow(m_trajectoryWindow)->move(30, 10);
			m_trajectoryWindow->show();
			espace.setActiveWindow(m_constantWindow);

			connect(m_trajectoryWindow, SIGNAL(trajectoryWindowIsClosed(int)), this, SLOT(initializeWindow(int)));// The signal is in the HatNameWindow.hpp file.
		}
	else
		return;
}
/***************************************** Implementation of the method montrerActionGenererD() ****************************************************/
void MainWindow::montrerActionGenererD() {

	actionGenerationD->setEnabled(true);
}

/*********************************** Implementation of the method montrerActionCompilation() *******************************************************/
void MainWindow::montrerActionCompilation() {

	actionCompilation->setEnabled(true);
}
 
/************************************************* Implementation of the method setProjectName(string chaine) **************************************/
void MainWindow::setProjectName(string chaine) {
 
	m_newProjectName = chaine; //To initialize or to give a name for the project.

}
/***************************************************** Implementation of the method getProjectName() **********************************************/
 string MainWindow::getProjectName() {
 	
	return m_newProjectName;
} 

/************************************* Implementation of the method setProjectPath(string aPath) ******************************************/
void MainWindow::setProjectPath(string aPath) {
 
	m_projectPath = aPath ; //We store here the project path. Ex: ~/interface/projects
}
 
/********************************************* Implementation of the method getProjectPath() ********************************************************/
string MainWindow::getProjectPath() {
 
	return m_projectPath; 
}

/********************************************* Implementation of the method setActiveProject(const bool aBool) ***********************************/
void MainWindow::setActiveProject(const bool aBool) {

	m_activeProject = aBool;
}

/********************************************* Implementation of the method isActiveProject() ***********************************/
 bool MainWindow::isActiveProject() {

	return m_activeProject;	
}

/**************************************** Implementation of the method generateDFile(string destination) (SLOT) *****************************/
void MainWindow::generateDFile(string destination) {
	
	date = new QDateEdit;
                 date->setDate(QDate::currentDate());

	
	try 
		{
			filename = getProjectName();
			filepath = destination + filename + "/" + filename + ".d"; //"projects/test/test.d";
			ofstream description(filepath.c_str(), ios::out | ios::binary | ios::trunc);

			if(!description.is_open())
				throw ofstream::failure("couldn't create " + filename);
			description << "#-------------------------------------------------------------------------------------------------" << endl;
			description << "#---Fichier " + filename + ".d généré par visual Yao le " << date->date().toString().toStdString()  << endl;
			description << "#-------------------------------------------------------------------------------------------------" << endl;

			if (!theConstantTable.empty()) {
			description << "#DEFVAL name value -------------------------------------------------------------------------------" << endl;
				for (Table<Constant>::iterator it = theConstantTable.begin(); it != theConstantTable.end(); it++)
					description << "defval " << it->getName() << " " << it->getText() << endl;
					description << endl;
			}
			if (!theHeaderList.empty()) {
			description << "#HATNAME fileList --------------------------------------------------------------------------------" << endl;
				for(vector <string>::iterator it = theHeaderList.begin(); it != theHeaderList.end(); it++)
					description << "hat_name \"" << it->c_str() << "\"" << endl;
					description << endl;
			}
			if (!theContextData.empty()) {
			description << "#OPTION (optionAttribute)+ ---------------------------------------------------------------------" << endl;
			description << /*m_contextWindow->getContextParameters()*/ theContextData << endl; //"option " << it->toStdString() << endl;
		//	cout << m_contextWindow->getContextParameters() << endl; //"option " << it->toStdString() << endl;
					description << endl;
			}
			if (!theTrajectoryTable.empty()) {
			description << "#TRAJ name type uptime offtime dtime steptime ------------------------------------------" << endl;
				for (Table<Trajectory>::iterator it = theTrajectoryTable.begin(); it != theTrajectoryTable.end(); it++)
					description << "traj " << it->getName() << " " << it->getType() << " " << it->getBoot() << " "  << it->getOffset() << " " << it->getStep() << " " << it->getSize()<< " " << endl;
					description << endl;
			}
			if(!theSpaceTable.empty()){
			description << "#SPACE name type dim1 [[dim2]---[dim3]] traj ---------------------------------------------------" << endl; 
				for (Table<Space>::iterator it = theSpaceTable.begin(); it != theSpaceTable.end(); it++)
					description << "space " << it->getProperty(0) << " M " << it->getProperty(1) << " " << it->getProperty(2) << endl;
					description << endl;
			}
			if(!theOperaTable.empty()) {
			description << "#OPERATOR name type shape parent --------------------------------------------------------------" << endl; 
				for (Table <Operator>::iterator it = theOperaTable.begin(); it != theOperaTable.end(); it++)
					description << "opera " << it->getProperty(0) << " " << it->getProperty(1) << " " << it->getProperty(2) << endl;
					description << endl;
			}
			if (!theNeuronTable.empty()) {
			description << "#NETWARD name indegree outdegree --------------------------------------------------------------" << endl;
				for (Table<Neuron>::iterator it = theNeuronTable.begin(); it != theNeuronTable.end(); it++)
					description << "netward " << it->getName() << " " << it->getInDegree() << " " << it->getOutDegree() << endl;
					description << endl;
			}
			if (!theModulTable.empty()){
			description << "#MODUL name parent ( modulAttribute )* --------------------------------------------------------" << endl;
				for (Table<Modul>::iterator it = theModulTable.begin(); it != theModulTable.end(); it++) {
					string parentType = it->isSpaceOrOperator()? "space " : "operator ";
					string aString =  "modul " + it->getName() + " " + parentType + it->getSpaceOrOperator(); 
					if (!it->getInput())
						aString.append(" input " + it->getInput());
					description << aString << " " << "output "<< it->getOutput() << " " << "target " << it->getTarget()<< endl;
				}
					description << endl;
			}
			if (!theConnectionTable.empty()){
			description << "#CONNECTIONS name range[0] FROM! name range[1] range_i ( range_jkt )? -------------------------" << endl;
				 for (Table<Connection>::iterator it = theConnectionTable.begin(); it != theConnectionTable.end(); it++)
					description << "ctin " << it->getInModule() << " " << it->getIn() << " from " << it->getOutModule() << " " << it->getOut() /*<< it->getI() */<< endl; 

					description << endl;
			}
			if (!theFunctionTable.empty()) {
			description << "#USER FUNCTIONS  ( ARG )? name ----------------------------------------------------------------" << endl;
				for (Table<Function>::iterator it = theFunctionTable.begin(); it != theFunctionTable.end(); it++) {
					string aString = it->isParameterized()? "arg" : "   ";
					description << "insert_fct " << aString << " " << it->getName() << endl;
					}
					//description << endl;
			}

			/*    for (QStringList::iterator it = m_insertFCTWindow->getDataFCT().begin(); it != m_insertFCTWindow->getDataFCT().end(); it++)
			description << "insert_fct " << it->toStdString() << endl;
			description << endl;
*/

			description.close();
		}

		catch (...) 
			{

				QMessageBox::critical(this, "Erreur", "Erreur dans la generation du fichier .d");
			}
}

/**************************************** Implementation of the method generateIFile() (SLOT) ****************************************************/
void MainWindow::generateIFile(string destination) {
	
	date = new QDateEdit;
                 date->setDate(QDate::currentDate());

try 
		{
			filename = getProjectName();
			filepath = destination + filename + "/" + filename + ".i"; //"projects/test/test.d";
			ofstream instruction(filepath.c_str(), ios::out | ios::binary | ios::trunc);

			if(!instruction.is_open())
				throw ofstream::failure("couldn't create " + filename);
			instruction << "#-------------------------------------------------------------------------------------------------" << endl;
			instruction << "#---Fichier " + filename + ".i généré par visual Yao le " << date->date().toString().toStdString()  << endl;
			instruction << "#-------------------------------------------------------------------------------------------------" << endl;
			
			if (!iw->getInstruction().isEmpty()) {
	    		
			for (vector <string>::iterator it = theInstructionData.begin(); it != theInstructionData.end(); it++)

				instruction << it->c_str() << endl;
			
				instruction << endl;
				
				//emit activeTheIAction();
			}
			instruction.close();

			QMessageBox::about(this, "Avis", "Le fichier " +QString(getProjectName().c_str())+".i a été généré avec succès.");
			
		}

		catch (...) 
			{

				QMessageBox::critical(this, "Erreur", "Erreur dans la generation du fichier .i");
			}


}

/********************************************* Implementation of the method instructionFileManager() *********************************************/
void MainWindow::instructionFileManager() {

	
	iw = new InstructionWindow(&theInstructionData, &theFunctionTable) ;
	espace.addWindow(iw)->move(0, 0); 
	iw->show();	

	connect(iw, SIGNAL(activeTheIAction()), this, SLOT(enableIAction()));
}

/********************************************* Implementation of the method initializeWindow(int anInt) *********************************************/
void MainWindow::initializeWindow(int anInt) {

	switch (anInt) {
	
		case 1: { 
				m_constantWindow = NULL; 
				break;
			}
		case 2: { 
				m_hatnameWindow = NULL; 
				break;
			}
		case 3: { 
				m_contextWindow  = NULL; 
				break;
			}
		case 4: { 
				m_trajectoryWindow = NULL; 
				break;
			}
		case 5: { 
				m_spaceWindow = NULL; 
				break;
			}
		case 6: { 
				m_operaWindow = NULL; 
			}	break;
		case 7: {		
				m_netwardWindow = NULL; 
				break;
			}
		case 8: { 
				m_modulWindow = NULL; 
				break;
			}
		case 9: { 
				m_ctinWindow = NULL; 
				break;
			}
		case 10: { 
				m_orderWindow = NULL; 
				break;
			}
		case 11: { 
				m_insertFCTWindow = NULL; 
				break;
			}
		default:  m_constantWindow = NULL;  m_hatnameWindow = NULL;  m_contextWindow  = NULL; m_trajectoryWindow = NULL;  m_spaceWindow = NULL;m_spaceWindow = NULL; m_operaWindow = NULL;  m_netwardWindow = NULL;   m_modulWindow = NULL;   m_ctinWindow = NULL;  m_orderWindow = NULL; m_insertFCTWindow = NULL; 
	}
	
}

/*********************************** Implementation of the method changeButtonColor() (SLOT) ********************************************************/
void MainWindow::changeButtonColor(QPushButton *aButton) {

	aButton->setStyleSheet("background-color: rgb(180, 180, 180)");

}

/*********************************** Implementation of the method changeColorConstantButton() (SLOT) ***********************************************/
void MainWindow::changeColorConstantButton() {

	changeButtonColor(m_constantButton);

}

/*********************************** Implementation of the method changeColorHatButton() (SLOT) ***************************************************/
void MainWindow::changeColorHatButton() {

	m_hatNameButton->setStyleSheet("background-color: rgb(180, 180, 180)");
}

/*********************************** Implementation of the method changeColorContextButton() (SLOT) ************************************************/
 void MainWindow::changeColorContextButton() {

	m_contextButton->setStyleSheet("background-color: rgb(180, 180, 180)");
 }

/************************************ Implementation of the method changeColorTrajButton() (SLOT) ***************************************************/
void MainWindow::changeColorTrajButton() {

	m_trajButton->setStyleSheet("background-color: rgb(180, 180, 180)");
}

/************************************* Implementation of the method changeColorSpaceButton() (SLOT) *************************************************/
void MainWindow::changeColorSpaceButton() {

	m_spaceButton->setStyleSheet("background-color: rgb(180, 180, 180)");

}
/********************************** Implementation of the method changeColorOperaButton() (SLOT) *****************************************************/
void MainWindow::changeColorOperaButton() {
 
	m_operaButton->setStyleSheet("background-color: rgb(180, 180, 180)");
 
 }

/*********************************** Implementation of the method changeColorModulButton() (SLOT) *************************************************/
void MainWindow::changeColorModulButton() {

	m_modulButton->setStyleSheet("background-color: rgb(180, 180, 180)");
}

/************************************ Implementation of the method changeColorCtinButton() (SLOT) **************************************************/
void MainWindow::changeColorCtinButton() {

	m_ctinButton->setStyleSheet("background-color: rgb(180, 180, 180)");

}

/********************************* Implementation of the method changeColorNetwardButton() (SLOT) **************************************************/
void MainWindow::changeColorNetwardButton() {

	m_netwardButton->setStyleSheet("background-color: rgb(180, 180, 180)");

}
/************************************* Implementation of the method changeColorInsertFCTButton() ***************************************************/
void MainWindow::changeColorInsertFCTButton() {

	m_insertFCTButton->setStyleSheet("background-color: rgb(180, 180, 180)");

}

/************************************ Implementation of the method changeColorOrderButton() whitch is a SLOT **********************************************/
void MainWindow::changeColorOrderButton() {

	m_orderButton->setStyleSheet("background-color: rgb(180, 180, 180)");

}

/*********************************** Implementation of the virtual method closeEvent() ************************************************************/
/*void MainWindow::closeEvent(QCloseEvent *event) {
	
      if (maybeSave()) {
            //writeSettings();
            event->accept();
      } 
	else 
            event->ignore();
      
}*/
/********************************** **/

/*********************************** Implementation of the destructor method (~MainWindow()) *******************************************************/
/*MainWindow::~MainWindow() {

                    delete menuFichier;
                    delete menuEdition;
                    delete menuAffichage;
                    delete menuExecution;
                    delete menuConfig;
                    delete menuAide;
                    delete actionFichierDescription;
                    delete actionFichierHat;
                    delete actionFichierInstruction;
                    delete actionGrapheModulaire;
                    delete actionInfosProjet;
                    delete actionNouveauProjet;
                    delete actionOuvrirProjet;
                    delete actionOuvrirProjetsRecents;
                    delete actionSaveProject;
                    delete actionSaveAsProject;
                    delete actionImprimerProjet;
                    delete actionSortieProjet;
                    delete actionCacherBarreOutils;
                    delete actionCacherFenetreApercu;
                    delete actionCacherFenetreProjet;
                    delete actionCacherFenetreDialog;
                    delete actionGenerationD;
                    delete actionCompilation;
                    delete actionExecution;
                    delete actionEditeur;
                    delete actionDocYao;
                    delete actionRapport;
                    delete m_contextButton;
                    delete m_trajButton;
                    delete m_spaceButton;
                    delete m_operaButton;
                    delete m_netwardButton;
                    delete m_modulButton;
                    delete m_ctinButton;
                    delete m_orderButton;
                    delete m_insertFCTButton;
                    delete yaoToolBar;
                    delete tableWidget;
}*/
/************************************* Enf of the destructor method. ******************************************************************************/
/*************************************          End of file.         ******************************************************************************/
/**************************************************************************************************************************************************/