source: trunk/yao/src/interface/src/MainWindow.cpp @ 476

//! \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.         ******************************************************************************/
/**************************************************************************************************************************************************/