qml 0.0.1

data/ext/qml/ext_metaobject.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "rubyvalue.h"
+#include <QtCore/QMetaObject>
+#include <QtCore/QVector>
+#include <QtCore/QHash>
+#include <QtCore/QObject>
+
+namespace RubyQml {
+namespace Ext {
+
+class MetaObject
+{
+public:
+    MetaObject(RubyValue self);
+
+    RubyValue className() const;
+
+    RubyValue methodNames() const;
+    RubyValue isPublic(RubyValue name) const;
+    RubyValue isProtected(RubyValue name) const;
+    RubyValue isPrivate(RubyValue name) const;
+    RubyValue isSignal(RubyValue name) const;
+
+    RubyValue invokeMethod(RubyValue object, RubyValue methodName, RubyValue args) const;
+    RubyValue connectSignal(RubyValue object, RubyValue signalName, RubyValue proc) const;
+
+    RubyValue propertyNames() const;
+    RubyValue getProperty(RubyValue object, RubyValue name) const;
+    RubyValue setProperty(RubyValue object, RubyValue name, RubyValue newValue) const;
+    RubyValue notifySignal(RubyValue name) const;
+
+    RubyValue enumerators() const;
+
+    RubyValue superClass() const;
+
+    RubyValue isEqual(RubyValue other) const;
+    RubyValue hash() const;
+
+    void setMetaObject(const QMetaObject *metaObject);
+    const QMetaObject *metaObject() const { return mMetaObject; }
+
+    void gc_mark() {}
+
+    static RubyValue fromMetaObject(const QMetaObject *metaObject);
+    static void defineClass();
+
+private:
+    void checkThread() const;
+
+    QList<int> findMethods(RubyValue name) const;
+    int findProperty(RubyValue name) const;
+
+    const RubyValue self;
+
+    const QMetaObject *mMetaObject = nullptr;
+    QMultiHash<ID, int> mMethodHash;
+    QHash<ID, int> mPropertyHash;
+};
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_pluginloader.cpp

@@ -0,0 +1,55 @@
+#include "ext_pluginloader.h"
+#include "ext_pointer.h"
+#include "rubyclass.h"
+#include <QtCore/QPluginLoader>
+#include <QtCore/QSet>
+
+namespace RubyQml {
+namespace Ext {
+
+PluginLoader::PluginLoader(RubyValue self) :
+    self(self),
+    mPluginLoader(new QPluginLoader())
+{
+}
+
+PluginLoader::~PluginLoader()
+{
+}
+
+RubyValue PluginLoader::initialize(RubyValue path)
+{
+    mPluginLoader->setFileName(path.to<QString>());
+    return self;
+}
+
+RubyValue PluginLoader::load()
+{
+    auto ok = mPluginLoader->load();
+    if (!ok) {
+        fail("QML::PluginError", mPluginLoader->errorString());
+    }
+    return self;
+}
+
+RubyValue PluginLoader::instance()
+{
+    self.send("load");
+    auto instance = mPluginLoader->instance();
+    if (instance) {
+        return RubyValue::from(instance);
+    } else {
+        return Qnil;
+    }
+}
+
+void PluginLoader::defineClass()
+{
+    WrapperRubyClass<PluginLoader> klass(RubyModule::fromPath("QML"), "PluginLoader");
+    klass.defineMethod(MethodAccess::Private, "initialize", RUBYQML_MEMBER_FUNCTION_INFO(&PluginLoader::initialize));
+    klass.defineMethod(MethodAccess::Public, "load", RUBYQML_MEMBER_FUNCTION_INFO(&PluginLoader::load));
+    klass.defineMethod(MethodAccess::Public, "instance", RUBYQML_MEMBER_FUNCTION_INFO(&PluginLoader::instance));
+}
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_pluginloader.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "rubyvalue.h"
+#include <memory>
+
+class QPluginLoader;
+
+namespace RubyQml {
+namespace Ext {
+
+class PluginLoader
+{
+public:
+    PluginLoader(RubyValue self);
+    ~PluginLoader();
+
+    RubyValue initialize(RubyValue path);
+    RubyValue load();
+    RubyValue instance();
+
+    void gc_mark() {}
+
+    static void defineClass();
+
+private:
+    const RubyValue self;
+    std::unique_ptr<QPluginLoader> mPluginLoader;
+};
+
+} // namespace Ext
+} // namespace RubyQml
+

data/ext/qml/ext_pointer.cpp

@@ -0,0 +1,134 @@
+#include "ext_pointer.h"
+#include "markable.h"
+#include "objectdata.h"
+#include "objectgc.h"
+#include "application.h"
+#include <QObject>
+#include <QHash>
+#include <QQmlEngine>
+#include <QQmlContext>
+#include <QDebug>
+#include <QCoreApplication>
+
+namespace RubyQml {
+namespace Ext {
+
+Pointer::Pointer(RubyValue self) :
+    self(self)
+{
+}
+
+Pointer::~Pointer()
+{
+    ObjectGC::instance()->debug() << "\u267B\uFE0F  releasing object:" << mObject << "managed:" << mIsManaged;
+}
+
+RubyValue Pointer::fromQObject(QObject *obj, bool owned)
+{
+    auto klass = wrapperRubyClass<Pointer>();
+    auto ptr = klass.newInstance();
+    klass.unwrap(ptr)->setQObject(obj, owned);
+    return ptr;
+}
+
+QObject *Pointer::fetchQObject()
+{
+    if (!mObject) {
+        fail("QML::QtObjectError", "referencing already deleted Qt Object");
+    }
+    return mObject;
+}
+
+void Pointer::setQObject(QObject *obj, bool managed)
+{
+    if (!obj) {
+        throw std::logic_error("null object");
+    }
+    mObject = obj;
+    ObjectGC::instance()->addObject(obj);
+
+    preferManaged(managed);
+    ObjectGC::instance()->debug() << "\u2728  acquiring object:" << mObject;
+}
+
+void Pointer::setManaged(bool managed)
+{
+    if (mObject) {
+        if (managed) {
+            QQmlEngine::setObjectOwnership(mObject, QQmlEngine::JavaScriptOwnership);
+            mJSValue = Application::engine()->newQObject(mObject);
+        } else {
+            QQmlEngine::setObjectOwnership(mObject, QQmlEngine::CppOwnership);
+            mJSValue = QJSValue();
+        }
+
+        ObjectData::getOrCreate(mObject)->owned = managed;
+        mIsManaged = managed;
+    }
+}
+
+void Pointer::preferManaged(bool managed)
+{
+    auto ownership = QQmlEngine::objectOwnership(mObject);
+
+    if (ownership == QQmlEngine::JavaScriptOwnership) {
+        managed = true;
+    } else {
+        // owned by parent
+        if (mObject->parent()) {
+            managed = false;
+        }
+    }
+
+    setManaged(managed);
+}
+
+RubyValue Pointer::ext_isManaged() const
+{
+    return RubyValue::from(mIsManaged);
+}
+
+RubyValue Pointer::ext_setManaged(RubyValue managed)
+{
+    setManaged(managed.to<bool>());
+    return ext_isManaged();
+}
+
+RubyValue Pointer::ext_preferManaged(RubyValue managed)
+{
+    preferManaged(managed.to<bool>());
+    return ext_isManaged();
+}
+
+RubyValue Pointer::ext_isNull() const
+{
+    return RubyValue::from(!mObject);
+}
+
+RubyValue Pointer::ext_toString() const
+{
+    QString name;
+    QDebug(&name) << mObject.data();
+    return RubyValue::from(name);
+}
+
+void Pointer::gc_mark()
+{
+    if (mIsManaged) {
+        ObjectGC::instance()->markOwnedObject(mObject);
+    }
+}
+
+void Pointer::defineClass()
+{
+    WrapperRubyClass<Pointer> klass(RubyModule::fromPath("QML"), "Pointer");
+    klass.defineMethod("managed?", RUBYQML_MEMBER_FUNCTION_INFO(&Pointer::ext_isManaged));
+    klass.defineMethod("managed=", RUBYQML_MEMBER_FUNCTION_INFO(&Pointer::ext_setManaged));
+    klass.defineMethod("prefer_managed", RUBYQML_MEMBER_FUNCTION_INFO(&Pointer::ext_preferManaged));
+    klass.defineMethod("null?", RUBYQML_MEMBER_FUNCTION_INFO(&Pointer::ext_isNull));
+    klass.defineMethod("to_s", RUBYQML_MEMBER_FUNCTION_INFO(&Pointer::ext_toString));
+    klass.aliasMethod("inspect", "to_s");
+}
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_pointer.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "rubyclass.h"
+#include <QPointer>
+#include <QJSValue>
+
+namespace RubyQml {
+namespace Ext {
+
+class Pointer
+{
+public:
+    Pointer(RubyValue self);
+    ~Pointer();
+
+    static RubyValue fromQObject(QObject *obj, bool owned);
+
+    QObject *qObject() { return mObject; }
+    QObject *fetchQObject();
+    void setQObject(QObject *obj, bool managed);
+    bool isManaged() const { return mIsManaged; }
+    void setManaged(bool managed);
+    void preferManaged(bool managed);
+
+    RubyValue ext_isManaged() const;
+    RubyValue ext_setManaged(RubyValue managed);
+    RubyValue ext_preferManaged(RubyValue managed);
+    RubyValue ext_isNull() const;
+    RubyValue ext_toString() const;
+
+    void gc_mark();
+
+    static void defineClass();
+
+private:
+    const RubyValue self;
+
+    bool mIsManaged = false;
+    QPointer<QObject> mObject;
+    QJSValue mJSValue;
+};
+
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_testutil.cpp

@@ -0,0 +1,42 @@
+#include "ext_testutil.h"
+#include "rubyclass.h"
+#include "objectgc.h"
+
+namespace RubyQml {
+namespace Ext {
+namespace TestUtil {
+
+namespace {
+
+RubyValue echoConversion(RubyValue self, RubyValue value)
+{
+    Q_UNUSED(self);
+    auto variant = RubyValue(value).to<QVariant>();
+    return RubyValue::from(variant);
+}
+
+RubyValue gcDebugMessageEnabled(RubyValue self)
+{
+    Q_UNUSED(self);
+    return RubyValue::from(ObjectGC::instance()->debugMessageEnabled());
+}
+
+RubyValue setGCDebugMessageEnabled(RubyValue self, RubyValue enabled)
+{
+    ObjectGC::instance()->setDebugMessageEnabled(enabled.to<bool>());
+    return gcDebugMessageEnabled(self);
+}
+
+}
+
+void defineModule()
+{
+    RubyModule testUtil(RubyModule::fromPath("QML"), "TestUtil");
+    testUtil.defineModuleFunction("echo_conversion", RUBYQML_FUNCTION_INFO(&echoConversion));
+    testUtil.defineModuleFunction("gc_debug_message_enabled?", RUBYQML_FUNCTION_INFO(&gcDebugMessageEnabled));
+    testUtil.defineModuleFunction("gc_debug_message_enabled=", RUBYQML_FUNCTION_INFO(&setGCDebugMessageEnabled));
+}
+
+} // namespace TestUtil
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/ext_testutil.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RubyQml {
+namespace Ext {
+namespace TestUtil {
+
+void defineModule();
+
+} // namespace TestUtil
+} // namespace Ext
+} // namespace RubyQml

data/ext/qml/extconf.rb

@@ -0,0 +1,84 @@
+require 'mkmf'
+require 'pathname'
+
+class Configurator
+
+  PKGS = %w{Qt5Core Qt5Gui Qt5Widgets Qt5Qml Qt5Quick libffi}
+  HEADERS = %w{QObject QVariant QApplication QQmlEngine QQmlComponent QQmlContext ffi.h}
+  CLASSES = %w{listmodel}
+
+  def initialize
+    find_dependencies
+    @cppflags = []
+    @ldflags = []
+  end
+
+  def find_dependencies
+    @pkgconfig = with_config('pkg-config') || find_executable('pkg-config')
+    abort 'pkg-config executable not found' unless @pkgconfig
+
+    @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..."
+    Pathname(__FILE__).+("../plugins").children.select(&:directory?).each do |dir|
+      Dir.chdir(dir) do
+        system("#{@qmake}") && 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
+      @ldflags << `#{@pkgconfig} --libs #{mod}`.chomp
+    end
+
+    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
+
+    $CPPFLAGS += " #{@cppflags.join(" ")}"
+    $LDFLAGS += " #{@ldflags.join(" ")}"
+    $CPPFLAGS += " -fPIC"
+
+    HEADERS.each do |h|
+      abort "header not found: #{h}" unless have_header(h)
+    end
+
+    $CPPFLAGS += " -std=c++11 -Wall -Wextra -pipe"
+    if enable_config('debug')
+      $CPPFLAGS += " -O0 -ggdb3"
+    else
+      $CPPFLAGS += " -O3"
+    end
+
+    CLASSES.each do |header|
+      File.write("moc_#{header}.cpp", `#{@moc} #{header}.h`)
+    end
+
+    create_makefile 'qml/qml'
+  end
+end
+
+configurator = Configurator.new
+configurator.build_plugins
+configurator.configure_extension