qml 0.0.7 → 1.0.0

data/examples/imageprovider/imageprovider.rb

@@ -1,57 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
-require 'qml'
-require 'open-uri'
-require 'singleton'
-require 'celluloid'
-
-module Examples
-  module ImageProvider
-
-    VERSION = '0.1.0'
-
-    class ImageFetcher
-      include Celluloid
-      include Singleton
-
-      def set_url(url)
-        @url = url
-      end
-
-      def fetch(request)
-        image =
-          case request.id
-          when "image"
-            open(@url, 'rb') { |f| f.read } rescue nil
-          end
-        request.finish(image || "")
-      end
-    end
-
-    class Controller
-      include QML::Access
-
-      property :url, ''
-
-      on_changed :url do
-        ImageFetcher.instance.async.set_url url
-      end
-
-      register_to_qml
-    end
-
-    class Provider < QML::ImageProvider
-
-      def request(req)
-        case req.id
-        when 'image'
-          ImageFetcher.instance.fetch(req)
-        end
-      end
-    end
-  end
-end
-
-QML.run do |app|
-  app.engine.add_image_provider 'example', Examples::ImageProvider::Provider.new
-  app.load_path Pathname(__FILE__) + '../main.qml'
-end

data/examples/imageprovider/main.qml

@@ -1,51 +0,0 @@
-import QtQuick 2.2
-import QtQuick.Controls 1.1
-import QtQuick.Layouts 1.1
-import Examples.ImageProvider 0.1
-
-ApplicationWindow {
-  visible: true
-  width: 200
-  height: 200
-
-  GridLayout {
-    anchors.fill: parent
-    anchors.margins: 10
-    columns: 1
-
-    Image {
-      id: image
-      source: 'image://example/image'
-      asynchronous: true
-      cache: false
-      fillMode: Image.Pad
-      Layout.fillHeight: true
-
-      function reload() {
-        source = ''
-        source = 'image://example/image'
-      }
-    }
-
-    GridLayout {
-      columns: 2
-
-      Label {
-        text: 'Image URL'
-      }
-
-      TextField {
-        id: textField
-        Layout.fillWidth: true
-        onEditingFinished: {
-          image.reload()
-        }
-      }
-    }
-  }
-
-  Controller {
-    id: provider
-    url: textField.text
-  }
-}

data/ext/qml/accessclass.cpp

@@ -1,65 +0,0 @@
-#include "accessclass.h"
-#include "accessobject.h"
-#include "util.h"
-#include <QDebug>
-
-namespace RubyQml {
-
-AccessClass::AccessClass(RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos)
-{
-    setClassName(className.to<QByteArray>());
-    rb_check_array_type(methodInfos);
-    rb_check_array_type(signalInfos);
-    rb_check_array_type(propertyInfos);
-    for (int i = 0; i < RARRAY_LEN(VALUE(methodInfos)); ++i) {
-        RubyValue info = RARRAY_AREF(VALUE(methodInfos), i);
-        auto nameSym = info.send("name");
-        addMethod(nameSym.to<QByteArray>(),
-                  nameSym.toID(),
-                  info.send("params").to<QList<QByteArray>>());
-    }
-    for (int i = 0; i < RARRAY_LEN(VALUE(signalInfos)); ++i) {
-        RubyValue info = RARRAY_AREF(VALUE(signalInfos), i);
-        auto nameSym = info.send("name");
-        addSignal(nameSym.to<QByteArray>(),
-                  nameSym.toID(),
-                  info.send("params").to<QList<QByteArray>>());
-    }
-    for (int i = 0; i < RARRAY_LEN(VALUE(propertyInfos)); ++i) {
-        RubyValue info = RARRAY_AREF(VALUE(propertyInfos), i);
-        addProperty(info.send("name").to<QByteArray>(),
-                    info.send("getter").toID(),
-                    info.send("setter").toID(),
-                    Property::Flag::Readable | Property::Flag::Writable,
-                    true,
-                    info.send("notifier").toID());
-    }
-}
-
-QVariant AccessClass::callMethod(ForeignObject *obj, size_t id, const QVariantList &args)
-{
-    auto self = static_cast<AccessWrapper *>(obj)->wrappedValue();
-    QVariant ret;
-    withGvl([&] {
-        std::vector<VALUE> values(args.size());
-        std::transform(args.begin(), args.end(), values.begin(), &RubyValue::from<QVariant>);
-        RubyValue retValue;
-        rescueNotify([&] {
-            retValue = rb_funcall2(self, id, values.size(), values.data());
-        });
-        ret = retValue.to<QVariant>();
-    });
-    return ret;
-}
-
-void AccessClass::setProperty(ForeignObject *obj, size_t id, const QVariant &variant)
-{
-    callMethod(obj, id, {variant});
-}
-
-QVariant AccessClass::getProperty(ForeignObject *obj, size_t id)
-{
-    return callMethod(obj, id, {});
-}
-
-} // namespace RubyQml

data/ext/qml/accessclass.h

@@ -1,19 +0,0 @@
-#pragma once
-#include "foreignclass.h"
-#include "rubyvalue.h"
-
-namespace RubyQml {
-
-class AccessWrapper;
-
-class AccessClass : public ForeignClass
-{
-public:
-    AccessClass(RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos);
-
-    QVariant callMethod(ForeignObject *obj, size_t id, const QVariantList &args) override;
-    void setProperty(ForeignObject *obj, size_t id, const QVariant &value) override;
-    QVariant getProperty(ForeignObject *obj, size_t id) override;
-};
-
-} // namespace RubyQml

data/ext/qml/accessobject.cpp

@@ -1,30 +0,0 @@
-#include "accessobject.h"
-#include "util.h"
-#include "rubyclass.h"
-#include <QSet>
-
-namespace RubyQml {
-
-AccessWrapper::AccessWrapper(const SP<ForeignMetaObject> &metaobj, RubyValue value) :
-    ForeignObject(metaobj),
-    mWrapped(value)
-{
-    if (!value.isKindOf(RubyModule::fromPath("QML::Access"))) {
-        std::logic_error("wrapping non QML::Access object");
-    }
-    value.send("access_wrappers").send("push", RubyValue::fromQObject(this, false));
-}
-
-AccessWrapper::~AccessWrapper()
-{
-    if (mWrapped.hasValue()) {
-        mWrapped.value().send("access_wrappers").send("delete", RubyValue::fromQObject(this, false));
-    }
-}
-
-void AccessWrapper::gc_mark()
-{
-    rb_gc_mark(mWrapped.value());
-}
-
-} // namespace RubyQml

data/ext/qml/accessobject.h

@@ -1,22 +0,0 @@
-#pragma once
-#include "weakvaluereference.h"
-#include "foreignobject.h"
-#include "markable.h"
-
-namespace RubyQml {
-
-class AccessWrapper : public ForeignObject, public Markable
-{
-public:
-    AccessWrapper(const SP<ForeignMetaObject> &metaobj, RubyValue wrappedValue);
-    ~AccessWrapper();
-
-    RubyValue wrappedValue() { return mWrapped.value(); }
-    void gc_mark() override;
-
-private:
-    WeakValueReference mWrapped;
-};
-
-} // namespace RubyQml
-

data/ext/qml/common.h

@@ -1,18 +0,0 @@
-#pragma once
-#include <memory>
-
-namespace RubyQml {
-
-template <typename T>
-using SP = std::shared_ptr<T>;
-
-template <typename T>
-using WP = std::weak_ptr<T>;
-
-template <typename T, typename ... Args>
-inline SP<T> makeSP(Args && ... args)
-{
-    return std::make_shared<T>(std::forward<Args>(args)...);
-}
-
-} // namespace RubyQml

data/ext/qml/conversionerror.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include <stdexcept>
-#include <QString>
-
-namespace RubyQml {
-
-class ConversionError : public std::runtime_error
-{
-public:
-    ConversionError(const QString &str) : std::runtime_error(str.toStdString()) {}
-};
-
-}

data/ext/qml/ext_accesswrapperfactory.cpp

@@ -1,75 +0,0 @@
-#include "ext_accesswrapperfactory.h"
-#include "ext_pointer.h"
-#include "rubyclass.h"
-#include "accessclass.h"
-#include "accessobject.h"
-#include "foreignmetaobject.h"
-#include "qmltyperegisterer.h"
-
-namespace RubyQml {
-
-Ext_AccessWrapperFactory::Ext_AccessWrapperFactory(RubyValue self) :
-    self(self)
-{
-}
-
-Ext_AccessWrapperFactory::~Ext_AccessWrapperFactory()
-{
-}
-
-RubyValue Ext_AccessWrapperFactory::ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos)
-{
-    mRubyClass = rubyClass;
-    mAccessClass = makeSP<AccessClass>(className, methodInfos, signalInfos, propertyInfos);
-    mMetaObject = makeSP<ForeignMetaObject>(mAccessClass);
-    return self;
-}
-
-RubyValue Ext_AccessWrapperFactory::ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args)
-{
-    auto accessObj = wrapperRubyClass<Ext_Pointer>().unwrap(obj.send("access_object"))->fetchQObject();
-    auto nameId = name.toID();
-    auto argVariants = args.to<QVariantList>();
-    withoutGvl([&] {
-        mMetaObject->emitSignal(dynamic_cast<ForeignObject *>(accessObj), nameId, argVariants);
-    });
-    return Qnil;
-}
-
-RubyValue Ext_AccessWrapperFactory::ext_registerToQml(RubyValue path, RubyValue majorVersion, RubyValue minorVersion, RubyValue name)
-{
-    using namespace std::placeholders;
-    if (!mTypeRegisterer) {
-        mTypeRegisterer = makeSP<QmlTypeRegisterer>(mMetaObject, std::bind(&Ext_AccessWrapperFactory::newInstanceInto, this, _1));
-        mTypeRegisterer->registerType(path.to<QByteArray>(), majorVersion.to<int>(), minorVersion.to<int>(), name.to<QByteArray>());
-    }
-    return self;
-}
-
-RubyValue Ext_AccessWrapperFactory::ext_create(RubyValue access)
-{
-    return RubyValue::fromQObject(create(access), false);
-}
-
-AccessWrapper *Ext_AccessWrapperFactory::create(RubyValue access)
-{
-    return new AccessWrapper(mMetaObject, access);
-}
-
-void Ext_AccessWrapperFactory::newInstanceInto(void *where)
-{
-    withGvl([&] {
-        new(where) AccessWrapper(mMetaObject, mRubyClass.send("new"));
-    });
-}
-
-void Ext_AccessWrapperFactory::defineClass()
-{
-    WrapperRubyClass<Ext_AccessWrapperFactory> klass(RubyModule::fromPath("QML"), "AccessWrapperFactory");
-    klass.defineMethod(MethodAccess::Protected, "initialize", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_initialize));
-    klass.defineMethod("emit_signal", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_emitSignal));
-    klass.defineMethod("register_to_qml", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_registerToQml));
-    klass.defineMethod("create", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_create));
-}
-
-} // namespace RubyQml

data/ext/qml/ext_accesswrapperfactory.h

@@ -1,39 +0,0 @@
-#pragma once
-#include "common.h"
-#include "rubyvalue.h"
-
-namespace RubyQml {
-
-class AccessClass;
-class ForeignMetaObject;
-class QmlTypeRegisterer;
-class AccessWrapper;
-
-class Ext_AccessWrapperFactory
-{
-public:
-    Ext_AccessWrapperFactory(RubyValue self);
-    ~Ext_AccessWrapperFactory();
-
-    RubyValue ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos);
-    RubyValue ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args);
-    RubyValue ext_registerToQml(RubyValue path, RubyValue majorVersion, RubyValue minorVersion, RubyValue name);
-    RubyValue ext_create(RubyValue access);
-
-    AccessWrapper *create(RubyValue access);
-
-    void gc_mark() {}
-    static void defineClass();
-
-private:
-
-    void newInstanceInto(void *where);
-
-    const RubyValue self;
-    RubyValue mRubyClass;
-    SP<AccessClass> mAccessClass;
-    SP<ForeignMetaObject> mMetaObject;
-    SP<QmlTypeRegisterer> mTypeRegisterer;
-};
-
-} // namespace RubyQml

data/ext/qml/ext_anywrapper.cpp

@@ -1,34 +0,0 @@
-#include "ext_anywrapper.h"
-#include "rubyclass.h"
-
-namespace RubyQml {
-
-Ext_AnyWrapper::Ext_AnyWrapper(RubyValue self)
-{
-    Q_UNUSED(self);
-}
-
-RubyValue Ext_AnyWrapper::create(const QVariant &value, void (*markFunction)(const QVariant &))
-{
-    auto klass = wrapperRubyClass<Ext_AnyWrapper>();
-    auto wrapper = klass.newInstance();
-    auto ptr = klass.unwrap(wrapper);
-    ptr->mValue = value;
-    ptr->mMarkFunction = markFunction;
-    return wrapper;
-}
-
-void Ext_AnyWrapper::defineClass()
-{
-    WrapperRubyClass<Ext_AnyWrapper> klass(RubyModule::fromPath("QML"), "AnyWrapper");
-    Q_UNUSED(klass);
-}
-
-void Ext_AnyWrapper::gc_mark()
-{
-    if (mMarkFunction) {
-        mMarkFunction(mValue);
-    }
-}
-
-} // namespace RubyQml

data/ext/qml/ext_anywrapper.h

@@ -1,23 +0,0 @@
-#pragma once
-#include <QVariant>
-
-namespace RubyQml {
-
-class RubyValue;
-
-class Ext_AnyWrapper
-{
-public:
-    Ext_AnyWrapper(RubyValue self);
-    static RubyValue create(const QVariant &value, void (*markFunction)(const QVariant &) = nullptr);
-    static void defineClass();
-
-    QVariant value() const { return mValue; }
-    void gc_mark();
-
-private:
-    QVariant mValue;
-    void (*mMarkFunction)(const QVariant &);
-};
-
-} // namespace RubyQml