qml 0.0.1

data/ext/qml/objectgc.h

@@ -0,0 +1,28 @@
+#pragma once
+#include <QSet>
+#include <QObject>
+
+namespace RubyQml {
+
+class ObjectGC : public QObject {
+public:
+
+    void addObject(QObject *obj);
+    void markOwnedObject(QObject *obj);
+    void markNonOwnedObjects();
+
+    void setDebugMessageEnabled(bool enabled) { mDebugMessageEnabled = enabled; }
+    bool debugMessageEnabled() { return mDebugMessageEnabled; }
+    QDebug debug();
+
+    static ObjectGC *instance();
+
+private:
+    ObjectGC() {}
+    void mark(QObject *obj, bool markOwned);
+
+    bool mDebugMessageEnabled = false;
+    QSet<QObject *> mObjects;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/core/applicationextension.cpp

@@ -0,0 +1,34 @@
+#include "applicationextension.h"
+#include <QApplication>
+#include <QTimer>
+#include <QDebug>
+
+namespace RubyQml {
+
+ApplicationExtension::ApplicationExtension(QApplication *app) :
+    mApp(app)
+{
+    auto timer = new QTimer(this);
+    timer->setInterval(0);
+    timer->setSingleShot(false);
+    timer->start();
+    connect(timer, &QTimer::timeout, this, &ApplicationExtension::eventsProcessed);
+}
+
+void ApplicationExtension::exec()
+{
+    mApp->exec();
+}
+
+void ApplicationExtension::processEvents()
+{
+    QCoreApplication::processEvents();
+    forceDeferredDeletes();
+}
+
+void ApplicationExtension::forceDeferredDeletes()
+{
+    QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/core/applicationextension.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <QObject>
+#include <QGuiApplication>
+
+class QGuiApplication;
+
+namespace RubyQml {
+
+class ApplicationExtension : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ApplicationExtension(QApplication *app);
+
+signals:
+    void eventsProcessed();
+
+public slots:
+    void exec();
+    void processEvents();
+    void forceDeferredDeletes();
+
+private:
+    QApplication *mApp;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/core/componentextension.cpp

@@ -0,0 +1,41 @@
+#include "componentextension.h"
+#include "qmlexception.h"
+#include <QQmlComponent>
+#include <QQmlEngine>
+#include <QDebug>
+
+namespace RubyQml {
+
+ComponentExtension::ComponentExtension(QQmlComponent *component) :
+    mComponent(component)
+{
+}
+
+void ComponentExtension::loadString(const QString &data, const QString &path)
+{
+    mComponent->setData(data.toUtf8(), QUrl::fromLocalFile(path));
+    throwIfError();
+}
+
+void ComponentExtension::loadFile(const QString &filePath)
+{
+    mComponent->loadUrl(QUrl::fromLocalFile(filePath));
+    throwIfError();
+}
+
+QObject *ComponentExtension::create(QQmlContext *context)
+{
+    auto created = mComponent->create(context);
+    throwIfError();
+    QQmlEngine::setObjectOwnership(created, QQmlEngine::JavaScriptOwnership);
+    return created;
+}
+
+void ComponentExtension::throwIfError()
+{
+    if (mComponent->status() == QQmlComponent::Error) {
+        throw QmlException(mComponent->errorString());
+    }
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/core/componentextension.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <QObject>
+#include <QQmlComponent>
+
+class QQmlComponent;
+
+namespace RubyQml {
+
+class ComponentExtension : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ComponentExtension(QQmlComponent *component);
+
+public slots:
+
+    void loadString(const QString &data, const QString &path);
+    void loadFile(const QString &filePath);
+    QObject *create(QQmlContext *context);
+
+private:
+    void throwIfError();
+
+    QQmlComponent *mComponent;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/core/contextextension.cpp

@@ -0,0 +1,39 @@
+#include "contextextension.h"
+#include "qmlexception.h"
+#include <QQmlContext>
+#include <QQmlExpression>
+
+namespace RubyQml {
+
+ContextExtension::ContextExtension(QQmlContext *context) :
+    mContext(context)
+{
+}
+
+QQmlEngine *ContextExtension::engine()
+{
+    return mContext->engine();
+}
+
+QVariant ContextExtension::evaluate(QObject *obj, const QString &str)
+{
+    QQmlExpression expression(mContext, obj, str);
+    auto result = expression.evaluate();
+    if (expression.hasError()) {
+        throw QmlException(expression.error().toString());
+    }
+    return result;
+}
+
+void ContextExtension::setContextProperty(const QString &key, const QVariant &value)
+{
+    mContext->setContextProperty(key, value);
+}
+
+QVariant ContextExtension::contextProperty(const QString &key)
+{
+    return mContext->contextProperty(key);
+}
+
+
+} // namespace RubyQml

data/ext/qml/plugins/core/contextextension.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <QObject>
+#include <QVariant>
+
+class QQmlContext;
+class QQmlEngine;
+
+namespace RubyQml {
+
+class ContextExtension : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlEngine* engine READ engine)
+public:
+    explicit ContextExtension(QQmlContext *context);
+    QQmlEngine *engine();
+
+public slots:
+
+    QVariant evaluate(QObject *obj, const QString &str);
+    void setContextProperty(const QString &key, const QVariant &value);
+    QVariant contextProperty(const QString &key);
+
+private:
+    QQmlContext *mContext;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/core/core.pro

@@ -0,0 +1,29 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2014-05-12T21:03:35
+#
+#-------------------------------------------------
+
+QT       += core gui qml quick widgets
+
+TARGET = rubyqml-core
+TEMPLATE = lib
+CONFIG += plugin c++11
+
+SOURCES += coreplugin.cpp \
+    qmlexception.cpp \
+    applicationextension.cpp \
+    componentextension.cpp \
+    contextextension.cpp \
+    engineextension.cpp \
+    imageprovider.cpp \
+    imagerequestpromise.cpp
+
+HEADERS += coreplugin.h \
+    qmlexception.h \
+    applicationextension.h \
+    componentextension.h \
+    contextextension.h \
+    engineextension.h \
+    imageprovider.h \
+    imagerequestpromise.h

data/ext/qml/plugins/core/coreplugin.cpp

@@ -0,0 +1,87 @@
+#include "coreplugin.h"
+#include "applicationextension.h"
+#include "engineextension.h"
+#include "componentextension.h"
+#include "contextextension.h"
+#include "imageprovider.h"
+#include <QApplication>
+#include <QQmlEngine>
+#include <QQmlComponent>
+#include <QQmlContext>
+#include <stdexcept>
+
+Q_DECLARE_METATYPE(const QMetaObject*)
+
+namespace RubyQml {
+
+CorePlugin::CorePlugin(QObject *parent) :
+    QObject(parent)
+{
+    qRegisterMetaType<ApplicationExtension *>();
+    qRegisterMetaType<EngineExtension *>();
+    qRegisterMetaType<ComponentExtension *>();
+    qRegisterMetaType<ContextExtension *>();
+    qRegisterMetaType<ImageProvider *>();
+    qRegisterMetaType<QApplication *>();
+    qRegisterMetaType<QCoreApplication *>();
+    qRegisterMetaType<QQmlEngine *>();
+    qRegisterMetaType<QQmlComponent *>();
+    qRegisterMetaType<QQmlContext *>();
+
+    const QMetaObject *metaObjects[] = {
+        &staticQtMetaObject,
+        &QApplication::staticMetaObject,
+        &QQmlEngine::staticMetaObject,
+        &QQmlComponent::staticMetaObject,
+        &QQmlContext::staticMetaObject};
+    for (auto metaobj : metaObjects) {
+        mMetaObjects[metaobj->className()] = QVariant::fromValue(metaobj);
+    }
+}
+
+QApplication *CorePlugin::applicationInstance()
+{
+    return qApp;
+}
+
+QQmlComponent *CorePlugin::createComponent(QQmlEngine *e)
+{
+    return new QQmlComponent(e);
+}
+
+QQmlContext *CorePlugin::createContext(QQmlEngine *engine)
+{
+    return new QQmlContext(engine);
+}
+
+ApplicationExtension *CorePlugin::createApplicationExtension(QApplication *app)
+{
+    return new ApplicationExtension(app);
+}
+
+EngineExtension *CorePlugin::createEngineExtension(QQmlEngine *engine)
+{
+    return new EngineExtension(engine);
+}
+
+ComponentExtension *CorePlugin::createComponentExtension(QQmlComponent *component)
+{
+    return new ComponentExtension(component);
+}
+
+ContextExtension *CorePlugin::createContextExtension(QQmlContext *context)
+{
+    return new ContextExtension(context);
+}
+
+QQmlContext *CorePlugin::contextForObject(QObject *object)
+{
+    return QQmlEngine::contextForObject(object);
+}
+
+ImageProvider *CorePlugin::createImageProvider(QObject *rubyCallback)
+{
+    return new ImageProvider(rubyCallback);
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/core/coreplugin.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <QObject>
+#include <QVariant>
+
+class QApplication;
+class QQmlEngine;
+class QQmlComponent;
+class QQmlContext;
+
+namespace RubyQml {
+
+class ApplicationExtension;
+class ComponentExtension;
+class EngineExtension;
+class ContextExtension;
+class ImageProvider;
+
+class CorePlugin : public QObject
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.ruby-qml.RubyQml.Core")
+
+public:
+    CorePlugin(QObject *parent = 0);
+
+public slots:
+    QVariantHash metaObjects() { return mMetaObjects; }
+
+    QApplication *applicationInstance();
+
+    QQmlComponent *createComponent(QQmlEngine *engine);
+    QQmlContext *createContext(QQmlEngine *engine);
+
+    RubyQml::ApplicationExtension *createApplicationExtension(QApplication *app);
+    RubyQml::EngineExtension *createEngineExtension(QQmlEngine *engine);
+    RubyQml::ComponentExtension *createComponentExtension(QQmlComponent *component);
+    RubyQml::ContextExtension *createContextExtension(QQmlContext *context);
+
+    QQmlContext *contextForObject(QObject *object);
+
+    RubyQml::ImageProvider *createImageProvider(QObject *rubyCallback);
+
+private:
+    QVariantHash mMetaObjects;
+};
+
+
+} // namespace RubyQml

data/ext/qml/plugins/core/engineextension.cpp

@@ -0,0 +1,27 @@
+#include "engineextension.h"
+#include "imageprovider.h"
+#include <QQmlEngine>
+
+namespace RubyQml {
+
+EngineExtension::EngineExtension(QQmlEngine *engine) :
+    mEngine(engine)
+{
+}
+
+QQmlContext *EngineExtension::rootContext()
+{
+    return mEngine->rootContext();
+}
+
+void EngineExtension::addImageProvider(const QString &id, ImageProvider *provider)
+{
+    mEngine->addImageProvider(id, provider);
+}
+
+void EngineExtension::collectGarbage()
+{
+    mEngine->collectGarbage();
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/core/engineextension.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <QObject>
+
+class QQmlEngine;
+class QQmlContext;
+
+namespace RubyQml {
+
+class ImageProvider;
+
+class EngineExtension : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QQmlContext* rootContext READ rootContext)
+public:
+    explicit EngineExtension(QQmlEngine *engine);
+    QQmlContext *rootContext();
+
+public slots:
+    void addImageProvider(const QString &id, RubyQml::ImageProvider *provider);
+    void collectGarbage();
+
+private:
+    QQmlEngine *mEngine;
+};
+
+} // namespace RubyQml