qml_bridge.cpp

Go to the documentation of this file.

/**
 * \file qml_bridge.cpp
 * \brief Implementation of the QML bridge.
 * \author Le Bars, Yoann
 *
 * This file is part of the pure C++ benchmark.
 *
 * This program 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.
 *
 * This program 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
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "qml_bridge.hpp"
 
#include <QApplication>
#include <QFile>
#include <QMessageBox>
#include <QTextStream>
#include <QWidget>
#include <config.hpp>
 
namespace Window {
 
    QmlBridge::QmlBridge(const Configuration::SimulationConfig& config,
                         QObject* parent)
        : QObject(parent), container_(nullptr) {
        // Create the 3D display
        display_ = std::make_unique<Display>(config);
 
        // Create a container widget for the Qt3D window
        // IMPORTANT: createWindowContainer does NOT take ownership of the window
        // The Display must remain alive as long as the container exists
        container_ = QWidget::createWindowContainer(display_.get());
        container_->setFocusPolicy(Qt::TabFocus);
        // Set parent to ensure proper cleanup
        container_->setParent(nullptr);  // Will be reparented when added to layout
 
        // Connect the simulation finished signal
        connect(display_.get(), &Display::simulationFinished, this,
                &QmlBridge::simulationFinished);
 
        // Load about text
        const auto aboutTextTemplate = loadAboutText();
        if (aboutTextTemplate) {
            aboutText_ = *aboutTextTemplate;
            aboutText_.replace(QStringLiteral("{}"),
                              QApplication::applicationVersion());
        } else {
            aboutText_ = tr("Could not load the About page. The resource "
                           "file might be missing or corrupted.");
        }
 
        emit displayContainerChanged();
        emit aboutTextChanged();
    }
 
    QmlBridge::~QmlBridge() {
        // Let Qt handle widget destruction automatically.
        // The container_ is owned by its parent widget (mainWindow), so it will
        // be destroyed when the parent is destroyed by QApplication.
        // The display_ will be destroyed by unique_ptr automatically.
    }
 
    QWidget* QmlBridge::displayContainer() const { return container_; }
 
    QString QmlBridge::aboutText() const { return aboutText_; }
 
    void QmlBridge::startSimulation() {
        if (display_) {
            display_->runSimulation();
        }
    }
 
    void QmlBridge::cleanup() {
        // Cleanup the display to stop threads and print profiling reports.
        // Let QApplication handle widget destruction automatically.
        if (display_) {
            display_->cleanup();
        }
    }
    
    void QmlBridge::releaseDisplay() {
        // Manually destroy the Display before the container is destroyed.
        // This prevents segfaults that occur when the container tries to access
        // the Display during its destruction.
        if (display_) {
            display_.reset();
        }
    }
 
    void QmlBridge::releaseDisplayDeferred(QWidget* container_for_deferred_delete) {
        // Defer Display destruction to avoid blocking cleanup on heavy Qt3D
        // teardown. The ownership is released from unique_ptr and transferred
        // to Qt's deferred deletion mechanism.
        if (display_) {
            Display* displayRaw = display_.release();
            if (container_for_deferred_delete) {
                // Enforce safe order: container is deleted only after Display.
                QObject::connect(displayRaw, &QObject::destroyed,
                                 container_for_deferred_delete,
                                 &QObject::deleteLater, Qt::QueuedConnection);
            }
            displayRaw->deleteLater();
        } else if (container_for_deferred_delete) {
            // Fallback: if Display is already gone, schedule container directly.
            container_for_deferred_delete->deleteLater();
        }
    }
 
    void QmlBridge::showAbout() {
        QMessageBox::about(
            nullptr, tr("About Pure C++", "About message box title"),
            aboutText_);
    }
 
    void QmlBridge::showAboutQt() {
        QApplication::aboutQt();
    }
 
    void QmlBridge::quit() { QApplication::quit(); }
 
    std::optional<QString> QmlBridge::loadAboutText() {
        // It tries to load a locale-specific version first (e.g.,
        // `about_fr_FR.htm`), falling back to the default `about.htm` if
        // the specific version is not found.
        const QStringList pathsToTry = {
            QStringLiteral(":/locales/about_%1.htm")
                .arg(QLocale::system().name()),
            QStringLiteral(":/locales/about.htm")};
 
        for (const auto& path : pathsToTry) {
            QFile file(path);
            if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
                QTextStream in(&file);
                return in.readAll();
            }
        }
 
        return std::nullopt;  // Return empty if no file could be opened.
    }
 
}  // namespace Window