qml 0.0.7 → 1.0.0

data/ext/qml/lib/libqmlbind/qmlbind/src/exporter.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "qmlbind/qmlbind_global.h"
+#include "backref.h"
+#include <private/qmetaobjectbuilder_p.h>
+#include <QSharedPointer>
+
+namespace QmlBind {
+
+class Exporter
+{
+public:
+
+    struct Method {
+        QByteArray name;
+        int arity;
+    };
+
+    struct Property {
+        QByteArray name;
+    };
+
+    Exporter(const char *className, const Backref &classRef);
+
+    QMetaMethodBuilder addMethod(const char *name, int arity);
+    QMetaMethodBuilder addSignal(const char *name, const QList<QByteArray> &args);
+    QMetaPropertyBuilder addProperty(const char *name, const char *notifier);
+    QSharedPointer<Interface> interface() const { return mClassRef.interface(); }
+
+    Backref classRef() const { return mClassRef; }
+    const QMetaObjectBuilder &metaObjectBuilder() const { return mBuilder; }
+    QHash<int, Method> methodMap() const { return mMethodMap; }
+    QHash<int, Property> propertyMap() const { return mPropertyMap; }
+    QHash<QByteArray, int> signalIndexMap() const { return mSignalIndexMap; }
+
+private:
+
+    Backref mClassRef;
+    QHash<int, Method> mMethodMap;
+    QHash<int, Property> mPropertyMap;
+    QHash<QByteArray, int> mSignalIndexMap;
+
+    QMetaObjectBuilder mBuilder;
+};
+
+} // namespace QmlBind

data/ext/qml/lib/libqmlbind/qmlbind/src/interface.cpp

@@ -0,0 +1,75 @@
+#include "interface.h"
+#include "backref.h"
+#include "engine.h"
+#include <QDebug>
+
+namespace QmlBind {
+
+Interface::Interface(qmlbind_interface_handlers handlers) :
+    mHandlers(handlers)
+{
+    if (!handlers.call_method) {
+        qFatal("qmlbind: call_method handler not specified");
+    }
+    if (!handlers.set_property) {
+        qFatal("qmlbind: set_property handler not specified");
+    }
+    if (!handlers.get_property) {
+        qFatal("qmlbind: get_property handler not specified");
+    }
+    if (!handlers.new_object) {
+        qFatal("qmlbind: new_object handler not specified");
+    }
+    if (!handlers.delete_object) {
+        qFatal("qmlbind: delete_object handler not specified");
+    }
+}
+
+QJSValue Interface::callMethod(QQmlEngine *engine, const Backref &obj, const QByteArray &method, int argc, QJSValue **argv) const
+{
+    QScopedPointer<const QJSValue> result(mHandlers.call_method(qobject_cast<Engine *>(engine), obj.backref(), method, argc, argv));
+    return *result;
+}
+
+QJSValue Interface::getProperty(QQmlEngine *engine, const Backref &obj, const QByteArray &property) const
+{
+    QScopedPointer<const QJSValue> result(mHandlers.get_property(qobject_cast<Engine *>(engine), obj.backref(), property));
+    return *result;
+}
+
+void Interface::setProperty(QQmlEngine *engine, const Backref &obj, const QByteArray &property, const QJSValue &value) const
+{
+    QJSValue val = value;
+    mHandlers.set_property(qobject_cast<Engine *>(engine), obj.backref(), property, &val);
+}
+
+Backref Interface::newObject(const Backref &klass, SignalEmitter *signalEmitter)
+{
+    return Backref(mHandlers.new_object(klass.backref(), signalEmitter), sharedFromThis());
+}
+
+void Interface::retainObject(qmlbind_backref ref)
+{
+    QMutexLocker locker(&mRefCountMutex);
+
+    if (mRefCount.contains(ref)) {
+        ++mRefCount[ref];
+    }
+    else {
+        mRefCount[ref] = 1;
+    }
+}
+
+void Interface::releaseObject(qmlbind_backref ref)
+{
+    QMutexLocker locker(&mRefCountMutex);
+
+    Q_ASSERT(mRefCount.contains(ref));
+    if (--mRefCount[ref] == 0) {
+        mHandlers.delete_object(ref);
+        mRefCount.remove(ref);
+    }
+}
+
+}
+

data/ext/qml/lib/libqmlbind/qmlbind/src/interface.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "qmlbind/qmlbind_global.h"
+#include <QJSValue>
+#include <QSharedPointer>
+#include <QMutex>
+
+class QQmlEngine;
+
+namespace QmlBind {
+
+class Backref;
+
+class Interface : public QEnableSharedFromThis<Interface>
+{
+public:
+    Interface(qmlbind_interface_handlers handlers);
+
+    QJSValue callMethod(QQmlEngine *engine, const Backref &obj, const QByteArray &method, int argc, QJSValue **argv) const;
+    QJSValue getProperty(QQmlEngine *engine, const Backref &obj, const QByteArray &property) const;
+    void setProperty(QQmlEngine *engine, const Backref &obj, const QByteArray &property, const QJSValue &value) const;
+
+    Backref newObject(const Backref &klass, SignalEmitter *signalEmitter);
+
+private:
+
+    friend class Backref;
+
+    void retainObject(qmlbind_backref ref);
+    void releaseObject(qmlbind_backref ref);
+
+    qmlbind_interface_handlers mHandlers;
+    QHash<qmlbind_backref, int> mRefCount;
+    QMutex mRefCountMutex;
+};
+
+} // namespace QmlBind

data/ext/qml/lib/libqmlbind/qmlbind/src/metaobject.cpp

@@ -0,0 +1,101 @@
+#include "metaobject.h"
+#include "exporter.h"
+#include "interface.h"
+#include "wrapper.h"
+#include <QJSValue>
+#include <QMetaMethod>
+#include <QDebug>
+#include <QQmlEngine>
+#include <QQmlContext>
+
+namespace QmlBind {
+
+MetaObject::MetaObject(const QSharedPointer<const Exporter> &exporter) :
+    mExporter(exporter),
+    mPrototype(exporter->metaObjectBuilder().toMetaObject())
+{
+    d = mPrototype->d;
+}
+
+MetaObject::~MetaObject()
+{
+}
+
+int MetaObject::metaCall(QObject *object, Call call, int index, void **argv) const
+{
+    index = object->QObject::qt_metacall(call, index ,argv);
+    if (index < 0) {
+        return index;
+    }
+
+    Backref ref = static_cast<Wrapper *>(object)->backref();
+
+    QQmlContext *context = QQmlEngine::contextForObject(object);
+    QQmlEngine *engine = context ? context->engine() : 0;
+
+    QSharedPointer<const Exporter> exporter = mExporter;
+    QSharedPointer<Interface> interface = ref.interface();
+
+    switch(call) {
+    case QMetaObject::ReadProperty:
+    {
+        int count = propertyCount() - propertyOffset();
+        if (index < count) {
+            *static_cast<QJSValue *>(argv[0]) = interface->getProperty(engine, ref, exporter->propertyMap()[index].name);
+        }
+        index -= count;
+        break;
+    }
+    case QMetaObject::WriteProperty:
+    {
+        int count = propertyCount() - propertyOffset();
+        if (index < count) {
+            interface->setProperty(engine, ref, exporter->propertyMap()[index].name, *static_cast<QJSValue *>(argv[0]));
+        }
+        index -= count;
+        break;
+    }
+    case QMetaObject::InvokeMetaMethod:
+    {
+        int count = methodCount() - methodOffset();
+        if (index < count) {
+            if (method(index + methodOffset()).methodType() == QMetaMethod::Signal) {
+                QMetaObject::activate(object, this, index, argv);
+            }
+            else {
+                Exporter::Method method = exporter->methodMap()[index];
+                *static_cast<QJSValue *>(argv[0]) = interface->callMethod(engine, ref, method.name, method.arity, reinterpret_cast<QJSValue **>(argv + 1));
+            }
+        }
+        index -= count;
+        break;
+    }
+    case QMetaObject::ResetProperty:
+    case QMetaObject::QueryPropertyDesignable:
+    case QMetaObject::QueryPropertyScriptable:
+    case QMetaObject::QueryPropertyStored:
+    case QMetaObject::QueryPropertyEditable:
+    case QMetaObject::QueryPropertyUser:
+    {
+        int count = propertyCount() - propertyOffset();
+        index -= count;
+        break;
+    }
+    case QMetaObject::RegisterPropertyMetaType:
+    {
+        int count = propertyCount() - propertyOffset();
+
+        if (index < count) {
+            *static_cast<int *>(argv[0]) = -1;
+        }
+        index -= count;
+        break;
+    }
+    default:
+        break;
+    }
+
+    return index;
+}
+
+} // namespace QmlBind

data/ext/qml/lib/libqmlbind/qmlbind/src/metaobject.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "qmlbind/qmlbind_global.h"
+#include "exporter.h"
+#include <QScopedPointer>
+#include <QSharedPointer>
+#include <private/qobject_p.h>
+
+namespace QmlBind {
+
+class Exporter;
+class Wrapper;
+
+class MetaObject : public QMetaObject
+{
+public:
+    MetaObject(const QSharedPointer<const Exporter> &exporter);
+    ~MetaObject();
+
+    QSharedPointer<const Exporter> exporter() const { return mExporter; }
+    int metaCall(QObject *object, Call call, int index, void **argv) const;
+
+private:
+
+    QSharedPointer<const Exporter> mExporter;
+    QScopedPointer<QMetaObject, QScopedPointerPodDeleter> mPrototype;
+};
+
+} // namespace QmlBind

data/ext/qml/lib/libqmlbind/qmlbind/src/signalemitter.cpp

@@ -0,0 +1,33 @@
+#include "signalemitter.h"
+#include "metaobject.h"
+#include "exporter.h"
+#include <QDebug>
+
+namespace QmlBind {
+
+SignalEmitter::SignalEmitter()
+{
+}
+
+void SignalEmitter::emitSignal(const QByteArray &name, int argc, QJSValue **argv)
+{
+    QSharedPointer<const MetaObject> metaObj = mWrapper->qmlbindMetaObject();
+    int index = metaObj->exporter()->signalIndexMap().value(name, -1);
+    if (index == -1) {
+        qWarning() << "no such signal found:" << name;
+        return;
+    }
+    int offset = metaObj->methodOffset();
+
+    QMetaMethod signal = metaObj->method(index + offset);
+    if (signal.parameterCount() != argc) {
+        qWarning() << "parameter count wrong:" << name;
+        return;
+    }
+    Q_ASSERT(signal.name() == name);
+
+    QMetaObject::activate(mWrapper, metaObj.data(), index, reinterpret_cast<void **>(argv - 1));
+}
+
+} // namespace QmlBind
+

data/ext/qml/lib/libqmlbind/qmlbind/src/signalemitter.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <QPointer>
+#include "wrapper.h"
+
+class QByteArray;
+
+namespace QmlBind {
+
+class Wrapper;
+
+class SignalEmitter
+{
+public:
+    SignalEmitter();
+
+    void setWrapper(Wrapper *wrapper) { mWrapper = wrapper; }
+    Wrapper *wrapper() { return mWrapper; }
+    void emitSignal(const QByteArray &name, int argc, QJSValue **argv);
+
+private:
+    QPointer<Wrapper> mWrapper;
+};
+
+} // namespace QmlBind

data/ext/qml/lib/libqmlbind/qmlbind/src/ticktimer.cpp

@@ -0,0 +1,15 @@
+#include "ticktimer.h"
+
+TickTimer::TickTimer(Callback *whereCallback, QObject *parent) : QTimer(parent), mWhereCallback(whereCallback)
+{
+    setInterval(0);
+    setSingleShot(false);
+    connect(this, SIGNAL(timeout()), this, SLOT(onTimeout()));
+}
+
+void TickTimer::onTimeout()
+{
+    if (*mWhereCallback) {
+        (*mWhereCallback)();
+    }
+}

data/ext/qml/lib/libqmlbind/qmlbind/src/ticktimer.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <QTimer>
+
+class TickTimer : public QTimer
+{
+    Q_OBJECT
+public:
+    typedef void (*Callback)();
+
+    explicit TickTimer(Callback *whereCallback, QObject *parent = 0);
+
+private slots:
+    void onTimeout();
+
+private:
+    Callback *mWhereCallback;
+};
+

data/ext/qml/lib/libqmlbind/qmlbind/src/typeregisterer.cpp

@@ -0,0 +1,112 @@
+#include "typeregisterer.h"
+#include "metaobject.h"
+#include "wrapper.h"
+#include "interface.h"
+#include "signalemitter.h"
+#include <QVector>
+#include <QtQml>
+
+#define MAX_CALLBACK_COUNT 256
+
+namespace QmlBind {
+
+template <int Index>
+void TypeRegisterer::create(void *memory)
+{
+    QSharedPointer<const MetaObject> metaobj = TypeRegisterer::instance().mMetaObjects[Index];
+    Backref classRef = metaobj->exporter()->classRef();
+    SignalEmitter *emitter = new SignalEmitter();
+    Backref ref = classRef.interface()->newObject(classRef, emitter);
+
+    Wrapper *wrapper = new (memory) Wrapper(metaobj, ref);
+    emitter->setWrapper(wrapper);
+}
+
+// statically generates callback array
+
+template <int Count, int Offset>
+struct TypeRegisterer::CreationCallbacksSetter
+{
+    void set(TypeRegisterer *self)
+    {
+        CreationCallbacksSetter<Count / 2, Offset>().set(self);
+        CreationCallbacksSetter<Count - Count / 2, Offset + Count / 2>().set(self);
+    }
+};
+
+template <int Offset>
+struct TypeRegisterer::CreationCallbacksSetter<1, Offset>
+{
+    void set(TypeRegisterer *self)
+    {
+        self->mCreationCallbacks[Offset] = create<Offset>;
+    }
+};
+
+TypeRegisterer::TypeRegisterer() :
+    mCreationCallbacks(MAX_CALLBACK_COUNT)
+{
+    CreationCallbacksSetter<MAX_CALLBACK_COUNT>().set(this);
+}
+
+int TypeRegisterer::registerType(const QSharedPointer<const MetaObject> &metaObject, const char *uri, int versionMajor, int versionMinor, const char *qmlName)
+{
+    int index = mMetaObjects.size();
+    if (MAX_CALLBACK_COUNT <= index) {
+        qWarning() << "Cannot register QML types more than" << MAX_CALLBACK_COUNT;
+        return false;
+    }
+    mMetaObjects << metaObject;
+
+    CreationCallback create = mCreationCallbacks[index];
+
+    registerType(metaObject, create, uri, versionMajor, versionMinor, qmlName);
+
+    return true;
+}
+
+void TypeRegisterer::registerType(const QSharedPointer<const MetaObject> &metaObject, CreationCallback create, const char *uri, int versionMajor, int versionMinor, const char *qmlName)
+{
+    QByteArray className;
+    className += metaObject->className();
+    className += "*";
+
+    QByteArray listName;
+    listName += "QQmlListProperty<";
+    listName += metaObject->className();
+    listName += ">";
+
+    QQmlPrivate::RegisterType type = {
+        0,
+        qRegisterNormalizedMetaType<Wrapper *>(className),
+        qRegisterNormalizedMetaType<QQmlListProperty<Wrapper> >(listName),
+        sizeof(Wrapper), create,
+        QString(),
+
+        uri, versionMajor, versionMinor, qmlName, metaObject.data(),
+
+        0, 0,
+
+        QQmlPrivate::StaticCastSelector<Wrapper,QQmlParserStatus>::cast(),
+        QQmlPrivate::StaticCastSelector<Wrapper,QQmlPropertyValueSource>::cast(),
+        QQmlPrivate::StaticCastSelector<Wrapper,QQmlPropertyValueInterceptor>::cast(),
+
+        0, 0,
+
+        0,
+        0
+    };
+
+    QQmlPrivate::qmlregister(QQmlPrivate::TypeRegistration, &type);
+}
+
+TypeRegisterer &TypeRegisterer::instance()
+{
+    static TypeRegisterer *i = 0;
+    if (!i) {
+        i = new TypeRegisterer();
+    }
+    return *i;
+}
+
+} // namespace QmlBind