qml 0.0.3 → 0.0.4

data/ext/qml/ext_metaobject.h

@@ -7,12 +7,11 @@
 #include <QtCore/QObject>
 
 namespace RubyQml {
-namespace Ext {
 
-class MetaObject
+class Ext_MetaObject
 {
 public:
-    MetaObject(RubyValue self);
+    Ext_MetaObject(RubyValue self);
 
     RubyValue className() const;
 
@@ -58,5 +57,4 @@ private:
     QHash<ID, int> mPropertyHash;
 };
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_pluginloader.cpp

@@ -5,25 +5,24 @@
 #include <QtCore/QSet>
 
 namespace RubyQml {
-namespace Ext {
 
-PluginLoader::PluginLoader(RubyValue self) :
+Ext_PluginLoader::Ext_PluginLoader(RubyValue self) :
     self(self),
     mPluginLoader(new QPluginLoader())
 {
 }
 
-PluginLoader::~PluginLoader()
+Ext_PluginLoader::~Ext_PluginLoader()
 {
 }
 
-RubyValue PluginLoader::initialize(RubyValue path)
+RubyValue Ext_PluginLoader::initialize(RubyValue path)
 {
     mPluginLoader->setFileName(path.to<QString>());
     return self;
 }
 
-RubyValue PluginLoader::load()
+RubyValue Ext_PluginLoader::load()
 {
     auto ok = mPluginLoader->load();
     if (!ok) {
@@ -32,7 +31,7 @@ RubyValue PluginLoader::load()
     return self;
 }
 
-RubyValue PluginLoader::instance()
+RubyValue Ext_PluginLoader::instance()
 {
     self.send("load");
     auto instance = mPluginLoader->instance();
@@ -43,13 +42,12 @@ RubyValue PluginLoader::instance()
     }
 }
 
-void PluginLoader::defineClass()
+void Ext_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));
+    WrapperRubyClass<Ext_PluginLoader> klass(RubyModule::fromPath("QML"), "PluginLoader");
+    klass.defineMethod(MethodAccess::Private, "initialize", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_PluginLoader::initialize));
+    klass.defineMethod(MethodAccess::Public, "load", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_PluginLoader::load));
+    klass.defineMethod(MethodAccess::Public, "instance", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_PluginLoader::instance));
 }
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_pluginloader.h

@@ -6,13 +6,12 @@
 class QPluginLoader;
 
 namespace RubyQml {
-namespace Ext {
 
-class PluginLoader
+class Ext_PluginLoader
 {
 public:
-    PluginLoader(RubyValue self);
-    ~PluginLoader();
+    Ext_PluginLoader(RubyValue self);
+    ~Ext_PluginLoader();
 
     RubyValue initialize(RubyValue path);
     RubyValue load();
@@ -27,6 +26,5 @@ private:
     std::unique_ptr<QPluginLoader> mPluginLoader;
 };
 
-} // namespace Ext
 } // namespace RubyQml
 

data/ext/qml/ext_pointer.cpp

@@ -2,7 +2,7 @@
 #include "markable.h"
 #include "objectdata.h"
 #include "objectgc.h"
-#include "application.h"
+#include "kernel.h"
 #include <QObject>
 #include <QHash>
 #include <QQmlEngine>
@@ -11,27 +11,26 @@
 #include <QCoreApplication>
 
 namespace RubyQml {
-namespace Ext {
 
-Pointer::Pointer(RubyValue self) :
+Ext_Pointer::Ext_Pointer(RubyValue self) :
     self(self)
 {
 }
 
-Pointer::~Pointer()
+Ext_Pointer::~Ext_Pointer()
 {
     ObjectGC::instance()->debug() << "\u267B\uFE0F  releasing object:" << mObject << "managed:" << mIsManaged;
 }
 
-RubyValue Pointer::fromQObject(QObject *obj, bool owned)
+RubyValue Ext_Pointer::fromQObject(QObject *obj, bool owned)
 {
-    auto klass = wrapperRubyClass<Pointer>();
+    auto klass = wrapperRubyClass<Ext_Pointer>();
     auto ptr = klass.newInstance();
     klass.unwrap(ptr)->setQObject(obj, owned);
     return ptr;
 }
 
-QObject *Pointer::fetchQObject()
+QObject *Ext_Pointer::fetchQObject()
 {
     if (!mObject) {
         fail("QML::QtObjectError", "referencing already deleted Qt Object");
@@ -39,7 +38,7 @@ QObject *Pointer::fetchQObject()
     return mObject;
 }
 
-void Pointer::setQObject(QObject *obj, bool managed)
+void Ext_Pointer::setQObject(QObject *obj, bool managed)
 {
     if (!obj) {
         throw std::logic_error("null object");
@@ -51,12 +50,12 @@ void Pointer::setQObject(QObject *obj, bool managed)
     ObjectGC::instance()->debug() << "\u2728  acquiring object:" << mObject;
 }
 
-void Pointer::setManaged(bool managed)
+void Ext_Pointer::setManaged(bool managed)
 {
     if (mObject) {
         if (managed) {
             QQmlEngine::setObjectOwnership(mObject, QQmlEngine::JavaScriptOwnership);
-            mJSValue = Application::engine()->newQObject(mObject);
+            mJSValue = Kernel::instance()->engine()->newQObject(mObject);
         } else {
             QQmlEngine::setObjectOwnership(mObject, QQmlEngine::CppOwnership);
             mJSValue = QJSValue();
@@ -67,7 +66,7 @@ void Pointer::setManaged(bool managed)
     }
 }
 
-void Pointer::preferManaged(bool managed)
+void Ext_Pointer::preferManaged(bool managed)
 {
     auto ownership = QQmlEngine::objectOwnership(mObject);
 
@@ -83,52 +82,51 @@ void Pointer::preferManaged(bool managed)
     setManaged(managed);
 }
 
-RubyValue Pointer::ext_isManaged() const
+RubyValue Ext_Pointer::ext_isManaged() const
 {
     return RubyValue::from(mIsManaged);
 }
 
-RubyValue Pointer::ext_setManaged(RubyValue managed)
+RubyValue Ext_Pointer::ext_setManaged(RubyValue managed)
 {
     setManaged(managed.to<bool>());
     return ext_isManaged();
 }
 
-RubyValue Pointer::ext_preferManaged(RubyValue managed)
+RubyValue Ext_Pointer::ext_preferManaged(RubyValue managed)
 {
     preferManaged(managed.to<bool>());
     return ext_isManaged();
 }
 
-RubyValue Pointer::ext_isNull() const
+RubyValue Ext_Pointer::ext_isNull() const
 {
     return RubyValue::from(!mObject);
 }
 
-RubyValue Pointer::ext_toString() const
+RubyValue Ext_Pointer::ext_toString() const
 {
     QString name;
     QDebug(&name) << mObject.data();
     return RubyValue::from(name);
 }
 
-void Pointer::gc_mark()
+void Ext_Pointer::gc_mark()
 {
     if (mIsManaged) {
         ObjectGC::instance()->markOwnedObject(mObject);
     }
 }
 
-void Pointer::defineClass()
+void Ext_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));
+    WrapperRubyClass<Ext_Pointer> klass(RubyModule::fromPath("QML"), "Pointer");
+    klass.defineMethod("managed?", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_Pointer::ext_isManaged));
+    klass.defineMethod("managed=", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_Pointer::ext_setManaged));
+    klass.defineMethod("prefer_managed", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_Pointer::ext_preferManaged));
+    klass.defineMethod("null?", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_Pointer::ext_isNull));
+    klass.defineMethod("to_s", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_Pointer::ext_toString));
     klass.aliasMethod("inspect", "to_s");
 }
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_pointer.h

@@ -4,13 +4,12 @@
 #include <QJSValue>
 
 namespace RubyQml {
-namespace Ext {
 
-class Pointer
+class Ext_Pointer
 {
 public:
-    Pointer(RubyValue self);
-    ~Pointer();
+    Ext_Pointer(RubyValue self);
+    ~Ext_Pointer();
 
     static RubyValue fromQObject(QObject *obj, bool owned);
 
@@ -39,5 +38,4 @@ private:
     QJSValue mJSValue;
 };
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_testutil.cpp

@@ -3,8 +3,7 @@
 #include "objectgc.h"
 
 namespace RubyQml {
-namespace Ext {
-namespace TestUtil {
+namespace Ext_TestUtil {
 
 namespace {
 
@@ -38,5 +37,4 @@ void defineModule()
 }
 
 } // namespace TestUtil
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_testutil.h

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

data/ext/qml/init.cpp

@@ -2,10 +2,10 @@
 #include "ext_pointer.h"
 #include "ext_pluginloader.h"
 #include "ext_anywrapper.h"
-#include "ext_accesssupport.h"
+#include "ext_accesswrapperfactory.h"
 #include "ext_testutil.h"
 #include "ext_kernel.h"
-#include "application.h"
+#include "kernel.h"
 #include "signalforwarder.h"
 #include "valuereference.h"
 #include "objectgc.h"
@@ -23,19 +23,19 @@ void defineMetaTypes()
 
 void defineClasses()
 {
-    Ext::MetaObject::defineClass();
-    Ext::Pointer::defineClass();
-    Ext::PluginLoader::defineClass();
-    Ext::AnyWrapper::defineClass();
-    Ext::AccessWrapperFactory::defineClass();
-    Ext::TestUtil::defineModule();
-    Ext::Kernel::defineModule();
+    Ext_MetaObject::defineClass();
+    Ext_Pointer::defineClass();
+    Ext_PluginLoader::defineClass();
+    Ext_AnyWrapper::defineClass();
+    Ext_AccessWrapperFactory::defineClass();
+    Ext_TestUtil::defineModule();
+    Ext_Kernel::defineModule();
     ListModel::defineUtilMethods();
 }
 
 void setupGlobalGCMarking()
 {
-    auto marker = Ext::AnyWrapper::create(QVariant(), [](const QVariant &) {
+    auto marker = Ext_AnyWrapper::create(QVariant(), [](const QVariant &) {
         ValueReference::markAllReferences();
         ObjectGC::instance()->markNonOwnedObjects();
     });

data/ext/qml/kernel.cpp

@@ -0,0 +1,39 @@
+#include "kernel.h"
+#include "util.h"
+#include <QTimer>
+
+namespace RubyQml {
+
+Kernel *Kernel::instance()
+{
+    if (!mInstance) {
+        fail("QML::UninitializedError", "ruby-qml not yet initialized");
+    }
+    return mInstance;
+}
+
+void Kernel::init(const QList<QByteArray> &args)
+{
+    if (mInstance) {
+        fail("QML::AlreadyInitializedErryr", "ruby-qml already initialized");
+    }
+    mInstance = new Kernel(args);
+}
+
+Kernel::Kernel(const QList<QByteArray> &args)
+{
+    mArgc = args.size();
+    mArgData = args;
+    mArgv = new char*[mArgc];
+    std::transform(mArgData.begin(), mArgData.end(), mArgv, [](QByteArray &ba) { return ba.data(); });
+
+    mApplication = new QApplication(mArgc, mArgv);
+    mEngine = new QQmlEngine();
+    mEventLoopHookTimer = new QTimer();
+    mEventLoopHookTimer->setInterval(0);
+    mEventLoopHookTimer->setSingleShot(false);
+}
+
+Kernel *Kernel::mInstance = nullptr;
+
+} // namespace RubyQml

data/ext/qml/kernel.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <QList>
+#include <QApplication>
+#include <QQmlEngine>
+
+namespace RubyQml {
+
+class Kernel
+{
+public:
+    QApplication *application() { return mApplication; }
+    QQmlEngine *engine() { return mEngine; }
+    QTimer *eventLoopHookTimer() { return mEventLoopHookTimer; }
+
+    static bool initialized() { return mInstance; }
+    static void init(const QList<QByteArray> &args);
+    static Kernel *instance();
+
+private:
+    Kernel(const QList<QByteArray> &args);
+    static Kernel *mInstance;
+
+    QList<QByteArray> mArgData;
+    int mArgc;
+    char **mArgv;
+    QApplication *mApplication = nullptr;
+    QQmlEngine *mEngine = nullptr;
+    QTimer *mEventLoopHookTimer = nullptr;
+};
+
+} // namespace RubyQml

data/ext/qml/plugins/core/applicationextension.cpp

@@ -8,11 +8,6 @@ namespace RubyQml {
 ApplicationExtension::ApplicationExtension(QApplication *app) :
     mApp(app)
 {
-    auto timer = new QTimer(this);
-    timer->setInterval(0);
-    timer->setSingleShot(false);
-    timer->start();
-    connect(timer, &QTimer::timeout, this, &ApplicationExtension::eventsProcessed);
 }
 
 void ApplicationExtension::exec()

data/ext/qml/plugins/core/applicationextension.h

@@ -13,9 +13,6 @@ class ApplicationExtension : public QObject
 public:
     explicit ApplicationExtension(QApplication *app);
 
-signals:
-    void eventsProcessed();
-
 public slots:
     void exec();
     void processEvents();

data/ext/qml/rubyvalue.cpp

@@ -5,7 +5,7 @@
 #include "objectdata.h"
 #include "accessobject.h"
 #include "listmodel.h"
-#include "ext_accesssupport.h"
+#include "ext_accesswrapperfactory.h"
 #include <ruby/intern.h>
 #define ONIG_ESCAPE_UCHAR_COLLISION
 #include <ruby/encoding.h>
@@ -328,7 +328,7 @@ template <> const QMetaObject *Conversion<const QMetaObject *>::from(RubyValue x
     if (x == RubyValue()) {
         return nullptr;
     }
-    return wrapperRubyClass<Ext::MetaObject>().unwrap(x)->metaObject();
+    return wrapperRubyClass<Ext_MetaObject>().unwrap(x)->metaObject();
 }
 
 template <> RubyValue Conversion<const QMetaObject *>::to(const QMetaObject *metaobj)
@@ -336,7 +336,7 @@ template <> RubyValue Conversion<const QMetaObject *>::to(const QMetaObject *met
     if (!metaobj) {
         return Qnil;
     }
-    return Ext::MetaObject::fromMetaObject(metaobj);
+    return Ext_MetaObject::fromMetaObject(metaobj);
 }
 
 } // namespace detail
@@ -449,7 +449,7 @@ bool RubyValue::isConvertibleTo(int metaType) const
             }
             return false;
         }
-        if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext::MetaObject>())) {
+        if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext_MetaObject>())) {
             return metaType == QMetaType::type("const QMetaObject*");
         }
         auto accessModule = RubyModule::fromPath("QML::Access");
@@ -524,7 +524,7 @@ int RubyValue::defaultMetaType() const
         if (rb_obj_is_kind_of(x, objectBaseClass)) {
             return QMetaType::QObjectStar;
         }
-        if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext::MetaObject>())) {
+        if (rb_obj_is_kind_of(x, wrapperRubyClass<Ext_MetaObject>())) {
             return QMetaType::type("const QMetaObject*");
         }
         auto accessModule = RubyModule::fromPath("QML::Access");
@@ -630,8 +630,8 @@ RubyValue RubyValue::fromQObject(QObject *obj, bool implicit)
         return data->rubyObject;
     }
 
-    auto metaobj = Ext::MetaObject::fromMetaObject(obj->metaObject());
-    auto pointer = Ext::Pointer::fromQObject(obj, false);
+    auto metaobj = Ext_MetaObject::fromMetaObject(obj->metaObject());
+    auto pointer = Ext_Pointer::fromQObject(obj, false);
 
     RubyValue wrapper;
     protect([&] {
@@ -656,7 +656,7 @@ QObject *RubyValue::toQObject() const
         auto wrapperFactory = protect([&] {
             return rb_funcall(rb_obj_class(x), RUBYQML_INTERN("access_wrapper_factory"), 0);
         });
-        return wrapperRubyClass<Ext::AccessWrapperFactory>().unwrap(wrapperFactory)->create(x);
+        return wrapperRubyClass<Ext_AccessWrapperFactory>().unwrap(wrapperFactory)->create(x);
     }
     static auto listModelClass = RubyModule::fromPath("QML::Data::ListModel");
     if (x.isKindOf(listModelClass)) {
@@ -670,8 +670,8 @@ QObject *RubyValue::toQObject() const
                 .arg(x.send("class").send("name").to<QString>()));
     }
     auto objptr = x.send(RUBYQML_INTERN("pointer"));
-    auto obj = wrapperRubyClass<Ext::Pointer>().unwrap(objptr)->fetchQObject();
-    Ext::MetaObject::fromMetaObject(obj->metaObject()).send(RUBYQML_INTERN("build_class"));
+    auto obj = wrapperRubyClass<Ext_Pointer>().unwrap(objptr)->fetchQObject();
+    Ext_MetaObject::fromMetaObject(obj->metaObject()).send(RUBYQML_INTERN("build_class"));
     return obj;
 }