qml 0.0.7 → 1.0.0

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

@@ -0,0 +1,27 @@
+#include "qmlbind/signal_emitter.h"
+#include "signalemitter.h"
+#include "engine.h"
+#include <QQmlEngine>
+#include <QQmlContext>
+
+using namespace QmlBind;
+
+extern "C" {
+
+void qmlbind_signal_emitter_emit(qmlbind_signal_emitter emitter, const char *signal_name, int argc, qmlbind_value *argv)
+{
+    emitter->emitSignal(signal_name, argc, argv);
+}
+
+qmlbind_engine qmlbind_signal_emitter_get_engine(qmlbind_signal_emitter emitter)
+{
+    Wrapper *wrapper = emitter->wrapper();
+    return qobject_cast<Engine *>(QQmlEngine::contextForObject(wrapper)->engine());
+}
+
+void qmlbind_signal_emitter_release(qmlbind_signal_emitter emitter)
+{
+    delete emitter;
+}
+
+}

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

@@ -0,0 +1,22 @@
+#include "qmlbind/string.h"
+#include <QByteArray>
+#include <QList>
+
+extern "C" {
+
+char *qmlbind_string_get_chars(qmlbind_string str)
+{
+    return str->data();
+}
+
+int qmlbind_string_get_length(qmlbind_string str)
+{
+    return str->size();
+}
+
+void qmlbind_string_release(qmlbind_string str)
+{
+    delete str;
+}
+
+}

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

@@ -0,0 +1,215 @@
+#include "qmlbind/value.h"
+#include "wrapper.h"
+#include <QJSValue>
+#include <QJSEngine>
+
+using namespace QmlBind;
+
+extern "C" {
+
+qmlbind_value qmlbind_value_new_undefined()
+{
+    return new QJSValue(QJSValue::UndefinedValue);
+}
+
+qmlbind_value qmlbind_value_new_null()
+{
+    return new QJSValue(QJSValue::NullValue);
+}
+
+void qmlbind_value_release(qmlbind_value self)
+{
+    delete self;
+}
+
+qmlbind_value qmlbind_value_clone(qmlbind_value self)
+{
+    return new QJSValue(*self);
+}
+
+int qmlbind_value_is_equal(qmlbind_value value1, qmlbind_value value2)
+{
+    return value1->equals(*value2);
+}
+
+int qmlbind_value_is_identical(qmlbind_value value1, qmlbind_value value2)
+{
+    return value1->strictlyEquals(*value2);
+}
+
+int qmlbind_value_is_undefined(qmlbind_value self)
+{
+    return self->isUndefined();
+}
+
+int qmlbind_value_is_null(qmlbind_value self)
+{
+    return self->isNull();
+}
+
+int qmlbind_value_is_boolean(qmlbind_value self)
+{
+    return self->isBool();
+}
+
+int qmlbind_value_is_number(qmlbind_value self)
+{
+    return self->isNumber();
+}
+
+int qmlbind_value_is_string(qmlbind_value self)
+{
+    return self->isString();
+}
+
+int qmlbind_value_is_object(qmlbind_value self)
+{
+    return self->isObject();
+}
+
+int qmlbind_value_is_array(qmlbind_value self)
+{
+    return self->isArray();
+}
+
+int qmlbind_value_is_function(qmlbind_value self)
+{
+    return self->isCallable();
+}
+
+int qmlbind_value_is_error(qmlbind_value self)
+{
+    return self->isError();
+}
+
+int qmlbind_value_is_wrapper(qmlbind_value self)
+{
+    return qmlbind_value_get_backref(self) != 0;
+}
+
+qmlbind_value qmlbind_value_new_boolean(int x)
+{
+    return new QJSValue(bool(x));
+}
+
+int qmlbind_value_get_boolean(qmlbind_value self)
+{
+    return self->toBool();
+}
+
+qmlbind_value qmlbind_value_new_number(double x)
+{
+    return new QJSValue(x);
+}
+
+double qmlbind_value_get_number(qmlbind_value self)
+{
+    return self->toNumber();
+}
+
+qmlbind_value qmlbind_value_new_string(int len, const char *str)
+{
+    return new QJSValue(QString::fromUtf8(str, len));
+}
+
+qmlbind_value qmlbind_value_new_string_cstr(const char *str)
+{
+    return new QJSValue(QString::fromUtf8(str));
+}
+
+qmlbind_string qmlbind_value_get_string(qmlbind_value self)
+{
+    return new QByteArray(self->toString().toUtf8());
+}
+
+qmlbind_value qmlbind_value_get_property(qmlbind_value self, const char *key)
+{
+    return new QJSValue(self->property(QString::fromUtf8(key)));
+}
+
+void qmlbind_value_set_property(qmlbind_value self, const char *key, qmlbind_value value)
+{
+    QJSValue obj = *self;
+    obj.setProperty(QString::fromUtf8(key), *value);
+}
+
+int qmlbind_value_delete_property(qmlbind_value self, const char *key)
+{
+    QJSValue value = *self;
+    return value.deleteProperty(key);
+}
+
+int qmlbind_value_has_property(qmlbind_value value, const char *key)
+{
+    return value->hasProperty(key);
+}
+
+int qmlbind_value_has_index(qmlbind_value value, int index)
+{
+    return value->hasProperty(QString::number(index));
+}
+
+int qmlbind_value_has_own_property(qmlbind_value value, const char *key)
+{
+    return value->hasOwnProperty(key);
+}
+
+qmlbind_value qmlbind_value_get_prototype(qmlbind_value value)
+{
+    return new QJSValue(value->prototype());
+}
+
+void qmlbind_value_set_prototype(qmlbind_value self, qmlbind_value proto)
+{
+    QJSValue obj = *self;
+    obj.setPrototype(*proto);
+}
+
+qmlbind_value qmlbind_value_get_array_item(qmlbind_value value, int index)
+{
+    return new QJSValue(value->property(index));
+}
+
+void qmlbind_value_set_array_item(qmlbind_value self, int index, qmlbind_value property)
+{
+    QJSValue obj = *self;
+    obj.setProperty(index, *property);
+}
+
+qmlbind_backref qmlbind_value_get_backref(qmlbind_value self)
+{
+    Wrapper *obj = dynamic_cast<Wrapper *>(self->toQObject());
+    if (!obj) {
+        return 0;
+    }
+    return obj->backref().backref();
+}
+
+static QJSValueList pack_args(int argc, qmlbind_value *argv)
+{
+    QJSValueList args;
+    for (int i = 0; i < argc; ++i) {
+        args << *argv[i];
+    }
+    return args;
+}
+
+qmlbind_value qmlbind_value_call(qmlbind_value self, int argc, qmlbind_value *argv)
+{
+    QJSValue func = *self;
+    return new QJSValue(func.call(pack_args(argc, argv)));
+}
+
+qmlbind_value qmlbind_value_call_constructor(qmlbind_value self, int argc, qmlbind_value *argv)
+{
+    QJSValue func = *self;
+    return new QJSValue(func.callAsConstructor(pack_args(argc, argv)));
+}
+
+qmlbind_value qmlbind_value_call_with_instance(qmlbind_value self, qmlbind_value instance, int argc, qmlbind_value *argv)
+{
+    QJSValue func = *self;
+    return new QJSValue(func.callWithInstance(*instance, pack_args(argc, argv)));
+}
+
+}

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

@@ -0,0 +1,54 @@
+#include "backref.h"
+#include "interface.h"
+
+namespace QmlBind {
+
+Backref::Backref()
+{
+}
+
+Backref::Backref(qmlbind_backref backref, const QSharedPointer<Interface> &interface) :
+    mBackref(backref),
+    mInterface(interface)
+{
+    retain();
+}
+
+Backref::Backref(const Backref &other) :
+    mBackref(other.mBackref),
+    mInterface(other.mInterface)
+{
+    retain();
+}
+
+Backref::~Backref()
+{
+    release();
+}
+
+Backref &Backref::operator=(const Backref &other)
+{
+    release();
+    mInterface = other.mInterface;
+    mBackref = other.mBackref;
+    retain();
+
+    return *this;
+}
+
+void Backref::retain()
+{
+    if (mInterface) {
+        mInterface->retainObject(mBackref);
+    }
+}
+
+void Backref::release()
+{
+    if (mInterface) {
+        mInterface->releaseObject(mBackref);
+    }
+}
+
+} // namespace QmlBind
+

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "qmlbind/qmlbind_global.h"
+#include <QSharedPointer>
+
+namespace QmlBind {
+
+class Backref
+{
+public:
+    Backref();
+    Backref(qmlbind_backref backref, const QSharedPointer<Interface> &interface);
+    Backref(const Backref &other);
+    ~Backref();
+
+    Backref &operator=(const Backref &other);
+
+    qmlbind_backref backref() const { return mBackref; }
+    QSharedPointer<Interface> interface() const { return mInterface; }
+
+private:
+    void retain();
+    void release();
+
+    qmlbind_backref mBackref;
+    QSharedPointer<Interface> mInterface;
+};
+
+} // namespace QmlBind

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

@@ -0,0 +1,32 @@
+#include "engine.h"
+#include <QQmlComponent>
+
+namespace QmlBind {
+
+Engine::Engine() : QQmlEngine(), mDeleteScheduled(false)
+{
+}
+
+void Engine::addComponent(QQmlComponent *component)
+{
+    mComponents << component;
+    connect(component, SIGNAL(destroyed(QObject*)), this, SLOT(onComponentRemoved()));
+}
+
+void Engine::scheduleDelete()
+{
+    if (mComponents.size() == 0) {
+        delete this;
+    }
+    mDeleteScheduled = true;
+}
+
+void Engine::onComponentRemoved()
+{
+    mComponents.removeAll(qobject_cast<QQmlComponent *>(sender()));
+    if (mComponents.size() == 0) {
+        delete this;
+    }
+}
+
+} // namespace QmlBind

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

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <QQmlEngine>
+
+namespace QmlBind {
+
+class Engine : public QQmlEngine
+{
+    Q_OBJECT
+public:
+    Engine();
+
+    void addComponent(QQmlComponent *component);
+    void scheduleDelete();
+
+signals:
+
+public slots:
+    void onComponentRemoved();
+
+private:
+
+    bool mDeleteScheduled;
+    QList<QQmlComponent *> mComponents;
+};
+
+} // namespace QmlBind

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

@@ -0,0 +1,73 @@
+#include "exporter.h"
+#include "interface.h"
+#include <stdexcept>
+#include <QVector>
+#include <QDebug>
+
+namespace QmlBind {
+
+Exporter::Exporter(const char *className, const Backref &classRef) :
+    mClassRef(classRef)
+{
+    mBuilder.setClassName(className);
+}
+
+static QByteArray methodSignature(const char *name, int arity)
+{
+    QByteArray sig;
+    sig += name;
+    sig += "(";
+    for (int i = 0; i < arity; ++i) {
+        if (i != 0) {
+            sig += ",";
+        }
+        sig += "QJSValue";
+    }
+    sig += ")";
+    return sig;
+}
+
+
+
+QMetaMethodBuilder Exporter::addMethod(const char *name, int arity)
+{
+    QMetaMethodBuilder method = mBuilder.addMethod(methodSignature(name, arity), "QJSValue");
+
+    Method methodInfo;
+    methodInfo.arity = arity;
+    methodInfo.name = name;
+
+    mMethodMap[method.index()] = methodInfo;
+
+    return method;
+}
+
+QMetaMethodBuilder Exporter::addSignal(const char *name, const QList<QByteArray> &args)
+{
+    QMetaMethodBuilder method = mBuilder.addSignal(methodSignature(name, args.size()));
+    method.setParameterNames(args);
+
+    mSignalIndexMap[name] = method.index();
+
+    return method;
+}
+
+QMetaPropertyBuilder Exporter::addProperty(const char *name, const char *notifier)
+{
+    if (!mSignalIndexMap.contains(notifier)) {
+        qWarning() << "signal" << notifier << "not yet added";
+    }
+    QMetaPropertyBuilder property = mBuilder.addProperty(name, "QJSValue", mSignalIndexMap[notifier]);
+
+    property.setReadable(true);
+    property.setWritable(true);
+
+    Property propertyInfo;
+    propertyInfo.name = name;
+
+    mPropertyMap[property.index()] = propertyInfo;
+
+    return property;
+}
+
+} // namespace QmlBind