app_manager.cpp

Go to the documentation of this file.

/**
 * \file app_manager.cpp
 * \brief Implementation of the application lifecycle manager.
 * \author Le Bars, Yoann
 *
 * This file is part of the pure C++ benchmark.
 */
 
#include "app_manager.hpp"
 
#include <QAction>
#include <QMainWindow>
#include <QMenu>
#include <QMenuBar>
#include <QWidget>
#include <chrono>
 
#include "app_profiler.hpp"
 
namespace App {
 
    /**
     * \brief Constructs the application manager and sets application-wide
     * metadata.
     */
    AppManager::AppManager() : mainWindow_(nullptr) {
        QApplication::setApplicationName(Configuration::PROJECT_NAME);
        QApplication::setOrganizationName("eiG");
        const QString version = QStringLiteral("%1.%2.%3")
                                    .arg(Configuration::VERSION_MAJOR)
                                    .arg(Configuration::VERSION_MINOR)
                                    .arg(Configuration::PATCH_VERSION);
        QApplication::setApplicationVersion(version);
    }
 
    /**
     * \brief Sets up all application components before running.
     */
    bool AppManager::setup() {
        /* Pre-scan for the diagnostics flag. This is done before full argument
           parsing to enable debug output during translation loading, which
           happens before the logger is fully configured. */
        bool diagnosticsEnabled = false;
        for (const auto& arg : QApplication::arguments()) {
            if (arg == QLatin1String("-D") ||
                arg == QLatin1String("--diagnostics") ||
                arg == QLatin1String("-c") ||
                arg == QLatin1String("--debugConsole")) {
                diagnosticsEnabled = true;
                break;
            }
        }
        AppUtils::TranslationLoader::loadTranslations(diagnosticsEnabled);
 
        // Create a lambda for translation to pass to the command-line parser.
        // Use "CmdLine::CmdLineArgs" context to match the existing translations
        // in the .ts files.
        auto tr_func = [](const char* text) {
            return QCoreApplication::translate("CmdLine::CmdLineArgs", text);
        };
        args_ = CmdLine::CmdLineArgs::parse(QApplication::arguments(), tr_func);
        if (!args_) {
            return false;  // --help or --version was requested.
        }
 
        logger_ = std::make_unique<AppUtils::Logger>(*args_);
        return true;
    }
 
    /**
     * \brief Runs the main application event loop.
     */
    int AppManager::run() {
        // Create the QML bridge (used for Display and actions)
        AppUtils::AppProfiler::startWindowCreation();
        bridge_ = new Window::QmlBridge(args_->toSimulationConfig(), this);
        AppUtils::AppProfiler::stopWindowCreation();
 
        // Create a main window widget to host the Display
        mainWindow_ = new QMainWindow();
        mainWindow_->setWindowTitle(
            QApplication::translate("MainWindow", "Pure C++"));
        mainWindow_->resize(800, 600);
 
        // Create native menu bar with QML bridge integration
        // Use "MainWindow" context to match the translations from main.ui
        QMenuBar* menuBar = mainWindow_->menuBar();
 
        // File menu
        QMenu* fileMenu =
            menuBar->addMenu(QApplication::translate("MainWindow", "&File"));
        QAction* quitAction =
            fileMenu->addAction(QApplication::translate("MainWindow", "&Quit"));
        quitAction->setShortcut(QKeySequence::Quit);
        connect(quitAction, &QAction::triggered, bridge_,
                &Window::QmlBridge::quit);
 
        // Help menu
        QMenu* helpMenu =
            menuBar->addMenu(QApplication::translate("MainWindow", "&Help"));
        QAction* aboutAction = helpMenu->addAction(
            QApplication::translate("MainWindow", "About Pure C++"));
        connect(aboutAction, &QAction::triggered, bridge_,
                &Window::QmlBridge::showAbout);
        QAction* aboutQtAction = helpMenu->addAction(
            QApplication::translate("MainWindow", "About Qt"));
        connect(aboutQtAction, &QAction::triggered, bridge_,
                &Window::QmlBridge::showAboutQt);
 
        // Add the Display container as the central widget
        // The container is owned by mainWindow, so it will be destroyed when
        // mainWindow is destroyed
        if (bridge_->displayContainer()) {
            mainWindow_->setCentralWidget(bridge_->displayContainer());
        }
 
        // Connect the application's aboutToQuit signal to our cleanup slot.
        // This ensures cleanup happens before the application exits
        connect(qApp, &QApplication::aboutToQuit, this, &AppManager::cleanup);
 
        // Connect simulation finished to close the window
        connect(bridge_, &Window::QmlBridge::simulationFinished, mainWindow_,
                &QMainWindow::close, Qt::QueuedConnection);
 
        // Prevent automatic deletion on close - let QApplication handle
        // destruction
        mainWindow_->setAttribute(Qt::WA_DeleteOnClose, false);
 
        // Show the window
        mainWindow_->show();
 
        // Start the simulation
        bridge_->startSimulation();
 
        // Start timing the event loop
        AppUtils::AppProfiler::startEventLoop();
        int exitCode = QApplication::exec();
        // Stop timing the event loop (exec() has returned)
        AppUtils::AppProfiler::stopEventLoop();
        return exitCode;
    }
 
    /**
     * \brief Performs cleanup after the event loop has finished.
     *
     * Two modes are supported via --cleanup-mode:
     * - fast (default): physics shutdown is synchronous; Qt3D/UI teardown is
     *   deferred (deleteLater), comparable to async Python GC for benchmarks.
     * - strict: synchronous UI teardown and processEvents for Valgrind.
     */
    void AppManager::cleanup() {
        using CleanupClock = std::chrono::high_resolution_clock;
        auto phaseStart = CleanupClock::now();
 
        // Stop event loop timing if it's still running (should already be
        // stopped, but be safe)
        AppUtils::AppProfiler::stopEventLoop();
        AppUtils::AppProfiler::startCleanup();
 
        const bool useFastCleanup =
            !args_ || args_->cleanup_mode_ != "strict";
 
        QWidget* container = nullptr;
        if (mainWindow_ && bridge_) {
            container = bridge_->displayContainer();
            if (container) {
                phaseStart = CleanupClock::now();
                mainWindow_->setCentralWidget(nullptr);
                AppUtils::AppProfiler::addCleanupAppDetachContainer(
                    std::chrono::duration<double>(CleanupClock::now() -
                                                  phaseStart)
                        .count());
            }
        }
 
        // Always stop the physics thread before QApplication is destroyed.
        phaseStart = CleanupClock::now();
        if (bridge_) {
            bridge_->shutdownSimulation();
        }
        AppUtils::AppProfiler::addCleanupAppBridgeCleanup(
            std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                .count());
 
        if (container && bridge_) {
            const auto manualDestroyStart = CleanupClock::now();
            phaseStart = CleanupClock::now();
            if (useFastCleanup) {
                bridge_->releaseDisplayDeferred(container);
            } else {
                bridge_->releaseDisplayStrict(container);
            }
            AppUtils::AppProfiler::addCleanupAppReleaseDisplay(
                std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                    .count());
            AppUtils::AppProfiler::addCleanupAppContainerDeleteSchedule(
                std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                    .count());
            AppUtils::AppProfiler::addCleanupAppManualDestroy(
                std::chrono::duration<double>(CleanupClock::now() -
                                              manualDestroyStart)
                    .count());
        }
 
        if (mainWindow_) {
            phaseStart = CleanupClock::now();
            if (useFastCleanup) {
                mainWindow_->deleteLater();
            } else {
                delete mainWindow_;
            }
            mainWindow_ = nullptr;
 
            if (!useFastCleanup) {
                phaseStart = CleanupClock::now();
                QApplication::processEvents(
                    QEventLoop::ExcludeUserInputEvents);
                AppUtils::AppProfiler::addCleanupAppProcessEvents(
                    std::chrono::duration<double>(CleanupClock::now() -
                                                  phaseStart)
                        .count());
            }
        }
 
        AppUtils::AppProfiler::stopCleanup();
        AppUtils::AppProfiler::printReport();
    }
 
}  // namespace App