qml 0.0.1

data/ext/qml/foreignmetaobject.h

@@ -0,0 +1,46 @@
+#pragma once
+#include <QMetaObject>
+#include <QVector>
+#include <QHash>
+#include <QVariant>
+#include "common.h"
+
+namespace RubyQml {
+
+class ForeignClass;
+class ForeignObject;
+
+class ForeignMetaObject : public QMetaObject
+{
+public:
+    ForeignMetaObject(const SP<ForeignClass> &foreignClass, const SP<ForeignMetaObject> &superMetaObject = SP<ForeignMetaObject>());
+
+    int dynamicMetaCall(ForeignObject *obj, QMetaObject::Call call, int index, void **argv);
+    void emitSignal(ForeignObject *obj, std::size_t id, const QVariantList &args);
+    void dump();
+
+private:
+    class StringPool;
+
+    void buildData();
+    QVector<uint> writeMetaData(StringPool &stringPool);
+
+    QVector<uint8_t> mStringData;
+    QVector<uint> mData;
+
+    SP<ForeignClass> mForeignClass;
+    SP<ForeignMetaObject> mSuperMetaObject;
+
+    QHash<std::size_t, int> mSignalIndexHash;
+
+    QList<std::size_t> mMethodIds;
+    QList<int> mMethodArities;
+    int mMethodCount;
+    int mSignalCount;
+
+    QList<std::size_t> mPropertySetterIds;
+    QList<std::size_t> mPropertyGetterIds;
+    int mPropertyCount;
+};
+
+} // namespace RubyQml

data/ext/qml/foreignobject.cpp

@@ -0,0 +1,22 @@
+#include "foreignobject.h"
+#include "foreignmetaobject.h"
+
+namespace RubyQml {
+
+ForeignObject::ForeignObject(const SP<ForeignMetaObject> &metaobj, QObject *parent) :
+    QObject(parent),
+    mMetaObject(metaobj)
+{
+}
+
+const QMetaObject *ForeignObject::metaObject() const
+{
+    return mMetaObject.get();
+}
+
+int ForeignObject::qt_metacall(QMetaObject::Call call, int index, void **argv)
+{
+    return mMetaObject->dynamicMetaCall(this, call, index, argv);
+}
+
+} // namespace RubyQml

data/ext/qml/foreignobject.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <QObject>
+#include "common.h"
+
+namespace RubyQml {
+
+class ForeignMetaObject;
+
+class ForeignObject : public QObject
+{
+public:
+    explicit ForeignObject(const SP<ForeignMetaObject> &mMetaObject, QObject *parent = 0);
+
+    const QMetaObject *metaObject() const override;
+    int qt_metacall(QMetaObject::Call call, int index, void **argv) override;
+
+private:
+    SP<ForeignMetaObject> mMetaObject;
+};
+
+} // namespace RubyQml

data/ext/qml/functioninfo.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RubyQml {
+
+template <typename TFunction, TFunction function>
+struct FunctionInfo {};
+
+#define RUBYQML_FUNCTION_INFO(func) FunctionInfo<decltype(func), func>()
+
+template <typename TMemberFunction, TMemberFunction memberFunction>
+struct MemberFunctionInfo {};
+
+#define RUBYQML_MEMBER_FUNCTION_INFO(memfn) MemberFunctionInfo<decltype(memfn), memfn>()
+
+
+} // namespace RubyQml

data/ext/qml/init.cpp

@@ -0,0 +1,69 @@
+#include "ext_metaobject.h"
+#include "ext_pointer.h"
+#include "ext_pluginloader.h"
+#include "ext_gcmarker.h"
+#include "ext_accesssupport.h"
+#include "ext_testutil.h"
+#include "ext_kernel.h"
+#include "application.h"
+#include "signalforwarder.h"
+#include "valuereference.h"
+#include "objectgc.h"
+#include "listmodel.h"
+#include <QtCore/QSet>
+
+using namespace RubyQml;
+
+namespace {
+
+void defineMetaTypes()
+{
+    qRegisterMetaType<const QMetaObject *>();
+}
+
+void defineClasses()
+{
+    Ext::MetaObject::defineClass();
+    Ext::Pointer::defineClass();
+    Ext::PluginLoader::defineClass();
+    Ext::GCMarker::defineClass();
+    Ext::AccessWrapperFactory::defineClass();
+    Ext::TestUtil::defineModule();
+    Ext::Kernel::defineModule();
+    ListModel::defineUtilMethods();
+}
+
+void setupGlobalGCMarking()
+{
+    auto marker = Ext::GCMarker::fromMarkFunction([] {
+        ValueReference::markAllReferences();
+        ObjectGC::instance()->markNonOwnedObjects();
+    });
+    rb_gc_register_mark_object(marker);
+}
+
+void cleanup()
+{
+}
+
+void setupEndProc()
+{
+    rb_set_end_proc([](VALUE) { unprotect(cleanup); }, Qnil);
+}
+
+}
+
+extern "C"
+void Init_qml()
+{
+    rb_require("date");
+    rb_require("qml/errors");
+    rb_require("qml/error_converter");
+
+    unprotect([&] {
+        defineMetaTypes();
+        defineClasses();
+        setupGlobalGCMarking();
+        setupEndProc();
+    });
+}

data/ext/qml/listmodel.cpp

@@ -0,0 +1,112 @@
+#include "listmodel.h"
+#include "rubyclass.h"
+#include <QMetaObject>
+#include <QMetaMethod>
+
+namespace RubyQml {
+
+ListModel::ListModel(RubyValue rubyModel, QObject *parent) :
+    QAbstractListModel(parent),
+    mRubyModel(rubyModel)
+{
+    auto columns = rubyModel.send("class").send("columns").to<QList<QByteArray>>();
+    for (int i = 0; i < columns.size(); ++i) {
+        auto role = Qt::UserRole + i;
+        mColumnNames[role] = columns[i];
+        mColumnIDs[role] = rb_intern(columns[i]);
+    }
+    rubyModel.send("qt_models").send("push", RubyValue::fromQObject(this, false));
+}
+
+ListModel::~ListModel()
+{
+    mRubyModel.send("qt_models").send("delete", RubyValue::fromQObject(this, false));
+}
+
+QHash<int, QByteArray> ListModel::roleNames() const
+{
+    return mColumnNames;
+}
+
+QVariant ListModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid()) {
+        return QVariant();
+    }
+
+    return mRubyModel.send("[]", RubyValue::from(index.row())).send("[]", RubyValue::fromID(mColumnIDs[role])).to<QVariant>();
+}
+
+int ListModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return mRubyModel.send("count").to<int>();
+}
+
+QModelIndex ListModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return QModelIndex();
+    }
+    return createIndex(row, column);
+}
+
+void ListModel::beginMove(int first, int last, int destination)
+{
+    beginMoveRows(QModelIndex(), first, last ,QModelIndex(), destination);
+}
+
+void ListModel::endMove()
+{
+    endMoveRows();
+}
+
+void ListModel::beginInsert(int first, int last)
+{
+    beginInsertRows(QModelIndex(), first, last);
+}
+
+void ListModel::endInsert()
+{
+    endInsertRows();
+}
+
+void ListModel::beginRemove(int first, int last)
+{
+    beginRemoveRows(QModelIndex(), first, last);
+}
+
+void ListModel::endRemove()
+{
+    endRemoveRows();
+}
+
+void ListModel::update(int first, int last)
+{
+    emit dataChanged(index(first), index(last));
+}
+
+void ListModel::gc_mark()
+{
+    rb_gc_mark(mRubyModel);
+}
+
+namespace {
+
+RubyValue createWrapper(RubyValue self)
+{
+    return RubyValue::fromQObject(new ListModel(self), false);
+}
+
+}
+
+void ListModel::defineUtilMethods()
+{
+    auto klass = RubyClass(RubyModule(RubyModule("QML"), "Data"), "ListModel");
+    klass.defineMethod("create_wrapper", RUBYQML_FUNCTION_INFO(&createWrapper));
+}
+
+} // namespace RubyQml

data/ext/qml/listmodel.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "markable.h"
+#include "rubyvalue.h"
+#include <QAbstractListModel>
+
+namespace RubyQml {
+
+class ListModel : public QAbstractListModel, public Markable
+{
+    Q_OBJECT
+public:
+    explicit ListModel(RubyValue rubyModel, QObject *parent = 0);
+    ~ListModel();
+
+    RubyValue rubyModel() { return mRubyModel; }
+
+    QHash<int, QByteArray> roleNames() const override;
+
+    QVariant data(const QModelIndex &index, int role) const override;
+    int rowCount(const QModelIndex &parent) const override;
+    QModelIndex index(int row, int column = 0, const QModelIndex &parent = QModelIndex()) const override;
+
+    void gc_mark() override;
+
+    static void defineUtilMethods();
+
+public slots:
+    void beginMove(int first, int last, int destination);
+    void endMove();
+    void beginInsert(int first, int last);
+    void endInsert();
+    void beginRemove(int first, int last);
+    void endRemove();
+    void update(int first, int last);
+
+private:
+    RubyValue mRubyModel;
+    QHash<int, QByteArray> mColumnNames;
+    QHash<int, ID> mColumnIDs;
+};
+
+} // namespace RubyQml

data/ext/qml/markable.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RubyQml {
+
+class Markable
+{
+public:
+    virtual ~Markable() {}
+    virtual void gc_mark() = 0;
+};
+
+} // namespace RubyQml

data/ext/qml/objectdata.cpp

@@ -0,0 +1,26 @@
+#include "objectdata.h"
+
+namespace RubyQml {
+
+ObjectData::ObjectData(QObject *target) :
+    QObject(target)
+{
+}
+
+ObjectData *ObjectData::getOrCreate(QObject *target)
+{
+    for (auto child : target->children()) {
+        auto data = dynamic_cast<ObjectData *>(child);
+        if (data) {
+            return data;
+        }
+    }
+    return new ObjectData(target);
+}
+
+void ObjectData::gc_mark()
+{
+    rb_gc_mark(rubyObject);
+}
+
+} // namespace RubyQml

data/ext/qml/objectdata.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <QObject>
+#include "rubyvalue.h"
+#include "markable.h"
+
+namespace RubyQml {
+
+class ObjectData : public QObject, public Markable
+{
+public:
+    ObjectData(QObject *target);
+    RubyValue rubyObject;
+    bool owned = false;
+
+    void gc_mark() override;
+
+    static ObjectData *getOrCreate(QObject *target);
+};
+
+} // namespace RubyQml

data/ext/qml/objectgc.cpp

@@ -0,0 +1,69 @@
+#include "objectgc.h"
+#include "markable.h"
+#include "objectdata.h"
+#include <QObject>
+#include <QDebug>
+#include <QBuffer>
+
+namespace RubyQml {
+
+void ObjectGC::addObject(QObject *obj)
+{
+    mObjects << obj;
+    connect(obj, &QObject::destroyed, this, [this](QObject *obj) {
+        mObjects.remove(obj);
+    });
+}
+
+void ObjectGC::mark(QObject *obj, bool markOwned)
+{
+    auto objData = dynamic_cast<ObjectData *>(obj);
+    if (!markOwned) {
+        if (objData && objData->owned) {
+            return;
+        }
+    }
+
+    auto markable = dynamic_cast<Markable *>(obj);
+    if (markable) {
+        debug() << "\u270F\uFE0F  marking object:" << obj << "parent:" << obj->parent();
+        markable->gc_mark();
+    }
+    for (auto child : obj->children()) {
+        mark(child, markOwned);
+    }
+}
+
+void ObjectGC::markOwnedObject(QObject *obj)
+{
+    mark(obj, true);
+}
+
+void ObjectGC::markNonOwnedObjects()
+{
+    for (auto obj : mObjects) {
+        mark(obj, false);
+    }
+}
+
+QDebug ObjectGC::debug()
+{
+    static auto emptyBuffer = [] {
+        auto buf = new QBuffer();
+        buf->open(QIODevice::WriteOnly);
+        return buf;
+    }();
+    if (mDebugMessageEnabled) {
+        return qDebug();
+    } else {
+        return QDebug(emptyBuffer);
+    }
+}
+
+ObjectGC *ObjectGC::instance()
+{
+    static auto gc = new ObjectGC();
+    return gc;
+}
+
+} // namespace RubyQml