qml 0.0.7 → 1.0.0

data/ext/qml/js_array.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "js_object.h"
+
+extern VALUE rbqml_cJSArray;
+
+void rbqml_init_js_array(void);

data/ext/qml/js_function.c

@@ -0,0 +1,109 @@
+#include "js_function.h"
+#include "conversion.h"
+#include "engine.h"
+
+VALUE rbqml_cJSFunction;
+
+typedef enum {
+    CallFunction, CallMethod, CallConstructor
+} CallType;
+
+typedef struct {
+    qmlbind_value func;
+    qmlbind_value instance;
+    int argc;
+    qmlbind_value *argv;
+    CallType type;
+} function_call_data;
+
+static void *function_call_impl(void *p) {
+    function_call_data *data = p;
+
+    switch (data->type) {
+    case CallFunction:
+        return qmlbind_value_call(data->func, data->argc, data->argv);
+    case CallMethod: {
+        return qmlbind_value_call_with_instance(data->func, data->instance, data->argc, data->argv);
+    }
+    case CallConstructor: {
+        return qmlbind_value_call_constructor(data->func, data->argc, data->argv);
+    }
+    }
+    return NULL;
+}
+
+static VALUE function_call(VALUE self, VALUE thisValue, VALUE args, CallType callType) {
+    qmlbind_value func = rbqml_js_object_get(self);
+
+    int argc = RARRAY_LEN(args);
+    qmlbind_value *qmlArgs = malloc(argc * sizeof(qmlbind_value));
+
+    for (int i = 0; i < argc; ++i) {
+        qmlbind_value value = rbqml_to_qml(RARRAY_AREF(args, i));
+        qmlArgs[i] = value;
+    }
+
+    function_call_data data;
+    data.func = func;
+    if (callType == CallMethod) {
+        data.instance = rbqml_js_object_get(thisValue);
+    }
+    data.argc = argc;
+    data.argv = qmlArgs;
+    data.type = callType;
+
+    qmlbind_value result = rb_thread_call_without_gvl(&function_call_impl, &data, RUBY_UBF_IO, NULL);
+
+    bool is_error = qmlbind_value_is_error(result);
+    VALUE resultValue = rbqml_to_ruby(result);
+    qmlbind_value_release(result);
+    qmlbind_value_release(func);
+
+    if (is_error) {
+        rb_exc_raise(rb_funcall(resultValue, rb_intern("to_error"), 0));
+    }
+    return resultValue;
+}
+
+static VALUE js_function_call(int argc, VALUE *argv, VALUE self) {
+    VALUE args;
+    VALUE block;
+    rb_scan_args(argc, argv, "*&", &args, &block);
+    if (!NIL_P(block)) {
+        args = rb_ary_concat(args, rb_ary_new_from_args(1, block));
+    }
+
+    return function_call(self, Qnil, args, CallFunction);
+}
+
+static VALUE js_function_new(int argc, VALUE *argv, VALUE self) {
+    VALUE args;
+    VALUE block;
+    rb_scan_args(argc, argv, "*&", &args, &block);
+    if (!NIL_P(block)) {
+        args = rb_ary_concat(args, rb_ary_new_from_args(1, block));
+    }
+
+    return function_call(self, Qnil, args, CallConstructor);
+}
+
+static VALUE js_function_call_with_instance(int argc, VALUE *argv, VALUE self) {
+    VALUE thisValue;
+    VALUE args;
+    VALUE block;
+    rb_scan_args(argc, argv, "1*&", &thisValue, &args, &block);
+    if (!NIL_P(block)) {
+        args = rb_ary_concat(args, rb_ary_new_from_args(1, block));
+    }
+
+    return function_call(self, thisValue, args, CallMethod);
+}
+
+void rbqml_init_js_function(void) {
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cJSFunction = rb_define_class_under(mQML, "JSFunction", rbqml_cJSObject);
+
+    rb_define_method(rbqml_cJSFunction, "call", js_function_call, -1);
+    rb_define_method(rbqml_cJSFunction, "new", js_function_new, -1);
+    rb_define_method(rbqml_cJSFunction, "call_with_instance", js_function_call_with_instance, -1);
+}

data/ext/qml/js_function.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "js_object.h"
+
+extern VALUE rbqml_cJSFunction;
+
+void rbqml_init_js_function(void);

data/ext/qml/js_object.c

@@ -0,0 +1,284 @@
+#include "js_object.h"
+#include "engine.h"
+#include "conversion.h"
+
+typedef struct {
+    qmlbind_value obj;
+    const char *key;
+} get_property_data;
+
+void *get_property_impl(void *p) {
+    get_property_data *data = p;
+    return qmlbind_value_get_property(data->obj, data->key);
+}
+
+qmlbind_value rbqml_get_property(qmlbind_value obj, const char *key) {
+    get_property_data data;
+    data.obj = obj;
+    data.key = key;
+    return rb_thread_call_without_gvl(&get_property_impl, &data, RUBY_UBF_IO, NULL);
+}
+
+typedef struct {
+    qmlbind_value obj;
+    int index;
+} get_array_item_data;
+
+void *get_array_item_impl(void *p) {
+    get_array_item_data *data = p;
+    return qmlbind_value_get_array_item(data->obj, data->index);
+}
+
+qmlbind_value rbqml_get_array_item(qmlbind_value obj, int index) {
+    get_array_item_data data;
+    data.obj = obj;
+    data.index = index;
+    return rb_thread_call_without_gvl(&get_array_item_impl, &data, RUBY_UBF_IO, NULL);
+}
+
+typedef struct {
+    qmlbind_value obj;
+    const char *key;
+    qmlbind_value value;
+} set_property_data;
+
+void *set_property_impl(void *p) {
+    set_property_data *data = p;
+    qmlbind_value_set_property(data->obj, data->key, data->value);
+    return NULL;
+}
+
+void rbqml_set_property(qmlbind_value obj, const char *key, qmlbind_value value) {
+    set_property_data data;
+    data.obj = obj;
+    data.key = key;
+    data.value = value;
+    rb_thread_call_without_gvl(&set_property_impl, &data, RUBY_UBF_IO, NULL);
+}
+
+typedef struct {
+    qmlbind_value obj;
+    int index;
+    qmlbind_value value;
+} set_array_item_data;
+
+void *set_array_item_impl(void *p) {
+    set_array_item_data *data = p;
+    qmlbind_value_set_array_item(data->obj, data->index, data->value);
+    return NULL;
+}
+
+void rbqml_set_array_item(qmlbind_value obj, int index, qmlbind_value value) {
+    set_array_item_data data;
+    data.obj = obj;
+    data.index = index;
+    data.value = value;
+    rb_thread_call_without_gvl(&set_array_item_impl, &data, RUBY_UBF_IO, NULL);
+}
+
+
+qmlbind_value rbqml_get_iterator_value(qmlbind_iterator iter) {
+    return rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_iterator_get_value, iter, RUBY_UBF_IO, NULL);
+}
+
+typedef struct {
+    qmlbind_value value;
+} js_object_t;
+
+VALUE rbqml_cJSObject;
+
+void free_js_object(void *ptr)
+{
+    js_object_t *obj = ptr;
+    qmlbind_value_release(obj->value);
+    xfree(obj);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::JSObject",
+    { NULL, &free_js_object }
+};
+
+static VALUE js_object_alloc(VALUE klass)
+{
+    return rbqml_js_object_new(klass, qmlbind_value_new_null());
+}
+
+VALUE rbqml_js_object_new(VALUE klass, qmlbind_value value)
+{
+    js_object_t *obj = ALLOC(js_object_t);
+    obj->value = qmlbind_value_clone(value);
+    return TypedData_Wrap_Struct(klass, &data_type, obj);
+}
+
+bool rbqml_js_object_p(VALUE value)
+{
+    return rb_type(value) == T_DATA && RTYPEDDATA_P(value) && RTYPEDDATA_TYPE(value) == &data_type;
+}
+
+qmlbind_value rbqml_js_object_get(VALUE jsobject)
+{
+    js_object_t *obj;
+    TypedData_Get_Struct(jsobject, js_object_t, &data_type, obj);
+    return qmlbind_value_clone(obj->value);
+}
+
+static void get_property_key(VALUE key, int *index, const char **keyStr)
+{
+    switch (rb_type(key)) {
+    case T_FIXNUM:
+        *index = NUM2INT(key);
+        break;
+    case T_STRING:
+        *keyStr = rb_string_value_cstr(&key);
+        break;
+    case T_SYMBOL:
+        *keyStr = rb_id2name(SYM2ID(key));
+        break;
+    default:
+        rb_raise(rb_eTypeError, "expected Fixnum, String or Symbol for index, got %s", rb_class2name(rb_obj_class(key)));
+        break;
+    }
+}
+
+static VALUE js_object_aref(VALUE self, VALUE key)
+{
+    qmlbind_value obj = rbqml_js_object_get(self);
+
+    int index = -1;
+    const char *keyStr;
+    get_property_key(key, &index, &keyStr);
+
+    qmlbind_value value;
+
+    if (index >= 0) {
+        value = rbqml_get_array_item(obj, index);
+    } else {
+        value = rbqml_get_property(obj, keyStr);
+    }
+
+    qmlbind_value_release(obj);
+
+    return rb_ensure(&rbqml_to_ruby, (VALUE)value, (VALUE (*)())&qmlbind_value_release, (VALUE)value);
+}
+
+static VALUE js_object_aset(VALUE self, VALUE key, VALUE value)
+{
+    qmlbind_value obj = rbqml_js_object_get(self);
+
+    qmlbind_value qmlValue = rbqml_to_qml(value);
+
+    int index = -1;
+    const char *keyStr;
+
+    get_property_key(key, &index, &keyStr);
+
+    if (index >= 0) {
+        rbqml_set_array_item(obj, index, qmlValue);
+    } else {
+        rbqml_set_property(obj, keyStr, qmlValue);
+    }
+
+    qmlbind_value_release(obj);
+
+    return value;
+}
+
+static VALUE js_object_each_iterator(VALUE data)
+{
+    qmlbind_iterator it = (qmlbind_iterator)data;
+    while (qmlbind_iterator_has_next(it)) {
+        qmlbind_iterator_next(it);
+
+        qmlbind_value value = rbqml_get_iterator_value(it);
+        VALUE rubyValue = rb_ensure(&rbqml_to_ruby, (VALUE)value, (VALUE (*)())&qmlbind_value_release, (VALUE)value);
+
+        qmlbind_string str = qmlbind_iterator_get_key(it);
+        VALUE rubyKey = rb_enc_str_new(qmlbind_string_get_chars(str), qmlbind_string_get_length(str), rb_utf8_encoding());
+        qmlbind_string_release(str);
+
+        VALUE pair[] = { rubyKey, rubyValue };
+
+        rb_yield(rb_ary_new_from_values(2, pair));
+    }
+    return Qnil;
+}
+
+static VALUE js_object_each_pair(VALUE self)
+{
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    qmlbind_value obj = rbqml_js_object_get(self);
+
+    qmlbind_iterator it = qmlbind_iterator_new(obj);
+    rb_ensure(&js_object_each_iterator, (VALUE)it, (VALUE (*)())&qmlbind_iterator_release, (VALUE)it);
+
+    qmlbind_value_release(obj);
+
+    return self;
+}
+
+static VALUE js_object_has_key_p(VALUE self, VALUE key)
+{
+    qmlbind_value obj = rbqml_js_object_get(self);
+
+    int index = -1;
+    const char *keyStr;
+
+    get_property_key(key, &index, &keyStr);
+
+    int ret;
+
+    if (index >= 0) {
+        ret = qmlbind_value_has_index(obj, index);
+    } else {
+        ret = qmlbind_value_has_property(obj, keyStr);
+    }
+
+    qmlbind_value_release(obj);
+
+    if (ret) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+static VALUE js_object_error_p(VALUE self)
+{
+    qmlbind_value obj = rbqml_js_object_get(self);
+    if (qmlbind_value_is_error(obj)) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/*
+ * Compares two JS objects by JavaScript identity (===).
+ * @return [Boolean]
+ */
+static VALUE js_object_equal_p(VALUE self, VALUE other)
+{
+    qmlbind_value obj = rbqml_js_object_get(self);
+    qmlbind_value otherObj = rbqml_js_object_get(other);
+
+    if (qmlbind_value_is_identical(obj, otherObj)) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+void rbqml_init_js_object(void)
+{
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cJSObject = rb_define_class_under(mQML, "JSObject", rb_cObject);
+
+    rb_define_method(rbqml_cJSObject, "[]", js_object_aref, 1);
+    rb_define_method(rbqml_cJSObject, "[]=", js_object_aset, 2);
+    rb_define_method(rbqml_cJSObject, "each_pair", js_object_each_pair, 0);
+    rb_define_method(rbqml_cJSObject, "has_key?", js_object_has_key_p, 1);
+    rb_define_method(rbqml_cJSObject, "error?", js_object_error_p, 0);
+    rb_define_method(rbqml_cJSObject, "==", js_object_equal_p, 1);
+}

data/ext/qml/js_object.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "qml.h"
+#include <stdbool.h>
+
+qmlbind_value rbqml_get_property(qmlbind_value obj, const char *key);
+qmlbind_value rbqml_get_array_item(qmlbind_value obj, int index);
+void rbqml_set_property(qmlbind_value obj, const char *key, qmlbind_value value);
+void rbqml_set_array_item(qmlbind_value obj, int index, qmlbind_value value);
+qmlbind_value rbqml_get_iterator_value(qmlbind_iterator iter);
+
+VALUE rbqml_js_object_new(VALUE klass, qmlbind_value value);
+
+bool rbqml_js_object_p(VALUE value);
+qmlbind_value rbqml_js_object_get(VALUE jsobject);
+
+extern VALUE rbqml_cJSObject;
+
+void rbqml_init_js_object(void);

data/ext/qml/js_wrapper.c

@@ -0,0 +1,19 @@
+#include "js_wrapper.h"
+
+VALUE rbqml_cJSWrapper;
+
+/*
+ * @return [QML::Access]
+ */
+static VALUE js_wrapper_unwrap(VALUE self) {
+    qmlbind_value wrapper = rbqml_js_object_get(self);
+    VALUE unwrapped = (VALUE)qmlbind_value_get_backref(wrapper);
+    qmlbind_value_release(wrapper);
+    return unwrapped;
+}
+
+void rbqml_init_js_wrapper(void) {
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cJSWrapper = rb_define_class_under(mQML, "JSWrapper", rbqml_cJSObject);
+    rb_define_method(rbqml_cJSWrapper, "unwrap", js_wrapper_unwrap, 0);
+}