FCL/sf/mw/qt: comparison src/corelib/kernel/qobject.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
 **
 two signals are emitted for duplicate connections. You can break
 all of these connections with a single disconnect() call.
 If you pass the Qt::UniqueConnection \a type, the connection will only
 be made if it is not a duplicate. If there is already a duplicate
 (exact same signal to the exact same slot on the same objects),
-the connection will fail and connect will return false
+the connection will fail and connect will return false.
 The optional \a type parameter describes the type of connection
 to establish. In particular, it determines whether a particular
 signal is delivered to a slot immediately or queued for delivery
 at a later time. If the signal is queued, the parameters must be
 }
 return true;
 }
 /*!\internal
 */
 bool QMetaObject::disconnect(const QObject *sender, int signal_index,
 const QObject *receiver, int method_index)
 {
 signal_index = methodIndexToSignalIndex(sender->metaObject(), signal_index);
 return QMetaObjectPrivate::disconnect(sender, signal_index,
 receiver, method_index);
+}
+/*!\internal
+Disconnect a single signal connection.  If QMetaObject::connect() has been called
+multiple times for the same sender, signal_index, receiver and method_index only
+one of these connections will be removed.
+*/
+bool QMetaObject::disconnectOne(const QObject *sender, int signal_index,
+const QObject *receiver, int method_index)
+{
+signal_index = methodIndexToSignalIndex(sender->metaObject(), signal_index);
+return QMetaObjectPrivate::disconnect(sender, signal_index,
+receiver, method_index,
+QMetaObjectPrivate::DisconnectOne);
 }
 /*! \internal
 Helper function to remove the connection from the senders list and setting the receivers to 0
 */
 bool QMetaObjectPrivate::disconnectHelper(QObjectPrivate::Connection *c,
 const QObject *receiver, int method_index,
-QMutex *senderMutex)
+QMutex *senderMutex, DisconnectType disconnectType)
 {
 bool success = false;
 while (c) {
 if (c->receiver
 && (receiver == 0 || (c->receiver == receiver
 receiverMutex->unlock();
 c->receiver = 0;
 success = true;
+if (disconnectType == DisconnectOne)
+return success;
 }
 c = c->nextConnectionList;
 }
 return success;
 }
 /*! \internal
 Same as the QMetaObject::disconnect, but \a signal_index must be the result of QObjectPrivate::signalIndex
 */
 bool QMetaObjectPrivate::disconnect(const QObject *sender, int signal_index,
-const QObject *receiver, int method_index)
+const QObject *receiver, int method_index,
+DisconnectType disconnectType)
 {
 if (!sender)
 return false;
 QObject *s = const_cast<QObject *>(sender);
 if (signal_index < 0) {
 // remove from all connection lists
 for (signal_index = -1; signal_index < connectionLists->count(); ++signal_index) {
 QObjectPrivate::Connection *c =
 (*connectionLists)[signal_index].first;
-if (disconnectHelper(c, receiver, method_index, senderMutex)) {
+if (disconnectHelper(c, receiver, method_index, senderMutex, disconnectType)) {
 success = true;
 connectionLists->dirty = true;
 }
 }
 } else if (signal_index < connectionLists->count()) {
 QObjectPrivate::Connection *c =
 (*connectionLists)[signal_index].first;
-if (disconnectHelper(c, receiver, method_index, senderMutex)) {
+if (disconnectHelper(c, receiver, method_index, senderMutex, disconnectType)) {
 success = true;
 connectionLists->dirty = true;
 }
 }
 continue;
 }
 const int method = c->method;
 QObjectPrivate::Sender currentSender;
-currentSender.sender = sender;
+const bool receiverInSameThread = currentThreadData == receiver->d_func()->threadData;
-currentSender.signal = signal_absolute_index;
-currentSender.ref = 1;
 QObjectPrivate::Sender *previousSender = 0;
-if (currentThreadData == receiver->d_func()->threadData)
+if (receiverInSameThread) {
+currentSender.sender = sender;
+currentSender.signal = signal_absolute_index;
+currentSender.ref = 1;
 previousSender = QObjectPrivate::setCurrentSender(receiver, &currentSender);
+}
 locker.unlock();
 if (qt_signal_spy_callback_set.slot_begin_callback != 0) {
 qt_signal_spy_callback_set.slot_begin_callback(receiver,
 method,
 #else
 QT_TRY {
 metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);
 } QT_CATCH(...) {
 locker.relock();
+if (receiverInSameThread)
 QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
 --connectionLists->inUse;
 Q_ASSERT(connectionLists->inUse >= 0);
 if (connectionLists->orphaned && !connectionLists->inUse)
 delete connectionLists;
 if (qt_signal_spy_callback_set.slot_end_callback != 0)
 qt_signal_spy_callback_set.slot_end_callback(receiver, method);
 locker.relock();
-QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
+if (receiverInSameThread)
+QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
 if (connectionLists->orphaned)
 break;
 } while (c != last && (c = c->nextConnectionList) != 0);

changeset 7	f7bc934e204c
parent 3	41300fa6a67c