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_ = new Display(config);
 
        // Create a container widget for the Qt3D window
        // IMPORTANT: createWindowContainer takes ownership of the window
        container_ = QWidget::createWindowContainer(display_);
        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_, &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() {
        shutdownSimulation();
        if (container_) {
            releaseDisplayStrict(container_.data());
        }
    }
 
    QWidget* QmlBridge::displayContainer() const { return container_; }
 
    QString QmlBridge::aboutText() const { return aboutText_; }
 
    void QmlBridge::startSimulation() {
        if (display_) {
            display_->runSimulation();
        }
    }
 
    void QmlBridge::shutdownSimulation() {
        if (display_) {
            display_->cleanup();
        }
    }
 
    void QmlBridge::releaseDisplayDeferred(
        QWidget* container_for_deferred_delete) {
        if (uiReleased_) {
            return;
        }
        uiReleased_ = true;
 
        if (!display_) {
            if (container_for_deferred_delete) {
                container_for_deferred_delete->deleteLater();
            }
            container_ = nullptr;
            return;
        }
 
        Display* displayRaw = display_.data();
        display_ = nullptr;
        if (container_for_deferred_delete) {
            QObject::connect(displayRaw, &QObject::destroyed,
                             container_for_deferred_delete,
                             &QObject::deleteLater, Qt::QueuedConnection);
        }
        displayRaw->deleteLater();
        container_ = nullptr;
    }
 
    void QmlBridge::releaseDisplayStrict(QWidget* container) {
        if (uiReleased_) {
            return;
        }
        uiReleased_ = true;
 
        if (container) {
            delete container;
        }
        container_ = nullptr;
        display_ = nullptr;
    }
 
    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