qml 0.0.1

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

@@ -0,0 +1,38 @@
+#include "imageprovider.h"
+#include "imagerequestpromise.h"
+#include <QDebug>
+#include <QApplication>
+
+namespace RubyQml {
+
+ImageProvider::ImageProvider(QObject *rubyCallback) :
+    QQuickImageProvider(QQuickImageProvider::Image, QQuickImageProvider::ForceAsynchronousImageLoading),
+    mRubyCallback(rubyCallback)
+{
+    rubyCallback->setParent(this);
+}
+
+QImage ImageProvider::requestImage(const QString &id, QSize *size, const QSize &requestedSize)
+{
+    std::promise<QImage> promise;
+    auto future = promise.get_future();
+    auto promiseObj = new ImageRequestPromise(std::move(promise));
+    promiseObj->moveToThread(qApp->thread());
+
+    mRubyCallback->metaObject()->invokeMethod(
+        mRubyCallback,
+        "request",
+        Qt::QueuedConnection,
+        Q_ARG(QVariant, id),
+        Q_ARG(QVariant, QVariant::fromValue(promiseObj)));
+
+    auto image = future.get();
+    if (requestedSize.isValid() && image.size() != requestedSize) {
+        image = image.scaled(requestedSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+    }
+
+    *size = image.size();
+    return image;
+}
+
+} // namespace RubyQml

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

@@ -0,0 +1,18 @@
+#pragma once
+#include <QObject>
+#include <QQuickImageProvider>
+
+namespace RubyQml {
+
+class ImageProvider : public QObject, public QQuickImageProvider
+{
+    Q_OBJECT
+public:
+    explicit ImageProvider(QObject *rubyImageProvider);
+    QImage requestImage(const QString &id, QSize *size, const QSize &requestedSize) override;
+
+private:
+    QObject *mRubyCallback = nullptr;
+};
+
+} // namespace RubyQml

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

@@ -0,0 +1,19 @@
+#include "imagerequestpromise.h"
+#include <QImage>
+#include <QDebug>
+
+namespace RubyQml {
+
+ImageRequestPromise::ImageRequestPromise(std::promise<QImage> &&promise, QObject *parent) :
+    QObject(parent),
+    mPromise(std::move(promise))
+{
+}
+
+void ImageRequestPromise::setData(const QByteArray &data)
+{
+    auto image = QImage::fromData(data);
+    mPromise.set_value(image);
+}
+
+} // namespace RubyQml

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

@@ -0,0 +1,21 @@
+#pragma once
+#include <QObject>
+#include <QImage>
+#include <future>
+
+namespace RubyQml {
+
+class ImageRequestPromise : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ImageRequestPromise(std::promise<QImage> &&promise, QObject *parent = 0);
+
+public slots:
+    void setData(const QByteArray &data);
+
+private:
+    std::promise<QImage> mPromise;
+};
+
+} // namespace RubyQml

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

@@ -0,0 +1,11 @@
+#include "qmlexception.h"
+#include <QString>
+
+namespace RubyQml {
+
+QmlException::QmlException(const QString &error) :
+    std::runtime_error(error.toStdString())
+{
+}
+
+} // namespace RubyQml

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

@@ -0,0 +1,17 @@
+#ifndef RUBYQML_QMLERROR_H
+#define RUBYQML_QMLERROR_H
+
+#include <stdexcept>
+class QString;
+
+namespace RubyQml {
+
+class QmlException : public std::runtime_error
+{
+public:
+    QmlException(const QString &error);
+};
+
+} // namespace RubyQml
+
+#endif // RUBYQML_QMLERROR_H

data/ext/qml/plugins/testutil/objectlifechecker.cpp

@@ -0,0 +1,17 @@
+#include "objectlifechecker.h"
+#include <QQmlEngine>
+
+namespace RubyQml {
+
+ObjectLifeChecker::ObjectLifeChecker(QObject *target) :
+    mTarget(target)
+{
+}
+
+bool ObjectLifeChecker::isOwnedByQml() const
+{
+    if (!mTarget) return false;
+    return QQmlEngine::objectOwnership(mTarget) == QQmlEngine::JavaScriptOwnership;
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/testutil/objectlifechecker.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <QObject>
+#include <QPointer>
+
+namespace RubyQml {
+
+class ObjectLifeChecker : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* target READ target)
+public:
+    explicit ObjectLifeChecker(QObject *target);
+    QObject *target() { return mTarget; }
+signals:
+
+public slots:
+    bool isAlive() const { return mTarget; }
+    bool isOwnedByQml() const;
+
+private:
+    QPointer<QObject> mTarget;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/testutil/ownershiptest.cpp

@@ -0,0 +1,26 @@
+#include "ownershiptest.h"
+
+namespace RubyQml {
+
+OwnershipTest::OwnershipTest(QObject *parent) :
+    QObject(parent)
+{
+    mSubObject = new QObject(this);
+    connect(mSubObject, &QObject::destroyed, this, &OwnershipTest::subObjectDeleted);
+    mPropertyObject = new QObject();
+    connect(mPropertyObject, &QObject::destroyed, this, &OwnershipTest::subObjectDeleted);
+}
+
+OwnershipTest::~OwnershipTest()
+{
+    delete mPropertyObject;
+}
+
+QObject *OwnershipTest::createObject()
+{
+    auto obj = new QObject();
+    connect(obj, &QObject::destroyed, this, &OwnershipTest::createdObjectDeleted);
+    return obj;
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/testutil/ownershiptest.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <QObject>
+
+namespace RubyQml {
+
+class OwnershipTest : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QObject* propertyObject READ propertyObject)
+public:
+    explicit OwnershipTest(QObject *parent = 0);
+    ~OwnershipTest();
+
+    QObject *propertyObject() { return mPropertyObject; }
+
+signals:
+    void subObjectDeleted();
+    void propertyObjectDeleted();
+    void createdObjectDeleted();
+
+public slots:
+    QObject *subObject() { return mSubObject; }
+    QObject *createObject();
+
+private:
+    QObject *mSubObject;
+    QObject *mPropertyObject;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/testutil/testobject.cpp

@@ -0,0 +1,6 @@
+#include "testobject.h"
+
+namespace RubyQml {
+
+} // namespace RubyQml
+

data/ext/qml/plugins/testutil/testobject.h

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <QObject>
+#include <QVariant>
+#include <QDebug>
+#include <QtPlugin>
+#include <stdexcept>
+
+namespace RubyQml {
+
+class TestObject : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString name MEMBER mName NOTIFY nameChanged)
+    Q_PROPERTY(double someValue MEMBER mSomeValue NOTIFY someValueChanged)
+    Q_PROPERTY(RubyQml::TestObject::Enums enumValue MEMBER mEnumValue NOTIFY enumValueChanged)
+
+public:
+    explicit TestObject(QObject *parent = 0) : QObject(parent)
+    {
+    }
+
+    enum Enums
+    {
+        Foo = 0,
+        Bar = 1,
+        FooBar = 2,
+    };
+
+public slots:
+
+    int normalMethod(int x, const QString &y)
+    {
+        return x + y.toInt();
+    }
+
+    QVariant variantMethod(const QVariant &x, const QVariant &y)
+    {
+        int sum = x.toInt();
+        auto list = y.toList();
+        for (const auto &variant : list) {
+            sum += variant.toInt();
+        }
+        return sum;
+    }
+
+    QString overloadedMethod(int x)
+    {
+        Q_UNUSED(x);
+        return "first";
+    }
+
+    QString overloadedMethod(const QString &x)
+    {
+        Q_UNUSED(x);
+        return "last";
+    }
+
+    QString overloadedMethod(const QString &x, int y)
+    {
+        Q_UNUSED(x)
+        Q_UNUSED(y)
+        return "2 params";
+    }
+
+    void emitSomeSignal(const QString &arg)
+    {
+        emit someSignal(arg);
+    }
+
+    QString getName() const
+    {
+        return mName;
+    }
+
+    void throwingMethod() const
+    {
+        throw std::runtime_error("test error");
+    }
+
+    const QMetaObject *metaObjectMethod() const
+    {
+        return &TestObject::staticMetaObject;
+    }
+
+    QObject *selfReturningMethod()
+    {
+        return this;
+    }
+
+signals:
+
+    void someSignal(const QString &arg);
+    void nameChanged(const QString &name);
+    void someValueChanged(double value);
+    void enumValueChanged(RubyQml::TestObject::Enums value);
+
+private:
+
+    Q_ENUMS(Enums)
+    QString mName;
+    double mSomeValue = 0;
+    Enums mEnumValue = Foo;
+};
+
+} // RubyQml
+
+Q_DECLARE_METATYPE(RubyQml::TestObject::Enums)

data/ext/qml/plugins/testutil/testobjectsubclass.cpp

@@ -0,0 +1,10 @@
+#include "testobjectsubclass.h"
+
+namespace RubyQml {
+
+TestObjectSubclass::TestObjectSubclass(QObject *parent) :
+    TestObject(parent)
+{
+}
+
+} // namespace RubyQml

data/ext/qml/plugins/testutil/testobjectsubclass.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "testobject.h"
+
+namespace RubyQml {
+
+class TestObjectSubclass : public TestObject
+{
+    Q_OBJECT
+public:
+    explicit TestObjectSubclass(QObject *parent = 0);
+
+signals:
+
+public slots:
+
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/testutil/testutil.pro

@@ -0,0 +1,20 @@
+TEMPLATE = lib
+CONFIG += plugin c++11
+QT += qml
+
+TARGET = rubyqml-testutil
+INCLUDEPATH += .
+
+# Input
+SOURCES += testobject.cpp \
+    testobjectsubclass.cpp \
+    ownershiptest.cpp \
+    testutilplugin.cpp \
+    objectlifechecker.cpp
+
+HEADERS += \
+    testobject.h \
+    testobjectsubclass.h \
+    ownershiptest.h \
+    testutilplugin.h \
+    objectlifechecker.h

data/ext/qml/plugins/testutil/testutilplugin.cpp

@@ -0,0 +1,47 @@
+#include "testutilplugin.h"
+#include "testobject.h"
+#include "testobjectsubclass.h"
+#include "ownershiptest.h"
+#include "objectlifechecker.h"
+#include <QtQml>
+
+Q_DECLARE_METATYPE(const QMetaObject*)
+
+namespace RubyQml {
+
+TestUtilPlugin::TestUtilPlugin(QObject *parent) :
+    QObject(parent)
+{
+    qRegisterMetaType<TestObject *>();
+    qRegisterMetaType<TestObject::Enums>();
+    qRegisterMetaType<TestObjectSubclass *>();
+    qRegisterMetaType<OwnershipTest *>();
+    qRegisterMetaType<ObjectLifeChecker *>();
+
+    auto metaObjects = { &TestObject::staticMetaObject, &ObjectLifeChecker::staticMetaObject};
+    for (auto metaobj : metaObjects) {
+        mMetaObjects[metaobj->className()] = QVariant::fromValue(metaobj);
+    }
+}
+
+TestObject *TestUtilPlugin::createTestObject()
+{
+    return new TestObject();
+}
+
+TestObjectSubclass *TestUtilPlugin::createTestObjectSubclass()
+{
+    return new TestObjectSubclass();
+}
+
+OwnershipTest *TestUtilPlugin::createOwnershipTest()
+{
+    return new OwnershipTest();
+}
+
+ObjectLifeChecker *TestUtilPlugin::createObjectLifeChecker(QObject *target)
+{
+    return new ObjectLifeChecker(target);
+}
+
+} // namespace RubyQml