qml 0.0.7 → 1.0.0

data/ext/qml/ext_metaobject.h

@@ -1,60 +0,0 @@
-#pragma once
-
-#include "rubyvalue.h"
-#include <QtCore/QMetaObject>
-#include <QtCore/QVector>
-#include <QtCore/QHash>
-#include <QtCore/QObject>
-
-namespace RubyQml {
-
-class Ext_MetaObject
-{
-public:
-    Ext_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 RubyQml

data/ext/qml/ext_pluginloader.cpp

@@ -1,53 +0,0 @@
-#include "ext_pluginloader.h"
-#include "ext_pointer.h"
-#include "rubyclass.h"
-#include <QtCore/QPluginLoader>
-#include <QtCore/QSet>
-
-namespace RubyQml {
-
-Ext_PluginLoader::Ext_PluginLoader(RubyValue self) :
-    self(self),
-    mPluginLoader(new QPluginLoader())
-{
-}
-
-Ext_PluginLoader::~Ext_PluginLoader()
-{
-}
-
-RubyValue Ext_PluginLoader::initialize(RubyValue path)
-{
-    mPluginLoader->setFileName(path.to<QString>());
-    return self;
-}
-
-RubyValue Ext_PluginLoader::load()
-{
-    auto ok = mPluginLoader->load();
-    if (!ok) {
-        fail("QML::PluginError", mPluginLoader->errorString());
-    }
-    return self;
-}
-
-RubyValue Ext_PluginLoader::instance()
-{
-    self.send("load");
-    auto instance = mPluginLoader->instance();
-    if (instance) {
-        return RubyValue::from(instance);
-    } else {
-        return Qnil;
-    }
-}
-
-void Ext_PluginLoader::defineClass()
-{
-    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 RubyQml

data/ext/qml/ext_pluginloader.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include "rubyvalue.h"
-#include <memory>
-
-class QPluginLoader;
-
-namespace RubyQml {
-
-class Ext_PluginLoader
-{
-public:
-    Ext_PluginLoader(RubyValue self);
-    ~Ext_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 RubyQml
-

data/ext/qml/ext_pointer.cpp

@@ -1,132 +0,0 @@
-#include "ext_pointer.h"
-#include "markable.h"
-#include "objectdata.h"
-#include "objectgc.h"
-#include "kernel.h"
-#include <QObject>
-#include <QHash>
-#include <QQmlEngine>
-#include <QQmlContext>
-#include <QDebug>
-#include <QCoreApplication>
-
-namespace RubyQml {
-
-Ext_Pointer::Ext_Pointer(RubyValue self) :
-    self(self)
-{
-}
-
-Ext_Pointer::~Ext_Pointer()
-{
-    ObjectGC::instance()->debug() << "\u267B\uFE0F  releasing object:" << mObject << "managed:" << mIsManaged;
-}
-
-RubyValue Ext_Pointer::fromQObject(QObject *obj, bool owned)
-{
-    auto klass = wrapperRubyClass<Ext_Pointer>();
-    auto ptr = klass.newInstance();
-    klass.unwrap(ptr)->setQObject(obj, owned);
-    return ptr;
-}
-
-QObject *Ext_Pointer::fetchQObject()
-{
-    if (!mObject) {
-        fail("QML::QtObjectError", "referencing already deleted Qt Object");
-    }
-    return mObject;
-}
-
-void Ext_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 Ext_Pointer::setManaged(bool managed)
-{
-    if (mObject) {
-        if (managed) {
-            QQmlEngine::setObjectOwnership(mObject, QQmlEngine::JavaScriptOwnership);
-            mJSValue = Kernel::instance()->engine()->newQObject(mObject);
-        } else {
-            QQmlEngine::setObjectOwnership(mObject, QQmlEngine::CppOwnership);
-            mJSValue = QJSValue();
-        }
-
-        ObjectData::getOrCreate(mObject)->owned = managed;
-        mIsManaged = managed;
-    }
-}
-
-void Ext_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 Ext_Pointer::ext_isManaged() const
-{
-    return RubyValue::from(mIsManaged);
-}
-
-RubyValue Ext_Pointer::ext_setManaged(RubyValue managed)
-{
-    setManaged(managed.to<bool>());
-    return ext_isManaged();
-}
-
-RubyValue Ext_Pointer::ext_preferManaged(RubyValue managed)
-{
-    preferManaged(managed.to<bool>());
-    return ext_isManaged();
-}
-
-RubyValue Ext_Pointer::ext_isNull() const
-{
-    return RubyValue::from(!mObject);
-}
-
-RubyValue Ext_Pointer::ext_toString() const
-{
-    QString name;
-    QDebug(&name) << mObject.data();
-    return RubyValue::from(name);
-}
-
-void Ext_Pointer::gc_mark()
-{
-    if (mIsManaged) {
-        ObjectGC::instance()->markOwnedObject(mObject);
-    }
-}
-
-void Ext_Pointer::defineClass()
-{
-    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 RubyQml

data/ext/qml/ext_pointer.h

@@ -1,41 +0,0 @@
-#pragma once
-#include "rubyclass.h"
-#include <QPointer>
-#include <QJSValue>
-
-namespace RubyQml {
-
-class Ext_Pointer
-{
-public:
-    Ext_Pointer(RubyValue self);
-    ~Ext_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 RubyQml

data/ext/qml/ext_testutil.cpp

@@ -1,40 +0,0 @@
-#include "ext_testutil.h"
-#include "rubyclass.h"
-#include "objectgc.h"
-
-namespace RubyQml {
-namespace Ext_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 RubyQml

data/ext/qml/ext_testutil.h

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

data/ext/qml/foreignclass.cpp

@@ -1,72 +0,0 @@
-#include "foreignclass.h"
-#include "foreignobject.h"
-#include <QDebug>
-
-namespace RubyQml {
-
-ForeignClass::ForeignClass()
-{
-}
-
-ForeignClass::~ForeignClass()
-{
-}
-
-QList<ForeignClass::Method> ForeignClass::signalMethods() const
-{
-    QList<Method> sigs;
-    std::copy_if(mMethods.begin(), mMethods.end(), std::back_inserter(sigs), [](const Method &m) {
-        return m.type == Method::Type::Signal;
-    });
-    return sigs;
-}
-
-QList<ForeignClass::Method> ForeignClass::nonSignalMethods() const
-{
-    QList<Method> sigs;
-    std::copy_if(mMethods.begin(), mMethods.end(), std::back_inserter(sigs), [](const Method &m) {
-        return m.type != Method::Type::Signal;
-    });
-    return sigs;
-}
-
-QVariant ForeignClass::callMethod(ForeignObject *obj, size_t id, const QVariantList &args)
-{
-    Q_UNUSED(obj);
-    Q_UNUSED(id);
-    Q_UNUSED(args);
-    return QVariant();
-}
-
-void ForeignClass::setProperty(ForeignObject *obj, size_t id, const QVariant &value)
-{
-    Q_UNUSED(obj);
-    Q_UNUSED(id);
-    Q_UNUSED(value);
-}
-
-QVariant ForeignClass::getProperty(ForeignObject *obj, size_t id)
-{
-    Q_UNUSED(obj);
-    Q_UNUSED(id);
-    return QVariant();
-}
-
-void ForeignClass::addMethod(const QByteArray &name, std::size_t id, const QList<QByteArray> &params, Method::Access access, Method::Type type)
-{
-    Method method = { .name = name, .params = params, .access = access, .type = type, .id = id };
-    mMethods << method;
-}
-
-void ForeignClass::addSignal(const QByteArray &name, std::size_t id, const QList<QByteArray> &params)
-{
-    addMethod(name, id, params, Method::Access::Protected, Method::Type::Signal);
-}
-
-void ForeignClass::addProperty(const QByteArray &name, std::size_t getterId, std::size_t setterId, Property::Flags flags, bool hasNotifySignal,std::size_t notifySignalId)
-{
-    Property property = { .name = name, .flags = flags, .setterId = setterId, .getterId = getterId, .hasNotifySignal = hasNotifySignal, .notifySignalId = notifySignalId};
-    mProperties << property;
-}
-
-} // namespace RubyQml

data/ext/qml/foreignclass.h

@@ -1,88 +0,0 @@
-#pragma once
-
-#include <QVariant>
-#include <QMetaMethod>
-#include <QMetaProperty>
-#include <QFlag>
-#include "common.h"
-
-class QByteArray;
-
-namespace RubyQml {
-
-class ForeignObject;
-
-class ForeignClass
-{
-public:
-    ForeignClass();
-    virtual ~ForeignClass();
-
-    struct Method
-    {
-        enum class Access
-        {
-            Private,
-            Protected,
-            Public
-        };
-
-        enum class Type
-        {
-            Method,
-            Signal
-        };
-
-        QByteArray name;
-        QList<QByteArray> params;
-        Access access;
-        Type type;
-        std::size_t id;
-    };
-
-    struct Property
-    {
-        enum class Flag
-        {
-            Readable = 1,
-            Writable = 1 << 1,
-            Constant = 1 << 2,
-        };
-        Q_DECLARE_FLAGS(Flags, Flag)
-
-        QByteArray name;
-        Flags flags;
-        std::size_t setterId;
-        std::size_t getterId;
-        bool hasNotifySignal;
-        std::size_t notifySignalId;
-    };
-
-    QByteArray className() const { return mClassName; }
-    QList<Method> methods() const { return mMethods; }
-    QList<Method> signalMethods() const;
-    QList<Method> nonSignalMethods() const;
-    QList<Property> properties() const { return mProperties; }
-
-    void setClassName(const QByteArray &name) { mClassName = name; }
-    void addMethod(const QByteArray &name, std::size_t id, const QList<QByteArray> &params, Method::Access access = Method::Access::Public, Method::Type type = Method::Type::Method);
-    void addSignal(const QByteArray &name, std::size_t id, const QList<QByteArray> &params);
-    void addProperty(const QByteArray &name, std::size_t getterId, std::size_t setterId, Property::Flags flags, bool hasNotifySignal = false, std::size_t notifySignalId = 0);
-
-    virtual QVariant callMethod(ForeignObject *obj, size_t id, const QVariantList &args);
-    virtual void setProperty(ForeignObject *obj, size_t id, const QVariant &value);
-    virtual QVariant getProperty(ForeignObject *obj, size_t id);
-
-protected:
-
-
-private:
-
-    QByteArray mClassName;
-    QList<Method> mMethods;
-    QList<Property> mProperties;
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(ForeignClass::Property::Flags)
-
-} // namespace RubyQml