qml 0.0.7 → 1.0.0

data/ext/qml/engine.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <ruby/ruby.h>
+#include <qmlbind.h>
+
+extern VALUE rbqml_cEngine;
+
+qmlbind_engine rbqml_get_engine(VALUE value);
+
+void rbqml_init_engine(void);

data/ext/qml/exporter.c

@@ -0,0 +1,93 @@
+#include "exporter.h"
+#include "conversion.h"
+#include "application.h"
+#include "interface.h"
+#include "engine.h"
+#include "meta_object.h"
+
+static VALUE referenced_objects;
+VALUE rbqml_cExporter;
+
+
+typedef struct {
+    qmlbind_exporter exporter;
+} exporter;
+
+static void exporter_free(void *p) {
+    exporter *data = (exporter *)p;
+
+    rb_thread_call_without_gvl((void *(*)(void *))&qmlbind_exporter_release, data->exporter, RUBY_UBF_IO, NULL);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::Exporter",
+    { NULL, &exporter_free }
+};
+
+qmlbind_exporter rbqml_get_exporter(VALUE self) {
+    exporter *data;
+    TypedData_Get_Struct(self, exporter, &data_type, data);
+    return data->exporter;
+}
+
+static VALUE exporter_alloc(VALUE klass) {
+    exporter *data = ALLOC(exporter);
+    data->exporter = NULL;
+    return TypedData_Wrap_Struct(klass, &data_type, data);
+}
+
+
+
+static VALUE exporter_initialize(VALUE self, VALUE klass, VALUE name) {
+    exporter *data;
+    TypedData_Get_Struct(self, exporter, &data_type, data);
+    data->exporter = qmlbind_exporter_new((qmlbind_backref)klass, rb_string_value_cstr(&name), rbqml_get_interface());
+
+    return self;
+}
+
+static VALUE exporter_add_method(VALUE self, VALUE name, VALUE arity) {
+    qmlbind_exporter exporter = rbqml_get_exporter(self);
+    qmlbind_exporter_add_method(exporter, rb_id2name(SYM2ID(name)), NUM2INT(arity));
+    return Qnil;
+}
+
+static VALUE exporter_add_signal(VALUE self, VALUE name, VALUE params) {
+    qmlbind_exporter exporter = rbqml_get_exporter(self);
+
+    int arity = RARRAY_LEN(params);
+
+    const char **paramStrs = alloca(arity * sizeof(char *));
+    for (int i = 0; i < arity; ++i) {
+        paramStrs[i] =  rb_id2name(SYM2ID(RARRAY_AREF(params, i)));
+    }
+
+    qmlbind_exporter_add_signal(exporter, rb_id2name(SYM2ID(name)), arity, paramStrs);
+    return Qnil;
+}
+
+static VALUE exporter_add_property(VALUE self, VALUE name, VALUE notifier) {
+    qmlbind_exporter exporter = rbqml_get_exporter(self);
+    qmlbind_exporter_add_property(exporter, rb_id2name(SYM2ID(name)), rb_id2name(SYM2ID(notifier)));
+    return Qnil;
+}
+
+static VALUE exporter_to_metaobject(VALUE self) {
+    qmlbind_exporter exporter = rbqml_get_exporter(self);
+    qmlbind_metaobject metaobj = qmlbind_metaobject_new(exporter);
+    return rbqml_metaobject_new(metaobj);
+}
+
+void rbqml_init_exporter() {
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cExporter = rb_define_class_under(mQML, "Exporter", rb_cObject);
+
+    rb_define_alloc_func(rbqml_cExporter, &exporter_alloc);
+
+    rb_define_private_method(rbqml_cExporter, "initialize", exporter_initialize, 2);
+    rb_define_method(rbqml_cExporter, "add_method", exporter_add_method, 2);
+    rb_define_method(rbqml_cExporter, "add_signal", exporter_add_signal, 2);
+    rb_define_method(rbqml_cExporter, "add_property", exporter_add_property, 2);
+    rb_define_method(rbqml_cExporter, "to_meta_object", exporter_to_metaobject, 0);
+}

data/ext/qml/exporter.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <ruby/ruby.h>
+#include <qmlbind.h>
+#include <stdbool.h>
+
+void rbqml_init_exporter();

data/ext/qml/extconf.rb

@@ -1,114 +1,55 @@
 require 'mkmf'
 require 'pathname'
+require '../../lib/qml/platform'
 
-class Configurator
+# find qmake
 
-  PKGS = %w{Qt5Core Qt5Gui Qt5Widgets Qt5Qml Qt5Quick libffi}
-  HEADERS = %w{QObject QVariant QApplication QQmlEngine QQmlComponent QQmlContext ffi.h}
-  CLASSES = %w{listmodel}
+qmake = with_config('qmake') || find_executable('qmake')
+debug_enabled = enable_config('debug')
+clean_enabled = enable_config('clean')
+qmake_opts = debug_enabled ? 'CONFIG+=debug' : ''
 
-  def initialize
-    find_dependencies
-    @cppflags = []
-    @ldflags = []
-    @debug_enabled = enable_config('debug')
-  end
+# build libqmlbind
 
-  def find_dependencies
-    @pkgconfig = with_config('pkg-config') || find_executable('pkg-config')
-    abort 'pkg-config executable not found' unless @pkgconfig
+qmlbind_dir = Pathname.pwd + 'lib/libqmlbind/qmlbind'
 
-    @qt_path = with_config('qt-dir')
-    @qt_path &&= Pathname(@qt_path).realpath
-
-    @ffi_path = with_config('libffi-dir')
-    @ffi_path &&= Pathname(@ffi_path).realpath
-
-    [@qt_path, @ffi_path].compact.each do |path|
-      ENV['PKG_CONFIG_PATH'] = "#{path + 'lib/pkgconfig'}:#{ENV['PKG_CONFIG_PATH']}"
-    end
-
-    @qmake = @qt_path ? @qt_path + 'bin/qmake' : find_executable('qmake')
-    @moc = @qt_path ? @qt_path + 'bin/moc' : find_executable('moc')
-    abort 'qmake executable not found' unless @qmake
-    abort 'moc executable not found' unless @moc
-  end
-
-  def build_plugins
-    puts "building plugins..."
-    qmake_opts = @debug_enabled ? 'CONFIG+=debug' : ''
-    Pathname(__FILE__).+("../plugins").children.select(&:directory?).each do |dir|
-      Dir.chdir(dir) do
-        system("#{@qmake} #{qmake_opts}") or abort "failed to configurate plugin: #{dir.basename}"
-        system('make clean') if enable_config('clean-plugin', false)
-        system('make') or abort "failed to build plugin: #{dir.basename}"
-      end
-    end
-  end
-
-  def configure_extension
-    RbConfig::CONFIG['CPP'].gsub!(RbConfig::CONFIG['CC'], RbConfig::CONFIG['CXX'])
-
-    PKGS.each do |mod|
-      @cppflags << `#{@pkgconfig} --cflags #{mod}`.chomp
-
-      libs =`#{@pkgconfig} --libs #{mod}`.chomp
-      @ldflags << libs
-
-      # add framework search path to cppflags
-      libs.split.each do |lib|
-        @cppflags << lib if /^-F/ =~ lib
-      end
-    end
+Dir.chdir(qmlbind_dir) do
+  puts "  >>> building libqmlbind..."
+  system "#{qmake} #{qmake_opts}"
+  system "make clean" if clean_enabled
+  system "make -j4" or abort "ERROR: Failed to build libqmlbind"
+end
 
-    # add private header directory of QtCore
-    qtversion = `#{@pkgconfig} --modversion Qt5Core`.chomp
-    `#{@pkgconfig} --cflags-only-I Qt5Core`.split.map { |i| Pathname(i.gsub("-I", "")) }.each do |dir|
-      private_dir = dir + "#{qtversion}/QtCore"
-      @cppflags << "-I#{private_dir}" if private_dir.exist?
-    end
+case
+when QML::Platform.mac?
+  lib_path = qmlbind_dir + 'libqmlbind.dylib'
+  system "install_name_tool -id #{lib_path} #{lib_path}"
+when QML::Platform.windows?
+  # TODO
+else
+  $LDFLAGS << " -Wl,-rpath #{qmlbind_dir}"
+end
 
-    # include framework headers in Mac
-    # (Qt official installer for Mac does not install header files in /include directory)
-    if /darwin/ =~ RUBY_PLATFORM
-      PKGS.map { |pkg| pkg.gsub(/^Qt5/, 'Qt') }.each do |framework|
-        @cppflags << "-I#{@qt_path + "lib/#{framework}.framework/Headers"}"
-      end
-      # add private header directory of QtCore
-      @cppflags << "-I#{@qt_path}/lib/QtCore.framework/Headers/#{qtversion}/QtCore"
-    end
+# build plugin
 
-    $CPPFLAGS += " #{@cppflags.join(" ")}"
-    $LDFLAGS += " #{@ldflags.join(" ")}"
-    $CPPFLAGS += " -fPIC"
+Dir.chdir "rubyqml-plugin" do
+  puts "  >>> building rubyqml-plugin..."
+  system "#{qmake} #{qmake_opts}"
+  system "make clean" if clean_enabled
+  system "make -j4" or abort "ERROR: Failed to build plugin"
+end
 
-    HEADERS.each do |h|
-      abort "header not found: #{h}" unless have_header(h)
-    end
+puts "  >>> configuring..."
 
-    unless have_func('rb_thread_call_with_gvl') && have_func('rb_thread_call_without_gvl')
-      abort "rb_thread_call_with_gvl and rb_thread_call_without_gvl not found"
-    end
-    $CPPFLAGS += " -DHAVE_RUBY_THREAD_H" if have_header('ruby/thread.h')
+# create makefile
 
-    have_func('rb_rational_num')
-    have_func('rb_rational_den')
+$LDFLAGS << " -L#{qmlbind_dir} -lqmlbind"
+$CPPFLAGS << " -I#{qmlbind_dir + 'include'}"
 
-    $CPPFLAGS += " -std=c++11 -Wall -Wextra -pipe -Wno-reserved-user-defined-literal"
-    if @debug_enabled
-      $CPPFLAGS += " -O0 -ggdb3"
-    else
-      $CPPFLAGS += " -O3"
-    end
+$CPPFLAGS << " -g" if debug_enabled
 
-    CLASSES.each do |header|
-      File.write("moc_#{header}.cpp", `#{@moc} #{header}.h`)
-    end
+$CPPFLAGS << " -std=c99"
 
-    create_makefile 'qml/qml'
-  end
-end
+# create makefile
 
-configurator = Configurator.new
-configurator.build_plugins
-configurator.configure_extension
+create_makefile 'qml/qml'

data/ext/qml/interface.c

@@ -0,0 +1,156 @@
+#include "engine.h"
+#include "conversion.h"
+#include "signal_emitter.h"
+#include "interface.h"
+
+VALUE rbqml_mInterface;
+static qmlbind_interface interface;
+static VALUE referenced_objects;
+
+qmlbind_interface rbqml_get_interface(void) {
+    return interface;
+}
+
+typedef struct {
+    qmlbind_backref class_handle;
+    qmlbind_signal_emitter emitter;
+} new_object_data;
+
+static void *new_object_impl(void *p) {
+    new_object_data *data = p;
+
+    VALUE klass = (VALUE)data->class_handle;
+    VALUE obj = rb_funcall(klass, rb_intern("new"), 0);
+    VALUE emitterValue = rbqml_signal_emitter_new(data->emitter);
+    rb_funcall(obj, rb_intern("set_signal_emitter"), 1, emitterValue);
+
+    rb_hash_aset(referenced_objects, obj, Qnil);
+    return (void *)obj;
+}
+
+static qmlbind_backref new_object(qmlbind_backref class_handle, qmlbind_signal_emitter emitter) {
+    new_object_data data;
+    data.class_handle = class_handle;
+    data.emitter = emitter;
+
+    return rb_thread_call_with_gvl(&new_object_impl, &data);
+}
+
+static void *delete_object_impl(void *data) {
+    rb_hash_delete(referenced_objects, (VALUE)data);
+    return NULL;
+}
+
+static void delete_object(qmlbind_backref handle) {
+    rb_thread_call_with_gvl(&delete_object_impl, handle);
+}
+
+typedef struct {
+    qmlbind_backref backref;
+    const char *name;
+    int argc;
+    qmlbind_value *argv;
+} call_method_data;
+
+static void *call_method_impl(void *p) {
+    call_method_data *data = p;
+
+    VALUE obj = (VALUE)data->backref;
+    VALUE method = ID2SYM(rb_intern(data->name));
+
+    VALUE *args = alloca(data->argc * sizeof(VALUE));
+    for (int i = 0; i < data->argc; ++i) {
+        args[i] = rbqml_to_ruby(data->argv[i]);
+    }
+
+    VALUE result = rb_funcall(rbqml_mInterface, rb_intern("call_method"), 3,
+                              obj, method, rb_ary_new_from_values(data->argc, args));
+
+    return rbqml_to_qml(result);
+}
+
+static qmlbind_value call_method(
+    qmlbind_engine engine,
+    qmlbind_backref object_backref, const char *name,
+    int argc, qmlbind_value *argv) {
+
+    call_method_data data;
+    data.backref = object_backref;
+    data.name = name;
+    data.argc = argc;
+    data.argv = argv;
+
+    return rb_thread_call_with_gvl(&call_method_impl, &data);
+}
+
+typedef struct {
+    qmlbind_backref backref;
+    const char *name;
+} get_property_data;
+
+static void *get_property_impl(void *p) {
+    get_property_data *data = p;
+
+    VALUE obj = (VALUE)data->backref;
+    VALUE method = ID2SYM(rb_intern(data->name));
+
+    VALUE result = rb_funcall(rbqml_mInterface, rb_intern("call_method"), 3,
+                              obj, method, rb_ary_new());
+
+    return rbqml_to_qml(result);
+}
+
+static qmlbind_value get_property(
+    qmlbind_engine engine,
+    qmlbind_backref object_backref, const char *name) {
+
+    get_property_data data;
+    data.backref = object_backref;
+    data.name = name;
+
+    return rb_thread_call_with_gvl(&get_property_impl, &data);
+}
+
+typedef struct {
+    qmlbind_backref backref;
+    const char *name;
+    qmlbind_value value;
+} set_property_data;
+
+static void *set_property_impl(void *p) {
+    set_property_data* data = p;
+
+    VALUE obj = (VALUE)data->backref;
+    VALUE method = rb_str_intern(rb_sprintf("%s=", data->name));
+
+    VALUE ruby_value = rbqml_to_ruby(data->value);
+
+    rb_funcall(rbqml_mInterface, rb_intern("call_method"), 3,
+                              obj, method, rb_ary_new_from_args(1, ruby_value));
+
+    return NULL;
+}
+
+static void set_property(
+    qmlbind_engine engine,
+    qmlbind_backref object_backref, const char *name, qmlbind_value value) {
+
+    set_property_data data;
+    data.backref = object_backref;
+    data.name = name;
+    data.value = value;
+
+    rb_thread_call_with_gvl(&set_property_impl, &data);
+}
+
+qmlbind_interface_handlers handlers = {
+    &new_object, &delete_object, &call_method, &get_property, &set_property
+};
+
+void rbqml_init_interface(void) {
+    rb_require("qml/interface");
+    rbqml_mInterface = rb_path2class("QML::Interface");
+    interface = qmlbind_interface_new(handlers);
+    referenced_objects = rb_hash_new();
+    rb_gc_register_address(&referenced_objects);
+}

data/ext/qml/interface.h

@@ -0,0 +1,11 @@
+#ifndef INTERFACE_H
+#define INTERFACE_H
+
+#include "qml.h"
+
+extern VALUE rbqml_mInterface;
+qmlbind_interface rbqml_get_interface(void);
+
+void rbqml_init_interface(void);
+
+#endif // INTERFACE_H

data/ext/qml/js_array.c

@@ -0,0 +1,47 @@
+#include "js_array.h"
+#include "conversion.h"
+#include "engine.h"
+
+VALUE rbqml_cJSArray;
+
+/*
+ * @return [Integer]
+ */
+static VALUE js_array_length(VALUE self)
+{
+    qmlbind_value array = rbqml_js_object_get(self);
+
+    qmlbind_value lenValue = qmlbind_value_get_property(array, "length");
+    int len = qmlbind_value_get_number(lenValue);
+    qmlbind_value_release(lenValue);
+
+    return INT2NUM(len);
+}
+
+static VALUE js_array_each(VALUE self)
+{
+    RETURN_SIZED_ENUMERATOR(self, 0, 0, &js_array_length);
+
+    qmlbind_value array = rbqml_js_object_get(self);
+
+    qmlbind_value lenValue = qmlbind_value_get_property(array, "length");
+    int len = qmlbind_value_get_number(lenValue);
+    qmlbind_value_release(lenValue);
+
+    for (int i = 0; i < len; ++i) {
+        qmlbind_value elem = qmlbind_value_get_array_item(array, i);
+        VALUE rubyElem = rb_ensure(&rbqml_to_ruby, (VALUE)elem, (VALUE (*)())&qmlbind_value_release, (VALUE)elem);
+        rb_yield(rubyElem);
+    }
+
+    return self;
+}
+
+void rbqml_init_js_array(void)
+{
+    VALUE mQML = rb_define_module("QML");
+    rbqml_cJSArray = rb_define_class_under(mQML, "JSArray", rbqml_cJSObject);
+
+    rb_define_method(rbqml_cJSArray, "length", js_array_length, 0);
+    rb_define_method(rbqml_cJSArray, "each", js_array_each, 0);
+}