qml 0.0.7 → 1.0.0

data/ext/qml/init.cpp

@@ -1,67 +0,0 @@
-#include "ext_metaobject.h"
-#include "ext_pointer.h"
-#include "ext_pluginloader.h"
-#include "ext_anywrapper.h"
-#include "ext_accesswrapperfactory.h"
-#include "ext_testutil.h"
-#include "ext_kernel.h"
-#include "kernel.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_AnyWrapper::defineClass();
-    Ext_AccessWrapperFactory::defineClass();
-    Ext_TestUtil::defineModule();
-    Ext_Kernel::defineModule();
-    ListModel::defineUtilMethods();
-}
-
-void setupGlobalGCMarking()
-{
-    auto marker = Ext_AnyWrapper::create(QVariant(), [](const QVariant &) {
-        ValueReference::markAllReferences();
-        ObjectGC::instance()->markNonOwnedObjects();
-    });
-    rb_gc_register_mark_object(marker);
-}
-
-void cleanup()
-{
-}
-
-void setupEndProc()
-{
-    rb_set_end_proc([](VALUE) { cleanup(); }, Qnil);
-}
-
-}
-
-extern "C"
-void Init_qml()
-{
-    rb_require("date");
-    rb_require("qml/errors");
-    rb_require("qml/error_converter");
-
-    defineMetaTypes();
-    defineClasses();
-    setupGlobalGCMarking();
-    setupEndProc();
-}

data/ext/qml/kernel.cpp

@@ -1,39 +0,0 @@
-#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

@@ -1,32 +0,0 @@
-#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/listmodel.cpp

@@ -1,137 +0,0 @@
-#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("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();
-    }
-
-    QVariant result;
-    withGvl([&] {
-        RubyValue value;
-        rescueNotify([&] {
-            auto subscribe = RUBYQML_INTERN("[]");
-            auto record = rb_funcall(mRubyModel, subscribe, 1, INT2NUM(index.row()));
-            value = rb_funcall(record, subscribe, 1, ID2SYM(mColumnIDs[role]));
-        });
-        result = value.toVariant();
-    });
-    return result;
-}
-
-int ListModel::rowCount(const QModelIndex &parent) const
-{
-    if (parent.isValid()) {
-        return 0;
-    }
-    int count;
-    withGvl([&] {
-        rescueNotify([&] {
-            count = NUM2INT(rb_funcall(mRubyModel, RUBYQML_INTERN("count"), 0));
-        });
-    });
-    return count;
-}
-
-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::beginReset()
-{
-    beginResetModel();
-}
-
-void ListModel::endReset()
-{
-    endResetModel();
-}
-
-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

@@ -1,45 +0,0 @@
-#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 beginReset();
-    void endReset();
-    void update(int first, int last);
-
-private:
-    RubyValue mRubyModel;
-    QHash<int, QByteArray> mColumnNames;
-    QHash<int, ID> mColumnIDs;
-};
-
-} // namespace RubyQml

data/ext/qml/markable.h

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

data/ext/qml/objectdata.cpp

@@ -1,26 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#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

@@ -1,69 +0,0 @@
-#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