TYMainWindow.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
// Added by qt3to4:
#include <QPixmap>
#include <QCloseEvent>
#include <qaction.h>
#include <qdir.h>
#include <qslider.h>
#include <qstatusbar.h>
#include <qmenubar.h>
#include <qtoolbar.h>
#include <qdialog.h>
#include <qlabel.h>
#include <qfile.h>
#include <qfiledialog.h>
#include <qfileinfo.h>
#include <qtoolbutton.h>
#include <qbuttongroup.h>
#include <qmessagebox.h>
#include <qcursor.h>
#include <qmainwindow.h>
#include <qprocess.h>
#include <qtextbrowser.h>
#include <qtextstream.h>
#include <QDockWidget>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QShortcut>
#include <qeventloop.h>
#include <QDateTime>
 
#include "Tympan/core/config.h"
#include <Tympan/core/logging.h>
#include "Tympan/models/business/acoustic/TYSpectre.h"
#include "Tympan/models/business/OLocalizator.h"
#include "Tympan/models/business/TYPreferenceManager.h"
#include "Tympan/models/business/TYXMLManager.h"
#include "Tympan/models/business/TYPluginManager.h"
#include "Tympan/gui/widgets/TYSpectreWidget.h"
#include "Tympan/gui/gl/TYPickingTable.h"
#include "Tympan/gui/app/TYCustomPopupMenu.h"
#include "Tympan/gui/app/TYCalculToolbar.h"
#include "Tympan/gui/app/TYInfraToolbar.h"
#include "Tympan/gui/app/TYTopoToolbar.h"
#include "Tympan/gui/app/TYBatimentToolbar.h"
#include "Tympan/gui/app/TYBatimentModelerFrame.h"
#include "Tympan/gui/app/TYFaceModelerFrame.h"
#include "Tympan/gui/app/TYFaceToolbar.h"
#include "Tympan/gui/app/TYMachineModelerFrame.h"
#include "Tympan/gui/app/TYMachineToolbar.h"
 
#include "Tympan/gui/app/TYModelerFrame.h"
#include "Tympan/gui/app/TYModelerToolbar.h"
#include "Tympan/gui/app/TYPreferenceDialog.h"
#include "Tympan/gui/app/TYOpenElementDialog.h"
#include "Tympan/gui/app/TYPluginDialog.h"
#include "Tympan/gui/app/TYCreateElementDialog.h"
#include "Tympan/gui/app/TYProjetFrame.h"
#include "Tympan/gui/app/TYSiteModelerFrame.h"
#include "Tympan/gui/app/TYSiteFrame.h"
#include "Tympan/gui/app/TYOutputFrame.h"
#include "Tympan/gui/app/TYApplication.h"
#include "Tympan/gis/TYIGNGeoProvider.h"
#include "TYMainWindow.h"
 
#define TR(id) OLocalizator::getString("TYMainWindow", (id))
#define IMG(id) OLocalizator::getPicture("TYMainWindow", (id))
 
// using namespace Qt;
 
// to avoid X11 macro conflit
#ifdef Always
    #undef Always
#endif
 
TYMainWindow::TYMainWindow() : QMainWindow(0)
{
    //  QApplication::setStyle(new QGtkStyle());
    _pDummyQOpenGLWidget = new QOpenGLWidget(this);
    _pDummyQOpenGLWidget->setVisible(false);
 
    TYPickingTable _pPickingTable;
 
    setWindowTitle(TR("id_caption") + "-" + TY_CURRENT_RELEASE_ + " (" + TY_PRODUCT_PLATFORM_ + ")");
 
    _closeAndQuit = true;
 
    // Gestion du workspace
    _pWorkspace = new QMdiArea();
    _pWorkspace->setActivationOrder(QMdiArea::ActivationHistoryOrder);
    setCentralWidget(_pWorkspace);
 
    // CLM-NT35 : Empecher de deplacer/tourner en vue perspective/mobile
    _pCurrentModeler = NULL;
 
    // Settings du docking
    // setDockWindowsMovable(true);
 
    // Navigateur d'aide
    _pHelpBrowser = new QTextBrowser(NULL);
    _pHelpBrowser->resize(800, 600);
    QString help_index_file = TYApplication::tympanAppDir() + "/" + TR("id_help_index_path");
    if (QFile::exists(help_index_file))
    {
        _pHelpBrowser->setSource(help_index_file);
    }
    _pHelpBrowser->hide();
 
    // Modes des Modelers
    _curSiteMode = TYModelerFrame::CameraMode;
    _curMachineMode = TYModelerFrame::CameraMode;
    _curBatimentMode = TYModelerFrame::CameraMode;
    _curFaceMode = TYModelerFrame::CameraMode;
 
    // Disambiguate the overloaded TYMainWindow signals
    void (TYMainWindow::*tyMainWindow_open)() = &TYMainWindow::open;
    bool (TYMainWindow::*tyMainWindow_save)() = &TYMainWindow::save;
    bool (TYMainWindow::*tyMainWindow_saveAs)() = &TYMainWindow::saveAs;
 
    // Actions
    _pCreateNewAction = new QAction(QPixmap(IMG("id_icon_createnew")), TR("id_menuitem_createnew"), this);
    _pCreateNewAction->setShortcut(Qt::CTRL + Qt::Key_N);
    _pCreateNewAction->setStatusTip(TR("id_status_createnew"));
    QObject::connect(_pCreateNewAction, &QAction::triggered, this, &TYMainWindow::createNew);
 
    _pOpenAction = new QAction(QPixmap(IMG("id_icon_open")), TR("id_menuitem_open"), this);
    _pOpenAction->setShortcut(Qt::CTRL + Qt::Key_O);
    _pOpenAction->setStatusTip(TR("id_status_open"));
    QObject::connect(_pOpenAction, &QAction::triggered, this, tyMainWindow_open);
 
    _pCloseAction = new QAction(QPixmap(IMG("id_icon_close")), TR("id_menuitem_close"), this);
    _pCloseAction->setStatusTip(TR("id_status_close"));
    QObject::connect(_pCloseAction, &QAction::triggered, this, &TYMainWindow::close);
    _pCloseAction->setEnabled(false);
 
    _pSaveAction = new QAction(QPixmap(IMG("id_icon_save")), TR("id_menuitem_save"), this);
    _pSaveAction->setShortcut(Qt::CTRL + Qt::Key_S);
    _pSaveAction->setStatusTip(TR("id_status_save"));
    QObject::connect(_pSaveAction, &QAction::triggered, this, tyMainWindow_save);
 
    _pSaveAsAction = new QAction(QPixmap(IMG("id_icon_save")), TR("id_menuitem_saveas"), this);
    _pSaveAsAction->setStatusTip(TR("id_status_saveas"));
    QObject::connect(_pSaveAsAction, &QAction::triggered, this, tyMainWindow_saveAs);
 
    _pSaveAsNoResultAction =
        new QAction(QPixmap(IMG("id_icon_save")), TR("id_menuitem_saveas_noresult"), this);
    _pSaveAsNoResultAction->setStatusTip(TR("id_status_saveas_noresult"));
    QObject::connect(_pSaveAsNoResultAction, &QAction::triggered, this, &TYMainWindow::saveAsNoResult);
 
    _pShowPluginManagerAction = new QAction(QPixmap(IMG("id_icon_plugin")), TR("id_menuitem_plugin"), this);
    _pShowPluginManagerAction->setStatusTip(TR("id_status_plugin"));
    QObject::connect(_pShowPluginManagerAction, &QAction::triggered, this, &TYMainWindow::showPluginManager);
 
    // az++:
    _pPrintAction = new QAction(QPixmap(IMG("id_icon_print")), TR("id_menuitem_print"), this);
    _pPrintAction->setShortcut(Qt::CTRL + Qt::Key_P);
    _pPrintAction->setStatusTip(TR("id_status_print"));
    QObject::connect(_pPrintAction, &QAction::triggered, this, &TYMainWindow::print);
    _pPrintAction->setEnabled(false);
 
    _pUndoAction = new QAction(QPixmap(IMG("id_icon_undo")), TR("id_menuitem_undo_na"), this);
    _pUndoAction->setShortcut(Qt::CTRL + Qt::Key_Z);
    _pUndoAction->setStatusTip(TR("id_status_undo"));
    QObject::connect(_pUndoAction, &QAction::triggered, this, &TYMainWindow::undo);
    _pUndoAction->setEnabled(false);
 
    _pRedoAction = new QAction(QPixmap(IMG("id_icon_redo")), TR("id_menuitem_redo_na"), this);
    _pRedoAction->setShortcut(Qt::CTRL + Qt::Key_Y);
    _pRedoAction->setStatusTip(TR("id_status_redo"));
    QObject::connect(_pRedoAction, &QAction::triggered, this, &TYMainWindow::redo);
    _pRedoAction->setEnabled(false);
 
    _pCutAction = new QAction(QPixmap(IMG("id_icon_cut")), TR("id_menuitem_cut"), this);
    _pCutAction->setShortcut(Qt::CTRL + Qt::Key_X);
    _pCutAction->setStatusTip(TR("id_status_cut"));
    QObject::connect(_pCutAction, &QAction::triggered, this, &TYMainWindow::cut);
    _pCutAction->setEnabled(false);
 
    _pCopyAction = new QAction(QPixmap(IMG("id_icon_copy")), TR("id_menuitem_copy"), this);
    _pCopyAction->setShortcut(Qt::CTRL + Qt::Key_C);
    _pCopyAction->setStatusTip(TR("id_status_cut"));
    QObject::connect(_pCopyAction, &QAction::triggered, this, &TYMainWindow::copy);
    _pCopyAction->setEnabled(false);
 
    _pPasteAction = new QAction(QPixmap(IMG("id_icon_paste")), TR("id_menuitem_paste"), this);
    _pPasteAction->setShortcut(Qt::CTRL + Qt::Key_V);
    _pPasteAction->setStatusTip(TR("id_status_paste"));
    QObject::connect(_pPasteAction, &QAction::triggered, this, &TYMainWindow::paste);
    _pPasteAction->setEnabled(false);
 
    _pHideOrShowSpectreMngrAction =
        new QAction(QPixmap(IMG("id_icon_show_spectremngr")), TR("id_menuitem_show_spectremngr"), this);
    _pHideOrShowSpectreMngrAction->setCheckable(false); // DT 18-05-04 (true change en false)
    _pHideOrShowSpectreMngrAction->setStatusTip(TR("id_status_show_spectremngr"));
    _pHideOrShowSpectreMngrAction->setEnabled(false); // Inactive au depart
    QObject::connect(_pHideOrShowSpectreMngrAction, &QAction::toggled, this,
                     &TYMainWindow::showSpectreManager);
 
    _pHideOrShowMaillageMngrAction =
        new QAction(QPixmap(IMG("id_icon_show_maillagemngr")), TR("id_menuitem_show_maillagemngr"), this);
    _pHideOrShowMaillageMngrAction->setCheckable(false); // DT 18-05-04 (true change en false)
    _pHideOrShowMaillageMngrAction->setStatusTip(TR("id_status_show_maillagemngr"));
    _pHideOrShowMaillageMngrAction->setEnabled(false); // Inactive au depart
    QObject::connect(_pHideOrShowMaillageMngrAction, &QAction::toggled, this,
                     &TYMainWindow::showMaillageManager);
 
    _pHideOrShowBiblioAction =
        new QAction(QPixmap(IMG("id_icon_show_biblio")), TR("id_menuitem_show_biblio"), this);
    _pHideOrShowBiblioAction->setCheckable(true);
    _pHideOrShowBiblioAction->setStatusTip(TR("id_status_show_biblio"));
    QObject::connect(_pHideOrShowBiblioAction, &QAction::toggled, this, &TYMainWindow::showBiblio);
    _pHideOrShowBiblioAction->setEnabled(false);
 
    _pHideOrShowOutputAction =
        new QAction(QPixmap(IMG("id_icon_show_output")), TR("id_menuitem_show_output"), this);
    _pHideOrShowOutputAction->setCheckable(true);
    _pHideOrShowOutputAction->setStatusTip(TR("id_status_show_output"));
    QObject::connect(_pHideOrShowOutputAction, &QAction::toggled, this, &TYMainWindow::showOutput);
 
    _pEditCurCalculAction =
        new QAction(QPixmap(IMG("id_icon_edit_curcalcul")), TR("id_menuitem_edit_curcalcul"), this);
    _pEditCurCalculAction->setStatusTip(TR("id_status_edit_curcalcul"));
    QObject::connect(_pEditCurCalculAction, &QAction::triggered, this, &TYMainWindow::editCurCalcul);
    _pEditCurCalculAction->setEnabled(false);
 
    _pGoAltiAction = new QAction(QPixmap(IMG("id_icon_alti")), TR("id_menuitem_lancer_calcul_alti"), this);
    _pGoAltiAction->setStatusTip(TR("id_status_lancer_alticalcul"));
    QObject::connect(_pGoAltiAction, &QAction::triggered, this, &TYMainWindow::goAltiCalcul);
    _pGoAltiAction->setEnabled(false);
 
    _pGoCurCalculAction =
        new QAction(QPixmap(IMG("id_icon_go_curcalcul")), TR("id_menuitem_lancer_calcul_courant"), this);
    _pGoCurCalculAction->setStatusTip(TR("id_status_go_curcalcul"));
    QObject::connect(_pGoCurCalculAction, &QAction::triggered, this, &TYMainWindow::goCurCalcul);
    _pGoCurCalculAction->setEnabled(false);
 
    QAction* pPrefDialogAction =
        new QAction(QPixmap(IMG("id_icon_prefdlg")), TR("id_menuitem_prefdlg"), this);
    QObject::connect(pPrefDialogAction, &QAction::triggered, this, &TYMainWindow::showPreferenceDialog);
 
    // Barre de menu
    QMenu* pFileMenu = new QMenu(TR("id_menu_file"), this);
    menuBar()->addMenu(pFileMenu);
 
    QMenu* pNewMenu = new QMenu(TR("id_menuitem_new"), this);
    pNewMenu->setTearOffEnabled(true);
    pNewMenu->addAction(TR("id_menuitem_newprojet"), this, &TYMainWindow::createNewProjet);
    pNewMenu->addAction(TR("id_menuitem_newgeoprojet"), this, &TYMainWindow::showZoneSelectPage);
    pNewMenu->addAction(TR("id_menuitem_newsite"), this, &TYMainWindow::createNewSite);
    pNewMenu->addAction(TR("id_menuitem_newbatiment"), this, &TYMainWindow::createNewBatiment);
    pNewMenu->addAction(TR("id_menuitem_newmachine"), this, &TYMainWindow::createNewMachine);
    pNewMenu->addAction(_pCreateNewAction);
 
    pFileMenu->addMenu(pNewMenu);
    pFileMenu->addAction(_pOpenAction);
    pFileMenu->addAction(_pCloseAction);
    pFileMenu->addSeparator();
    pFileMenu->addAction(_pSaveAction);
    pFileMenu->addAction(_pSaveAsAction);
    pFileMenu->addAction(_pSaveAsNoResultAction);
    pFileMenu->addSeparator();
    pFileMenu->addAction(_pShowPluginManagerAction);
    pFileMenu->addSeparator();
    pFileMenu->addAction(_pPrintAction);
    pFileMenu->addSeparator();
    pFileMenu->addAction(TR("id_menuitem_quit"), this, &TYMainWindow::quitte, QKeySequence("Ctrl+Q"));
 
    QMenu* pEditMenu = new QMenu(TR("id_menu_edit"), this);
    menuBar()->addMenu(pEditMenu);
    pEditMenu->addAction(_pUndoAction);
    pEditMenu->addAction(_pRedoAction);
    pEditMenu->addSeparator();
    pEditMenu->addAction(_pCutAction);
    pEditMenu->addAction(_pCopyAction);
    pEditMenu->addAction(_pPasteAction);
    pEditMenu->addSeparator();
    pEditMenu->addAction(QPixmap(IMG("id_icon_prefdlg")), TR("id_menuitem_prefdlg"), this,
                         &TYMainWindow::showPreferenceDialog);
 
    _pWindowsMenu = new QMenu(TR("id_menu_windows"), this);
    connect(_pWindowsMenu, &QMenu::aboutToShow, this, &TYMainWindow::windowsMenuAboutToShow);
    menuBar()->addMenu(_pWindowsMenu);
 
    menuBar()->addSeparator();
 
    QMenu* pHelpMenu = new QMenu(TR("id_menu_help"), this);
    menuBar()->addMenu(pHelpMenu);
    pHelpMenu->addAction(TR("id_menuitem_help"), this, &TYMainWindow::showHelp, QKeySequence("F1"));
    pHelpMenu->addSeparator();
    pHelpMenu->addAction(TR("id_menuitem_about"), this, &TYMainWindow::about);
 
    // Barre d'outils fichier
    _pMainToolbar = new QToolBar(TR("id_toolbar_file"), this);
    addToolBar(_pMainToolbar);
    QToolButton* pToolNewFile = new QToolButton(this);
    pToolNewFile->setIcon(QPixmap(IMG("id_icon_new")));
    pToolNewFile->setToolTip(TR("id_menuitem_new"));
    pToolNewFile->setMenu(pNewMenu);
    pToolNewFile->setPopupMode(QToolButton::InstantPopup);
    _pMainToolbar->addWidget(pToolNewFile);
    _pMainToolbar->addSeparator();
    _pMainToolbar->addAction(_pOpenAction);
    _pMainToolbar->addAction(_pSaveAction);
    _pMainToolbar->addSeparator();
    _pMainToolbar->addAction(_pPrintAction);
    _pMainToolbar->addSeparator();
    _pMainToolbar->addAction(_pCutAction);
    _pMainToolbar->addAction(_pCopyAction);
    _pMainToolbar->addAction(_pPasteAction);
    _pMainToolbar->addSeparator();
    _pMainToolbar->addAction(_pUndoAction);
    _pMainToolbar->addAction(_pRedoAction);
    _pMainToolbar->setObjectName("MainToolbar");
 
    // Barre d'outils des fenetres
    _pWindowToolbar = new QToolBar(TR("id_toolbar_window"), this);
    addToolBar(_pWindowToolbar);
    _pWindowToolbar->addAction(_pHideOrShowSpectreMngrAction);
    _pWindowToolbar->addAction(_pHideOrShowMaillageMngrAction);
    _pWindowToolbar->addAction(_pHideOrShowBiblioAction);
    _pWindowToolbar->addSeparator();
    _pWindowToolbar->addAction(_pHideOrShowOutputAction);
    _pWindowToolbar->addSeparator();
    _pWindowToolbar->addAction(pPrefDialogAction);
    _pWindowToolbar->setObjectName("WindowToolbar");
 
    // Barre d'outils de calcul acoustique
    _pCalculAcousticToolbar = new QToolBar(TR("id_toolbar_calculacoustic"), this);
    addToolBar(_pCalculAcousticToolbar);
    _pCalculAcousticToolbar->addAction(_pEditCurCalculAction);
    _pCalculAcousticToolbar->addAction(_pGoAltiAction);
    _pCalculAcousticToolbar->addAction(_pGoCurCalculAction);
    _pCalculAcousticToolbar->setObjectName("CalculAcousticToolbar");
 
    // Barre d'outils pour les modelers
    _pToolbarModeler = new TYModelerToolbar(0, this, TR("id_toolbar_modeler"));
    addToolBar(_pToolbarModeler);
    _pToolbarModeler->setObjectName("ToolbarModeler");
 
    // Btn group pour Site
    _pSiteBtnGroup = new QButtonGroup(this);
    //  _pSiteBtnGroup->hide();
    _pSiteBtnGroup->setExclusive(true);
 
    // Barre d'outils Topographie
    _pToolbarTopo = new TYTopoToolbar(_pSiteBtnGroup, this, TR("id_toolbar_topo"));
    addToolBar(_pToolbarTopo);
    _pToolbarTopo->setObjectName("ToolbarTopo");
 
    // Barre d'outils Calcul
    _pToolbarCalcul = new TYCalculToolbar(_pSiteBtnGroup, this, TR("id_toolbar_calcul"));
    addToolBar(_pToolbarCalcul);
    _pToolbarCalcul->setObjectName("ToolbarCalcul");
 
    // Barre d'outils Infrastructure
    _pToolbarInfra = new TYInfraToolbar(_pSiteBtnGroup, this, TR("id_toolbar_infra"));
    addToolBar(_pToolbarInfra);
    _pToolbarInfra->setObjectName("ToolbarInfra");
 
    // Btn group pour Machine
    _pMachineBtnGroup = new QButtonGroup(this);
    //  _pMachineBtnGroup->hide();
    _pMachineBtnGroup->setExclusive(true);
 
    // Barre d'outils Machine
    _pToolbarMachine = new TYMachineToolbar(_pMachineBtnGroup, this, TR("id_toolbar_machine"));
    addToolBar(_pToolbarMachine);
    _pToolbarMachine->setObjectName("ToolbarMachine");
 
    // Btn group pour Face
    _pFaceBtnGroup = new QButtonGroup(this);
    //  _pFaceBtnGroup->hide();
    _pFaceBtnGroup->setExclusive(true);
 
    // Barre d'outils Face
    _pToolbarFace = new TYFaceToolbar(_pFaceBtnGroup, this, TR("id_toolbar_Face"));
    addToolBar(_pToolbarFace);
    _pToolbarFace->setObjectName("ToolbarFace");
 
    // Btn group pour Batiment
    _pBatimentBtnGroup = new QButtonGroup(this);
    //  _pBatimentBtnGroup->hide();
    _pBatimentBtnGroup->setExclusive(true);
 
    // Barre d'outils Batiment
    _pToolbarBatiment = new TYBatimentToolbar(_pBatimentBtnGroup, this, TR("id_toolbar_batiment"));
    addToolBar(_pToolbarBatiment);
    _pToolbarBatiment->setObjectName("ToolbarBatiment");
 
    // Fenetre Projet
    _pProjetDockWnd = new QDockWidget(TR("id_toolbar_projet"), this);
    _pProjetDockWnd->setFloating(false);
    _pProjetFrame = new TYProjetFrame(_pProjetDockWnd);
    _pProjetDockWnd->setWidget(_pProjetFrame);
    _pProjetDockWnd->setObjectName("ProjetDockWnd");
    _pProjetDockWnd->setContentsMargins(0, 0, 0, 0);
    addDockWidget(Qt::LeftDockWidgetArea, _pProjetDockWnd);
 
    // Fenetre Site
    _pSiteDockWnd = new QDockWidget(TR("id_toolbar_site"), this);
    _pSiteDockWnd->setFloating(false);
    _pSiteFrame = new TYSiteFrame(_pSiteDockWnd);
    _pSiteDockWnd->setWidget(_pSiteFrame);
    _pSiteDockWnd->setObjectName("SiteDockWnd");
    addDockWidget(Qt::LeftDockWidgetArea, _pSiteDockWnd);
 
    // Fenetre Output
    _pOutputDockWnd = new QDockWidget(TR("id_toolbar_output"), this);
    _pOutputDockWnd->setFloating(false);
    _pOutputFrame = new TYOutputFrame(_pOutputDockWnd);
    _pOutputDockWnd->setWidget(_pOutputFrame);
    _pOutputDockWnd->setObjectName("OutputDockWnd");
    addDockWidget(Qt::LeftDockWidgetArea, _pOutputDockWnd);
 
    // Connexion des signaux
    QObject::connect(_pOutputDockWnd, &QDockWidget::visibilityChanged, this,
                     &TYMainWindow::updateHideOrShowOutputAction);
    QObject::connect(getTYApp(), &TYApplication::curProjetChanged, this, &TYMainWindow::setCurProjet);
    QObject::connect(getTYApp(), &TYApplication::curSiteNodeChanged, this, &TYMainWindow::setCurSiteNode);
    QObject::connect(_pProjetFrame, &TYProjetFrame::changeCurrentCalcul, _pSiteFrame,
                     &TYSiteFrame::setCurrentCalcul);
    QObject::connect(_pProjetFrame, &TYProjetFrame::changeSite, _pSiteFrame, &TYSiteFrame::setSiteNodeRoot);
    QObject::connect(_pProjetFrame, &TYProjetFrame::changeCurrentCalcul, this,
                     &TYMainWindow::updateCurCalcul);
    QObject::connect(_pWorkspace, &QMdiArea::subWindowActivated, this, &TYMainWindow::subWindowActivated);
 
    QShortcut* shortcut = new QShortcut(QKeySequence(Qt::Key_Escape), this);
    connect(shortcut, &QShortcut::activated, this, &TYMainWindow::setDefaultCameraMode);
 
    // Connecte l'Action Manager de l'Application
    connectDefaultActionManager();
 
    // Connecte le gestionnaire geographique IGN
    TYIGNGeoProvider* geoProvider = TYIGNGeoProvider::getInstance();
    QObject::connect(geoProvider, &TYIGNGeoProvider::geoProjectCreationRequested, this,
                     &TYMainWindow::createNewGeoProjet);
 
    // Desactive tous les boutons
    subWindowActivated();
 
    // On active la sauvegarde des instances de type TYElement et derivees
    TYElement::setLogInstances(true);
 
    // Ready to work !!
    statusBar()->showMessage(TR("id_status_ready"));
 
    // Indique que les TYElement sont ok (rien a sauvegarder)
    TYElement::setIsSavedOk(false);
}
 
TYMainWindow::~TYMainWindow()
{
    delete _pHelpBrowser;
    _pHelpBrowser = NULL;
}
 
QMenu* TYMainWindow::createPopupMenu()
{
    QMenu* returnedMenu = QMainWindow::createPopupMenu();
    TYCustomPopupMenu* myMenu = new TYCustomPopupMenu();
    myMenu->addActions(returnedMenu->actions());
    delete returnedMenu;
    return myMenu;
}
 
void TYMainWindow::saveGeometryToPreferences()
{
    // Main window
    TYPreferenceManager::saveGeometryToPreferences(metaObject()->className(), this);
 
    // Dock windows
    QObjectList objectsList = children(); // dockWindows();
    QWidget* pDockWnd = NULL;
    QObject* pObject = NULL;
 
    for (int _i = 0; _i < objectsList.size(); _i++)
    {
        pObject = objectsList[_i];
        if ((pObject->objectName() == "ProjetDockWnd") || (pObject->objectName() == "SiteDockWnd") ||
            (pObject->objectName() == "OutputDockWnd") ||
            (strcmp(pObject->metaObject()->className(), "QToolBar") == 0) ||
            (dynamic_cast<QToolBar*>(pObject) != nullptr))
        {
 
            pDockWnd = (QWidget*)pObject;
            QString key = pDockWnd->objectName();
 
            // Geometry
            TYPreferenceManager::saveGeometryToPreferences(key, pDockWnd);
        }
    }
}
 
void TYMainWindow::reloadSlots() {}
 
bool TYMainWindow::loadSettings(const QString& fileName)
{
    // Only for loading settings
    bool res = true;
 
    statusBar()->showMessage(TR("id_status_load_settings"), 3000);
 
    // Save user dir before loading settings from file for the case Settings.xml is copied from
    // DefaultSettings.xml
    QString userDir = QDir::toNativeSeparators(getTYApp()->tympanUserDir());
    // Try to load MainWindowIHM.bin in order to restore Main Window state
    auto inFile = searchSettingsFile(userDir, fileName, QString("MainWindowIHM.bin"),
                                     QString("Settings4.[0-9]MainWindowIHM.bin"));
    // If a file SettingsMainWindowIHM.bin has been found
    if (inFile != nullptr && inFile->open(QIODevice::ReadOnly))
    {
        QByteArray byteArray = inFile->readAll();
        if (!byteArray.isEmpty())
        {
            restoreState(byteArray);
        }
        inFile->close();
    }
 
    // Init Settings.xml file
    bool isCopiedFromDefaultSettings = false;
    auto settingsFile =
        searchSettingsFile(userDir, fileName, QString(".xml"), QString("Settings4.[0-9].xml"));
 
    // If initialization succeeds
    res = res &&
          TYPreferenceManager::init(fileName + ".xml", isCopiedFromDefaultSettings, std::move(settingsFile));
    if (res)
    {
        // Load settings from file Settings.xml
        res = res && TYPreferenceManager::read();
        // If reading succeeded
        if (res)
        {
            // If file is newly created, then we have to init path preferences with specific user path
            if (isCopiedFromDefaultSettings)
            {
                TYPreferenceManager::setString(TYDIRPREFERENCEMANAGER, "WorkDirPath", userDir);
                QString libraryDir = QDir::toNativeSeparators(userDir + "/library/");
                TYPreferenceManager::setString(TYDIRPREFERENCEMANAGER, "BiblioPath", libraryDir);
            }
 
            // Apply settings
            TYPreferenceManager::loadGeometryFromPreferences(metaObject()->className(), this);
 
            // Dock windows
            QObjectList objectsList = children(); // dockWindows();
            QWidget* pDockWnd = NULL;
            QObject* pObject = NULL;
 
            for (int _i = 0; _i < objectsList.size(); _i++)
            {
                pObject = objectsList[_i];
                if ((pObject->objectName() == "ProjetDockWnd") || (pObject->objectName() == "SiteDockWnd") ||
                    (pObject->objectName() == "OutputDockWnd") ||
                    (strcmp(pObject->metaObject()->className(), "QToolBar") == 0) ||
                    (dynamic_cast<QToolBar*>(pObject) != nullptr))
                {
                    pDockWnd = (QWidget*)pObject;
                    QString key = pDockWnd->objectName();
                    // Geometry
                    TYPreferenceManager::loadGeometryFromPreferences(key, pDockWnd);
                }
            }
        }
    }
 
    return res;
}
 
std::unique_ptr<QFile> TYMainWindow::searchSettingsFile(const QString& TympanUserDir,
                                                        const QString& fileNameBegin,
                                                        const QString& fileNameEnd,
                                                        const QString& fileNamePattern)
{
    // First try to load regular SettingsMainWindowIHM.bin
    auto regularFile = std::make_unique<QFile>(QString(fileNameBegin) + QString(fileNameEnd));
    if (regularFile->exists())
    {
        qDebug() << "Regular file" << QString(fileNameBegin + fileNameEnd) << "found.";
        return regularFile;
    }
    else
    // Else try to load the most recent file matching the pattern
    {
        qDebug() << "Regular file" << QString(fileNameBegin + fileNameEnd)
                 << "NOT found, searching for oldest files";
 
        // Create a QDir object for the specified folder
        QDir folder(TympanUserDir);
 
        // Get a list of files matching the pattern
        QStringList matchingFiles = folder.entryList(QStringList(fileNamePattern), QDir::Files);
 
        // Check if any matching files were found
        if (!matchingFiles.isEmpty())
        {
            qDebug() << "File(s) macthing" << fileNamePattern << "pattern found in the folder.";
 
            QString selectedFile; // Variable to store the selected file
            int maxDigit = -1;    // Variable to store the maximum digit value
 
            // Iterate through the matching files
            for (const QString& matchingFile : matchingFiles)
            {
                // Extract the digit 'x' from the file name
                int digit = matchingFile.mid(10, 1).toInt();
 
                // Check if the current digit is greater than the maximum digit found so far
                if (digit > maxDigit)
                {
                    maxDigit = digit;
                    selectedFile = matchingFile;
                }
            }
 
            // Print and return the selected file
            qDebug() << "Selected file: " << selectedFile;
            return std::make_unique<QFile>(QDir::toNativeSeparators(TympanUserDir + "/" + selectedFile));
        }
        else
        {
            // Return nullptr if no file is found
            qDebug() << "No matching files found in the folder.";
            return nullptr;
        }
    }
}
 
bool TYMainWindow::saveSettings(const QString& fileName)
{
    bool res = false;
 
    QByteArray byteArray = saveState();
    QFile* outFile = new QFile(QString(fileName) + QString("MainWindowIHM.bin"));
    if (outFile->open(QIODevice::WriteOnly))
    {
        outFile->write(byteArray);
        outFile->close();
    }
 
    delete outFile;
 
    // Sauvegarde des settings
    QString finalFileName = QString(fileName) + QString(".xml");
    TYPreferenceManager::setFileName(finalFileName);
    res = TYPreferenceManager::write();
 
    return res;
}
 
void TYMainWindow::showHelp()
{
    _pHelpBrowser->show();
}
 
void TYMainWindow::about()
{
    // Dlg "A propos de Tympan"
    QMessageBox* pAboutTympan = new QMessageBox(NULL);
    pAboutTympan->setWindowTitle(windowTitle());
    QString msg = TR("id_about_msg");
    msg = msg.arg(TY_PRODUCT_NAME_);
    msg = msg.arg(TY_CURRENT_RELEASE_);
    msg = msg.arg(TY_PRODUCT_PLATFORM_);
    msg = msg.arg(TY_PRODUCT_COPYRIGHT_);
    msg = msg.arg(TY_BUILD_DATE_);
    msg = msg.arg(TY_BUILD_TIME_);
    msg = msg.arg(TY_CUSTOMER_);
    msg = msg.arg(TY_LICENCE_NUMBER_);
    msg = msg.arg(TY_TIME_LIMIT_);
    pAboutTympan->setText(msg);
    pAboutTympan->setIconPixmap(IMG("id_logo_about"));
 
    // Affichage
    pAboutTympan->exec();
 
    // Nettoyage
    delete pAboutTympan;
    pAboutTympan = NULL;
}
 
bool TYMainWindow::makeModeler(TYElement* pElt)
{
    if (!pElt)
    {
        return true;
    }
 
    TYProjet* pProj = dynamic_cast<TYProjet*>(pElt);
    if (pProj != nullptr)
    {
        makeProjetModeler(pProj);
        return true;
    }
    else if (pElt->isA("TYSiteNode"))
    {
        makeSiteModeler(static_cast<TYSiteNode*>(pElt));
        return true;
    }
    else if (pElt->isA("TYBatiment"))
    {
        return (makeBatimentModeler(static_cast<TYBatiment*>(pElt)));
    }
    else if (pElt->isA("TYMachine"))
    {
        return (makeMachineModeler(static_cast<TYMachine*>(pElt)));
    }
    else
    {
        return true;
    }
}
 
bool TYMainWindow::makeBatimentModeler(LPTYBatiment pBatiment)
{
    bool ret = false;
    TYBatimentModelerFrame* pBatimentModeler =
        new TYBatimentModelerFrame(NULL, _pWorkspace, "TYBatimentModelerFrame");
    pBatimentModeler->setAttribute(Qt::WA_DeleteOnClose);
    _pWorkspace->addSubWindow(pBatimentModeler)->setObjectName("TYBatimentModelerFrame");
 
    QObject::connect(pBatimentModeler, &TYBatimentModelerFrame::editorModeChanged, this,
                     &TYMainWindow::saveCurBatimentMode);
    QObject::connect(pBatimentModeler, &TYBatimentModelerFrame::frameResized, this,
                     &TYMainWindow::refreshWindowTitle);
    QObject::connect(pBatimentModeler, &QObject::destroyed, this, &TYMainWindow::onDestroyed);
 
    if (!pBatiment)
    {
        pBatiment = new TYBatiment();
    }
    pBatimentModeler->setBatiment(pBatiment);
 
    pBatimentModeler->showMaximized();
    pBatimentModeler->fit();
 
    // Waiting for the "aboutToClose" signal to be emited before moving to the next step
    QEventLoop loop;
    connect(pBatimentModeler, &TYBatimentModelerFrame::aboutToClose, &loop, &QEventLoop::quit);
    loop.exec();
    // If there is no volume, the modeler maker returns false
    if (pBatiment->getNbChild() == 0)
    {
        ret = false;
    }
    else
    {
        ret = true;
    }
    return ret;
}
 
bool TYMainWindow::makeMachineModeler(LPTYMachine pMachine)
{
    bool ret = false;
    TYMachineModelerFrame* pMachineModeler =
        new TYMachineModelerFrame(NULL, _pWorkspace, "TYMachineModelerFrame");
    pMachineModeler->setAttribute(Qt::WA_DeleteOnClose);
 
    _pWorkspace->addSubWindow(pMachineModeler)->setObjectName("TYMachineModelerFrame");
 
    QObject::connect(pMachineModeler, &TYMachineModelerFrame::editorModeChanged, this,
                     &TYMainWindow::saveCurMachineMode);
    QObject::connect(pMachineModeler, &TYMachineModelerFrame::frameResized, this,
                     &TYMainWindow::refreshWindowTitle);
    QObject::connect(pMachineModeler, &QObject::destroyed, this, &TYMainWindow::onDestroyed);
 
    if (!pMachine)
    {
        pMachine = new TYMachine();
    }
    pMachineModeler->setMachine(pMachine);
 
    pMachineModeler->showMaximized();
    pMachineModeler->fit();
 
    // Waiting for the "aboutTpClose" signal to be emited before moving to the next step
    QEventLoop loop;
    connect(pMachineModeler, &TYMachineModelerFrame::aboutToClose, &loop, &QEventLoop::quit);
    loop.exec();
    // If there is no volume, the modeler maker returns false
    if (pMachine->getNbChild() == 0)
    {
        ret = false;
    }
    else
    {
        ret = true;
    }
    return ret;
}
 
void TYMainWindow::makeSiteModeler(LPTYSiteNode pSite)
{
    TYSiteModelerFrame* pSiteModeler = new TYSiteModelerFrame(pSite, _pWorkspace, "TYSiteModelerFrame");
    pSiteModeler->setAttribute(Qt::WA_DeleteOnClose);
 
    _pWorkspace->addSubWindow(pSiteModeler)->setObjectName("TYSiteModelerFrame");
 
    QObject::connect(pSiteModeler, &TYSiteModelerFrame::editorModeChanged, this,
                     &TYMainWindow::saveCurSiteMode);
    QObject::connect(pSiteModeler, &TYSiteModelerFrame::frameResized, this,
                     &TYMainWindow::refreshWindowTitle);
    QObject::connect(pSiteModeler, &QObject::destroyed, this, &TYMainWindow::onDestroyed);
 
    pSiteModeler->showMaximized();
    pSiteModeler->fit();
}
 
void TYMainWindow::makeProjetModeler(LPTYProjet pProjet)
{
    TYSiteModelerFrame* pSiteModeler = new TYSiteModelerFrame(pProjet, _pWorkspace, "TYSiteModelerFrame");
    pSiteModeler->setAttribute(Qt::WA_DeleteOnClose);
 
    _pWorkspace->addSubWindow(pSiteModeler)->setObjectName("TYSiteModelerFrame");
 
    QObject::connect(pSiteModeler, &TYSiteModelerFrame::editorModeChanged, this,
                     &TYMainWindow::saveCurSiteMode);
    QObject::connect(pSiteModeler, &TYSiteModelerFrame::frameResized, this,
                     &TYMainWindow::refreshWindowTitle);
    QObject::connect(pSiteModeler, &QObject::destroyed, this, &TYMainWindow::onDestroyed);
 
    pSiteModeler->showMaximized();
    pSiteModeler->fit();
}
 
void TYMainWindow::connectActionManager(TYActionManager* pActionManager)
{
    QObject::disconnect(this, &TYMainWindow::onUndo, 0, 0);
    QObject::disconnect(this, &TYMainWindow::onRedo, 0, 0);
 
    if (pActionManager)
    {
        QObject::connect(this, &TYMainWindow::onUndo, pActionManager, &TYActionManager::undo);
        QObject::connect(this, &TYMainWindow::onRedo, pActionManager, &TYActionManager::redo);
 
        QObject::connect(pActionManager, &TYActionManager::undoRedoChanged, this,
                         &TYMainWindow::updateUndoRedo);
        pActionManager->emitUndoRedo();
    }
    else
    {
        connectDefaultActionManager();
    }
}
 
void TYMainWindow::connectDefaultActionManager()
{
    connectActionManager(getTYApp()->getActionManager());
}
 
void TYMainWindow::updateModelers(bool clipping /*=true*/, bool axesAndGrid /*=true*/,
                                  bool displayList /*=true*/)
{
    QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
    for (int i = 0; i < int(windows.count()); ++i)
    {
        QWidget* internal_window = windows.at(i)->widget();
 
        TYModelerFrame* pInW = dynamic_cast<TYModelerFrame*>(internal_window);
        if (pInW != nullptr)
        {
            pInW->updateView(clipping, axesAndGrid);
            if (displayList)
            {
                TYRenderWindowInteractor* pView = ((TYModelerFrame*)internal_window)->getView();
                TYOpenGLRenderer* pOpenGLRenderer = pView->getRenderer();
 
                TYModelerFrame* pModelerFrame = dynamic_cast<TYModelerFrame*>(internal_window);
                if (pModelerFrame != nullptr)
                {
                    // Update state of keep rays button
                    bool keepRays = false;
                    if (_pProjetFrame->getProjet() && _pProjetFrame->getProjet()->getCurrentCalcul())
                    {
                        keepRays = _pProjetFrame->getProjet()->getCurrentCalcul()->getKeepRays();
                    }
                    pModelerFrame->setKeepRays(keepRays);
                }
                TYSiteModelerFrame* pSiteModelerFrame = dynamic_cast<TYSiteModelerFrame*>(internal_window);
                if (pSiteModelerFrame != nullptr)
                {
                    // Enable or disable altimetry button
                    bool enableAltimetrieButton = false;
                    if (_pSiteFrame->getSiteNodeRoot() && _pSiteFrame->getSiteNodeRoot()->getAltimetry())
                    {
                        enableAltimetrieButton = _pSiteFrame->getSiteNodeRoot()->getAltimetry()->isUpToDate();
                    }
                    pSiteModelerFrame->enableAltimetrieButton(enableAltimetrieButton);
                    // If altimetry is not consistent with data then hide it
                    if (!enableAltimetrieButton)
                    {
                        pSiteModelerFrame->showAltimetrie(false);
                    }
                }
 
                pOpenGLRenderer->invalidateScene();
                ((TYModelerFrame*)internal_window)->updateView(clipping, axesAndGrid);
                pView->update();
            }
        }
    }
    if (_pCurrentModeler != nullptr)
    {
        _pCurrentModeler->setFocus();
    }
}
 
void TYMainWindow::updateModelersElementGraphic(bool force /* = false */)
{
    QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
    for (int i = 0; i < int(windows.count()); ++i)
    {
        QWidget* internal_window = windows.at(i)->widget();
 
        TYModelerFrame* pInW = dynamic_cast<TYModelerFrame*>(internal_window);
        if (pInW != nullptr)
        {
            pInW->updateElementGraphic(force);
        }
    }
}
 
void TYMainWindow::updateModelersAfterComputation(LPTYProjet& result)
{
    QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
    for (int i = 0; i < int(windows.count()); ++i)
    {
        QWidget* internal_window = windows.at(i)->widget();
 
        TYModelerFrame* pInW = dynamic_cast<TYModelerFrame*>(internal_window);
 
#ifdef _DEBUG
        // For Debug purpose
        QString windowTitle = internal_window->windowTitle();
#endif
 
        if (pInW != nullptr)
        {
            if (pInW->isActiveWindow())
            {
                _pCurrentModeler = pInW;
            }
            TYSiteModelerFrame* psiteframe = dynamic_cast<TYSiteModelerFrame*>(internal_window);
            if (psiteframe != nullptr)
            {
                psiteframe->getView()->getRenderer()->clearTabSelectedElement();
                psiteframe->setProjet(result);
                psiteframe->getView()->getRenderer()->invalidateScene();
                psiteframe->updateView();
                psiteframe->setMaillageRenderModeSlot();
            }
            else
            {
                TYBatimentModelerFrame* pbatimentframe =
                    dynamic_cast<TYBatimentModelerFrame*>(internal_window);
                if (pbatimentframe != nullptr)
                {
                    TYUUID uuid = pbatimentframe->getBatiment()->getID();
                    TYElement* newElement = TYElement::getInstance(uuid);
                    // When batiment modeler is empty, newElement is null
                    if (newElement != nullptr)
                    {
                        pbatimentframe->setBatiment((TYBatiment*)newElement);
                    }
                }
                TYMachineModelerFrame* pmachineframe = dynamic_cast<TYMachineModelerFrame*>(internal_window);
                if (pmachineframe != nullptr)
                {
                    TYUUID uuid = pmachineframe->getMachine()->getID();
                    TYElement* newElement = TYElement::getInstance(uuid);
                    // When machine modeler is empty, newElement is null
                    if (newElement != nullptr)
                    {
                        pmachineframe->setMachine((TYMachine*)newElement);
                    }
                }
            }
        }
    }
    if (_pCurrentModeler != nullptr)
    {
        _pCurrentModeler->setFocus();
    }
}
 
void TYMainWindow::closeModeler(const TYElement* pElement)
{
    QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
    for (int i = 0; i < int(windows.count()); ++i)
    {
        QWidget* internal_window = windows.at(i)->widget();
        QWidget* container_window = windows.at(i);
 
        if (dynamic_cast<TYModelerFrame*>(internal_window) != nullptr)
        {
            if (static_cast<TYModelerFrame*>(internal_window)->getElement() == pElement)
            {
                //              internal_window->close();
                container_window->close();
            }
        }
    }
}
 
void TYMainWindow::closeModelers()
{
    QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
    for (int i = 0; i < int(windows.count()); ++i)
    {
        QWidget* container_window = windows.at(i);
        container_window->close();
    }
}
 
void TYMainWindow::editCurCalcul()
{
    if (_pProjetFrame->getProjet() && _pProjetFrame->getProjet()->getCurrentCalcul())
    {
        _pProjetFrame->getProjet()->getCurrentCalcul()->edit(this);
    }
}
 
void TYMainWindow::goAltiCalcul()
{
    OMessageManager& logger = *OMessageManager::get();
    logger.debug("goAltiCalcul");
    if (!_pSiteFrame)
    {
        return;
    }
 
    LPTYSiteNode pRootSite = _pSiteFrame->getSiteNodeRoot();
    if (!pRootSite)
    {
        return;
    }
 
    getTYApp()->getCalculManager()->launchAltiComputation(pRootSite);
}
 
void TYMainWindow::goCurCalcul()
{
    getTYApp()->getCalculManager()->launchCurrent();
}
 
void TYMainWindow::windowsMenuAboutToShow()
{
    _pWindowsMenu->clear();
 
    QAction* cascadeId =
        _pWindowsMenu->addAction(TR("id_menuitem_cascade"), _pWorkspace, &QMdiArea::cascadeSubWindows);
    QAction* tileId =
        _pWindowsMenu->addAction(TR("id_menuitem_tile"), _pWorkspace, &QMdiArea::tileSubWindows);
 
    QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
    if (windows.isEmpty())
    {
        cascadeId->setEnabled(false);
        tileId->setEnabled(false);
    }
 
    _pWindowsMenu->addSeparator();
 
    QMenu* viewMenu = createPopupMenu();
    viewMenu->setTitle(TR("id_menuitem_views"));
    _pWindowsMenu->addMenu(viewMenu);
 
    _pWindowsMenu->addSeparator();
 
    for (int i = 0; i < int(windows.count()); ++i)
    {
        QWidget* internal_window = windows.at(i)->widget();
 
        if (!internal_window)
        {
            break;
        } // Securite
 
        QAction* id = _pWindowsMenu->addAction(internal_window->windowTitle(), this,
                                               &TYMainWindow::windowsMenuActivated);
        id->setData(i);
        id->setChecked(_pWorkspace->activeSubWindow() == windows.at(i));
    }
}
 
void TYMainWindow::windowsMenuActivated()
{
    QAction* action = (QAction*)sender();
    int id = action->data().toInt();
 
    QWidget* pWidget = _pWorkspace->subWindowList().at(id)->widget();
 
    if (pWidget)
    {
        pWidget->showNormal();
        pWidget->setFocus();
 
        if (QString(pWidget->metaObject()->className()).compare("TYSpectreManager") == 0)
        {
            _pHideOrShowSpectreMngrAction->setChecked(true);
        }
        else if (QString(pWidget->metaObject()->className()).compare("TYDataBaseFrame") == 0)
        {
            _pHideOrShowBiblioAction->setChecked(true);
        }
        else if (QString(pWidget->metaObject()->className()).compare("TYMaillageManager") == 0)
        {
            _pHideOrShowMaillageMngrAction->setChecked(true);
        }
    }
}
 
void TYMainWindow::setDefaultCameraMode()
{
    if (_pCurrentModeler != NULL)
    {
        _pCurrentModeler->setEditorModeToCamera();
    }
}
 
void TYMainWindow::subWindowActivated()
{
    _pCurrentModeler = nullptr;
    QWidget* pW = NULL;
    QMdiSubWindow* subWindow = _pWorkspace->activeSubWindow();
    if (_pWorkspace->subWindowList().count() > 0 && subWindow)
    {
        pW = subWindow->widget();
    }
 
    _pPrintAction->setEnabled(false);
 
    // Toolbars modeler
    _pToolbarCalcul->activeButtons(false);
    _pToolbarInfra->activeButtons(false);
    _pToolbarTopo->activeButtons(false);
    _pSiteBtnGroup->disconnect();
 
    _pToolbarMachine->activeButtons(false);
    _pMachineBtnGroup->disconnect();
 
    _pToolbarFace->activeButtons(false);
    _pFaceBtnGroup->disconnect();
 
    _pToolbarBatiment->activeButtons(false);
    _pBatimentBtnGroup->disconnect();
 
    _pToolbarModeler->activeButtons(false);
    _pBatimentBtnGroup->disconnect();
 
    // TODO Check this work around : it seems we were emptying the BtnGroups here,
    // which is a priori doubtful
    /*
    _pToolbarModeler->removeFromButtonGroup(_pSiteBtnGroup);
    _pToolbarModeler->removeFromButtonGroup(_pMachineBtnGroup);
    _pToolbarModeler->removeFromButtonGroup(_pFaceBtnGroup);
    _pToolbarModeler->removeFromButtonGroup(_pBatimentBtnGroup);
    */
 
    // Disambiguate the overloaded signals
    void (QButtonGroup::*qButtonGroup_clicked)(int) = &QButtonGroup::idClicked;
    void (TYFaceModelerFrame::*tyFaceModelerFrame_editorModeChanged)(int) =
        &TYFaceModelerFrame::editorModeChanged;
 
    connectDefaultActionManager(); // On commence par desactiver tous les boutons
 
    if (pW == NULL)
    {
        connectDefaultActionManager();
        return;
    }
 
    if (dynamic_cast<TYModelerFrame*>(pW) != nullptr)
    {
        TYModelerFrame* pModeler = (TYModelerFrame*)pW;
        _pCurrentModeler = pModeler;
 
        connectActionManager(pModeler->getActionManager());
 
        _pPrintAction->setEnabled(true);
 
        QObject::connect(pModeler, &TYModelerFrame::viewTypeChanged, _pToolbarModeler,
                         &TYModelerToolbar::viewTypeChanged);
 
        // On desactive toutes les toolbars...
        _pToolbarCalcul->activeButtons(false);
        _pToolbarInfra->activeButtons(false);
        _pToolbarTopo->activeButtons(false);
        _pToolbarMachine->activeButtons(false);
        _pToolbarBatiment->activeButtons(false);
        _pToolbarFace->activeButtons(false);
        // ...Puis on active celles qui nous sont utiles
 
        if (QString(pW->metaObject()->className()).compare("TYSiteModelerFrame") == 0)
        {
            TYSiteModelerFrame* pS = (TYSiteModelerFrame*)pW;
 
            QObject::connect(_pSiteBtnGroup, qButtonGroup_clicked, this, &TYMainWindow::saveCurSiteMode);
            QObject::connect(_pSiteBtnGroup, qButtonGroup_clicked, pS, &TYSiteModelerFrame::setEditorMode);
 
            // On fait en sorte de n'activer la toolbar de calcul que pour le modeler pointant
            // sur le site racine ou le projet
            bool bActiveCalculToolBar = false;
 
            // On recupere le site node represente
            if (pS->getElement()->isA("TYProjet"))
            {
                bActiveCalculToolBar = true;
            }
            else
            {
                if (TYSiteNode::safeDownCast(pS->getElement())->getRoot())
                {
                    bActiveCalculToolBar = true;
                }
            }
 
            // Si le calcul est bloque, on ne peut modifier le  projet // DTn 20110915 : Meme comportement
            // dans tous les cas
            if (_pProjetFrame->getProjet() && _pProjetFrame->getProjet()->getCurrentCalcul() &&
                (_pProjetFrame->getProjet()->getCurrentCalcul()->getState() == TYCalcul::Locked))
            {
                _pToolbarCalcul->activeButtons(bActiveCalculToolBar);
                _pToolbarInfra->activeButtons(true);
                _pToolbarTopo->activeButtons(true);
                _pToolbarModeler->activeButtons(true);
            }
            else
            {
                _pToolbarCalcul->activeButtons(bActiveCalculToolBar);
                _pToolbarInfra->activeButtons(true);
                _pToolbarTopo->activeButtons(true);
                _pToolbarModeler->activeButtons(true);
            }
 
            _pToolbarModeler->addToButtonGroup(_pSiteBtnGroup);
 
            pS->setEditorMode(_curSiteMode);
        }
        else if (QString(pW->metaObject()->className()).compare("TYMachineModelerFrame") == 0)
        {
            TYMachineModelerFrame* pM = (TYMachineModelerFrame*)pW;
 
            QObject::connect(_pMachineBtnGroup, qButtonGroup_clicked, this,
                             &TYMainWindow::saveCurMachineMode);
            QObject::connect(_pMachineBtnGroup, qButtonGroup_clicked, pM,
                             &TYMachineModelerFrame::setEditorMode);
 
            // Si le calcul est bloque, on ne peut modifier le  projet
            if (_pProjetFrame->getProjet() && (_pProjetFrame->getProjet()->getCurrentCalcul()->getState() ==
                                               TYCalcul::Locked)) // DTn : Neutralisation : 20110915
            {
                _pToolbarMachine->activeButtons(true);
                _pToolbarModeler->activeButtons(true);
            }
            else
            {
                _pToolbarMachine->activeButtons(true);
                _pToolbarModeler->activeButtons(true);
            }
 
            _pToolbarModeler->addToButtonGroup(_pMachineBtnGroup);
 
            pM->setEditorMode(_curMachineMode);
        }
        else if (QString(pW->metaObject()->className()).compare("TYBatimentModelerFrame") == 0)
        {
            TYBatimentModelerFrame* pB = (TYBatimentModelerFrame*)pW;
 
            QObject::connect(_pBatimentBtnGroup, qButtonGroup_clicked, this,
                             &TYMainWindow::saveCurBatimentMode);
            QObject::connect(_pBatimentBtnGroup, qButtonGroup_clicked, pB,
                             &TYBatimentModelerFrame::setEditorMode);
 
            if (_pProjetFrame->getProjet() && (_pProjetFrame->getProjet()->getCurrentCalcul()->getState() ==
                                               TYCalcul::Locked)) // DTn : Neutralisation : 20110915
            {
                _pToolbarModeler->activeModif(false);
                _pToolbarBatiment->activeButtons(false);
            }
            else
            {
                _pToolbarModeler->activeButtons(true);
                _pToolbarBatiment->activeButtons(true);
            }
 
            _pToolbarModeler->addToButtonGroup(_pBatimentBtnGroup);
 
            pB->setEditorMode(_curBatimentMode);
        }
        else if (QString(pW->metaObject()->className()).compare("TYFaceModelerFrame") == 0)
        {
            TYFaceModelerFrame* pF = (TYFaceModelerFrame*)pW;
 
            QObject::disconnect(pF, tyFaceModelerFrame_editorModeChanged, this,
                                &TYMainWindow::saveCurFaceMode);
            QObject::connect(pF, tyFaceModelerFrame_editorModeChanged, this, &TYMainWindow::saveCurFaceMode);
 
            QObject::connect(_pFaceBtnGroup, qButtonGroup_clicked, this, &TYMainWindow::saveCurFaceMode);
            QObject::connect(_pFaceBtnGroup, qButtonGroup_clicked, pF, &TYFaceModelerFrame::setEditorMode);
 
            if (_pProjetFrame->getProjet() && (_pProjetFrame->getProjet()->getCurrentCalcul()->getState() ==
                                               TYCalcul::Locked)) // DTn : Neutralisation : 20110915
            {
                _pToolbarModeler->activeModif(false);
                _pToolbarFace->activeButtons(false);
            }
            else
            {
                _pToolbarModeler->activeButtons(true);
                _pToolbarFace->activeButtons(true);
            }
 
            _pToolbarModeler->addToButtonGroup(_pFaceBtnGroup);
 
            pF->setEditorMode(_curFaceMode);
        }
 
        _pToolbarModeler->activeCameraButtons(pModeler->getCurrentView());
 
        pModeler->getView()->getRenderer()->invalidateScene();
    }
    else
    {
        connectDefaultActionManager();
        _pCurrentModeler = NULL;
    }
}
 
void TYMainWindow::saveCurSiteMode(int mode)
{
    _curSiteMode = mode;
    assert(_pSiteBtnGroup->button(mode)); // XXX This is a bug point : mode does not match a button.
    _pSiteBtnGroup->button(mode)->setChecked(true);
}
 
void TYMainWindow::saveCurMachineMode(int mode)
{
    _curMachineMode = mode;
    assert(_pMachineBtnGroup->button(mode));
    _pMachineBtnGroup->button(mode)->setChecked(true);
}
 
void TYMainWindow::saveCurBatimentMode(int mode)
{
    _curBatimentMode = mode;
    assert(_pBatimentBtnGroup->button(mode)); // XXX This is a bug point : mode does not match a button.
    _pBatimentBtnGroup->button(mode)->setChecked(true);
}
 
void TYMainWindow::saveCurFaceMode(int mode)
{
    _curFaceMode = mode;
    assert(_pFaceBtnGroup->button(mode));
    _pFaceBtnGroup->button(mode)->setChecked(true);
}
 
void TYMainWindow::updateUndoRedo(bool undoAvailable, bool redoAvailable, const QString& undoCmd,
                                  const QString& redoCmd)
{
    _pUndoAction->setEnabled(undoAvailable);
    _pRedoAction->setEnabled(redoAvailable);
 
    if (!undoCmd.isEmpty())
    {
        _pUndoAction->setText(TR("id_menuitem_undo_name").arg(undoCmd));
    }
    else
    {
        _pUndoAction->setText(TR("id_menuitem_undo_na"));
    }
 
    if (!redoCmd.isEmpty())
    {
        _pRedoAction->setText(TR("id_menuitem_redo_name").arg(redoCmd));
    }
    else
    {
        _pRedoAction->setText(TR("id_menuitem_redo_na"));
    }
 
    _pUndoAction->setToolTip(_pUndoAction->text());
    _pRedoAction->setToolTip(_pRedoAction->text());
}
 
void TYMainWindow::onCourbeNiveauCreated(LPTYCourbeNiveau courbeNiveau)
{
    LPTYSiteNode mainSite = this->getProjetFrame()->getProjet()->getSite();
    mainSite->getTopographie()->addCrbNiv(courbeNiveau);
    TYProjet* pProjet = getTYApp()->getCurProjet();
    if (pProjet)
    {
        LPTYCalcul pCalcul = getTYApp()->getCurProjet()->getCurrentCalcul();
        if (pCalcul)
        {
            pCalcul->addToSelection(courbeNiveau);
        }
    }
}
 
void TYMainWindow::setCurProjet(LPTYProjet pProjet)
{
    _pProjetFrame->setProjet(pProjet);
 
    // if (pProjet) {
    //  getTYApp()->setCurSiteNode(pProjet->getSite());
    //} else {
    //  getTYApp()->setCurSiteNode(NULL);
    //}
 
    _pCloseAction->setEnabled(pProjet ? true : false);
    //  updateCurCalcul();
}
 
void TYMainWindow::setCurSiteNode(LPTYSiteNode pSiteNode)
{
    _pSiteFrame->setSiteNodeRoot(pSiteNode);
    _pCloseAction->setEnabled(pSiteNode ? true : false);
}
 
void TYMainWindow::updateCurCalcul()
{
    if (_pProjetFrame->getProjet() && _pProjetFrame->getProjet()->getCurrentCalcul())
    {
        if (!_pProjetFrame->getProjet()->getStatusSolver()) // Le solveur du calcul n'est pas disponible
        {
            if (QMessageBox::warning(this, "Tympan", TR("id_msg_solver_out"), QMessageBox::Yes,
                                     QMessageBox::No) == QMessageBox::Yes)
            {
                // L'utilisateur accepte d'utiliser le solveur par defaut
                _pProjetFrame->getProjet()->getCurrentCalcul()->setSolverId(
                    OGenID(QString(DEFAULT_SOLVER_UUID)));
                _pProjetFrame->getProjet()->getCurrentCalcul()->setState(TYCalcul::Actif);
                _pProjetFrame->getProjet()->setStatusSolver(true); // On est ok sur le solveur
            }
            else
            {
                // Le calcul est bloque. Si l'utilisateur le debloque, lancer le calcul appelera le solveur
                // courant
                _pProjetFrame->getProjet()->getCurrentCalcul()->setState(TYCalcul::Locked);
            }
        }
    }
 
    _pGoCurCalculAction->setEnabled(true);
    _pGoAltiAction->setEnabled(true);
    _pEditCurCalculAction->setEnabled(true);
}
 
void TYMainWindow::createNew()
{
    close(); // Fermeture de l'lement precedemment actif
    TYCreateElementDialog* pDlg = new TYCreateElementDialog(this);
    pDlg->exec();
    TYElement::setIsSavedOk(true);
}
 
void TYMainWindow::createNewProjet()
{
    close(); // Fermeture de l'élément précédemment actif
    TYCreateElementDialog* pDlg = new TYCreateElementDialog(this);
    pDlg->createElement("TYProjet");
    TYElement::setIsSavedOk(true);
 
    // Save project
    bool ret = saveAs();
    if (!ret)
    {
        qInfo() << "Impossible to save project file to " << getTYApp()->getCurrentFileName();
        TYElement::setIsSavedOk(false);
        close();
        return;
    }
 
    // CLM-NT33 - Ouverture automatique du modeler projet
    // DTn 20111003 Plus la peine : ouverture assuree par le openElementDialog appele par le
    // createElementDialog
    //  makeProjetModeler(_pProjetFrame->getProjet());
}
 
void TYMainWindow::showZoneSelectPage()
{
    close(); // Fermeture de l'lement precedemment actif
 
    // Initialize geo provider engine if necessary
    if (!TYIGNGeoProvider::getInstance()->isInitialised())
    {
        TYIGNGeoProvider::getInstance()->initEngine();
    }
 
    // If TYMPAN_MOCK_IGN option is activated
#if MOCK_IGN
    bool hasMockSucceeded;
    hasMockSucceeded = TYIGNGeoProvider::getInstance()->mockGeoPf();
    if (!hasMockSucceeded)
    {
        qCritical()
            << "Mocking IGN Geoplatform resources has failed. Please check mock resources availability.";
    }
 
#else
    // Call the function to open the modal window
    TYIGNGeoProvider::getInstance()->openModalWindow(this);
#endif
}
 
void TYMainWindow::createNewGeoProjet()
{
    OMessageManager::get()->debug(QString("TYMainWindow::createNewGeoProjet"));
    TYCreateElementDialog* pDlg = new TYCreateElementDialog(this);
    pDlg->createElement("TYProjet");
    LPTYSiteNode mainSite = this->getProjetFrame()->getProjet()->getSite();
 
    // Save project
    bool ret = saveAs();
    if (!ret)
    {
        qInfo() << "Impossible to save project file to " << getTYApp()->getCurrentFileName();
        TYElement::setIsSavedOk(false);
        close();
        return;
    }
 
    QFileInfo fileInfo(getTYApp()->getCurrentFileName());
    QString imageFilePath =
        fileInfo.path().replace("\\", "/") + "/" + fileInfo.completeBaseName() + "." + "png";
    bool retImageSave = TYIGNGeoProvider::getInstance()->saveImageToFile(imageFilePath);
    if (!retImageSave)
    {
        qInfo() << "Impossible to save image file to " << imageFilePath;
        TYElement::setIsSavedOk(false);
        close();
        return;
    }
 
    mainSite->setUseTopoFile(true);
#if MOCK_IGN
    imageFilePath = "C:/projects/tympan/issues/530 - Mock IGN/image.png";
    mainSite->setTopoFileName(imageFilePath);
    TYIGNGeoProvider::getInstance()->closeModalWindow();
#else
    mainSite->setTopoFileName(imageFilePath);
#endif
 
    // Set current working directory of the application to folder containing background image to ensure
    // correct loading of topographic file.
    QString dirName = QFileInfo(imageFilePath).absolutePath();
    QDir::setCurrent(dirName);
 
    // Build level curves from geo provider
    std::shared_ptr<TYIGNLevelCurvesParser> parser = TYIGNGeoProvider::getInstance()->_parser;
    // Build coordinate system to build level curves
 
    QString coord = TYIGNGeoProvider::getInstance()->getLandtakeCoord().trimmed();
    if (coord.isEmpty())
    {
        qDebug() << "Error getting selected zone coords, aborting project creation";
        TYElement::setIsSavedOk(false);
        close();
        return;
    }
    QStringList listCoords = coord.split(",");
    const int len = listCoords.size();
    if (len != 4)
    {
        qDebug() << "The zone must be a box, aborting project creation";
        TYElement::setIsSavedOk(false);
        close();
        return;
    }
 
    std::vector<double> coordsDouble = TYIGNGeoProvider::getInstance()->coordinatesToDouble(coord);
    OBox selectedZone{coordsDouble[0], coordsDouble[1], 0.0, coordsDouble[2], coordsDouble[3], 0.0};
    OCoord3D SIGCoords{(selectedZone._min._x + selectedZone._max._x) * 0.5,
                       (selectedZone._min._y + selectedZone._max._y) * 0.5, 0.0};
    // Temporary scale set
    QString imageWidthString = TYIGNGeoProvider::getInstance()->getImageWidth();
    double imageWidth = imageWidthString.toDouble();
    QString scaleFactorString = TYIGNGeoProvider::getInstance()->getScaleFactor();
    qInfo() << "scaleFactorString : " << scaleFactorString;
    double scaleFactor = scaleFactorString.toDouble();
    qInfo() << "scaleFactor : " << scaleFactor;
    mainSite->setEchelle(abs(coordsDouble[2] - coordsDouble[0]) * scaleFactor / imageWidth);
    connect(parser.get(), &TYIGNLevelCurvesParser::courbeNiveauCreated, this,
            &TYMainWindow::onCourbeNiveauCreated);
    TYIGNGeoProvider::getInstance()->buildLevelCurves(SIGCoords, selectedZone, scaleFactor);
 
    // Landtake creation
    std::vector<TYPoint> coords(4);
    double demiX = abs(coordsDouble[2] - coordsDouble[0]) * scaleFactor / 2;
    double demiY = abs(coordsDouble[3] - coordsDouble[1]) * scaleFactor / 2;
    coords[0] = TYPoint(demiX, demiY, 0, false);
    coords[1] = TYPoint(demiX, -demiY, 0, false);
    coords[2] = TYPoint(-demiX, -demiY, 0, false);
    coords[3] = TYPoint(-demiX, demiY, 0, false);
    mainSite->setEmprise(coords);
    mainSite->setUseEmpriseAsCrbNiv(false);
 
    mainSite->loadTopoFile();
 
    TYElement::setIsSavedOk(true);
 
    ret = save();
    if (!ret)
    {
        qInfo() << "Impossible to save project file to " << getTYApp()->getCurrentFileName();
        TYElement::setIsSavedOk(false);
        close();
        return;
    }
 
    // Update
    getSiteFrame()->updateList();
    updateModelers(false, false);
}
 
void TYMainWindow::createNewSite()
{
    close(); // Fermeture de l'lement precedemment actif
    TYCreateElementDialog* pDlg = new TYCreateElementDialog(this);
    pDlg->createElement("TYSiteNode");
    TYElement::setIsSavedOk(true);
}
 
void TYMainWindow::createNewBatiment()
{
    close(); // Fermeture de l'lement precedemment actif
    TYCreateElementDialog* pDlg = new TYCreateElementDialog(this);
    pDlg->createElement("TYBatiment");
    TYElement::setIsSavedOk(true);
}
 
void TYMainWindow::createNewMachine()
{
    close(); // Fermeture de l'lement precedemment actif
    TYCreateElementDialog* pDlg = new TYCreateElementDialog(this);
    pDlg->createElement("TYMachine");
    TYElement::setIsSavedOk(true);
}
 
void TYMainWindow::open()
{
    close();            // Ferme l'element en cours en demandant la sauvegarde si necessaire
    if (!_closeAndQuit) // L'utilisateur ne souhaite pas fermer son projet
    {
        _closeAndQuit = true;
        return;
    }
 
    TYOpenElementDialog* pDlg = new TYOpenElementDialog(this);
    pDlg->setMultiSelect(false); // Un seul element peut etre selectionne
    pDlg->setDirName(getTYApp()->getCurrentDirName());
    pDlg->open();
 
    if (pDlg->result() == QDialog::Accepted) // si le choix du fichier XML est OK
    {
        // CLM-NT33 - Choix automatique
        if (pDlg->getAvailableElements().size() == 1)
        {
            pDlg->openElement(pDlg->getAvailableElements()[0]);
        }
        else
        {
            pDlg->exec();
        }
 
        TYApplication::setOverrideCursor(Qt::WaitCursor);
 
        QString strExtend = "";
        if (pDlg->isFileReadOnly())
        {
            strExtend = TR("id_status_file_ro");
            _pSaveAction->setEnabled(false); // Desactivation de la fnction de sauvegarde
        }
 
        QString fileName = pDlg->getFileName(); // Nom du fichier lu
        setWindowTitle(TR("id_caption") + "-" + TY_CURRENT_RELEASE_ + " (" + TY_PRODUCT_PLATFORM_ +
                       ") : " + fileName + ' ' + strExtend);
 
        TYApplication::setCurrentFileName(fileName);
        getTYApp()->setCurrentDirName(pDlg->getDirName());
 
        TYElement::setIsSavedOk(false); // Tous les elements sont up to date apres le chargement
 
        TYApplication::restoreOverrideCursor();
    }
}
 
void TYMainWindow::open(std::vector<LPTYElement>& tabElem, const bool& bRegenerate /*=false*/)
{
    TYElement::setRegenerateID(bRegenerate);
 
    TYOpenElementDialog* pDlg = new TYOpenElementDialog(this);
    pDlg->setMultiSelect(true); // Plusieurs elements peuvent etre selectionnes
    pDlg->setDirName(getTYApp()->getCurrentDirName());
    pDlg->open();
 
    if (pDlg->result() == QDialog::Accepted)
    {
        if (pDlg->getAvailableElements().size() == 1)
        {
            tabElem.push_back(pDlg->getAvailableElements()[0]);
        }
        else
        {
            pDlg->exec();
            tabElem = pDlg->getTabElem();
        }
    }
 
    TYElement::setRegenerateID(false);
}
 
void TYMainWindow::close()
{
    if (TYElement::getIsSavedOk() == true) // Si un element a ete modifie, il faut sauvegarder
    {
        auto ret = QMessageBox::warning(this, "Attention", TR("id_file_not_saved"),
                                        QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel,
                                        QMessageBox::Cancel);
        switch (ret)
        {
            case QMessageBox::Yes:
                if (_pSaveAction->isEnabled())
                {
                    _closeAndQuit = save();
                }
                else
                {
                    _closeAndQuit = saveAs();
                }
 
                break;
 
            case QMessageBox::No:
                _closeAndQuit = true;
                break;
 
            case QMessageBox::Cancel:
                _closeAndQuit = false;
                break;
        }
    }
 
    if (_closeAndQuit)
    {
        // Fermeture de toutes les fenetres
        QList<QMdiSubWindow*> windows = _pWorkspace->subWindowList();
 
        for (int i = 0; i < int(windows.count()); ++i)
        {
            windows.at(i)->close();
        }
 
        // On reinitialise le projet et le site courant
        getTYApp()->setCurProjet(NULL);
        getTYApp()->setCurSiteNode(NULL);
        // Par securite, on inhibe le calcul courant connu du calculManager (pourrait expliquer des plantages
        // ...)
        getTYApp()->getCalculManager()->setCurrent(NULL);
 
        // On efface le nom de fichier en cours
        QString fileName = "";
        updateCurrentFileName(fileName);
 
        _pSaveAction->setEnabled(true); // Plus de fichier ouvert, remise en etat de save
 
        // plus rien en memoire (theoriquement) donc rien a sauvegarder
        TYElement::setIsSavedOk(false);
    }
}
 
void TYMainWindow::quitte()
{
    _closeAndQuit = true; // A priori
 
    // Ferme le projet courant et demande si necessaire la sauvegarde du fichier.
    close();
 
    // Ferme l'application
    if (_closeAndQuit)
    {
        // Sauvegarde la geometrie des fenetres dans les preferences
        saveGeometryToPreferences();
        // Sauvegarde des settings
        saveSettings(QDir::toNativeSeparators(getTYApp()->getSettingsDir() + "/Settings"));
        // Fermeture de toutes les fenetres
        closeModelers();
        // Quitte l'application
        getTYApp()->quit();
    }
}
 
TYElement* TYMainWindow::elementToSave()
{
    TYElement* pElement = NULL;
 
    if (_pProjetFrame->getProjet()) // Si on est dans un projet, on le sauve (avec son site)
    {
        pElement = (TYElement*)_pProjetFrame->getProjet();
    }
    else if (_pSiteFrame->getSiteNodeRoot()) // On sauve que le site si pas de projet mais un site
    {
        pElement = (TYElement*)_pSiteFrame->getSiteNodeRoot();
    }
    else // Sinon  on sauve ce qu'on peut, l'element actif
    {
        QWidget* pW = this->focusWidget();
        if (pW && (dynamic_cast<TYModelerFrame*>(pW) != nullptr))
        {
            pElement = ((TYModelerFrame*)pW)->getElement();
 
            if (pElement && (dynamic_cast<TYAcousticVolume*>(pElement) != nullptr))
            {
                return pElement;
            }
 
            // Recherche d'un parent de type "acousticVolume"
            TYElement* pParent = pElement->getParent();
            while (pParent && (dynamic_cast<TYAcousticVolumeNode*>(pParent) == nullptr))
            {
                pParent = pParent->getParent();
            };
 
            if (pParent && (dynamic_cast<TYAcousticVolumeNode*>(pParent) != nullptr))
            {
                return pParent;
            }
        }
    }
 
    return pElement;
}
 
bool TYMainWindow::save()
{
    bool bRet = false;
 
    TYElement* pElement = elementToSave();
 
    if (!pElement)
    {
        QMessageBox::warning(this, "Tympan", TR("id_nothingtoexport"));
        return false;
    }
 
    QString dirName;
    QString fileName = getFileName("XML (*.xml)", dirName); // Recuperation du nom du fichier courant
 
    bRet = save(dirName, fileName, pElement, true);
 
    if (bRet)
    {
        QMessageBox::information(this, "Tympan", TR("id_export_ok").arg(fileName));
        updateCurrentAppFile(dirName, fileName);
 
        // Indique que les TYElement sont ok (rien a sauvegarder)
        TYElement::setIsSavedOk(false);
    }
    else
    {
        QMessageBox::critical(this, "Tympan", TR("id_export_failed").arg(fileName));
    }
 
    return bRet;
}
 
bool TYMainWindow::save(QString dirName, QString& fileName, TYElement* pElement,
                        const bool& saveBackup /*= false*/)
{
    // Controle des parametres
    if (!pElement || fileName.isEmpty())
    {
        return false;
    }
    if (dirName.isEmpty())
    {
        dirName = getTYApp()->getCurrentDirName();
    }
 
    formatFileName(fileName); // Ajoute l'extension si necessaire
 
    // Creation du fichier XML
    TYXMLManager xmlManager;
 
    QString version(TY_CURRENT_RELEASE_);
    QString tiret(" - ");
    QString licencie(TY_CUSTOMER_);
    QString licenceNumber(TY_LICENCE_NUMBER_);
 
    QString messageVersion = version + tiret + licencie + tiret + licenceNumber;
    TYXMLManager::setSavedFileName(fileName);
 
    xmlManager.createDoc(TY_PRODUCT_XMLTAG_, messageVersion); // TY_PRODUCT_VERSION_);
    xmlManager.addElement(pElement);
 
    bool saveSucceeded = xmlManager.save(fileName) == 0;
 
    if (!saveSucceeded)
    {
        return false;
    }
 
    if (saveBackup)
    {
        bool saveBakSucceeded = backupFile(fileName);
        if (!saveBakSucceeded)
        {
            return false;
        }
    }
 
    return true;
}
 
bool TYMainWindow::saveAs()
{
    bool bRet = false;
 
    TYElement* pElement = elementToSave();
 
    if (!pElement)
    {
        QMessageBox::warning(this, "Tympan", TR("id_nothingtoexport"));
        return false;
    }
 
    QString dirName;
    QString fileName = getFileName("XML (*.xml)", dirName, true);
 
    if (testFile(fileName))
    {
        bRet = save(dirName, fileName, pElement, true);
 
        if (bRet)
        {
            QMessageBox::information(this, "Tympan", TR("id_export_ok").arg(fileName));
            updateCurrentAppFile(dirName, fileName);
 
            // Indique que les TYElement sont ok (rien a sauvegarder)
            TYElement::setIsSavedOk(false);
        }
        else
        {
            QMessageBox::critical(this, "Tympan", TR("id_export_failed").arg(fileName));
        }
    }
 
    return bRet;
}
 
bool TYMainWindow::saveAsNoResult()
{
    bool bRet = false;
 
    TYProjet* pProjet = getTYApp()->getCurProjet();
 
    if (!pProjet)
    {
        QMessageBox::warning(this, "Tympan", TR("id_nothingtoexport"));
        return false;
    }
 
    QString dirName;
    QString fileName = getFileName("XML (*.xml)", dirName, true);
 
    TYProjet::gSaveValues = false;
    if (testFile(fileName))
    {
        bRet = save(dirName, fileName, pProjet, true);
 
        if (bRet)
        {
            QMessageBox::information(this, "Tympan", TR("id_export_ok").arg(fileName));
        }
        else
        {
            QMessageBox::critical(this, "Tympan", TR("id_export_failed").arg(fileName));
        }
    }
 
    TYProjet::gSaveValues = true;
 
    return bRet;
}
 
bool TYMainWindow::saveAs(LPTYElement pElement)
{
    bool bRet = false;
 
    if (pElement == NULL)
    {
        return bRet;
    }
 
    QString dirName;
    QString fileName = getFileName("XML (*.xml)", dirName, true);
 
    if (testFile(fileName))
    {
        bRet = save(dirName, fileName, pElement);
 
        if (bRet)
        {
            QMessageBox::information(this, "Tympan", TR("id_export_ok").arg(fileName));
        }
        else
        {
            QMessageBox::critical(this, "Tympan", TR("id_export_failed").arg(fileName));
        }
    }
 
    return bRet;
}
 
void TYMainWindow::updateCurrentAppFile(const QString& dirName, const QString& fileName)
{
    getTYApp()->setCurrentDirName(dirName);
    getTYApp()->setCurrentFileName(fileName);
 
    setWindowTitle(TR("id_caption") + "-" + TY_CURRENT_RELEASE_ + " (" + TY_PRODUCT_PLATFORM_ +
                   ") : " + fileName);
}
 
bool TYMainWindow::backupFile(const QString& fileName)
{
    // Creation du nom du fichier
    QFileInfo fi(fileName);
 
    QString bakBasename = fi.absolutePath() + '/' + fi.completeBaseName() + ".bak";
    QDateTime now = QDateTime::currentDateTime();
    QString nowAsStr = now.toString("yyyy-MM-dd_hh-mm-ss");
    QString nomFichier = bakBasename + "_" + nowAsStr;
 
    // Ouverture du fichier d'origine
    QFile fileToSave(fileName);
    bool bOpen = fileToSave.open(QIODevice::ReadOnly);
 
    if (!bOpen)
    {
        return false;
    }
 
    // Ouverture du fichier backup
    QFile backupFile(nomFichier);
    bOpen = backupFile.open(QIODevice::WriteOnly);
 
    if (!bOpen)
    {
        fileToSave.close();
        return false;
    }
 
    // Copie en bloc de l'un dans l'autre
    backupFile.write(fileToSave.readAll());
 
    // Fermeture des fichier
    fileToSave.close();
    backupFile.close();
 
    const int nbBackupsToKeep = 3;
    bool cleanUpOk = keepOnlyMostRecentBackups(bakBasename, nbBackupsToKeep);
    if (!cleanUpOk)
    {
        return false;
    }
 
    return true;
}
 
void TYMainWindow::showPluginManager()
{
    TYPluginDialog* pDlg = new TYPluginDialog(this);
    pDlg->exec();
 
    // Mise a jour du solveur pour le calcul courant si calcul pas bloque
    if (_pProjetFrame->getProjet())
        if (_pProjetFrame->getProjet()->getCurrentCalcul())
            if (_pProjetFrame->getProjet()->getCurrentCalcul()->getState() == TYCalcul::Actif)
            {
                _pProjetFrame->getProjet()->getCurrentCalcul()->setSolverId(pDlg->current_solver);
            }
}
 
bool TYMainWindow::testFile(const QString& fileName)
{
    // Verification de l'etat du fichier
    QFileInfo fi(fileName);
    // Si le fichier existe , on demande confirmation a l'utilisateur
    if (fi.exists())
    {
        // On ecrase le fichier, puis on sauve
        QFile* file = new QFile(fileName);
        switch (
            QMessageBox::warning(this, "Attention", TR("id_file_exist"), QMessageBox::Yes, QMessageBox::No))
        {
            case QMessageBox::Yes:
                if (!file->remove())
                {
                    QMessageBox::warning(this, "Attention", TR("id_file_cannot_be_clear"));
                    return false;
                }
 
                break;
            case QMessageBox::No:
                return false; // On sort sans sauvegarder
                break;
        }
 
        delete file;
        file = NULL;
    }
 
    return true;
}
 
QString TYMainWindow::getFileName(const QString& filter, QString& dirName,
                                  const bool& forceNewName /*=false*/)
{
    QString fileName = getTYApp()->getCurrentFileName(); // Recuperation du nom du fichier courant
    // NOUVELLE VERSION POUR RECUPERER LE REPERTOIRE
    dirName = getTYApp()->getCurrentDirName();
 
    if (!forceNewName && !fileName.isEmpty())
    {
        return fileName;
    }
 
    // Recuperation de la terminaison de fichier a creer
    short index = filter.indexOf(".");
    QString end = filter.mid(index, 4);
 
    QFileDialog* pDialog = new QFileDialog(parentWidget(), "Choose a file", dirName, filter);
    pDialog->setFileMode(QFileDialog::AnyFile);
    pDialog->setAcceptMode(QFileDialog::AcceptSave);
    pDialog->setWindowModality(Qt::WindowModal); // Set window modality
    pDialog->exec();
 
    QStringList list = pDialog->selectedFiles();
    if ((pDialog->result() == QDialog::Accepted) && (!list.isEmpty()))
    {
        fileName = list.first();
 
        QDir dir = pDialog->directory();
        dirName = dir.absolutePath();
 
        pDialog = NULL;
 
        if (!fileName.endsWith(end))
        {
            fileName += end;
        }
    }
    else
    {
        fileName = "";
    }
 
    return fileName;
}
 
bool TYMainWindow::keepOnlyMostRecentBackups(const QString& bakBasename, const int& nbToKeep) const
{
    const QFileInfo fiBakBasename(bakBasename);
 
    QDir workingDir(fiBakBasename.absolutePath());
 
    workingDir.setNameFilters(QStringList(fiBakBasename.fileName() + "*"));
    workingDir.setFilter(QDir::Files);
    workingDir.setSorting(QDir::Name);
    const QFileInfoList fiBakList = workingDir.entryInfoList();
 
    const int nbBakFiles = fiBakList.size();
    if (nbBakFiles > nbToKeep)
    {
        const int nbBakToRemove = nbBakFiles - nbToKeep;
        const QFileInfoList fiBakToRemoveList = fiBakList.sliced(0, nbBakToRemove);
        for (const QFileInfo& fiBakToRemove : fiBakToRemoveList)
        {
            const bool removeSucceeded = workingDir.remove(fiBakToRemove.fileName());
            if (!removeSucceeded)
            {
                return false;
            }
        }
    }
 
    return true;
}
 
void TYMainWindow::print()
{
    QWidget* pW = this->focusWidget();
 
    if (pW && (dynamic_cast<TYModelerFrame*>(pW) != nullptr))
    {
        ((TYModelerFrame*)pW)->print();
    }
}
 
void TYMainWindow::undo()
{
    emit onUndo();
}
 
void TYMainWindow::redo()
{
    emit onRedo();
}
 
void TYMainWindow::cut()
{
    about();
}
 
void TYMainWindow::copy()
{
    about();
}
 
void TYMainWindow::paste()
{
    about();
}
 
void TYMainWindow::showSpectreManager(bool show) {}
 
void TYMainWindow::showMaillageManager(bool show) {}
 
void TYMainWindow::showBiblio(bool show) {}
 
void TYMainWindow::showPreferenceDialog()
{
    TYPreferenceDialog* pDlg = new TYPreferenceDialog(this);
    pDlg->exec();
}
 
void TYMainWindow::showOutput(bool show)
{
    _pOutputDockWnd->setVisible(show);
}
 
void TYMainWindow::updateHideOrShowOutputAction(bool visibilityChanged)
{
    _pHideOrShowOutputAction->setChecked(_pOutputDockWnd->isVisible());
}
 
void TYMainWindow::launchImporter()
{
    QProcess* pImporterLauncher = new QProcess(this);
 
    // On travail dans le repertoire utilisateur
    pImporterLauncher->setWorkingDirectory(TYApplication::tympanUserDir());
 
    // Le nom de l'executable
    // pImporterLauncher->addArgument("Importer");
 
    // Lancement
    pImporterLauncher->start("Importer", QStringList(""));
 
    if (pImporterLauncher->state() == QProcess::Running)
    {
        writeOutputMsg(TR("id_msg_importer_ok"));
    }
    else
    {
        writeOutputMsg(TR("id_msg_importer_fail"));
    }
}
 
void TYMainWindow::closeEvent(QCloseEvent* pEvent)
{
    // Evite les boucles de fermeture si quit() redéclenche des closeEvent
    if (_handlingCloseEvent)
    {
        pEvent->accept();
        return;
    }
    _handlingCloseEvent = true;
 
    // Même intention que menu Quitter : on décide nous-même si on quitte ou non
    _closeAndQuit = true;
 
    // Ferme le projet courant (avec demande de sauvegarde si nécessaire)
    close();
 
    if (_closeAndQuit)
    {
        // Comportement identique à la méthode quitte()
        saveGeometryToPreferences();
        saveSettings(QDir::toNativeSeparators(getTYApp()->getSettingsDir() + "/Settings"));
        closeModelers();
 
        pEvent->accept();
        getTYApp()->quit();
    }
    else
    {
        pEvent->ignore();
    }
 
    _handlingCloseEvent = false;
}
 
void TYMainWindow::updateCurrentFileName(const QString& fileName)
{
    // Informe l'application du nom du fichier courant
    TYApplication::setCurrentFileName(fileName);
 
    // Change le titre de la fenetre pour afficher le nom du fichier
    setWindowTitle(TR("id_caption") + "-" + TY_CURRENT_RELEASE_ + " (" + TY_PRODUCT_PLATFORM_ +
                   ") : " + fileName);
}
 
// CLM-NT33 : Raffraichissement du nom de fichier en vue modeleur
void TYMainWindow::refreshWindowTitle()
{
    // Change le titre de la fenetre pour afficher le nom du fichier
    setWindowTitle(TR("id_caption") + "-" + TY_CURRENT_RELEASE_ + " (" + TY_PRODUCT_PLATFORM_ +
                   ") : " + TYApplication::getCurrentFileName());
}
 
// CLM-NT33 : Fin