diff options
17 files changed, 643 insertions, 34 deletions
diff --git a/src/corelib/kernel/qobject_p.h b/src/corelib/kernel/qobject_p.h index 3d9ea64..c7aa683 100644 --- a/src/corelib/kernel/qobject_p.h +++ b/src/corelib/kernel/qobject_p.h @@ -179,6 +179,11 @@ public: int signalIndex(const char *signalName) const; inline bool isSignalConnected(uint signalIdx) const; + // To allow arbitrary objects to call connectNotify()/disconnectNotify() without making + // the API public in QObject. This is used by QDeclarativeNotifierEndpoint. + inline void connectNotify(const char *signal); + inline void disconnectNotify(const char *signal); + public: QString objectName; ExtraData *extraData; // extra data set by the user @@ -229,6 +234,16 @@ inline bool QObjectPrivate::isSignalConnected(uint signal_index) const || qt_signal_spy_callback_set.signal_end_callback); } +inline void QObjectPrivate::connectNotify(const char *signal) +{ + q_ptr->connectNotify(signal); +} + +inline void QObjectPrivate::disconnectNotify(const char *signal) +{ + q_ptr->disconnectNotify(signal); +} + inline QObjectPrivate::Sender *QObjectPrivate::setCurrentSender(QObject *receiver, Sender *sender) { diff --git a/src/declarative/qml/qdeclarativebinding.cpp b/src/declarative/qml/qdeclarativebinding.cpp index 5acbec9..779fdd1 100644 --- a/src/declarative/qml/qdeclarativebinding.cpp +++ b/src/declarative/qml/qdeclarativebinding.cpp @@ -75,8 +75,11 @@ Bindings are free to implement their own memory management, so the delete operat necessarily safe. The default implementation clears the binding, removes it from the object and calls delete. */ -void QDeclarativeAbstractBinding::destroy() +void QDeclarativeAbstractBinding::destroy(DestroyMode mode) { + if (mode == DisconnectBinding) + disconnect(QDeclarativeAbstractBinding::DisconnectOne); + removeFromObject(); clear(); @@ -488,6 +491,12 @@ QString QDeclarativeBinding::expression() const return QDeclarativeExpression::expression(); } +void QDeclarativeBinding::disconnect(DisconnectMode disconnectMode) +{ + Q_UNUSED(disconnectMode); + setNotifyOnValueChanged(false); +} + QDeclarativeValueTypeProxyBinding::QDeclarativeValueTypeProxyBinding(QObject *o, int index) : m_object(o), m_index(index), m_bindings(0) { @@ -539,6 +548,12 @@ void QDeclarativeValueTypeProxyBinding::update(QDeclarativePropertyPrivate::Writ { } +void QDeclarativeValueTypeProxyBinding::disconnect(DisconnectMode disconnectMode) +{ + Q_UNUSED(disconnectMode); + // Nothing to do +} + QDeclarativeAbstractBinding *QDeclarativeValueTypeProxyBinding::binding(int propertyIndex) { QDeclarativeAbstractBinding *binding = m_bindings; diff --git a/src/declarative/qml/qdeclarativebinding_p.h b/src/declarative/qml/qdeclarativebinding_p.h index 01d5070..a6bde99 100644 --- a/src/declarative/qml/qdeclarativebinding_p.h +++ b/src/declarative/qml/qdeclarativebinding_p.h @@ -71,10 +71,39 @@ public: QDeclarativeAbstractBinding(); - virtual void destroy(); + enum DestroyMode { + // The binding should disconnect itself upon destroy + DisconnectBinding, + + // The binding doesn't need to disconnect itself, but it can if it wants to. + // + // This is used in QDeclarativeData::destroyed() - at the point at which the bindings are + // destroyed, the notifiers are already disconnected, so no need to disconnect each + // binding again. + // + // Bindings can use this flag to speed up destruction, especially for compiled bindings + // disconnecting a single binding might be slow. + KeepBindingConnected + }; + + virtual void destroy(DestroyMode mode = DisconnectBinding); virtual QString expression() const; + enum DisconnectMode { + + // Just this single binding is getting disconnected, other bindings remain connected and + // should not be changed. + DisconnectOne, + + // All bindings of the same object are getting disconnected. As an optimization, it is + // therefore valid to disconnect all bindings in one go. + DisconnectAll + }; + + // disconnectMode can be ignored, it is just a hint for potential optimization + virtual void disconnect(DisconnectMode disconnectMode) = 0; + enum Type { PropertyBinding, ValueTypeProxy }; virtual Type bindingType() const { return PropertyBinding; } @@ -123,6 +152,7 @@ public: virtual void setEnabled(bool, QDeclarativePropertyPrivate::WriteFlags); virtual void update(QDeclarativePropertyPrivate::WriteFlags); + virtual void disconnect(DisconnectMode disconnectMode); QDeclarativeAbstractBinding *binding(int propertyIndex); @@ -168,6 +198,7 @@ public: virtual void setEnabled(bool, QDeclarativePropertyPrivate::WriteFlags flags); virtual void update(QDeclarativePropertyPrivate::WriteFlags flags); virtual QString expression() const; + virtual void disconnect(DisconnectMode disconnectMode); typedef int Identifier; static Identifier Invalid; diff --git a/src/declarative/qml/qdeclarativeboundsignal.cpp b/src/declarative/qml/qdeclarativeboundsignal.cpp index 089449e..c6ab1f1 100644 --- a/src/declarative/qml/qdeclarativeboundsignal.cpp +++ b/src/declarative/qml/qdeclarativeboundsignal.cpp @@ -97,21 +97,23 @@ QDeclarativeAbstractBoundSignal::~QDeclarativeAbstractBoundSignal() QDeclarativeBoundSignal::QDeclarativeBoundSignal(QObject *scope, const QMetaMethod &signal, QObject *parent) -: m_expression(0), m_signal(signal), m_paramsValid(false), m_isEvaluating(false), m_params(0) +: m_expression(0), m_signal(signal), m_paramsValid(false), m_isEvaluating(false), m_params(0), + m_scope(scope, this) { - // This is thread safe. Although it may be updated by two threads, they - // will both set it to the same value - so the worst thing that can happen - // is that they both do the work to figure it out. Boo hoo. - if (evaluateIdx == -1) evaluateIdx = metaObject()->methodCount(); - - QDeclarative_setParent_noEvent(this, parent); - QDeclarativePropertyPrivate::connect(scope, m_signal.methodIndex(), this, evaluateIdx); + init(parent); } QDeclarativeBoundSignal::QDeclarativeBoundSignal(QDeclarativeContext *ctxt, const QString &val, QObject *scope, const QMetaMethod &signal, QObject *parent) -: m_expression(0), m_signal(signal), m_paramsValid(false), m_isEvaluating(false), m_params(0) +: m_expression(0), m_signal(signal), m_paramsValid(false), m_isEvaluating(false), m_params(0), + m_scope(scope, this) +{ + init(parent); + m_expression = new QDeclarativeExpression(ctxt, scope, val); +} + +void QDeclarativeBoundSignal::init(QObject *parent) { // This is thread safe. Although it may be updated by two threads, they // will both set it to the same value - so the worst thing that can happen @@ -119,17 +121,25 @@ QDeclarativeBoundSignal::QDeclarativeBoundSignal(QDeclarativeContext *ctxt, cons if (evaluateIdx == -1) evaluateIdx = metaObject()->methodCount(); QDeclarative_setParent_noEvent(this, parent); - QDeclarativePropertyPrivate::connect(scope, m_signal.methodIndex(), this, evaluateIdx); + QDeclarativePropertyPrivate::connect(m_scope, m_signal.methodIndex(), this, evaluateIdx); - m_expression = new QDeclarativeExpression(ctxt, scope, val); + QDeclarativeData * const data = QDeclarativeData::get(m_scope, true); + data->addBoundSignal(this); } QDeclarativeBoundSignal::~QDeclarativeBoundSignal() { + unregisterScopeObject(); delete m_expression; m_expression = 0; } +void QDeclarativeBoundSignal::disconnect() +{ + QObjectPrivate * const priv = QObjectPrivate::get(m_scope); + priv->disconnectNotify(m_signal.signature()); +} + int QDeclarativeBoundSignal::index() const { return m_signal.methodIndex(); @@ -196,6 +206,15 @@ int QDeclarativeBoundSignal::qt_metacall(QMetaObject::Call c, int id, void **a) } } +void QDeclarativeBoundSignal::unregisterScopeObject() +{ + if (m_scope) { + QDeclarativeData * const data = QDeclarativeData::get(m_scope, false); + if (data) + data->removeBoundSignal(this); + } +} + QDeclarativeBoundSignalParameters::QDeclarativeBoundSignalParameters(const QMetaMethod &method, QObject *parent) : QObject(parent), types(0), values(0) diff --git a/src/declarative/qml/qdeclarativeboundsignal_p.h b/src/declarative/qml/qdeclarativeboundsignal_p.h index a0dfe18..4ba8592 100644 --- a/src/declarative/qml/qdeclarativeboundsignal_p.h +++ b/src/declarative/qml/qdeclarativeboundsignal_p.h @@ -54,6 +54,7 @@ // #include "qdeclarativeexpression.h" +#include "qdeclarativeguard_p.h" #include <QtCore/qmetaobject.h> @@ -67,6 +68,10 @@ class QDeclarativeAbstractBoundSignal : public QObject public: QDeclarativeAbstractBoundSignal(QObject *parent = 0); virtual ~QDeclarativeAbstractBoundSignal() = 0; + virtual void disconnect() = 0; + +protected slots: + virtual void unregisterScopeObject() = 0; }; class QDeclarativeBoundSignalParameters; @@ -78,6 +83,8 @@ public: const QMetaMethod &signal, QObject *parent); virtual ~QDeclarativeBoundSignal(); + void disconnect(); + int index() const; QDeclarativeExpression *expression() const; @@ -88,14 +95,35 @@ public: static QDeclarativeBoundSignal *cast(QObject *); protected: + void unregisterScopeObject(); virtual int qt_metacall(QMetaObject::Call c, int id, void **a); private: + class ScopeGuard : public QDeclarativeGuard<QObject> + { + public: + ScopeGuard(QObject *object, QDeclarativeBoundSignal *signal) + : QDeclarativeGuard<QObject>(object), m_signal(signal) + { + } + + void objectDestroyed(QObject *obj) { + Q_UNUSED(obj); + m_signal->unregisterScopeObject(); + } + + private: + QDeclarativeBoundSignal *m_signal; + }; + + void init(QObject *parent); + QDeclarativeExpression *m_expression; QMetaMethod m_signal; bool m_paramsValid : 1; bool m_isEvaluating : 1; QDeclarativeBoundSignalParameters *m_params; + ScopeGuard m_scope; }; QT_END_NAMESPACE diff --git a/src/declarative/qml/qdeclarativecompiledbindings.cpp b/src/declarative/qml/qdeclarativecompiledbindings.cpp index 3ee365a..5aefa4a 100644 --- a/src/declarative/qml/qdeclarativecompiledbindings.cpp +++ b/src/declarative/qml/qdeclarativecompiledbindings.cpp @@ -216,7 +216,8 @@ public: // Inherited from QDeclarativeAbstractBinding virtual void setEnabled(bool, QDeclarativePropertyPrivate::WriteFlags flags); virtual void update(QDeclarativePropertyPrivate::WriteFlags flags); - virtual void destroy(); + virtual void destroy(DestroyMode mode); + virtual void disconnect(DisconnectMode disconnectMode); int index:30; bool enabled:1; @@ -238,6 +239,7 @@ public: QDeclarativeRefCount *dataRef; Binding *m_bindings; quint32 *m_signalTable; + bool m_bindingsDisconnected; static int methodCount; @@ -246,9 +248,10 @@ public: QDeclarativeDelayedError *error, QObject *scope, QObject *output, QDeclarativePropertyPrivate::WriteFlags storeFlags); - inline void unsubscribe(int subIndex); inline void subscribeId(QDeclarativeContextData *p, int idIndex, int subIndex); inline void subscribe(QObject *o, int notifyIndex, int subIndex); + inline void disconnectAll(); + inline void disconnectOne(Binding *bindingToDisconnect); QDeclarativePropertyCache::Data *findproperty(QObject *obj, const QScriptDeclarativeClass::Identifier &name, @@ -268,7 +271,8 @@ public: }; QDeclarativeCompiledBindingsPrivate::QDeclarativeCompiledBindingsPrivate() -: subscriptions(0), identifiers(0), programData(0), dataRef(0), m_bindings(0), m_signalTable(0) + : subscriptions(0), identifiers(0), programData(0), dataRef(0), m_bindings(0), m_signalTable(0), + m_bindingsDisconnected(false) { } @@ -343,14 +347,25 @@ void QDeclarativeCompiledBindingsPrivate::Binding::update(QDeclarativePropertyPr QDeclarativeDebugTrace::endRange(QDeclarativeDebugTrace::Binding); } -void QDeclarativeCompiledBindingsPrivate::Binding::destroy() +void QDeclarativeCompiledBindingsPrivate::Binding::destroy(DestroyMode mode) { + if (mode == DisconnectBinding) + disconnect(QDeclarativeAbstractBinding::DisconnectOne); + enabled = false; removeFromObject(); clear(); parent->q_func()->release(); } +void QDeclarativeCompiledBindingsPrivate::Binding::disconnect(DisconnectMode disconnectMode) +{ + if (disconnectMode == QDeclarativeAbstractBinding::DisconnectAll) + parent->disconnectAll(); + else + parent->disconnectOne(this); +} + int QDeclarativeCompiledBindings::qt_metacall(QMetaObject::Call c, int id, void **) { Q_D(QDeclarativeCompiledBindings); @@ -696,26 +711,20 @@ struct QDeclarativeBindingCompilerPrivate QByteArray buildExceptionData() const; }; -void QDeclarativeCompiledBindingsPrivate::unsubscribe(int subIndex) -{ - QDeclarativeCompiledBindingsPrivate::Subscription *sub = (subscriptions + subIndex); - sub->disconnect(); -} - void QDeclarativeCompiledBindingsPrivate::subscribeId(QDeclarativeContextData *p, int idIndex, int subIndex) { Q_Q(QDeclarativeCompiledBindings); - unsubscribe(subIndex); + QDeclarativeCompiledBindingsPrivate::Subscription *sub = (subscriptions + subIndex); + sub->disconnect(); if (p->idValues[idIndex]) { - QDeclarativeCompiledBindingsPrivate::Subscription *sub = (subscriptions + subIndex); sub->target = q; sub->targetMethod = methodCount + subIndex; sub->connect(&p->idValues[idIndex].bindings); } } - + void QDeclarativeCompiledBindingsPrivate::subscribe(QObject *o, int notifyIndex, int subIndex) { Q_Q(QDeclarativeCompiledBindings); @@ -729,6 +738,43 @@ void QDeclarativeCompiledBindingsPrivate::subscribe(QObject *o, int notifyIndex, sub->disconnect(); } +void QDeclarativeCompiledBindingsPrivate::disconnectAll() +{ + // This gets called multiple times in QDeclarativeData::disconnectNotifiers(), avoid unneeded + // work for all but the first call. + if (m_bindingsDisconnected) + return; + + // We disconnect all subscriptions, so we can call disconnect() unconditionally if there is at + // least one connection + Program *program = (Program *)programData; + for (int subIndex = 0; subIndex < program->subscriptions; ++subIndex) { + Subscription * const sub = (subscriptions + subIndex); + if (sub->isConnected()) + sub->disconnect(); + } + m_bindingsDisconnected = true; +} + +void QDeclarativeCompiledBindingsPrivate::disconnectOne( + QDeclarativeCompiledBindingsPrivate::Binding *bindingToDisconnect) +{ + // We iterate over the signal table to find all subscriptions for this binding. This is slowish, + // but disconnectOne() is only called when overwriting a binding, which is quite rare. + Program *program = (Program *)programData; + for (int subIndex = 0; subIndex < program->subscriptions; ++subIndex) { + Subscription * const sub = (subscriptions + subIndex); + quint32 *reeval = m_signalTable + m_signalTable[subIndex]; + quint32 bindingCount = *reeval; + ++reeval; + for (quint32 bindingIndex = 0; bindingIndex < bindingCount; ++bindingIndex) { + Binding * const binding = m_bindings + reeval[bindingIndex]; + if (binding == bindingToDisconnect) + sub->deref(); + } + } +} + // Conversion functions - these MUST match the QtScript expression path inline static qreal toReal(Register *reg, int type, bool *ok = 0) { diff --git a/src/declarative/qml/qdeclarativedata_p.h b/src/declarative/qml/qdeclarativedata_p.h index 7d71406..0057840 100644 --- a/src/declarative/qml/qdeclarativedata_p.h +++ b/src/declarative/qml/qdeclarativedata_p.h @@ -61,6 +61,7 @@ QT_BEGIN_NAMESPACE class QDeclarativeGuardImpl; class QDeclarativeCompiledData; class QDeclarativeAbstractBinding; +class QDeclarativeAbstractBoundSignal; class QDeclarativeContext; class QDeclarativePropertyCache; class QDeclarativeContextData; @@ -154,9 +155,12 @@ public: bool hasExtendedData() const { return extendedData != 0; } QDeclarativeNotifier *objectNameNotifier() const; QHash<int, QObject *> *attachedProperties() const; + void addBoundSignal(QDeclarativeAbstractBoundSignal *signal); + void removeBoundSignal(QDeclarativeAbstractBoundSignal *signal); + void disconnectNotifiers(); private: - // For objectNameNotifier and attachedProperties + // For objectNameNotifier, attachedProperties and bound signal list mutable QDeclarativeDataExtended *extendedData; }; diff --git a/src/declarative/qml/qdeclarativeengine.cpp b/src/declarative/qml/qdeclarativeengine.cpp index a787fb6..92a7391 100644 --- a/src/declarative/qml/qdeclarativeengine.cpp +++ b/src/declarative/qml/qdeclarativeengine.cpp @@ -42,6 +42,7 @@ #include "private/qdeclarativeengine_p.h" #include "qdeclarativeengine.h" +#include "private/qdeclarativeboundsignal_p.h" #include "private/qdeclarativecontext_p.h" #include "private/qdeclarativecompiler_p.h" #include "private/qdeclarativeglobalscriptclass_p.h" @@ -547,6 +548,11 @@ void QDeclarativePrivate::qdeclarativeelement_destructor(QObject *o) d->context->destroy(); d->context = 0; } + + // Disconnect the notifiers now - during object destruction this would be too late, since + // the disconnect call wouldn't be able to call disconnectNotify(), as it isn't possible to + // get the metaobject anymore. + d->disconnectNotifiers(); } } @@ -1108,6 +1114,7 @@ public: QHash<int, QObject *> attachedProperties; QDeclarativeNotifier objectNameNotifier; + QList<QDeclarativeAbstractBoundSignal *> boundSignals; }; QDeclarativeDataExtended::QDeclarativeDataExtended() @@ -1130,6 +1137,32 @@ QHash<int, QObject *> *QDeclarativeData::attachedProperties() const return &extendedData->attachedProperties; } +void QDeclarativeData::addBoundSignal(QDeclarativeAbstractBoundSignal *signal) +{ + if (!extendedData) extendedData = new QDeclarativeDataExtended; + extendedData->boundSignals.append(signal); +} + +void QDeclarativeData::removeBoundSignal(QDeclarativeAbstractBoundSignal *signal) +{ + if (extendedData) + extendedData->boundSignals.removeAll(signal); +} + +void QDeclarativeData::disconnectNotifiers() +{ + QDeclarativeAbstractBinding *binding = bindings; + while (binding) { + binding->disconnect(QDeclarativeAbstractBinding::DisconnectAll); + binding = binding->m_nextBinding; + } + + if (extendedData) { + Q_FOREACH (QDeclarativeAbstractBoundSignal *signal, extendedData->boundSignals) + signal->disconnect(); + } +} + void QDeclarativeData::destroyed(QObject *object) { if (deferredComponent) @@ -1145,7 +1178,7 @@ void QDeclarativeData::destroyed(QObject *object) QDeclarativeAbstractBinding *next = binding->m_nextBinding; binding->m_prevBinding = 0; binding->m_nextBinding = 0; - binding->destroy(); + binding->destroy(QDeclarativeAbstractBinding::KeepBindingConnected); binding = next; } diff --git a/src/declarative/qml/qdeclarativenotifier.cpp b/src/declarative/qml/qdeclarativenotifier.cpp index b625038..a3fae93 100644 --- a/src/declarative/qml/qdeclarativenotifier.cpp +++ b/src/declarative/qml/qdeclarativenotifier.cpp @@ -71,8 +71,10 @@ void QDeclarativeNotifierEndpoint::connect(QObject *source, int sourceSignal) { Signal *s = toSignal(); - if (s->source == source && s->sourceSignal == sourceSignal) + if (s->source == source && s->sourceSignal == sourceSignal) { + refCount++; return; + } disconnect(); @@ -80,6 +82,7 @@ void QDeclarativeNotifierEndpoint::connect(QObject *source, int sourceSignal) s->source = source; s->sourceSignal = sourceSignal; + refCount++; } void QDeclarativeNotifierEndpoint::copyAndClear(QDeclarativeNotifierEndpoint &other) diff --git a/src/declarative/qml/qdeclarativenotifier_p.h b/src/declarative/qml/qdeclarativenotifier_p.h index 524a966..ee80c9a 100644 --- a/src/declarative/qml/qdeclarativenotifier_p.h +++ b/src/declarative/qml/qdeclarativenotifier_p.h @@ -43,6 +43,7 @@ #define QDECLARATIVENOTIFIER_P_H #include "private/qdeclarativeguard_p.h" +#include <QtCore/qmetaobject.h> QT_BEGIN_NAMESPACE @@ -77,8 +78,13 @@ public: void connect(QObject *source, int sourceSignal); inline void connect(QDeclarativeNotifier *); + + // Disconnects unconditionally, regardless of the refcount inline void disconnect(); + // Decreases the refcount and disconnects when refcount reaches 0 + inline void deref(); + void copyAndClear(QDeclarativeNotifierEndpoint &other); private: @@ -110,6 +116,8 @@ private: Notifier notifier; }; + quint16 refCount; + inline Notifier *toNotifier(); inline Notifier *asNotifier(); inline Signal *toSignal(); @@ -143,12 +151,12 @@ void QDeclarativeNotifier::notify() } QDeclarativeNotifierEndpoint::QDeclarativeNotifierEndpoint() -: target(0), targetMethod(0), type(InvalidType) + : target(0), targetMethod(0), type(InvalidType), refCount(0) { } QDeclarativeNotifierEndpoint::QDeclarativeNotifierEndpoint(QObject *t, int m) -: target(t), targetMethod(m), type(InvalidType) +: target(t), targetMethod(m), type(InvalidType), refCount(0) { } @@ -186,8 +194,10 @@ void QDeclarativeNotifierEndpoint::connect(QDeclarativeNotifier *notifier) { Notifier *n = toNotifier(); - if (n->notifier == notifier) + if (n->notifier == notifier) { + refCount++; return; + } disconnect(); @@ -196,6 +206,7 @@ void QDeclarativeNotifierEndpoint::connect(QDeclarativeNotifier *notifier) notifier->endpoints = this; n->prev = ¬ifier->endpoints; n->notifier = notifier; + refCount++; } void QDeclarativeNotifierEndpoint::disconnect() @@ -204,6 +215,9 @@ void QDeclarativeNotifierEndpoint::disconnect() Signal *s = asSignal(); if (s->source) { QMetaObject::disconnectOne(s->source, s->sourceSignal, target, targetMethod); + QObjectPrivate * const priv = QObjectPrivate::get(s->source); + const QMetaMethod signal = s->source->metaObject()->method(s->sourceSignal); + priv->disconnectNotify(signal.signature()); s->source = 0; } } else if (type == NotifierType) { @@ -217,6 +231,14 @@ void QDeclarativeNotifierEndpoint::disconnect() n->disconnected = 0; n->notifier = 0; } + refCount = 0; +} + +void QDeclarativeNotifierEndpoint::deref() +{ + refCount--; + if (refCount <= 0) + disconnect(); } QDeclarativeNotifierEndpoint::Notifier *QDeclarativeNotifierEndpoint::toNotifier() diff --git a/src/declarative/qml/qdeclarativeproperty.cpp b/src/declarative/qml/qdeclarativeproperty.cpp index 84f492d..2867d27 100644 --- a/src/declarative/qml/qdeclarativeproperty.cpp +++ b/src/declarative/qml/qdeclarativeproperty.cpp @@ -1626,13 +1626,17 @@ it connects any lazy "proxy" signal connections set up by QML. It is possible that this logic should be moved to QMetaObject::connect(). */ -bool QDeclarativePropertyPrivate::connect(const QObject *sender, int signal_index, +bool QDeclarativePropertyPrivate::connect(QObject *sender, int signal_index, const QObject *receiver, int method_index, int type, int *types) { flush_vme_signal(sender, signal_index); flush_vme_signal(receiver, method_index); + const QMetaMethod signal = sender->metaObject()->method(signal_index); + QObjectPrivate * const senderPriv = QObjectPrivate::get(sender); + senderPriv->connectNotify(signal.signature()); + return QMetaObject::connect(sender, signal_index, receiver, method_index, type, types); } diff --git a/src/declarative/qml/qdeclarativeproperty_p.h b/src/declarative/qml/qdeclarativeproperty_p.h index 21e3341..4847445 100644 --- a/src/declarative/qml/qdeclarativeproperty_p.h +++ b/src/declarative/qml/qdeclarativeproperty_p.h @@ -134,7 +134,7 @@ public: static int valueTypeCoreIndex(const QDeclarativeProperty &that); static int bindingIndex(const QDeclarativeProperty &that); static QMetaMethod findSignalByName(const QMetaObject *mo, const QByteArray &); - static bool connect(const QObject *sender, int signal_index, + static bool connect(QObject *sender, int signal_index, const QObject *receiver, int method_index, int type = 0, int *types = 0); static const QMetaObject *metaObjectForProperty(const QMetaObject *, int); diff --git a/tests/auto/declarative/declarative.pro b/tests/auto/declarative/declarative.pro index 08d59d3..c9486b0 100644 --- a/tests/auto/declarative/declarative.pro +++ b/tests/auto/declarative/declarative.pro @@ -17,6 +17,7 @@ SUBDIRS += \ qdeclarativelayoutitem \ qdeclarativelistreference \ qdeclarativemoduleplugin \ + qdeclarativenotifier \ qdeclarativeparticles \ qdeclarativepixmapcache \ qdeclarativeqt \ diff --git a/tests/auto/declarative/qdeclarativenotifier/data/Base.qml b/tests/auto/declarative/qdeclarativenotifier/data/Base.qml new file mode 100644 index 0000000..1335b9d --- /dev/null +++ b/tests/auto/declarative/qdeclarativenotifier/data/Base.qml @@ -0,0 +1,5 @@ +import QtQuick 1.0 + +Item { + property int normalBinding +} diff --git a/tests/auto/declarative/qdeclarativenotifier/data/connectnotify.qml b/tests/auto/declarative/qdeclarativenotifier/data/connectnotify.qml new file mode 100644 index 0000000..5412f33 --- /dev/null +++ b/tests/auto/declarative/qdeclarativenotifier/data/connectnotify.qml @@ -0,0 +1,69 @@ +import QtQuick 1.0 +import Test 1.0 + +Base { + id: root + ExportedClass { + id: exportedClass + objectName: "exportedClass" + onBoundSignal: {} + property int buw: selfProp + } + + property int compiledBinding: exportedClass.compiledBindingProp + + normalBinding: { + Math.abs(12); // Prevent optimization to a compiled binding + return exportedClass.normalBindingProp + } + + property int foo: exportedClass.qmlObjectProp + property int baz: _exportedObject.cppObjectProp + + // Compiled bindings that share a subscription. + property int compiledBindingShared_1: exportedClass.compiledBindingPropShared + property int compiledBindingShared_2: exportedClass.compiledBindingPropShared + + function removeCompiledBinding() { + //console.log("Going to remove compiled binding...") + root.compiledBinding = 1; + //console.log("Binding removed!") + } + + function removeNormalBinding() { + //console.log("Going to remove normal binding...") + root.normalBinding = 1; + //console.log("Binding removed!") + } + + function removeCompiledBindingShared_1() { + //console.log("Going to remove compiled binding shared 1...") + root.compiledBindingShared_1 = 1; + //console.log("Binding removed!") + } + + function removeCompiledBindingShared_2() { + //console.log("Going to remove compiled binding shared 2...") + root.compiledBindingShared_2 = 1; + //console.log("Binding removed!") + } + + function readProperty() { + var test = exportedClass.unboundProp + } + + + function changeState() { + //console.log("Changing state...") + if (root.state == "") root.state = "state1" + else root.state = "" + //console.log("State changed.") + } + + property int someValue: 42 + + states: State { + name: "state1" + PropertyChanges { target: root; someValue: exportedClass.unboundProp } + } +} diff --git a/tests/auto/declarative/qdeclarativenotifier/qdeclarativenotifier.pro b/tests/auto/declarative/qdeclarativenotifier/qdeclarativenotifier.pro new file mode 100644 index 0000000..e7f5b19 --- /dev/null +++ b/tests/auto/declarative/qdeclarativenotifier/qdeclarativenotifier.pro @@ -0,0 +1,12 @@ +load(qttest_p4) +contains(QT_CONFIG,declarative): QT += declarative +SOURCES += tst_qdeclarativenotifier.cpp +macx:CONFIG -= app_bundle + +wince*: { + DEFINES += SRCDIR=\\\".\\\" +} else:!symbian: { + DEFINES += SRCDIR=\\\"$$PWD\\\" +} + +CONFIG += parallel_test diff --git a/tests/auto/declarative/qdeclarativenotifier/tst_qdeclarativenotifier.cpp b/tests/auto/declarative/qdeclarativenotifier/tst_qdeclarativenotifier.cpp new file mode 100644 index 0000000..9fb028b --- /dev/null +++ b/tests/auto/declarative/qdeclarativenotifier/tst_qdeclarativenotifier.cpp @@ -0,0 +1,302 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Research In Motion +** Contact: http://www.qt-project.org/ +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this +** file. Please review the following information to ensure the GNU Lesser +** General Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <qtest.h> +#include <QDebug> +#include <QDeclarativeEngine> +#include <QDeclarativeComponent> +#include <QDeclarativeContext> +#include <qdeclarative.h> +#include <QMetaMethod> + +#ifdef Q_OS_SYMBIAN +// In Symbian OS test data is located in applications private dir +#define SRCDIR "." +#endif + + +class ExportedClass : public QObject +{ + Q_OBJECT + Q_PROPERTY(int selfProp READ selfProp NOTIFY selfPropChanged) + Q_PROPERTY(int qmlObjectProp READ qmlObjectProp NOTIFY qmlObjectPropChanged) + Q_PROPERTY(int cppObjectProp READ cppObjectProp NOTIFY cppObjectPropChanged) + Q_PROPERTY(int unboundProp READ unboundProp NOTIFY unboundPropChanged) + Q_PROPERTY(int normalBindingProp READ normalBindingProp NOTIFY normalBindingPropChanged) + Q_PROPERTY(int compiledBindingProp READ compiledBindingProp NOTIFY compiledBindingPropChanged) + Q_PROPERTY(int compiledBindingPropShared READ compiledBindingPropShared NOTIFY compiledBindingPropSharedChanged) +public: + int selfPropConnections; + int qmlObjectPropConnections; + int cppObjectPropConnections; + int unboundPropConnections; + int normalBindingPropConnections; + int compiledBindingPropConnections; + int compiledBindingPropSharedConnections; + int boundSignalConnections; + int unusedSignalConnections; + + ExportedClass() + : selfPropConnections(0), qmlObjectPropConnections(0), cppObjectPropConnections(0), + unboundPropConnections(0), normalBindingPropConnections(0), compiledBindingPropConnections(0), + compiledBindingPropSharedConnections(0), boundSignalConnections(0), + unusedSignalConnections(0) + {} + + ~ExportedClass() + { + QCOMPARE(selfPropConnections, 0); + QCOMPARE(qmlObjectPropConnections, 0); + QCOMPARE(cppObjectPropConnections, 0); + QCOMPARE(unboundPropConnections, 0); + QCOMPARE(normalBindingPropConnections, 0); + QCOMPARE(compiledBindingPropConnections, 0); + QCOMPARE(compiledBindingPropSharedConnections, 0); + QCOMPARE(boundSignalConnections, 0); + QCOMPARE(unusedSignalConnections, 0); + } + + int selfProp() const { return 42; } + int qmlObjectProp() const { return 42; } + int unboundProp() const { return 42; } + int normalBindingProp() const { return 42; } + int compiledBindingProp() const { return 42; } + int compiledBindingPropShared() const { return 42; } + int cppObjectProp() const { return 42; } +protected: + void connectNotify(const char *signal) + { + const QString signalName(signal); + if (signalName == "selfPropChanged()") selfPropConnections++; + if (signalName == "qmlObjectPropChanged()") qmlObjectPropConnections++; + if (signalName == "cppObjectPropChanged()") cppObjectPropConnections++; + if (signalName == "unboundPropChanged()") unboundPropConnections++; + if (signalName == "normalBindingPropChanged()") normalBindingPropConnections++; + if (signalName == "compiledBindingPropChanged()") compiledBindingPropConnections++; + if (signalName == "compiledBindingPropSharedChanged()") compiledBindingPropSharedConnections++; + if (signalName == "boundSignal()") boundSignalConnections++; + if (signalName == "unusedSignal()") unusedSignalConnections++; + //qDebug() << Q_FUNC_INFO << this << signalName; + } + + void disconnectNotify(const char *signal) + { + const QString signalName(signal); + if (signalName == "selfPropChanged()") selfPropConnections--; + if (signalName == "qmlObjectPropChanged()") qmlObjectPropConnections--; + if (signalName == "cppObjectPropChanged()") cppObjectPropConnections--; + if (signalName == "unboundPropChanged()") unboundPropConnections--; + if (signalName == "normalBindingPropChanged()") normalBindingPropConnections--; + if (signalName == "compiledBindingPropChanged()") compiledBindingPropConnections--; + if (signalName == "compiledBindingPropSharedChanged()") compiledBindingPropSharedConnections--; + if (signalName == "boundSignal()") boundSignalConnections--; + if (signalName == "unusedSignal()") unusedSignalConnections--; + //qDebug() << Q_FUNC_INFO << this << signalName; + } + +signals: + void selfPropChanged(); + void qmlObjectPropChanged(); + void cppObjectPropChanged(); + void unboundPropChanged(); + void normalBindingPropChanged(); + void compiledBindingPropChanged(); + void compiledBindingPropSharedChanged(); + void boundSignal(); + void unusedSignal(); +}; + +class tst_qdeclarativenotifier : public QObject +{ + Q_OBJECT +public: + tst_qdeclarativenotifier() + : root(0), exportedClass(0), exportedObject(0) + {} + +private slots: + void initTestCase(); + void cleanupTestCase(); + void connectNotify(); + + void removeCompiledBinding(); + void removeCompiledBindingShared(); + void removeNormalBinding(); + // No need to test value type proxy bindings - the user can't override disconnectNotify() anyway, + // as the classes are private to the QML engine + + void readProperty(); + void propertyChange(); + void disconnectOnDestroy(); + +private: + void createObjects(); + + QDeclarativeEngine engine; + QObject *root; + ExportedClass *exportedClass; + ExportedClass *exportedObject; +}; + +void tst_qdeclarativenotifier::initTestCase() +{ + qmlRegisterType<ExportedClass>("Test", 1, 0, "ExportedClass"); +} + +void tst_qdeclarativenotifier::createObjects() +{ + delete root; + root = 0; + exportedClass = exportedObject = 0; + + QDeclarativeComponent component(&engine, QUrl::fromLocalFile(SRCDIR "/data/connectnotify.qml")); + exportedObject = new ExportedClass(); + exportedObject->setObjectName("exportedObject"); + engine.rootContext()->setContextProperty("_exportedObject", exportedObject); + root = component.create(); + QVERIFY(root != 0); + exportedClass = qobject_cast<ExportedClass *>( + root->findChild<ExportedClass*>("exportedClass")); + QVERIFY(exportedClass != 0); +} + +void tst_qdeclarativenotifier::cleanupTestCase() +{ + delete root; + root = 0; + delete exportedObject; + exportedObject = 0; +} + +void tst_qdeclarativenotifier::connectNotify() +{ + createObjects(); + + QCOMPARE(exportedClass->selfPropConnections, 1); + QCOMPARE(exportedClass->qmlObjectPropConnections, 1); + QCOMPARE(exportedClass->cppObjectPropConnections, 0); + QCOMPARE(exportedClass->unboundPropConnections, 0); + QCOMPARE(exportedClass->normalBindingPropConnections, 1); + QCOMPARE(exportedClass->compiledBindingPropConnections, 1); + QCOMPARE(exportedClass->compiledBindingPropSharedConnections, 1); + QCOMPARE(exportedClass->boundSignalConnections, 1); + QCOMPARE(exportedClass->unusedSignalConnections, 0); + + QCOMPARE(exportedObject->selfPropConnections, 0); + QCOMPARE(exportedObject->qmlObjectPropConnections, 0); + QCOMPARE(exportedObject->cppObjectPropConnections, 1); + QCOMPARE(exportedObject->unboundPropConnections, 0); + QCOMPARE(exportedObject->normalBindingPropConnections, 0); + QCOMPARE(exportedObject->compiledBindingPropConnections, 0); + QCOMPARE(exportedObject->compiledBindingPropSharedConnections, 0); + QCOMPARE(exportedObject->boundSignalConnections, 0); + QCOMPARE(exportedObject->unusedSignalConnections, 0); +} + +void tst_qdeclarativenotifier::removeCompiledBinding() +{ + createObjects(); + + // Removing a binding should disconnect all of its guarded properties + QVERIFY(QMetaObject::invokeMethod(root, "removeCompiledBinding")); + QCOMPARE(exportedClass->compiledBindingPropConnections, 0); +} + +void tst_qdeclarativenotifier::removeCompiledBindingShared() +{ + createObjects(); + + // In this case, the compiledBindingPropShared property is used by two compiled bindings. + // Make sure that removing one binding doesn't by accident disconnect all. Behind the scenes, + // the subscription is shared between multiple bindings. + QVERIFY(QMetaObject::invokeMethod(root, "removeCompiledBindingShared_1")); + QCOMPARE(exportedClass->compiledBindingPropSharedConnections, 1); + + // Removing the second binding should trigger a disconnect now. + QVERIFY(QMetaObject::invokeMethod(root, "removeCompiledBindingShared_2")); + QCOMPARE(exportedClass->compiledBindingPropSharedConnections, 0); +} + +void tst_qdeclarativenotifier::removeNormalBinding() +{ + createObjects(); + + // Removing a binding should disconnect all of its guarded properties + QVERIFY(QMetaObject::invokeMethod(root, "removeNormalBinding")); + QCOMPARE(exportedClass->normalBindingPropConnections, 0); +} + +void tst_qdeclarativenotifier::readProperty() +{ + createObjects(); + + // Reading a property should not connect to it + QVERIFY(QMetaObject::invokeMethod(root, "readProperty")); + QCOMPARE(exportedClass->unboundPropConnections, 0); +} + +void tst_qdeclarativenotifier::propertyChange() +{ + createObjects(); + + // Changing the state will trigger the PropertyChange to overwrite a value with a binding. + // For this, the new binding needs to be connected, and afterwards disconnected. + QVERIFY(QMetaObject::invokeMethod(root, "changeState")); + QCOMPARE(exportedClass->unboundPropConnections, 1); + QVERIFY(QMetaObject::invokeMethod(root, "changeState")); + QCOMPARE(exportedClass->unboundPropConnections, 0); +} + +void tst_qdeclarativenotifier::disconnectOnDestroy() +{ + createObjects(); + + // Deleting a QML object should remove all connections. For exportedClass, this is tested in + // the destructor, and for exportedObject, it is tested below. + delete root; + root = 0; + QCOMPARE(exportedObject->cppObjectPropConnections, 0); +} + +QTEST_MAIN(tst_qdeclarativenotifier) + +#include "tst_qdeclarativenotifier.moc" + |