Qt Meta Object system 学习(三)

Qt Meta Object system 学习(三)

看 ActiveQt 模块的源码，看到信号槽部分，实在看不懂了，只好回来继续学习 元对象系统 了。

在 Qt Meta Object system 学习(一) 中简单整理了Q_OBJECT宏 与 moc 生成的文件，在 Qt Meta Object system 学习(二) 中学习了属性系统的宏 Q_PROPERTY。现在该看看源码中信号槽相关的内容了(Qt4.7的源码，其他版本与此可能不同)

QObject::connect

非常重要的函数，不是么？

函数一开始是这么一段：

{
const void *cbdata[] = { sender, signal, receiver, method, &type };
if (QInternal::activateCallbacks(QInternal::ConnectCallback, (void **) cbdata))
return true;
}

• 这个复合语句的作用看不太懂，QInternal类的定义在 src/corelib/global/qnamespace.h 中，类成员的实现在 src/corelib/global/qglobal.cpp 中。

然后检测4个参数是否都非空

if (sender == 0 || receiver == 0 || signal == 0 || method == 0)
{
qWarning("QObject::connect: Cannot connect %s::%s to %s::%s",
sender ? sender->metaObject()->className() : "(null)",
(signal && *signal) ? signal+1 : "(null)",
receiver ? receiver->metaObject()->className() : "(null)",
(method && *method) ? method+1 : "(null)");
return false;
}

然后

if (!check_signal_macro(sender, signal, "connect", "bind"))
return false;
const QMetaObject *smeta = sender->metaObject();

• 检测信号格式是否有效(是否是通过SIGNAL生成的)，然后从元对象系统中获得信号的索引

与信号类似

if (!check_method_code(membcode, receiver, method, "connect"))
return false;
const char *method_arg = method;

• 检测与信号连接的“信号或槽”是否符合格式，然后从元对象系统中获得相应的索引

检测信号与槽的参数是否匹配，对与Queued连接，检测参数是否注册到元对象系统

if (!QMetaObject::checkConnectArgs(signal, method)) {
qWarning("QObject::connect: Incompatible sender/receiver arguments"
"\n %s::%s --> %s::%s",
sender->metaObject()->className(), signal,
receiver->metaObject()->className(), method);
return false;
}
    int *types = 0;
if ((type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
&& !(types = queuedConnectionTypes(smeta->method(signal_absolute_index).parameterTypes())))
return false;

若这一切都通过了，调用 QMetaObjectPrivate 的connect成员。调用成功，则调用 sender 对象的 connectNofify 函数(ActiveQt模块使用了该函数)

if (!QMetaObjectPrivate::connect(sender, signal_index, receiver, method_index, type, types))
return false;
const_cast<QObject*>(sender)->connectNotify(signal - 1);QMetaObjectPrivate::connect

首先，检测是否是 uniqueconnection ，如果是，则先搜索已有的连接，找到则函数返回

if (type & Qt::UniqueConnection) {
QObjectConnectionListVector *connectionLists = QObjectPrivate::get(s)->connectionLists;
if (connectionLists && connectionLists->count() > signal_index) {
const QObjectPrivate::Connection *c2 =
(*connectionLists)[signal_index].first;
while (c2) {
if (c2->receiver == receiver && c2->method == method_index)
return false;
c2 = c2->nextConnectionList;
}
}
type &= Qt::UniqueConnection - 1;
}

创建连接

QObjectPrivate::Connection *c = new QObjectPrivate::Connection;
c->sender = s;
c->receiver = r;
c->method = method_index;
c->connectionType = type;
c->argumentTypes = types;
c->nextConnectionList = 0;

    QT_TRY {
QObjectPrivate::get(s)->addConnection(signal_index, c);
} QT_CATCH(...) {
delete c;
QT_RETHROW;
}

其他还有部分代码，看不太懂，暂略(应该不影响理解)

QMetaObject::activate

信号的定义体在 moc 生成的文件内，在定义体中会调用 QMetaObject::activate 函数来实现信号的功能。

首先判断该信号有无被链接，是否是block设置(具体含义?)

if (!sender->d_func()->isSignalConnected(signal_index))
return; // nothing connected to these signals, and no spy
if (sender->d_func()->blockSig)
return;

和signal spy有关的一些代码

void *empty_argv[] = { 0 };
if (qt_signal_spy_callback_set.signal_begin_callback != 0) {
qt_signal_spy_callback_set.signal_begin_callback(sender, signal_absolute_index,
argv ? argv : empty_argv);
}
QThreadData *currentThreadData = QThreadData::current();
QMutexLocker locker(signalSlotLock(sender));
QObjectConnectionListVector *connectionLists = sender->d_func()->connectionLists; if (!connectionLists) {
locker.unlock();
if (qt_signal_spy_callback_set.signal_end_callback != 0)
qt_signal_spy_callback_set.signal_end_callback(sender, signal_absolute_index);
return;
}
++connectionLists->inUse;

用双重循环依次处理每一个信号的每一个连接

do {
QObjectPrivate::Connection *c = connectionLists->at(signal_index).first;
if (!c) continue;
// We need to check against last here to ensure that signals added
  // during the signal emission are not emitted in this emission.
QObjectPrivate::Connection *last = connectionLists->at(signal_index).last;
 
       do {
if (!c->receiver)
continue;
QObject * const receiver = c->receiver;

对queued的连接单独处理

if ((c->connectionType == Qt::AutoConnection
&& (currentThreadData != sender->d_func()->threadData
|| receiver->d_func()->threadData != sender->d_func()->threadData))
|| (c->connectionType == Qt::QueuedConnection)) {
queued_activate(sender, signal_absolute_index, c, argv ? argv : empty_argv);
continue;
} else if (c->connectionType == Qt::BlockingQueuedConnection)
{
blocking_activate(sender, signal_absolute_index, c, argv ? argv : empty_argv);
continue;
}

对其他连接，继续（发送与接收者在同一线程，则设置当前发送者，QObject::sender() 需要该功能）

const int method = c->method;
QObjectPrivate::Sender currentSender;
const bool receiverInSameThread = currentThreadData == receiver->d_func()->threadData;
QObjectPrivate::Sender *previousSender = 0;
if (receiverInSameThread) {
currentSender.sender = sender;
currentSender.signal = signal_absolute_index;
currentSender.ref = 1;
previousSender = QObjectPrivate::setCurrentSender(receiver, &currentSender);
}
locker.unlock();

调用metacall

metacall(receiver, QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);QMetaObject::metacall

int QMetaObject::metacall(QObject *object, Call cl, int idx, void **argv)
{
if (QMetaObject *mo = object->d_ptr->metaObject)
return static_cast<QAbstractDynamicMetaObject*>(mo)->metaCall(cl, idx, argv);
else
return object->qt_metacall(cl, idx, argv);
}

前面的 QAbstractDynamicMetaObject 部分不清楚作用，后面的 qt_metacall 比较好理解了(代码在moc生成的文件中)

queued_activate

首先是参数检测

...
if (c->argumentTypes == &DIRECT_CONNECTION_ONLY) // cannot activate
return;

然后是构建 QMetaCallEvent 事件，并post该事件

QCoreApplication::postEvent(c->receiver, new QMetaCallEvent(c->method,
sender,
signal,
nargs,
types,
args,
semaphore));blocking_activate

检测是否是同一线程

if (QThread::currentThread() == c->receiver->thread()) {
qWarning("Qt: Dead lock detected while activating a BlockingQueuedConnection: "
"Sender is %s(%p), receiver is %s(%p)",
sender->metaObject()->className(), sender,
c->receiver->metaObject()->className(), c->receiver);
}

调用

#ifdef QT_NO_THREAD
queued_activate(sender, signal, c, argv);
#else
QSemaphore semaphore;
queued_activate(sender, signal, c, argv, &semaphore);
QMutex *mutex = signalSlotLock(sender);
mutex->unlock();
semaphore.acquire();
mutex->lock();
#endifQObject::event

既然与事件有关postEvent，我们就需要看看事件接收者的如何处理这个调用事件的

case QEvent::MetaCall:
{
d_func()->inEventHandler = false;
QMetaCallEvent *mce = static_cast<QMetaCallEvent*>(e);
QObjectPrivate::Sender currentSender;
currentSender.sender = const_cast<QObject*>(mce->sender());
currentSender.signal = mce->signalId();
currentSender.ref = 1;
QObjectPrivate::Sender * const previousSender =
QObjectPrivate::setCurrentSender(this, &currentSender);
#if defined(QT_NO_EXCEPTIONS)
    mce->placeMetaCall(this);
#else
QT_TRY {
mce->placeMetaCall(this);
} QT_CATCH(...) {
QObjectPrivate::resetCurrentSender(this, &currentSender, previousSender);
QT_RETHROW;
}
#endif
QObjectPrivate::resetCurrentSender(this, &currentSender, previousSender);
break;
}

可以看到，这儿调用了 placeMetaCall

int QMetaCallEvent::placeMetaCall(QObject *object)
{
return QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, id_, args_);
}参考

• http://blog.csdn.net/tingsking18/archive/2009/11/12/4800828.aspx

• http://blog.csdn.net/tingsking18/archive/2009/12/12/4991563.aspx