qml 0.0.7 → 1.0.0

data/ext/qml/lib/libqmlbind/testplugin/testplugin.cpp

@@ -0,0 +1,11 @@
+#include "testplugin.h"
+
+
+TestPlugin::TestPlugin(QObject *parent) :
+    QObject(parent)
+{
+}
+
+#if QT_VERSION < 0x050000
+Q_EXPORT_PLUGIN2(testplugin, TestPlugin)
+#endif // QT_VERSION < 0x050000

data/ext/qml/lib/libqmlbind/testplugin/testplugin.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <QObject>
+
+class TestPlugin : public QObject
+{
+    Q_OBJECT
+#if QT_VERSION >= 0x050000
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QGenericPluginFactoryInterface" FILE "testplugin.json")
+#endif // QT_VERSION >= 0x050000
+
+    Q_PROPERTY(int test READ test)
+
+public:
+    TestPlugin(QObject *parent = 0);
+
+    int test() const
+    {
+        return 12345;
+    }
+};

data/ext/qml/lib/libqmlbind/testplugin/testplugin.json

@@ -0,0 +1,3 @@
+{
+    "Keys" : [ ]
+}

data/ext/qml/lib/libqmlbind/testplugin/testplugin.pro

@@ -0,0 +1,21 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2015-05-16T02:03:07
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+TARGET = testplugin
+TEMPLATE = lib
+CONFIG += plugin
+
+SOURCES += testplugin.cpp
+
+HEADERS += testplugin.h
+DISTFILES += testplugin.json
+
+unix {
+    target.path = /usr/lib
+    INSTALLS += target
+}

data/ext/qml/meta_object.c

@@ -0,0 +1,81 @@
+#include "meta_object.h"
+#include "engine.h"
+#include "conversion.h"
+
+VALUE rbqml_cMetaObject;
+
+typedef struct {
+    qmlbind_metaobject metaobject;
+} metaobject;
+
+static void metaobject_free(void *p) {
+    metaobject *data = p;
+
+    rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_metaobject_release, data->metaobject, RUBY_UBF_IO, NULL);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::MetaObject",
+    { NULL, metaobject_free }
+};
+
+qmlbind_metaobject rbqml_get_metaobject(VALUE self) {
+    metaobject *data;
+    TypedData_Get_Struct(self, metaobject, &data_type, data);
+    return data->metaobject;
+}
+
+static VALUE metaobject_alloc(VALUE klass) {
+    metaobject *data = ALLOC(metaobject);
+    data->metaobject = NULL;
+    return TypedData_Wrap_Struct(klass, &data_type, data);
+}
+
+VALUE rbqml_metaobject_new(qmlbind_metaobject metaobj) {
+    VALUE self = metaobject_alloc(rbqml_cMetaObject);
+    metaobject *data;
+    TypedData_Get_Struct(self, metaobject, &data_type, data);
+    data->metaobject = metaobj;
+    return self;
+}
+
+typedef struct {
+    qmlbind_engine engine;
+    qmlbind_metaobject metaobject;
+    qmlbind_backref backref;
+} wrap_data;
+
+void *wrap_impl(void *p) {
+    wrap_data *data = p;
+    return qmlbind_engine_new_wrapper(data->engine, data->metaobject, data->backref);
+}
+
+VALUE metaobject_wrap(VALUE self, VALUE access) {
+    wrap_data data;
+    data.engine = rbqml_get_engine(rbqml_engine);
+    data.metaobject = rbqml_get_metaobject(self);
+    data.backref = (qmlbind_backref)access;
+
+    qmlbind_value wrapped = rb_thread_call_without_gvl(wrap_impl, &data, RUBY_UBF_IO, NULL);
+    return rbqml_to_ruby(wrapped);
+}
+
+static VALUE metaobject_register(VALUE self, VALUE uri, VALUE versionMajor, VALUE versionMinor, VALUE qmlName) {
+    qmlbind_metaobject metaobj = rbqml_get_metaobject(self);
+    qmlbind_register_type(
+        metaobj,
+        rb_string_value_cstr(&uri),
+        NUM2INT(versionMajor), NUM2INT(versionMinor),
+        rb_string_value_cstr(&qmlName));
+    return self;
+}
+
+void rbqml_init_meta_object(void) {
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cMetaObject = rb_define_class_under(mQML, "MetaObject", rb_cObject);
+
+    rb_define_alloc_func(rbqml_cMetaObject, metaobject_alloc);
+    rb_define_method(rbqml_cMetaObject, "wrap", metaobject_wrap, 1);
+    rb_define_method(rbqml_cMetaObject, "register", metaobject_register, 4);
+}

data/ext/qml/meta_object.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "qml.h"
+
+extern VALUE rbqml_mMetaObject;
+
+VALUE rbqml_metaobject_new(qmlbind_metaobject metaobj);
+void rbqml_init_meta_object(void);

data/ext/qml/plugin_loader.c

@@ -0,0 +1,71 @@
+#include "plugin_loader.h"
+#include "engine.h"
+#include "conversion.h"
+
+static VALUE cPluginError;
+VALUE rbqml_cPluginLoader;
+
+typedef struct {
+    qmlbind_plugin plugin;
+} plugin_loader_t;
+
+static void plugin_loader_free(void *p) {
+    plugin_loader_t *data = (plugin_loader_t*)p;
+    qmlbind_plugin_release(data->plugin);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::PluginLoader",
+    { NULL, &plugin_loader_free }
+};
+
+qmlbind_plugin rbqml_get_plugin(VALUE self) {
+    plugin_loader_t *data;
+    TypedData_Get_Struct(self, plugin_loader_t, &data_type, data);
+    return data->plugin;
+}
+
+static VALUE plugin_loader_alloc(VALUE klass) {
+    plugin_loader_t *data = ALLOC(plugin_loader_t);
+    data->plugin = NULL;
+    return TypedData_Wrap_Struct(klass, &data_type, data);
+}
+
+static VALUE plugin_loader_init(VALUE self, VALUE path) {
+    plugin_loader_t *data;
+    TypedData_Get_Struct(self, plugin_loader_t, &data_type, data);
+    data->plugin = qmlbind_plugin_new(rb_string_value_cstr(&path));
+    return self;
+}
+
+/*
+ * Loads the plugin and returns the instance of the plugin.
+ * @return [QML::JSObject]
+ */
+static VALUE plugin_loader_instance(VALUE self) {
+    qmlbind_plugin plugin = rbqml_get_plugin(self);
+
+    qmlbind_string qmlerror = qmlbind_plugin_get_error_string(plugin);
+    if (qmlerror) {
+        VALUE errorStr = rb_enc_str_new(qmlbind_string_get_chars(qmlerror), qmlbind_string_get_length(qmlerror), rb_utf8_encoding());
+        qmlbind_string_release(qmlerror);
+
+        VALUE error = rb_funcall(cPluginError, rb_intern("new"), 1, errorStr);
+        rb_exc_raise(error);
+    }
+
+    qmlbind_value loaded = qmlbind_plugin_get_instance(plugin, rbqml_get_engine(rbqml_engine));
+    return rbqml_to_ruby(loaded);
+}
+
+void rbqml_init_plugin_loader(void) {
+    cPluginError = rb_path2class("QML::PluginError");
+
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cPluginLoader = rb_define_class_under(mQML, "PluginLoader", rb_cObject);
+    rb_define_alloc_func(rbqml_cPluginLoader, &plugin_loader_alloc);
+
+    rb_define_private_method(rbqml_cPluginLoader, "initialize_impl", plugin_loader_init, 1);
+    rb_define_method(rbqml_cPluginLoader, "instance", plugin_loader_instance, 0);
+}

data/ext/qml/plugin_loader.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "qml.h"
+
+extern VALUE rbqml_cPluginLoader;
+
+void rbqml_init_plugin_loader();

data/ext/qml/qml.c

@@ -0,0 +1,95 @@
+#include "qml.h"
+#include "application.h"
+#include "component.h"
+#include "engine.h"
+#include "exporter.h"
+#include "interface.h"
+#include "js_object.h"
+#include "js_array.h"
+#include "js_function.h"
+#include "js_wrapper.h"
+#include "signal_emitter.h"
+#include "plugin_loader.h"
+#include "dispatcher.h"
+#include "meta_object.h"
+
+VALUE rbqml_mQML;
+VALUE rbqml_application = Qnil;
+VALUE rbqml_engine = Qnil;
+
+/*
+ * @api private
+ */
+static VALUE qml_init(VALUE module, VALUE args) {
+    if (!NIL_P(rbqml_application)) {
+        rb_raise(rb_eRuntimeError, "QML already initialized");
+    }
+
+    rbqml_application = rb_funcall(rbqml_cApplication, rb_intern("new"), 1, args);
+    rbqml_engine = rb_funcall(rbqml_cEngine, rb_intern("new"), 0);
+
+    rb_gc_register_address(&rbqml_application);
+    rb_gc_register_address(&rbqml_engine);
+
+    VALUE blocks = rb_const_get(module, rb_intern("INIT_BLOCKS"));
+    for (int i = 0; i < RARRAY_LEN(blocks); ++i) {
+        rb_proc_call(RARRAY_AREF(blocks, i), rb_ary_new());
+    }
+
+    return module;
+}
+
+static VALUE qml_initialized_p(VALUE module) {
+    if (NIL_P(rbqml_application)) {
+        return Qfalse;
+    } else {
+        return Qtrue;
+    }
+}
+
+/*
+ * Returns the instance of {Application}.
+ * @return [Application]
+ */
+static VALUE qml_application(VALUE module) {
+    if (NIL_P(rbqml_application)) {
+        rb_raise(rb_eRuntimeError, "QML not yet initialized");
+    }
+    return rbqml_application;
+}
+
+/*
+ * Returns the instance of {Engine}.
+ * @return [Engine]
+ */
+static VALUE qml_engine(VALUE module) {
+    if (NIL_P(rbqml_engine)) {
+        rb_raise(rb_eRuntimeError, "QML not yet initialized");
+    }
+    return rbqml_engine;
+
+}
+
+void Init_qml(void)
+{
+    rbqml_mQML = rb_define_module("QML");
+
+    rbqml_init_application();
+    rbqml_init_engine();
+    rbqml_init_component();
+    rbqml_init_interface();
+    rbqml_init_exporter();
+    rbqml_init_js_object();
+    rbqml_init_js_array();
+    rbqml_init_js_function();
+    rbqml_init_js_wrapper();
+    rbqml_init_signal_emitter();
+    rbqml_init_plugin_loader();
+    rbqml_init_dispatcher();
+    rbqml_init_meta_object();
+
+    rb_define_module_function(rbqml_mQML, "initialized?", qml_initialized_p, 0);
+    rb_define_module_function(rbqml_mQML, "init_impl", qml_init, 1);
+    rb_define_module_function(rbqml_mQML, "application", qml_application, 0);
+    rb_define_module_function(rbqml_mQML, "engine", qml_engine, 0);
+}

data/ext/qml/qml.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <ruby/ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/thread.h>
+#include <qmlbind.h>
+
+extern VALUE rbqml_mQML;
+extern VALUE rbqml_application;
+extern VALUE rbqml_engine;

data/ext/qml/rubyqml-plugin/listmodel.cpp

@@ -0,0 +1,102 @@
+#include "listmodel.h"
+#include <QQmlEngine>
+#include <QDebug>
+
+namespace RubyQml {
+
+static QJSValue callMethod(QJSValue self, const QString &name, const QJSValueList &args)
+{
+    QJSValue func = self.property(name);
+    return func.callWithInstance(self, args);
+}
+
+ListModel::ListModel(const QJSValue &rubyModelAccess, QObject *parent) : QAbstractListModel(parent),
+    mRubyModelAccess(rubyModelAccess)
+{
+    QObject *access = rubyModelAccess.toQObject();
+    Q_ASSERT(access);
+    QQmlEngine::setObjectOwnership(access, QQmlEngine::CppOwnership);
+    access->setParent(this);
+
+    QVariantList columns = callMethod(rubyModelAccess, "columns", QJSValueList()).toVariant().toList();
+    for (int i = 0; i < columns.size(); ++i) {
+        mRoleNames[Qt::UserRole + i] = columns[i].toString().toUtf8();
+    }
+
+    connect(access, SIGNAL(begin_insert(QJSValue,QJSValue)), this, SLOT(beginInsert(QJSValue,QJSValue)));
+    connect(access, SIGNAL(end_insert()), this, SLOT(endInsert()));
+    connect(access, SIGNAL(begin_remove(QJSValue,QJSValue)), this, SLOT(beginRemove(QJSValue,QJSValue)));
+    connect(access, SIGNAL(end_remove()), this, SLOT(endRemove()));
+    connect(access, SIGNAL(begin_move(QJSValue,QJSValue,QJSValue)), this, SLOT(beginMove(QJSValue,QJSValue,QJSValue)));
+    connect(access, SIGNAL(end_move()), this, SLOT(endMove()));
+    connect(access, SIGNAL(update(QJSValue,QJSValue)), this, SLOT(update(QJSValue,QJSValue)));
+    connect(access, SIGNAL(begin_reset()), this, SLOT(beginReset()));
+    connect(access, SIGNAL(end_reset()), this, SLOT(endReset()));
+}
+
+QHash<int, QByteArray> ListModel::roleNames() const
+{
+    return mRoleNames;
+}
+
+QVariant ListModel::data(const QModelIndex &index, int role) const
+{
+    QJSValueList args;
+    args << index.row();
+    args << QString::fromUtf8(mRoleNames[role]);
+    return QVariant::fromValue(callMethod(mRubyModelAccess, "data", args));
+}
+
+int ListModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return callMethod(mRubyModelAccess, "count", QJSValueList()).toInt();
+}
+
+void ListModel::beginMove(const QJSValue &first, const QJSValue &last, const QJSValue &destination)
+{
+    beginMoveRows(QModelIndex(), first.toInt(), last.toInt(), QModelIndex(), destination.toInt());
+}
+
+void ListModel::endMove()
+{
+    endMoveRows();
+}
+
+void ListModel::beginInsert(const QJSValue &first, const QJSValue &last)
+{
+    beginInsertRows(QModelIndex(), first.toInt(), last.toInt());
+}
+
+void ListModel::endInsert()
+{
+    endInsertRows();
+}
+
+void ListModel::beginRemove(const QJSValue &first, const QJSValue &last)
+{
+    beginRemoveRows(QModelIndex(), first.toInt(), last.toInt());
+}
+
+void ListModel::endRemove()
+{
+    endRemoveRows();
+}
+
+void ListModel::beginReset()
+{
+    beginResetModel();
+}
+
+void ListModel::endReset()
+{
+    endResetModel();
+}
+
+void ListModel::update(const QJSValue &first, const QJSValue &last)
+{
+    emit dataChanged(index(first.toInt()), index(last.toInt()));
+}
+
+} // namespace RubyQml
+

data/ext/qml/rubyqml-plugin/listmodel.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <QAbstractListModel>
+#include <QJSValue>
+
+namespace RubyQml {
+
+class ListModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    explicit ListModel(const QJSValue &rubyModelAccess, QObject *parent = 0);
+
+    QHash<int, QByteArray> roleNames() const;
+    QVariant data(const QModelIndex &index, int role) const;
+    int rowCount(const QModelIndex &parent) const;
+
+signals:
+
+public slots:
+    void beginMove(const QJSValue &first, const QJSValue &last, const QJSValue &destination);
+    void endMove();
+    void beginInsert(const QJSValue &first, const QJSValue &last);
+    void endInsert();
+    void beginRemove(const QJSValue &first, const QJSValue &last);
+    void endRemove();
+    void beginReset();
+    void endReset();
+    void update(const QJSValue &first, const QJSValue &last);
+
+private:
+
+    QHash<int, QByteArray> mRoleNames;
+    QJSValue mRubyModelAccess;
+};
+
+} // namespace RubyQml