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_ = std::make_unique<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_.get(),
                &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_.get(),
                &Window::QmlBridge::showAbout);
        QAction* aboutQtAction = helpMenu->addAction(
            QApplication::translate("MainWindow", "About Qt"));
        connect(aboutQtAction, &QAction::triggered, bridge_.get(),
                &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_.get(), &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.
     *
     * According to Qt best practices, we should let QApplication handle widget
     * destruction automatically. However, QWindowContainer has a special
     * requirement: the QWindow (Display) must still be valid when the container
     * is destroyed. Therefore, we must destroy the container explicitly BEFORE
     * QmlBridge (which owns Display) is destroyed.
     */
    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();
 
        // Stop the physics thread and cleanup the display (prints profiling
        // report) This is the only cleanup we need to do manually, as the
        // thread must be stopped before QApplication is destroyed
        phaseStart = CleanupClock::now();
        if (bridge_) {
            bridge_->cleanup();
        }
        AppUtils::AppProfiler::addCleanupAppBridgeCleanup(
            std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                .count());
 
        // CRITICAL: Destroy the Display BEFORE the container to avoid
        // segfaults. QWindowContainer tries to access the Display during its
        // destruction. If Display is already destroyed, the container can't
        // corrupt it. This is the opposite of what one might expect, but it's
        // what works.
        //
        // Two cleanup modes are supported:
        // - fast   (default): deferred destruction, non-blocking cleanup path
        // - strict: synchronous destruction, conservative behavior
        if (mainWindow_ && bridge_ && bridge_->displayContainer()) {
            const bool useFastCleanup =
                !args_ || args_->cleanup_mode_ != "strict";
            QWidget* container = bridge_->displayContainer();
            const auto manualDestroyStart = CleanupClock::now();
            // Remove from mainWindow first to break parent-child relationship
            phaseStart = CleanupClock::now();
            mainWindow_->setCentralWidget(nullptr);
            AppUtils::AppProfiler::addCleanupAppDetachContainer(
                std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                    .count());
            // Destroy Display BEFORE container (prevents container from
            // corrupting Display).
            phaseStart = CleanupClock::now();
            if (useFastCleanup) {
                // In fast mode, container deletion is chained to Display
                // destruction to preserve a deterministic safe order.
                bridge_->releaseDisplayDeferred(container);
            } else {
                bridge_->releaseDisplay();
            }
            AppUtils::AppProfiler::addCleanupAppReleaseDisplay(
                std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                    .count());
            // Fast mode schedules deletion in the event loop (non-blocking).
            // Strict mode performs immediate deletion (synchronous).
            phaseStart = CleanupClock::now();
            if (useFastCleanup) {
                // No direct deleteLater() here: releaseDisplayDeferred() links
                // container deletion to Display::destroyed.
            } else {
                delete container;
            }
            AppUtils::AppProfiler::addCleanupAppContainerDeleteSchedule(
                std::chrono::duration<double>(CleanupClock::now() - phaseStart)
                    .count());
            AppUtils::AppProfiler::addCleanupAppManualDestroy(
                std::chrono::duration<double>(CleanupClock::now() -
                                              manualDestroyStart)
                    .count());
 
            // In strict mode we process pending events synchronously.
            if (!useFastCleanup) {
                phaseStart = CleanupClock::now();
                QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
                AppUtils::AppProfiler::addCleanupAppProcessEvents(
                    std::chrono::duration<double>(CleanupClock::now() -
                                                  phaseStart)
                        .count());
            }
        }
 
        // Let QApplication handle the rest of widget destruction automatically.
        // mainWindow_ will be destroyed when QApplication is destroyed, but
        // container is already gone, so no issue.
 
        AppUtils::AppProfiler::stopCleanup();
        AppUtils::AppProfiler::printReport();
    }
 
}  // namespace App