qml 0.0.7 → 1.0.0

data/examples/twitter/twitter.rb

@@ -2,7 +2,6 @@ $LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'qml'
 require 'twitter'
 require 'yaml'
-require 'celluloid'
 
 module Examples
   module Twitter
@@ -43,7 +42,7 @@ module Examples
       include QML::Access
       register_to_qml
 
-      property :model, QML::Data::ArrayModel.new(:tweet_text, :user_name, :user_icon)
+      property(:model) { QML::ArrayModel.new(:tweet_text, :user_name, :user_icon) }
       property :word
 
       def initialize
@@ -64,9 +63,12 @@ module Examples
         word = self.word
         @thread = Thread.new do
           TweetFetcher.new.start(word) do |tweet|
-            later.add_tweet(tweet)
+            QML.next_tick do
+              add_tweet(tweet)
+            end
           end
         end
+        nil
       end
     end
   end

data/ext/qml/application.c

@@ -0,0 +1,88 @@
+#include "application.h"
+#include "interface.h"
+
+VALUE rbqml_cApplication = Qnil;
+
+typedef struct {
+    qmlbind_application application;
+} application_t;
+
+static void application_free(void *p) {
+    application_t *data = (application_t*)p;
+    // application is never released
+    // qmlbind_application_release(data->application);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::Application",
+    { NULL, &application_free }
+};
+
+qmlbind_application rbqml_get_application(VALUE self) {
+    application_t *data;
+    TypedData_Get_Struct(self, application_t, &data_type, data);
+    return data->application;
+}
+
+static VALUE application_alloc(VALUE klass) {
+    application_t *data = ALLOC(application_t);
+    data->application = NULL;
+    return TypedData_Wrap_Struct(klass, &data_type, data);
+}
+
+static VALUE application_initialize(VALUE self, VALUE args) {
+    if (rb_thread_main() != rb_thread_current()) {
+        rb_raise(rb_eThreadError, "Initializing QML::Application outside the main thread");
+    }
+
+    application_t *data;
+    TypedData_Get_Struct(self, application_t, &data_type, data);
+
+    if (rb_type(args) != T_ARRAY) {
+        rb_raise(rb_eTypeError, "Expected Array");
+    }
+
+    args = rb_ary_concat(rb_ary_new_from_args(1, rb_argv0), args);
+
+    int argc = RARRAY_LEN(args);
+    char **argv = malloc(argc * sizeof(char *));
+
+    for (int i = 0; i < argc; ++i) {
+        VALUE arg = RARRAY_AREF(args, i);
+        argv[i] = rb_string_value_cstr(&arg);
+    }
+
+    data->application = qmlbind_application_new(argc, argv);
+
+    return self;
+}
+
+/*
+ * Starts the event loop of the application.
+ * This method never returns until the application quits.
+ */
+static VALUE application_exec(VALUE self) {
+    qmlbind_application app = rbqml_get_application(self);
+    int ret = (int)rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_application_exec, app, RUBY_UBF_IO, NULL);
+    return INT2NUM(ret);
+}
+
+/*
+ * Processes queued events in the event loop manually.
+ * This method is useful when you are combining an external event loop like EventMachine.
+ */
+static VALUE application_process_events(VALUE application) {
+    rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_process_events, NULL, RUBY_UBF_IO, NULL);
+    return Qnil;
+}
+
+void rbqml_init_application(void) {
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cApplication = rb_define_class_under(mQML, "Application", rb_cObject);
+    rb_define_alloc_func(rbqml_cApplication, application_alloc);
+
+    rb_define_private_method(rbqml_cApplication, "initialize", application_initialize, 1);
+    rb_define_method(rbqml_cApplication, "exec", application_exec, 0);
+    rb_define_method(rbqml_cApplication, "process_events", application_process_events, 0);
+}

data/ext/qml/application.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "qml.h"
+
+extern VALUE rbqml_cApplication;
+
+qmlbind_application rbqml_get_application(VALUE self);
+
+void rbqml_init_application(void);

data/ext/qml/component.c

@@ -0,0 +1,89 @@
+#include "qml.h"
+#include "component.h"
+#include "engine.h"
+#include "conversion.h"
+
+VALUE rbqml_cComponent;
+
+typedef struct {
+    qmlbind_component component;
+} component_t;
+
+static void component_free(void *p) {
+    component_t *data = (component_t *)p;
+    rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_component_release, data->component, RUBY_UBF_IO, NULL);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::Component",
+    { NULL, &component_free }
+};
+
+qmlbind_component rbqml_get_component(VALUE self) {
+    component_t *data;
+    TypedData_Get_Struct(self, component_t, &data_type, data);
+    return data->component;
+}
+
+static VALUE component_alloc(VALUE klass) {
+    component_t *data = ALLOC(component_t);
+    data->component = NULL;
+    return TypedData_Wrap_Struct(klass, &data_type, data);
+}
+
+static VALUE component_initialize(VALUE self) {
+    component_t *data;
+    TypedData_Get_Struct(self, component_t, &data_type, data);
+    data->component = qmlbind_component_new(rbqml_get_engine(rbqml_engine));
+
+    return self;
+}
+
+static VALUE component_load_path(VALUE self, VALUE path) {
+    qmlbind_component component = rbqml_get_component(self);
+    qmlbind_component_load_path(component, rb_string_value_cstr(&path));
+
+    return self;
+}
+
+static VALUE component_load_data(VALUE self, VALUE data, VALUE path) {
+    qmlbind_component component = rbqml_get_component(self);
+    qmlbind_component_set_data(component, rb_string_value_cstr(&data), rb_string_value_cstr(&path));
+
+    return self;
+}
+
+static VALUE component_error_string(VALUE self) {
+    qmlbind_component component = rbqml_get_component(self);
+    qmlbind_string error = qmlbind_component_get_error_string(component);
+    if (error) {
+        VALUE str = rb_enc_str_new(qmlbind_string_get_chars(error), qmlbind_string_get_length(error), rb_utf8_encoding());
+        qmlbind_string_release(error);
+        return str;
+    } else {
+        return Qnil;
+    }
+}
+
+static VALUE component_create(VALUE self) {
+    component_t *data;
+    TypedData_Get_Struct(self, component_t, &data_type, data);
+
+    qmlbind_value obj = rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_component_create, data->component, RUBY_UBF_IO, NULL);
+    VALUE result = rbqml_to_ruby(obj);
+    qmlbind_value_release(obj);
+
+    return result;
+}
+
+void rbqml_init_component() {
+    rbqml_cComponent = rb_define_class_under(rb_path2class("QML"), "Component", rb_cObject);
+    rb_define_alloc_func(rbqml_cComponent, &component_alloc);
+
+    rb_define_private_method(rbqml_cComponent, "initialize_impl", &component_initialize, 0);
+    rb_define_private_method(rbqml_cComponent, "load_path_impl", &component_load_path, 1);
+    rb_define_private_method(rbqml_cComponent, "load_data_impl", &component_load_data, 2);
+    rb_define_private_method(rbqml_cComponent, "error_string", &component_error_string, 0);
+    rb_define_private_method(rbqml_cComponent, "create_impl", &component_create, 0);
+}

data/ext/qml/component.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <ruby/ruby.h>
+#include <qmlbind.h>
+
+extern VALUE rbqml_cComponent;
+
+qmlbind_component rbqml_get_component(VALUE value);
+
+void rbqml_init_component(void);

data/ext/qml/conversion.c

@@ -0,0 +1,60 @@
+#include "qml.h"
+#include "conversion.h"
+#include "js_object.h"
+#include "js_array.h"
+#include "js_function.h"
+#include "js_wrapper.h"
+
+VALUE rbqml_to_ruby(qmlbind_value value)
+{
+    if (qmlbind_value_is_undefined(value) || qmlbind_value_is_null(value)) {
+        return Qnil;
+    }
+    if (qmlbind_value_is_boolean(value)) {
+        return qmlbind_value_get_boolean(value) ? Qtrue : Qfalse;
+    }
+    if (qmlbind_value_is_number(value)) {
+        double num = qmlbind_value_get_number(value);
+        return rb_float_new(num);
+    }
+    if (qmlbind_value_is_string(value)) {
+        qmlbind_string str = qmlbind_value_get_string(value);
+        return rb_enc_str_new(qmlbind_string_get_chars(str), qmlbind_string_get_length(str), rb_utf8_encoding());
+    }
+
+    VALUE klass;
+
+    if (qmlbind_value_is_array(value)) {
+        klass = rbqml_cJSArray;
+    } else if (qmlbind_value_is_function(value)) {
+        klass = rbqml_cJSFunction;
+    } else if (qmlbind_value_is_wrapper(value)) {
+        klass = rbqml_cJSWrapper;
+    } else {
+        klass = rbqml_cJSObject;
+    }
+
+    return rbqml_js_object_new(klass, value);
+}
+
+qmlbind_value rbqml_to_qml(VALUE value)
+{
+    value = rb_funcall(value, rb_intern("to_qml"), 0);
+
+    switch (rb_type(value)) {
+    case T_NIL:
+        return qmlbind_value_new_null();
+    case T_TRUE:
+        return qmlbind_value_new_boolean(true);
+    case T_FALSE:
+        return qmlbind_value_new_boolean(false);
+    case T_FLOAT:
+        return qmlbind_value_new_number(rb_float_value(value));
+    case T_STRING:
+        return qmlbind_value_new_string(RSTRING_LEN(value), RSTRING_PTR(value));
+    default:
+        break;
+    }
+
+    return rbqml_js_object_get(value);
+}

data/ext/qml/conversion.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <ruby/ruby.h>
+#include <qmlbind.h>
+#include <stdbool.h>
+
+VALUE rbqml_to_ruby(qmlbind_value value);
+qmlbind_value rbqml_to_qml(VALUE value);

data/ext/qml/dispatcher.c

@@ -0,0 +1,31 @@
+#include "dispatcher.h"
+
+VALUE rbqml_cDispatcher;
+int callback_enabled = 1;
+
+static void tick_callback_impl() {
+    VALUE dispatcher = rb_funcall(rbqml_cDispatcher, rb_intern("instance"), 0);
+    rb_funcall(dispatcher, rb_intern("run_tasks"), 0);
+}
+
+static void tick_callback() {
+    if (__sync_fetch_and_add(&callback_enabled, 0)) {
+        rb_thread_call_with_gvl((void *(*)(void *))&tick_callback_impl, NULL);
+    }
+}
+
+static VALUE dispatcher_callback_enabled_set(VALUE self, VALUE enabled) {
+    if (RTEST(enabled)) {
+        __sync_fetch_and_or(&callback_enabled, 1);
+    } else {
+        __sync_fetch_and_and(&callback_enabled, 0);
+    }
+    return enabled;
+}
+
+void rbqml_init_dispatcher(void) {
+    rbqml_cDispatcher = rb_define_class_under(rb_path2class("QML"), "Dispatcher", rb_cObject);
+    rb_define_private_method(rbqml_cDispatcher, "callback_enabled=", &dispatcher_callback_enabled_set, 1);
+
+    qmlbind_set_tick_callback(&tick_callback);
+}

data/ext/qml/dispatcher.h

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

data/ext/qml/engine.c

@@ -0,0 +1,135 @@
+#include "engine.h"
+#include "conversion.h"
+#include "application.h"
+#include "js_object.h"
+#include "js_array.h"
+
+VALUE rbqml_cEngine;
+
+typedef struct {
+    qmlbind_engine engine;
+} engine_t;
+
+static void engine_free(void *p) {
+    engine_t *data = (engine_t *)p;
+
+    //rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_engine_release, data->engine, RUBY_UBF_IO, NULL);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::Engine",
+    { NULL, &engine_free }
+};
+
+qmlbind_engine rbqml_get_engine(VALUE self) {
+    engine_t *data;
+    TypedData_Get_Struct(self, engine_t, &data_type, data);
+    return data->engine;
+}
+
+static VALUE engine_alloc(VALUE klass) {
+    engine_t *data = ALLOC(engine_t);
+    data->engine = NULL;
+    return TypedData_Wrap_Struct(klass, &data_type, data);
+}
+
+static VALUE engine_initialize(VALUE self) {
+    engine_t *data;
+    TypedData_Get_Struct(self, engine_t, &data_type, data);
+    data->engine = qmlbind_engine_new();
+    return self;
+}
+
+/*
+ * Adds a QML import path to the {Engine}.
+ * @param path [String]
+ * @see http://doc.qt.io/qt-5/qtqml-syntax-imports.html#qml-import-path
+ */
+static VALUE engine_add_import_path(VALUE self, VALUE path) {
+    qmlbind_engine engine = rbqml_get_engine(self);
+    path = rb_funcall(path, rb_intern("to_s"), 0);
+    qmlbind_engine_add_import_path(engine, rb_string_value_cstr(&path));
+    return self;
+}
+
+typedef struct {
+    qmlbind_engine engine;
+    const char *str;
+    const char *file;
+    int lineNum;
+} evaluate_data;
+
+static void *evaluate_impl(void *p) {
+    evaluate_data *data = p;
+    return qmlbind_engine_eval(data->engine, data->str, data->file, data->lineNum);
+}
+
+static VALUE engine_evaluate(VALUE self, VALUE str, VALUE file, VALUE lineNum) {
+    qmlbind_engine engine = rbqml_get_engine(self);
+
+    evaluate_data data;
+    data.engine = engine;
+    data.str = rb_string_value_cstr(&str);
+    data.file = rb_string_value_cstr(&file);
+    data.lineNum = NUM2INT(lineNum);
+
+    qmlbind_value value = rb_thread_call_without_gvl(&evaluate_impl, &data, RUBY_UBF_IO, NULL);
+
+    VALUE result = rbqml_to_ruby(value);
+    qmlbind_value_release(value);
+
+    return result;
+}
+
+/*
+ * @paran [Integer] len
+ * @return [QML::JSArray]
+ */
+static VALUE engine_new_array(VALUE self, VALUE len) {
+    qmlbind_engine engine = rbqml_get_engine(self);
+
+    qmlbind_value array = qmlbind_engine_new_array(engine, NUM2INT(len));
+    VALUE value = rbqml_js_object_new(rbqml_cJSArray, array);
+    qmlbind_value_release(array);
+
+    return value;
+}
+
+/*
+ * @return [QML::JSObject]
+ */
+static VALUE engine_new_object(VALUE self) {
+    qmlbind_engine engine = rbqml_get_engine(self);
+
+    qmlbind_value obj = qmlbind_engine_new_object(engine);
+    VALUE value = rbqml_js_object_new(rbqml_cJSObject, obj);
+    qmlbind_value_release(obj);
+
+    return value;
+}
+
+/*
+ * Starts garbage collection on the {Engine}.
+ */
+static VALUE engine_collect_garbage(VALUE self) {
+    qmlbind_engine engine = rbqml_get_engine(self);
+    qmlbind_engine_collect_garbage(engine);
+    return self;
+}
+
+void rbqml_init_engine() {
+    rb_require("qml/errors");
+
+    VALUE mQML = rb_define_module("QML");
+
+    rbqml_cEngine = rb_define_class_under(mQML, "Engine", rb_cObject);
+    rb_define_alloc_func(rbqml_cEngine, &engine_alloc);
+
+    rb_define_private_method(rbqml_cEngine, "initialize", engine_initialize, 0);
+    rb_define_method(rbqml_cEngine, "add_import_path", engine_add_import_path, 1);
+    rb_define_private_method(rbqml_cEngine, "evaluate_impl", engine_evaluate, 3);
+    rb_define_method(rbqml_cEngine, "new_array", engine_new_array, 1);
+    rb_define_method(rbqml_cEngine, "new_object", engine_new_object, 0);
+    rb_define_method(rbqml_cEngine, "collect_garbage", engine_collect_garbage, 0);
+}