os.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/>.
 */
 
#include <QCoreApplication>
#include <qmessagebox.h>
#include <QTimer>
 
#include "Tympan/models/business/subprocess_util.h"
#include "Tympan/gui/app/TYApplication.h"
#include "Tympan/core/logging.h"
#include "Tympan/models/business/TYProgressManager.h"
#include "Tympan/gui/app/PythonRunner.h" // <— NEW include
#include "os.h"
 
#include <QThread>
#include <QEventLoop>
#include <QElapsedTimer>
#include <QProgressBar>
#include "Tympan/gui/app/PythonRunner.h"
 
// Helper: update label with elapsed time (French user-facing text)
static void set_elapsed_label_seconds(qint64 seconds)
{
    const QString msg = QStringLiteral("Calcul acoustique en cours…\nTemps écoulé : %1 s").arg(seconds);
    TYProgressManager::setMessage(msg.toUtf8().constData());
}
 
bool python_gui(QStringList args)
{
    TYApplication::setCurrentQtDir();
 
#if TY_USE_IHM
    // Lazily create the progress dialog
    if (!TYProgressManager::getProgressDialog())
        TYProgressManager::create(getTYMainWnd(), "Calcul acoustique");
    auto* dlg = TYProgressManager::getProgressDialog();
    if (dlg)
        dlg->setWindowModality(Qt::ApplicationModal);
 
    // Show a static (non-animated) progress bar + elapsed time label
    TYProgressManager::set(100);       // ensures the dialog is shown (0..100 range)
    TYProgressManager::setProgress(0); // keep it fixed (no spinner)
    // Hide the “%” text on the progress bar
    if (dlg)
    {
        if (auto* bar = dlg->findChild<QProgressBar*>())
        {
            bar->setTextVisible(false);
        }
        else
        {
            auto* bar2 = new QProgressBar(dlg);
            bar2->setRange(0, 100);
            bar2->setValue(0);
            bar2->setTextVisible(false);
            dlg->setBar(bar2);
        }
    }
    set_elapsed_label_seconds(0); // initial label
 
    // Elapsed time updater (1 Hz)
    QElapsedTimer chrono;
    chrono.start();
    QTimer elapsedTimer;
    elapsedTimer.setInterval(1000);
    QObject::connect(&elapsedTimer, &QTimer::timeout,
                     [&] { set_elapsed_label_seconds(chrono.elapsed() / 1000); });
    elapsedTimer.start();
 
    // Cancellation: hide dialog and propagate cancel to subprocess
    bool userCanceled = false;
    if (dlg)
    {
        QObject::connect(dlg, &QProgressDialog::canceled,
                         [&]
                         {
                             userCanceled = true;
                             elapsedTimer.stop();
                             dlg->hide();
                             python_request_cancel();
                         });
        dlg->raise();
        dlg->activateWindow();
        qApp->processEvents();
    }
#endif // TY_USE_IHM
 
    // Run python() in a worker thread (keeps UI responsive)
    QThread* thread = new QThread;
    PythonRunner* runner = new PythonRunner(args);
    runner->moveToThread(thread);
 
    bool computation_ok = false;
    QString error_msg_qs;
    QEventLoop waitLoop;
 
    QObject::connect(thread, &QThread::started, runner, &PythonRunner::run);
    QObject::connect(runner, &PythonRunner::finished,
                     [&](bool ok, const QString& msg)
                     {
                         computation_ok = ok;
                         error_msg_qs = msg;
                         waitLoop.quit();
                     });
    QObject::connect(runner, &PythonRunner::finished, thread, &QThread::quit);
    QObject::connect(thread, &QThread::finished, runner, &QObject::deleteLater);
    QObject::connect(thread, &QThread::finished, thread, &QObject::deleteLater);
 
    thread->start();
    waitLoop.exec(); // UI remains responsive; only the label is updated each second
 
#if TY_USE_IHM
    // Cleanup timers/UI
    elapsedTimer.stop();
    const bool cancelled = python_cancel_was_requested();
 
    if (!computation_ok)
    {
        if (dlg)
            dlg->hide();
        if (cancelled || userCanceled)
        {
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Information);
            msgBox.setText("Calcul acoustique interrompu par l'utilisateur.");
            msgBox.exec();
        }
        else
        {
            OMessageManager& logger = *OMessageManager::get();
            logger.error("Echec du calcul acoustique: %s", error_msg_qs.toStdString().c_str());
            QMessageBox msgBox;
            msgBox.setIcon(QMessageBox::Critical);
            msgBox.setText("Echec du calcul acoustique. Veuillez consulter le journal d'erreurs.\n");
            msgBox.exec();
        }
    }
    else
    {
        TYProgressManager::stepToEnd(); // success → close cleanly
    }
#endif // TY_USE_IHM
 
    return computation_ok;
}