qml 0.0.7 → 1.0.0

data/ext/qml/rubyqml-plugin/rubyqml-plugin.pro

@@ -0,0 +1,19 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2015-05-16T11:55:09
+#
+#-------------------------------------------------
+
+QT += core gui qml
+
+TARGET = rubyqml-plugin
+TEMPLATE = lib
+CONFIG += plugin
+
+SOURCES += \
+    rubyqmlplugin.cpp \
+    listmodel.cpp
+
+HEADERS += \
+    rubyqmlplugin.h \
+    listmodel.h

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

@@ -0,0 +1,25 @@
+#include "rubyqmlplugin.h"
+#include "listmodel.h"
+#include <QQmlEngine>
+#include <QQmlContext>
+
+namespace RubyQml {
+
+RubyQmlPlugin::RubyQmlPlugin(QObject *parent) :
+    QObject(parent)
+{
+}
+
+QJSValue RubyQmlPlugin::createListModel(const QJSValue &rubyModelAccess)
+{
+    QObject *access = rubyModelAccess.toQObject();
+    Q_ASSERT(access);
+    QQmlEngine *engine = QQmlEngine::contextForObject(access)->engine();
+
+    ListModel *listModel = new ListModel(rubyModelAccess);
+    QQmlEngine::setObjectOwnership(listModel, QQmlEngine::JavaScriptOwnership);
+
+    return engine->newQObject(listModel);
+}
+
+}

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

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <QObject>
+#include <QJSValue>
+
+namespace RubyQml {
+
+class RubyQmlPlugin : public QObject
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.ruby-qml.RubyQml")
+
+public:
+    RubyQmlPlugin(QObject *parent = 0);
+
+    Q_INVOKABLE QJSValue createListModel(const QJSValue &rubyModelAccess);
+};
+
+}

data/ext/qml/signal_emitter.c

@@ -0,0 +1,71 @@
+#include "signal_emitter.h"
+#include "conversion.h"
+#include "engine.h"
+
+VALUE rbqml_cSignalEmitter;
+
+typedef struct {
+    qmlbind_signal_emitter emitter;
+} emitter_t;
+
+static void emitter_free(void *p) {
+    emitter_t *data = (emitter_t *)p;
+    qmlbind_signal_emitter_release(data->emitter);
+    xfree(data);
+}
+
+static const rb_data_type_t data_type = {
+    "QML::SignalEmitter",
+    { NULL, &emitter_free }
+};
+
+VALUE rbqml_signal_emitter_new(qmlbind_signal_emitter emitter) {
+    emitter_t *data = ALLOC(emitter_t);
+    data->emitter = emitter;
+    return TypedData_Wrap_Struct(rbqml_cSignalEmitter, &data_type, data);
+}
+
+static VALUE emitter_alloc(VALUE klass) {
+    rb_raise(rb_eTypeError, "QML::SignalEmitter cannot be created from Ruby");
+}
+
+typedef struct {
+    qmlbind_signal_emitter emitter;
+    const char *name;
+    int argc;
+    qmlbind_value *argv;
+} emit_data;
+
+static void *emit_impl(void *p) {
+    emit_data *data = p;
+    qmlbind_signal_emitter_emit(data->emitter, data->name, data->argc, data->argv);
+    return NULL;
+}
+
+static VALUE emitter_emit(VALUE self, VALUE name, VALUE args) {
+    emitter_t *d;
+    TypedData_Get_Struct(self, emitter_t, &data_type, d);
+
+    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;
+    }
+
+    emit_data data;
+    data.emitter = d->emitter;
+    data.name = rb_id2name(SYM2ID(name));
+    data.argc = argc;
+    data.argv = qmlArgs;
+
+    rb_thread_call_without_gvl(&emit_impl, &data, RUBY_UBF_IO, NULL);
+    return self;
+}
+
+void rbqml_init_signal_emitter(void) {
+    rbqml_cSignalEmitter = rb_define_class_under(rb_path2class("QML"), "SignalEmitter", rb_cObject);
+    rb_define_alloc_func(rbqml_cSignalEmitter, &emitter_alloc);
+    rb_define_method(rbqml_cSignalEmitter, "emit", &emitter_emit, 2);
+}

data/ext/qml/signal_emitter.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "qml.h"
+
+extern VALUE rbqml_cSignalEmitter;
+
+VALUE rbqml_signal_emitter_new(qmlbind_signal_emitter emitter);
+
+void rbqml_init_signal_emitter(void);

data/lib/qml.rb

@@ -1,22 +1,23 @@
 require 'qml/version'
+require 'qml/errors'
 require 'qml/qml'
 
-require 'qml/geometry'
-require 'qml/reactive'
+require 'qml/core_ext'
 
-require 'qml/init'
-require 'qml/meta_object'
 require 'qml/plugin_loader'
+require 'qml/plugins'
 require 'qml/component'
 require 'qml/engine'
-require 'qml/context'
 require 'qml/application'
-require 'qml/image_provider'
-require 'qml/qt'
+require 'qml/dispatcher'
+require 'qml/signal'
+require 'qml/reactive'
 require 'qml/access'
+require 'qml/qt'
 require 'qml/root_path'
-require 'qml/dispatcher'
-require 'qml/dispatchable'
+require 'qml/js_object'
+require 'qml/js_array'
+require 'qml/js_util'
+require 'qml/proc_access'
 
 require 'qml/data'
-require 'qml/test_util'

data/lib/qml/access.rb

@@ -1,33 +1,29 @@
-require 'ostruct'
-require 'qml/qml'
-require 'qml/dispatchable'
-require 'qml/wrappable'
-
 module QML
 
   # {Access} enables classes to be exposed to QML.
   #
   module Access
-    include Dispatchable
-    include Wrappable
-    # @!parse include Reactive::Object
+    # @!parse include Reactive
     # @!parse extend ClassMethods
 
+    def set_signal_emitter(emitter)
+      self.class.signals.each do |name|
+        __send__(name).connect do |*args|
+          emitter.emit(name, args)
+        end
+      end
+    end
+    private :set_signal_emitter
+
     def self.included(derived)
       derived.class_eval do
-        include Reactive::Object
+        include Reactive
         extend ClassMethods
       end
     end
 
-    # @api private
-    def self.unregistered_classes
-      @unregistered_classes ||= []
-    end
-
-    # @api private
-    def self.register_classes
-      unregistered_classes.each(&:register_to_qml_real)
+    def to_qml
+      @qml_value ||= self.class.meta_object.wrap(self)
     end
 
     # allowed name patterns for exposed method names
@@ -35,12 +31,62 @@ module QML
 
     module ClassMethods
 
+      def meta_object
+        @meta_object ||= begin
+          exporter = Exporter.new(self, name)
+
+          signals = self.signals.grep(ALLOWED_PATTERN)
+          properties = self.properties.grep(ALLOWED_PATTERN)
+
+          signals.each do |signal|
+            exporter.add_signal(signal, signal_infos[signal].params)
+          end
+
+          properties.each do |prop|
+            exporter.add_property(prop, :"#{prop}_changed")
+          end
+
+          methods = ancestors.take_while { |k| k.include?(Access) }
+            .map { |k| k.instance_methods(false) }.inject(&:|)
+            .grep(ALLOWED_PATTERN)
+          ignored_methods = signals | properties.flat_map { |p| [p, :"#{p}=", :"#{p}_changed"] }
+
+          (methods - ignored_methods).each do |method|
+            instance_method = self.instance_method(method)
+            # ignore variadic methods
+            if instance_method.arity >= 0
+              exporter.add_method(method, instance_method.arity)
+            end
+          end
+          exporter.to_meta_object
+        end
+      end
+
       # Registers the class as a QML type.
       # @param opts [Hash]
       # @option opts [String] :under the namespece which encapsulates the exported QML type. If not specified, automatically inferred from the module nesting of the class.
       # @option opts [String] :version the version of the type. Defaults to VERSION constant of the encapsulating module / class of the class.
       # @option opts [String] :name the name of the type. Defaults to the name of the class.
       def register_to_qml(opts = {})
+        QML.on_init do
+          register_to_qml_impl(opts)
+        end
+      end
+
+      def register_to_qml_impl(opts)
+        metadata = guess_metadata(opts)
+
+        meta_object.register(
+          metadata[:under],
+          metadata[:versions][0],
+          metadata[:versions][1],
+          metadata[:name]
+        )
+      end
+
+      private
+
+      def guess_metadata(opts)
         under = opts[:under]
         version = opts[:version]
         name = opts[:name]
@@ -59,76 +105,8 @@ module QML
         fail AccessError, 'insufficient version (major and minor versions required)' unless versions.size >= 2
         name ||= path.last
 
-        @qml_registeration = {
-          under: under,
-          version_major: versions[0],
-          version_minor: versions[1],
-          name: name
-        }
-        Access.unregistered_classes << self
-      end
-
-      # @api private
-      def register_to_qml_real
-        access_wrapper_factory.register_to_qml(
-          @qml_registeration[:under],
-          @qml_registeration[:version_major],
-          @qml_registeration[:version_minor],
-          @qml_registeration[:name])
-      end
-
-      # @api private
-      def access_wrapper_factory
-        @access_wrapper_factory ||= create_access_wrapper_factory
-      end
-
-      private
-
-      def create_access_wrapper_factory
-        classname = "RubyQml::Access::#{name}"
-
-        signals = instance_signals.grep(ALLOWED_PATTERN)
-        properties = instance_properties.grep(ALLOWED_PATTERN)
-
-        signal_infos = signals
-          .map { |name| instance_signal(name) }
-          .reject(&:variadic?)
-          .map { |signal| OpenStruct.new(name: signal.name, params: signal.parameters.map(&:last)) }
-
-        property_infos = properties
-          .map { |name| OpenStruct.new(name: name, getter: name, setter: :"#{name}=", notifier: :"#{name}_changed") }
-
-        methods = ancestors.take_while { |k| k.include?(Access) }
-          .map { |k| k.instance_methods(false) }.inject(&:|)
-          .grep(ALLOWED_PATTERN)
-        ignored_methods = signals | property_infos.flat_map { |p| [p.getter, p.setter, p.notifier] }
-        method_infos = (methods - ignored_methods)
-          .map { |name| instance_method(name) }
-          .select { |method| method.parameters.all? { |param| param[0] == :req } }
-          .map { |method| OpenStruct.new(name: method.name, params: method.parameters.map(&:last)) }
-
-        AccessWrapperFactory.new(self, classname, method_infos, signal_infos, property_infos)
-      end
-    end
-
-    # @api private
-    attr_reader :access_wrappers
-
-    def initialize(*args, &block)
-      signal_names = signals + properties.map { |name| :"#{name}_changed" }
-      signal_names.each do |name|
-        __send__(name).connect do |*args|
-          @access_wrappers.each do |obj|
-            obj.class.meta_object.invoke_method(obj.pointer, name, args)
-          end
-        end
+        {under: under, versions: versions, name: name}
       end
-      @access_wrappers = []
-      super
-    end
-
-    def create_wrapper
-      self.class.access_wrapper_factory.create(self)
     end
   end
 end

data/lib/qml/application.rb

@@ -1,42 +1,13 @@
-require 'qml/qt_classes'
-
 module QML
-  # @!parse class Application < QtObjectBase; end
-
   # {Application} represents a Qt application instance.
   # It provides the event loop and manages Application-level configurations.
   #
   # @see http://qt-project.org/doc/qt-5/qapplication.html QApplication (C++)
   class Application
 
-    # @return [Application] The application instance.
-    def self.instance
-      Kernel.application
-    end
-
-    def self.notify_error(error)
-      instance.notify_error(error)
-    end
-
-    # @note This method cannot be called because {Application} is singleton. 
-    def self.new
-      fail ApplicationError, "cannot create Application instance manually"
-    end
-
-    def initialize
-      super()
-      @extension = Plugins.core.createApplicationExtension(self)
-    end
-
     # @return [Engine] The engine of the application.
     def engine
-      Kernel.engine
-    end
-
-    # @return [Context] The root context of the engine.
-    # @see #engine
-    def context
-      engine.context
+      QML.engine
     end
 
     # @return [Component] The root component of the application that represents the loaded QML file.
@@ -48,12 +19,11 @@ module QML
     end
 
     # Loads a QML file. The loaded component can be accessed by {#root_component}
-    # @param [Hash] opts
-    # @option opts [String] :data
-    # @option opts [String] :path
+    # @param [String] data
+    # @param [String] path
     # @see Component
-    def load(opts)
-      @root_component = Component.new(data: opts[:data], path: opts[:path])
+    def load(data: nil, path: nil)
+      @root_component = Component.new(data: data, path: path)
       @root = @root_component.create
     end
 
@@ -74,58 +44,37 @@ module QML
       @root or fail "QML data or file has not been loaded"
     end
 
-    # Starts the event loop of the application.
-    # This method never returns until the application quits.
-    def exec
-      @extension.exec
-    end
-
-    # Processes queued events in the event loop manually.
-    # This method is useful when you are combining an external event loop like EventMachine.
-    def process_events
-      @extension.process_events
+    # Quits the application.
+    def quit
+      QML.qt.quit
     end
+  end
 
-    def force_deferred_deletes
-      @extension.force_deferred_deletes
-    end
+  INIT_BLOCKS = []
 
-    # Runs garbage collection of Ruby and QML and deletes unused objects.
-    def collect_garbage
-      ::GC.start
-      engine.collect_garbage
-      force_deferred_deletes
-    end
+  module_function
 
-    # Called when an Ruby error is occured in executing Qt code.
-    # @param error The error (or the exception)
-    def notify_error(error)
-      warn "-- An error occured when running Ruby code from Qt --"
-      warn "#{error.class.name}: #{error.message}"
-      warn "Backtrace: \n\t#{error.backtrace.join("\n\t")}"
-    end
+  def on_init(&block)
+    INIT_BLOCKS << block
   end
 
-  # Returns the instance of {Application}.
-  # @return [Application]
-  def application
-    Application.instance
+  # Initializes ruby-qml.
+  # @param [Array<String>] args Arguments to pass to the application
+  def init(args = [])
+    init_impl(args)
   end
 
-  # Call {init} if ruby-qml is not initialized, then yields the application instance and then call {Application#exec}.
+  # Creates an {Application}, yields it and then call {QML::Application#exec}.
   # @return [Application]
   # @example
   #   QML.run do |app|
-  #     app.context[:foo] = 'foo'
   #     app.load_path Pathname(__FILE__) + '../main.qml'
   #   end
   def run
-    QML.init unless QML.initialized?
-    Application.instance.tap do |app|
+    QML.init
+    QML.application.tap do |app|
       yield app
       app.exec
     end
   end
-
-  module_function :application, :run
 end