File indexing completed on 2025-03-09 05:02:43

 /*
     SPDX-FileCopyrightText: 2013 Marco Martin <mart@kde.org>
     SPDX-FileCopyrightText: 2023 Alexander Lohnau <alexander.lohnau@gmx.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "sharedqmlengine.h"
 #include "appletcontext_p.h"
 
 #include <KLocalizedContext>
 #include <QDebug>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QQmlNetworkAccessManagerFactory>
 #include <QQuickItem>
 #include <QTimer>
 
 #include <Plasma/Applet>
 
 #include "debug_p.h"
 
 namespace PlasmaQuick
 {
 
 class SharedQmlEnginePrivate
 {
 public:
     SharedQmlEnginePrivate(SharedQmlEngine *parent)
         : q(parent)
         , component(nullptr)
         , delay(false)
         , m_engine(engine())
     {
         executionEndTimer = new QTimer(q);
         executionEndTimer->setInterval(0);
         executionEndTimer->setSingleShot(true);
         QObject::connect(executionEndTimer, &QTimer::timeout, q, [this]() {
             scheduleExecutionEnd();
         });
     }
 
     ~SharedQmlEnginePrivate() = default;
 
     void errorPrint(QQmlComponent *component);
     void execute(const QUrl &source);
     void scheduleExecutionEnd();
     void minimumWidthChanged();
     void minimumHeightChanged();
     void maximumWidthChanged();
     void maximumHeightChanged();
     void preferredWidthChanged();
     void preferredHeightChanged();
 
     SharedQmlEngine *q;
 
     QUrl source;
 
     QPointer<QObject> rootObject;
     QQmlComponent *component;
     QTimer *executionEndTimer;
     KLocalizedContext *context{nullptr};
     QQmlContext *rootContext;
     bool delay;
     std::shared_ptr<QQmlEngine> m_engine;
 
 private:
     static std::shared_ptr<QQmlEngine> engine()
     {
         if (auto locked = s_engine.lock()) {
             return locked;
         }
         auto createdEngine = std::make_shared<QQmlEngine>();
         s_engine = createdEngine;
         return createdEngine;
     }
 
     static std::weak_ptr<QQmlEngine> s_engine;
 };
 
 std::weak_ptr<QQmlEngine> SharedQmlEnginePrivate::s_engine = {};
 
 void SharedQmlEnginePrivate::errorPrint(QQmlComponent *component)
 {
     QString errorStr = QStringLiteral("Error loading QML file.\n");
     if (component->isError()) {
         const QList<QQmlError> errors = component->errors();
         for (const QQmlError &error : errors) {
             errorStr +=
                 (error.line() > 0 ? QString(QString::number(error.line()) + QLatin1String(": ")) : QLatin1String("")) + error.description() + QLatin1Char('\n');
         }
     }
     qWarning(LOG_PLASMAQUICK) << component->url().toString() << '\n' << errorStr;
 }
 
 void SharedQmlEnginePrivate::execute(const QUrl &source)
 {
     if (source.isEmpty()) {
         qWarning(LOG_PLASMAQUICK) << "File name empty!";
         return;
     }
 
     delete component;
     component = new QQmlComponent(m_engine.get(), q);
     QObject::connect(component, &QQmlComponent::statusChanged, q, &SharedQmlEngine::statusChanged, Qt::QueuedConnection);
 
     component->loadUrl(source);
     rootObject = component->beginCreate(rootContext);
 
     if (delay) {
         executionEndTimer->start(0);
     } else {
         scheduleExecutionEnd();
     }
 }
 
 void SharedQmlEnginePrivate::scheduleExecutionEnd()
 {
     if (component->isReady() || component->isError()) {
         q->completeInitialization();
     } else {
         QObject::connect(component, &QQmlComponent::statusChanged, q, [this]() {
             q->completeInitialization();
         });
     }
 }
 
 SharedQmlEngine::SharedQmlEngine(QObject *parent)
     : QObject(parent)
     , d(new SharedQmlEnginePrivate(this))
 {
     d->rootContext = new QQmlContext(engine().get());
     d->rootContext->setParent(this); // Delete the context when deleting the shared engine
 
     d->context = new KLocalizedContext(d->rootContext);
     d->rootContext->setContextObject(d->context);
 }
 
 SharedQmlEngine::SharedQmlEngine(Plasma::Applet *applet, QObject *parent)
     : QObject(parent)
     , d(new SharedQmlEnginePrivate(this))
 {
     d->rootContext = new AppletContext(engine().get(), applet, this);
 
     d->context = new KLocalizedContext(d->rootContext);
     d->rootContext->setContextObject(d->context);
 }
 
 SharedQmlEngine::~SharedQmlEngine()
 {
     delete d->component;
     if (QJSEngine::objectOwnership(d->rootObject) == QJSEngine::CppOwnership) {
         delete d->rootObject;
     }
 }
 
 void SharedQmlEngine::setTranslationDomain(const QString &translationDomain)
 {
     d->context->setTranslationDomain(translationDomain);
 }
 
 QString SharedQmlEngine::translationDomain() const
 {
     return d->context->translationDomain();
 }
 
 void SharedQmlEngine::setSource(const QUrl &source)
 {
     d->source = source;
     d->execute(source);
 }
 
 QUrl SharedQmlEngine::source() const
 {
     return d->source;
 }
 
 void SharedQmlEngine::setInitializationDelayed(const bool delay)
 {
     d->delay = delay;
 }
 
 bool SharedQmlEngine::isInitializationDelayed() const
 {
     return d->delay;
 }
 
 std::shared_ptr<QQmlEngine> SharedQmlEngine::engine()
 {
     return d->m_engine;
 }
 
 QObject *SharedQmlEngine::rootObject() const
 {
     return d->rootObject;
 }
 
 QQmlComponent *SharedQmlEngine::mainComponent() const
 {
     return d->component;
 }
 
 QQmlContext *SharedQmlEngine::rootContext() const
 {
     return d->rootContext;
 }
 
 QQmlComponent::Status SharedQmlEngine::status() const
 {
     if (!d->m_engine) {
         return QQmlComponent::Error;
     }
 
     if (!d->component) {
         return QQmlComponent::Null;
     }
 
     return QQmlComponent::Status(d->component->status());
 }
 
 void SharedQmlEngine::completeInitialization(const QVariantHash &initialProperties)
 {
     d->executionEndTimer->stop();
 
     if (!d->component) {
         qWarning(LOG_PLASMAQUICK) << "No component for" << source();
         return;
     }
 
     if (d->component->status() != QQmlComponent::Ready || d->component->isError()) {
         d->errorPrint(d->component);
         return;
     }
 
     for (auto it = initialProperties.constBegin(); it != initialProperties.constEnd(); ++it) {
         d->rootObject->setProperty(it.key().toUtf8().data(), it.value());
     }
 
     d->component->completeCreate();
     Q_EMIT finished();
 }
 
 QObject *SharedQmlEngine::createObjectFromSource(const QUrl &source, QQmlContext *context, const QVariantHash &initialProperties)
 {
     QQmlComponent *component = new QQmlComponent(d->m_engine.get(), this);
     component->loadUrl(source);
 
     return createObjectFromComponent(component, context, initialProperties);
 }
 
 QObject *SharedQmlEngine::createObjectFromComponent(QQmlComponent *component, QQmlContext *context, const QVariantHash &initialProperties)
 {
     QObject *object = component->beginCreate(context ? context : d->rootContext);
 
     for (auto it = initialProperties.constBegin(); it != initialProperties.constEnd(); ++it) {
         object->setProperty(it.key().toUtf8().data(), it.value());
     }
     component->completeCreate();
 
     if (!component->isError() && object) {
         // memory management
         component->setParent(object);
         // reparent to root object if wasn't specified otherwise by initialProperties
         if (!initialProperties.contains(QLatin1String("parent"))) {
             if (qobject_cast<QQuickItem *>(rootObject())) {
                 object->setProperty("parent", QVariant::fromValue(rootObject()));
             } else {
                 object->setParent(rootObject());
             }
         }
 
         return object;
 
     } else {
         d->errorPrint(component);
         delete object;
         return nullptr;
     }
 }
 }
 
 #include "moc_sharedqmlengine.cpp"