qml 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 531c290e09cd315f45f4cfb07d55d9e16e16fef6
-  data.tar.gz: 5452466222e562568f69b30771a6adc51e00e892
+  metadata.gz: 525fa2715a8aadc120216147318e0179a578d546
+  data.tar.gz: ca001300069503c335494e26bd443ef123b56179
 SHA512:
-  metadata.gz: 297b2394051b19603dda694d5c4890a39cbeaf1c2123d9365586bc2de30c24d179c76f71c491b4671701e3f9ab6d690de87d0760bb958196874cb560e6e51aa1
-  data.tar.gz: c6a5ef840aa64784c9eb0f4af85261c5ff92a021f1f4eb3a81ddef60f488c6873cd8a97fa3297d317dbd29bcbb3192ff16ab6eefda22ff7c7d6ebb4f4a0ce34d
+  metadata.gz: e6468fcf25055c17367415cca0d62b540eacf732de0028958a1337af8e9b157c85a9602e4fc07b47b9a64f130a8797e76dfdf6bcd43b2f9907c41cbfb354f627
+  data.tar.gz: 865173142d1e3e4ed48d52c08fc52cb77e0fa51b43188388b3fe9074d9b273e1fc9dfdf5f27667505c1b618447038be10f61c1377c82ff007c0010c039e0a291

data/README.md

@@ -1,8 +1,11 @@
-# ruby-qml
+ruby-qml
+================
 
 [![Gem Version](https://badge.fury.io/rb/qml.svg)](http://badge.fury.io/rb/qml)
+[![Dependency Status](https://gemnasium.com/seanchas116/ruby-qml.svg)](https://gemnasium.com/seanchas116/ruby-qml)
 [![Build Status](https://travis-ci.org/seanchas116/ruby-qml.svg?branch=master)](https://travis-ci.org/seanchas116/ruby-qml)
 [![Coverage Status](https://coveralls.io/repos/seanchas116/ruby-qml/badge.png?branch=master)](https://coveralls.io/r/seanchas116/ruby-qml?branch=master)
+[![Inline docs](http://inch-ci.org/github/seanchas116/ruby-qml.png?branch=master)](http://inch-ci.org/github/seanchas116/ruby-qml)
 
 ruby-qml is a QML / Qt Quick wrapper for Ruby.
 It provides bindings between QML and Ruby and enables you to use Qt Quick-based GUI from Ruby.

data/changes.md

@@ -1,3 +1,7 @@
+## 0.0.4 (2014-07-24)
+
+* Fix 100% CPU usage in idling
+
 ## 0.0.3 (2014-07-22)
 
 * Support Ruby 1.9.3

data/examples/twitter/twitter.rb

@@ -33,8 +33,7 @@ module Examples
         @streaming_client.filter(track: word) do |object|
           case object
           when ::Twitter::Tweet
-            puts object
-            QML.later { yield object }
+            yield object
           end
         end
       end

data/ext/qml/{ext_accesssupport.cpp → ext_accesswrapperfactory.cpp}

@@ -1,4 +1,4 @@
-#include "ext_accesssupport.h"
+#include "ext_accesswrapperfactory.h"
 #include "ext_pointer.h"
 #include "rubyclass.h"
 #include "accessclass.h"
@@ -7,18 +7,17 @@
 #include "qmltyperegisterer.h"
 
 namespace RubyQml {
-namespace Ext {
 
-AccessWrapperFactory::AccessWrapperFactory(RubyValue self) :
+Ext_AccessWrapperFactory::Ext_AccessWrapperFactory(RubyValue self) :
     self(self)
 {
 }
 
-AccessWrapperFactory::~AccessWrapperFactory()
+Ext_AccessWrapperFactory::~Ext_AccessWrapperFactory()
 {
 }
 
-RubyValue AccessWrapperFactory::ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos)
+RubyValue Ext_AccessWrapperFactory::ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos)
 {
     mRubyClass = rubyClass;
     mAccessClass = makeSP<AccessClass>(className, methodInfos, signalInfos, propertyInfos);
@@ -26,9 +25,9 @@ RubyValue AccessWrapperFactory::ext_initialize(RubyValue rubyClass, RubyValue cl
     return self;
 }
 
-RubyValue AccessWrapperFactory::ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args)
+RubyValue Ext_AccessWrapperFactory::ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args)
 {
-    auto accessObj = wrapperRubyClass<Pointer>().unwrap(obj.send("access_object"))->fetchQObject();
+    auto accessObj = wrapperRubyClass<Ext_Pointer>().unwrap(obj.send("access_object"))->fetchQObject();
     auto nameId = name.toID();
     auto argVariants = args.to<QVariantList>();
     withoutGvl([&] {
@@ -37,41 +36,40 @@ RubyValue AccessWrapperFactory::ext_emitSignal(RubyValue obj, RubyValue name, Ru
     return Qnil;
 }
 
-RubyValue AccessWrapperFactory::ext_registerToQml(RubyValue path, RubyValue majorVersion, RubyValue minorVersion, RubyValue name)
+RubyValue Ext_AccessWrapperFactory::ext_registerToQml(RubyValue path, RubyValue majorVersion, RubyValue minorVersion, RubyValue name)
 {
     using namespace std::placeholders;
     if (!mTypeRegisterer) {
-        mTypeRegisterer = makeSP<QmlTypeRegisterer>(mMetaObject, std::bind(&AccessWrapperFactory::newInstanceInto, this, _1));
+        mTypeRegisterer = makeSP<QmlTypeRegisterer>(mMetaObject, std::bind(&Ext_AccessWrapperFactory::newInstanceInto, this, _1));
         mTypeRegisterer->registerType(path.to<QByteArray>(), majorVersion.to<int>(), minorVersion.to<int>(), name.to<QByteArray>());
     }
     return self;
 }
 
-RubyValue AccessWrapperFactory::ext_create(RubyValue access)
+RubyValue Ext_AccessWrapperFactory::ext_create(RubyValue access)
 {
     return RubyValue::fromQObject(create(access), false);
 }
 
-AccessWrapper *AccessWrapperFactory::create(RubyValue access)
+AccessWrapper *Ext_AccessWrapperFactory::create(RubyValue access)
 {
     return new AccessWrapper(mMetaObject, access);
 }
 
-void AccessWrapperFactory::newInstanceInto(void *where)
+void Ext_AccessWrapperFactory::newInstanceInto(void *where)
 {
     withGvl([&] {
         new(where) AccessWrapper(mMetaObject, mRubyClass.send("new"));
     });
 }
 
-void AccessWrapperFactory::defineClass()
+void Ext_AccessWrapperFactory::defineClass()
 {
-    WrapperRubyClass<AccessWrapperFactory> klass(RubyModule::fromPath("QML"), "AccessWrapperFactory");
-    klass.defineMethod(MethodAccess::Protected, "initialize", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_initialize));
-    klass.defineMethod("emit_signal", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_emitSignal));
-    klass.defineMethod("register_to_qml", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_registerToQml));
-    klass.defineMethod("create", RUBYQML_MEMBER_FUNCTION_INFO(&AccessWrapperFactory::ext_create));
+    WrapperRubyClass<Ext_AccessWrapperFactory> klass(RubyModule::fromPath("QML"), "AccessWrapperFactory");
+    klass.defineMethod(MethodAccess::Protected, "initialize", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_initialize));
+    klass.defineMethod("emit_signal", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_emitSignal));
+    klass.defineMethod("register_to_qml", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_registerToQml));
+    klass.defineMethod("create", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_AccessWrapperFactory::ext_create));
 }
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/{ext_accesssupport.h → ext_accesswrapperfactory.h}

@@ -9,13 +9,11 @@ class ForeignMetaObject;
 class QmlTypeRegisterer;
 class AccessWrapper;
 
-namespace Ext {
-
-class AccessWrapperFactory
+class Ext_AccessWrapperFactory
 {
 public:
-    AccessWrapperFactory(RubyValue self);
-    ~AccessWrapperFactory();
+    Ext_AccessWrapperFactory(RubyValue self);
+    ~Ext_AccessWrapperFactory();
 
     RubyValue ext_initialize(RubyValue rubyClass, RubyValue className, RubyValue methodInfos, RubyValue signalInfos, RubyValue propertyInfos);
     RubyValue ext_emitSignal(RubyValue obj, RubyValue name, RubyValue args);
@@ -38,5 +36,4 @@ private:
     SP<QmlTypeRegisterer> mTypeRegisterer;
 };
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_anywrapper.cpp

@@ -2,16 +2,15 @@
 #include "rubyclass.h"
 
 namespace RubyQml {
-namespace Ext {
 
-AnyWrapper::AnyWrapper(RubyValue self)
+Ext_AnyWrapper::Ext_AnyWrapper(RubyValue self)
 {
     Q_UNUSED(self);
 }
 
-RubyValue AnyWrapper::create(const QVariant &value, void (*markFunction)(const QVariant &))
+RubyValue Ext_AnyWrapper::create(const QVariant &value, void (*markFunction)(const QVariant &))
 {
-    auto klass = wrapperRubyClass<AnyWrapper>();
+    auto klass = wrapperRubyClass<Ext_AnyWrapper>();
     auto wrapper = klass.newInstance();
     auto ptr = klass.unwrap(wrapper);
     ptr->mValue = value;
@@ -19,18 +18,17 @@ RubyValue AnyWrapper::create(const QVariant &value, void (*markFunction)(const Q
     return wrapper;
 }
 
-void AnyWrapper::defineClass()
+void Ext_AnyWrapper::defineClass()
 {
-    WrapperRubyClass<AnyWrapper> klass(RubyModule::fromPath("QML"), "AnyWrapper");
+    WrapperRubyClass<Ext_AnyWrapper> klass(RubyModule::fromPath("QML"), "AnyWrapper");
     Q_UNUSED(klass);
 }
 
-void AnyWrapper::gc_mark()
+void Ext_AnyWrapper::gc_mark()
 {
     if (mMarkFunction) {
         mMarkFunction(mValue);
     }
 }
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_anywrapper.h

@@ -5,12 +5,10 @@ namespace RubyQml {
 
 class RubyValue;
 
-namespace Ext {
-
-class AnyWrapper
+class Ext_AnyWrapper
 {
 public:
-    AnyWrapper(RubyValue self);
+    Ext_AnyWrapper(RubyValue self);
     static RubyValue create(const QVariant &value, void (*markFunction)(const QVariant &) = nullptr);
     static void defineClass();
 
@@ -22,5 +20,4 @@ private:
     void (*mMarkFunction)(const QVariant &);
 };
 
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_kernel.cpp

@@ -1,24 +1,42 @@
 #include "ext_kernel.h"
-#include "application.h"
+#include "kernel.h"
 #include "rubyvalue.h"
 #include "rubyclass.h"
+#include <QTimer>
 
 namespace RubyQml {
-namespace Ext {
-namespace Kernel {
+namespace Ext_Kernel {
 
 namespace {
 
 RubyValue application(RubyValue self)
 {
     Q_UNUSED(self);
-    return RubyValue::from(Application::application());
+    return RubyValue::from(Kernel::instance()->application());
 }
 
 RubyValue engine(RubyValue self)
 {
     Q_UNUSED(self);
-    return RubyValue::from(Application::engine());
+    return RubyValue::from(Kernel::instance()->engine());
+}
+
+RubyValue eventLoopHookTimer(RubyValue self)
+{
+    Q_UNUSED(self);
+    return RubyValue::from(Kernel::instance()->eventLoopHookTimer());
+}
+
+RubyValue setEventLoopHookEnabledLater(RubyValue self, RubyValue enabled)
+{
+    Q_UNUSED(self);
+    auto timer = Kernel::instance()->eventLoopHookTimer();
+    if (enabled) {
+        timer->metaObject()->invokeMethod(timer, "start", Qt::QueuedConnection);
+    } else {
+        timer->metaObject()->invokeMethod(timer, "stop", Qt::QueuedConnection);
+    }
+    return enabled;
 }
 
 RubyValue applicationMetaObject()
@@ -34,14 +52,14 @@ RubyValue engineMetaObject()
 RubyValue init(RubyValue self, RubyValue argv)
 {
     Q_UNUSED(self);
-    Application::init(argv.to<QList<QByteArray>>());
+    Kernel::init(argv.to<QList<QByteArray>>());
     return Qnil;
 }
 
 RubyValue initialized(RubyValue self)
 {
     Q_UNUSED(self);
-    return RubyValue::from(Application::initialized());
+    return RubyValue::from(Kernel::initialized());
 }
 
 }
@@ -51,6 +69,8 @@ void defineModule()
     RubyModule kernel(RubyModule::fromPath("QML"), "Kernel");
     kernel.defineModuleFunction("application", RUBYQML_FUNCTION_INFO(&application));
     kernel.defineModuleFunction("engine", RUBYQML_FUNCTION_INFO(&engine));
+    kernel.defineModuleFunction("event_loop_hook_timer", RUBYQML_FUNCTION_INFO(&eventLoopHookTimer));
+    kernel.defineModuleFunction("set_event_loop_hook_enabled_later", RUBYQML_FUNCTION_INFO(&setEventLoopHookEnabledLater));
     kernel.defineModuleFunction("application_meta_object", RUBYQML_FUNCTION_INFO(&applicationMetaObject));
     kernel.defineModuleFunction("engine_meta_object", RUBYQML_FUNCTION_INFO(&engineMetaObject));
     kernel.defineModuleFunction("init", RUBYQML_FUNCTION_INFO(&init));
@@ -58,5 +78,4 @@ void defineModule()
 }
 
 } // namespace Kernel
-} // namespace Ext
 } // namespace RubyQml

data/ext/qml/ext_kernel.h

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

data/ext/qml/ext_metaobject.cpp

@@ -13,7 +13,6 @@
 #include <QtQml/QQmlEngine>
 
 namespace RubyQml {
-namespace Ext {
 
 namespace {
 
@@ -30,38 +29,38 @@ RubyValue idListToArray(const QList<ID> &xs)
 
 }
 
-MetaObject::MetaObject(RubyValue self) :
+Ext_MetaObject::Ext_MetaObject(RubyValue self) :
     self(self)
 {
     setMetaObject(&QObject::staticMetaObject);
 }
 
-RubyValue MetaObject::className() const
+RubyValue Ext_MetaObject::className() const
 {
     return rb_str_new_cstr(mMetaObject->className());
 }
 
-RubyValue MetaObject::methodNames() const
+RubyValue Ext_MetaObject::methodNames() const
 {
     return idListToArray(mMethodHash.keys());
 }
 
-RubyValue MetaObject::isPublic(RubyValue name) const
+RubyValue Ext_MetaObject::isPublic(RubyValue name) const
 {
     auto methods = findMethods(name);
     return RubyValue::from(mMetaObject->method(methods.first()).access() == QMetaMethod::Public);
 }
-RubyValue MetaObject::isProtected(RubyValue name) const
+RubyValue Ext_MetaObject::isProtected(RubyValue name) const
 {
     auto methods = findMethods(name);
     return RubyValue::from(mMetaObject->method(methods.first()).access() == QMetaMethod::Protected);
 }
-RubyValue MetaObject::isPrivate(RubyValue name) const
+RubyValue Ext_MetaObject::isPrivate(RubyValue name) const
 {
     auto methods = findMethods(name);
     return RubyValue::from(mMetaObject->method(methods.first()).access() == QMetaMethod::Private);
 }
-RubyValue MetaObject::isSignal(RubyValue name) const
+RubyValue Ext_MetaObject::isSignal(RubyValue name) const
 {
     auto methods = findMethods(name);
     return RubyValue::from(mMetaObject->method(methods.first()).methodType() == QMetaMethod::Signal);
@@ -132,7 +131,7 @@ public:
             auto ret = RubyValue::from(returnValue);
             static auto objectBaseClass = RubyClass::fromPath("QML::QtObjectBase");
             if (ret.isKindOf(objectBaseClass)) {
-                auto pointer = wrapperRubyClass<Pointer>().unwrap(ret.send("pointer"));
+                auto pointer = wrapperRubyClass<Ext_Pointer>().unwrap(ret.send("pointer"));
                 pointer->preferManaged(true);
             }
             return ret;
@@ -143,7 +142,7 @@ private:
     QMetaMethod mMethod;
 };
 
-RubyValue MetaObject::invokeMethod(RubyValue object, RubyValue methodName, RubyValue args) const
+RubyValue Ext_MetaObject::invokeMethod(RubyValue object, RubyValue methodName, RubyValue args) const
 {
     checkThread();
 
@@ -152,7 +151,7 @@ RubyValue MetaObject::invokeMethod(RubyValue object, RubyValue methodName, RubyV
     protect([&] {
         args = rb_check_array_type(args);
     });
-    auto obj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    auto obj = wrapperRubyClass<Ext_Pointer>().unwrap(object)->fetchQObject();
     for (int i : methodIndexes) {
         MethodInvoker invoker(args, mMetaObject->method(i));
         if (invoker.isArgsCompatible()) {
@@ -173,10 +172,10 @@ RubyValue MetaObject::invokeMethod(RubyValue object, RubyValue methodName, RubyV
     return Qnil;
 }
 
-RubyValue MetaObject::connectSignal(RubyValue object, RubyValue signalName, RubyValue proc) const
+RubyValue Ext_MetaObject::connectSignal(RubyValue object, RubyValue signalName, RubyValue proc) const
 {
     auto id = signalName.toID();
-    auto obj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    auto obj = wrapperRubyClass<Ext_Pointer>().unwrap(object)->fetchQObject();
 
     proc = proc.send("to_proc");
 
@@ -199,18 +198,18 @@ RubyValue MetaObject::connectSignal(RubyValue object, RubyValue signalName, Ruby
     return Qnil;
 }
 
-RubyValue MetaObject::propertyNames() const
+RubyValue Ext_MetaObject::propertyNames() const
 {
     return idListToArray(mPropertyHash.keys());
 }
 
-RubyValue MetaObject::getProperty(RubyValue object, RubyValue name) const
+RubyValue Ext_MetaObject::getProperty(RubyValue object, RubyValue name) const
 {
     checkThread();
 
     auto metaProperty = mMetaObject->property(findProperty(name));
 
-    auto qobj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    auto qobj = wrapperRubyClass<Ext_Pointer>().unwrap(object)->fetchQObject();
     QVariant result;
     withoutGvl([&] {
         result = metaProperty.read(qobj);
@@ -218,7 +217,7 @@ RubyValue MetaObject::getProperty(RubyValue object, RubyValue name) const
     return RubyValue::from(result);
 }
 
-RubyValue MetaObject::setProperty(RubyValue object, RubyValue name, RubyValue newValue) const
+RubyValue Ext_MetaObject::setProperty(RubyValue object, RubyValue name, RubyValue newValue) const
 {
     checkThread();
 
@@ -231,7 +230,7 @@ RubyValue MetaObject::setProperty(RubyValue object, RubyValue name, RubyValue ne
         });
     }
 
-    auto qobj = wrapperRubyClass<Pointer>().unwrap(object)->fetchQObject();
+    auto qobj = wrapperRubyClass<Ext_Pointer>().unwrap(object)->fetchQObject();
     auto variant = newValue.to<QVariant>();
     QVariant result;
     withoutGvl([&] {
@@ -241,7 +240,7 @@ RubyValue MetaObject::setProperty(RubyValue object, RubyValue name, RubyValue ne
     return RubyValue::from(result);
 }
 
-RubyValue MetaObject::notifySignal(RubyValue name) const
+RubyValue Ext_MetaObject::notifySignal(RubyValue name) const
 {
     auto metaProperty = mMetaObject->property(findProperty(name));
     auto signal = metaProperty.notifySignal();
@@ -253,14 +252,14 @@ RubyValue MetaObject::notifySignal(RubyValue name) const
     }
 }
 
-void MetaObject::checkThread() const
+void Ext_MetaObject::checkThread() const
 {
     if (rb_thread_current() != rb_thread_main()) {
         fail("QML::InvalidThreadError", "Qt object accessed from non-main thread");
     }
 }
 
-QList<int> MetaObject::findMethods(RubyValue name) const
+QList<int> Ext_MetaObject::findMethods(RubyValue name) const
 {
     auto id = name.toID();
     auto methodIndexes = mMethodHash.values(id);
@@ -275,7 +274,7 @@ QList<int> MetaObject::findMethods(RubyValue name) const
     return methodIndexes;
 }
 
-int MetaObject::findProperty(RubyValue name) const
+int Ext_MetaObject::findProperty(RubyValue name) const
 {
     auto id = name.toID();
     if (!mPropertyHash.contains(id)) {
@@ -288,7 +287,7 @@ int MetaObject::findProperty(RubyValue name) const
     return mPropertyHash[id];
 }
 
-RubyValue MetaObject::enumerators() const
+RubyValue Ext_MetaObject::enumerators() const
 {
     QHash<QByteArray, QHash<QByteArray, int>> enums;
 
@@ -308,7 +307,7 @@ RubyValue MetaObject::enumerators() const
     return RubyValue::from(enums);
 }
 
-RubyValue MetaObject::superClass() const
+RubyValue Ext_MetaObject::superClass() const
 {
     auto superclass = mMetaObject->superClass();
     if (!superclass) {
@@ -317,17 +316,17 @@ RubyValue MetaObject::superClass() const
     return fromMetaObject(superclass);
 }
 
-RubyValue MetaObject::isEqual(RubyValue other) const
+RubyValue Ext_MetaObject::isEqual(RubyValue other) const
 {
-    return RubyValue::from(mMetaObject == wrapperRubyClass<MetaObject>().unwrap(other)->mMetaObject);
+    return RubyValue::from(mMetaObject == wrapperRubyClass<Ext_MetaObject>().unwrap(other)->mMetaObject);
 }
 
-RubyValue MetaObject::hash() const
+RubyValue Ext_MetaObject::hash() const
 {
     return RubyValue::from(reinterpret_cast<size_t>(mMetaObject)).send("hash");
 }
 
-void MetaObject::setMetaObject(const QMetaObject *metaObject)
+void Ext_MetaObject::setMetaObject(const QMetaObject *metaObject)
 {
     int methodCount = metaObject->methodCount() - metaObject->methodOffset();
 
@@ -370,43 +369,42 @@ void MetaObject::setMetaObject(const QMetaObject *metaObject)
     mPropertyHash = propertyHash;
 }
 
-RubyValue MetaObject::fromMetaObject(const QMetaObject *metaObject)
+RubyValue Ext_MetaObject::fromMetaObject(const QMetaObject *metaObject)
 {
-    auto klass = wrapperRubyClass<MetaObject>();
+    auto klass = wrapperRubyClass<Ext_MetaObject>();
     auto value = klass.newInstance();
     klass.unwrap(value)->setMetaObject(metaObject);
     return value;
 }
 
-void MetaObject::defineClass()
+void Ext_MetaObject::defineClass()
 {
-    WrapperRubyClass<MetaObject> klass(RubyModule::fromPath("QML"), "MetaObject");
+    WrapperRubyClass<Ext_MetaObject> klass(RubyModule::fromPath("QML"), "MetaObject");
 
-    klass.defineMethod("name", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::className));
+    klass.defineMethod("name", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::className));
 
-    klass.defineMethod("method_names", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::methodNames));
-    klass.defineMethod("public?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isPublic));
-    klass.defineMethod("protected?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isProtected));
-    klass.defineMethod("private?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isPrivate));
-    klass.defineMethod("signal?", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isSignal));
+    klass.defineMethod("method_names", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::methodNames));
+    klass.defineMethod("public?", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::isPublic));
+    klass.defineMethod("protected?", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::isProtected));
+    klass.defineMethod("private?", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::isPrivate));
+    klass.defineMethod("signal?", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::isSignal));
 
-    klass.defineMethod("invoke_method", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::invokeMethod));
-    klass.defineMethod("connect_signal", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::connectSignal));
+    klass.defineMethod("invoke_method", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::invokeMethod));
+    klass.defineMethod("connect_signal", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::connectSignal));
 
-    klass.defineMethod("property_names", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::propertyNames));
-    klass.defineMethod("get_property", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::getProperty));
-    klass.defineMethod("set_property", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::setProperty));
-    klass.defineMethod("notify_signal", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::notifySignal));
+    klass.defineMethod("property_names", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::propertyNames));
+    klass.defineMethod("get_property", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::getProperty));
+    klass.defineMethod("set_property", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::setProperty));
+    klass.defineMethod("notify_signal", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::notifySignal));
 
-    klass.defineMethod("enumerators", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::enumerators));
+    klass.defineMethod("enumerators", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::enumerators));
 
-    klass.defineMethod("super_class", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::superClass));
+    klass.defineMethod("super_class", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::superClass));
 
-    klass.defineMethod("==", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::isEqual));
-    klass.defineMethod("hash", RUBYQML_MEMBER_FUNCTION_INFO(&MetaObject::hash));
+    klass.defineMethod("==", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::isEqual));
+    klass.defineMethod("hash", RUBYQML_MEMBER_FUNCTION_INFO(&Ext_MetaObject::hash));
 
     klass.aliasMethod("eql?", "==");
 }
 
-} // namespace Ext
 } // namespace RubyQml