1 | // Copyright (C) 2021 The Qt Company Ltd. |
2 | // Copyright (C) 2016 Intel Corporation. |
3 | // Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com> |
4 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only |
5 | |
6 | #include "qobject.h" |
7 | #include "qobject_p.h" |
8 | #include "qobject_p_p.h" |
9 | #include "qmetaobject_p.h" |
10 | |
11 | #include "qabstracteventdispatcher.h" |
12 | #include "qabstracteventdispatcher_p.h" |
13 | #include "qcoreapplication.h" |
14 | #include "qcoreapplication_p.h" |
15 | #include "qloggingcategory.h" |
16 | #include "qvariant.h" |
17 | #include "qmetaobject.h" |
18 | #if QT_CONFIG(regularexpression) |
19 | # include <qregularexpression.h> |
20 | #endif |
21 | #include <qthread.h> |
22 | #include <private/qthread_p.h> |
23 | #include <qdebug.h> |
24 | #include <qpair.h> |
25 | #include <qvarlengtharray.h> |
26 | #include <qscopeguard.h> |
27 | #include <qset.h> |
28 | #if QT_CONFIG(thread) |
29 | #include <qsemaphore.h> |
30 | #endif |
31 | |
32 | #include <private/qorderedmutexlocker_p.h> |
33 | #include <private/qhooks_p.h> |
34 | #include <qtcore_tracepoints_p.h> |
35 | |
36 | #include <new> |
37 | #include <mutex> |
38 | #include <memory> |
39 | |
40 | #include <ctype.h> |
41 | #include <limits.h> |
42 | |
43 | QT_BEGIN_NAMESPACE |
44 | |
45 | Q_TRACE_POINT(qtcore, QObject_ctor, QObject *object); |
46 | Q_TRACE_POINT(qtcore, QObject_dtor, QObject *object); |
47 | Q_TRACE_POINT(qtcore, QMetaObject_activate_entry, QObject *sender, int signalIndex); |
48 | Q_TRACE_POINT(qtcore, QMetaObject_activate_exit); |
49 | Q_TRACE_POINT(qtcore, QMetaObject_activate_slot_entry, QObject *receiver, int slotIndex); |
50 | Q_TRACE_POINT(qtcore, QMetaObject_activate_slot_exit); |
51 | Q_TRACE_POINT(qtcore, QMetaObject_activate_slot_functor_entry, void *slotObject); |
52 | Q_TRACE_POINT(qtcore, QMetaObject_activate_slot_functor_exit); |
53 | Q_TRACE_POINT(qtcore, QMetaObject_activate_declarative_signal_entry, QObject *sender, int signalIndex); |
54 | Q_TRACE_POINT(qtcore, QMetaObject_activate_declarative_signal_exit); |
55 | |
56 | static int DIRECT_CONNECTION_ONLY = 0; |
57 | |
58 | Q_LOGGING_CATEGORY(lcConnectSlotsByName, "qt.core.qmetaobject.connectslotsbyname" ) |
59 | Q_LOGGING_CATEGORY(lcConnect, "qt.core.qobject.connect" ) |
60 | |
61 | Q_CORE_EXPORT QBasicAtomicPointer<QSignalSpyCallbackSet> qt_signal_spy_callback_set = Q_BASIC_ATOMIC_INITIALIZER(nullptr); |
62 | |
63 | void qt_register_signal_spy_callbacks(QSignalSpyCallbackSet *callback_set) |
64 | { |
65 | qt_signal_spy_callback_set.storeRelease(newValue: callback_set); |
66 | } |
67 | |
68 | QDynamicMetaObjectData::~QDynamicMetaObjectData() |
69 | { |
70 | } |
71 | |
72 | QAbstractDynamicMetaObject::~QAbstractDynamicMetaObject() |
73 | { |
74 | } |
75 | |
76 | static int *queuedConnectionTypes(const QMetaMethod &method) |
77 | { |
78 | const auto parameterCount = method.parameterCount(); |
79 | int *typeIds = new int[parameterCount + 1]; |
80 | Q_CHECK_PTR(typeIds); |
81 | for (int i = 0; i < parameterCount; ++i) { |
82 | const QMetaType metaType = method.parameterMetaType(index: i); |
83 | if (metaType.flags() & QMetaType::IsPointer) |
84 | typeIds[i] = QMetaType::VoidStar; |
85 | else |
86 | typeIds[i] = metaType.id(); |
87 | if (!typeIds[i] && method.parameterTypeName(index: i).endsWith(c: '*')) |
88 | typeIds[i] = QMetaType::VoidStar; |
89 | if (!typeIds[i]) { |
90 | const QByteArray typeName = method.parameterTypeName(index: i); |
91 | qCWarning(lcConnect, |
92 | "QObject::connect: Cannot queue arguments of type '%s'\n" |
93 | "(Make sure '%s' is registered using qRegisterMetaType().)" , |
94 | typeName.constData(), typeName.constData()); |
95 | delete[] typeIds; |
96 | return nullptr; |
97 | } |
98 | } |
99 | typeIds[parameterCount] = 0; |
100 | |
101 | return typeIds; |
102 | } |
103 | |
104 | static int *queuedConnectionTypes(const QArgumentType *argumentTypes, int argc) |
105 | { |
106 | auto types = std::make_unique<int[]>(num: argc + 1); |
107 | for (int i = 0; i < argc; ++i) { |
108 | const QArgumentType &type = argumentTypes[i]; |
109 | if (type.type()) |
110 | types[i] = type.type(); |
111 | else if (type.name().endsWith(c: '*')) |
112 | types[i] = QMetaType::VoidStar; |
113 | else |
114 | types[i] = QMetaType::fromName(name: type.name()).id(); |
115 | |
116 | if (!types[i]) { |
117 | qCWarning(lcConnect, |
118 | "QObject::connect: Cannot queue arguments of type '%s'\n" |
119 | "(Make sure '%s' is registered using qRegisterMetaType().)" , |
120 | type.name().constData(), type.name().constData()); |
121 | return nullptr; |
122 | } |
123 | } |
124 | types[argc] = 0; |
125 | |
126 | return types.release(); |
127 | } |
128 | |
129 | Q_CONSTINIT static QBasicMutex _q_ObjectMutexPool[131]; |
130 | |
131 | /** |
132 | * \internal |
133 | * mutex to be locked when accessing the connection lists or the senders list |
134 | */ |
135 | static inline QBasicMutex *signalSlotLock(const QObject *o) |
136 | { |
137 | return &_q_ObjectMutexPool[uint(quintptr(o)) % sizeof(_q_ObjectMutexPool)/sizeof(QBasicMutex)]; |
138 | } |
139 | |
140 | void (*QAbstractDeclarativeData::destroyed)(QAbstractDeclarativeData *, QObject *) = nullptr; |
141 | void (*QAbstractDeclarativeData::signalEmitted)(QAbstractDeclarativeData *, QObject *, int, void **) = nullptr; |
142 | int (*QAbstractDeclarativeData::receivers)(QAbstractDeclarativeData *, const QObject *, int) = nullptr; |
143 | bool (*QAbstractDeclarativeData::isSignalConnected)(QAbstractDeclarativeData *, const QObject *, int) = nullptr; |
144 | void (*QAbstractDeclarativeData::setWidgetParent)(QObject *, QObject *) = nullptr; |
145 | |
146 | /*! |
147 | \fn QObjectData::QObjectData() |
148 | \internal |
149 | */ |
150 | |
151 | |
152 | QObjectData::~QObjectData() {} |
153 | |
154 | QMetaObject *QObjectData::dynamicMetaObject() const |
155 | { |
156 | return metaObject->toDynamicMetaObject(q_ptr); |
157 | } |
158 | |
159 | QObjectPrivate::QObjectPrivate(int version) |
160 | : threadData(nullptr), currentChildBeingDeleted(nullptr) |
161 | { |
162 | checkForIncompatibleLibraryVersion(version); |
163 | |
164 | // QObjectData initialization |
165 | q_ptr = nullptr; |
166 | parent = nullptr; // no parent yet. It is set by setParent() |
167 | isWidget = false; // assume not a widget object |
168 | blockSig = false; // not blocking signals |
169 | wasDeleted = false; // double-delete catcher |
170 | isDeletingChildren = false; // set by deleteChildren() |
171 | sendChildEvents = true; // if we should send ChildAdded and ChildRemoved events to parent |
172 | receiveChildEvents = true; |
173 | postedEvents = 0; |
174 | extraData = nullptr; |
175 | metaObject = nullptr; |
176 | isWindow = false; |
177 | deleteLaterCalled = false; |
178 | isQuickItem = false; |
179 | willBeWidget = false; |
180 | wasWidget = false; |
181 | } |
182 | |
183 | QObjectPrivate::~QObjectPrivate() |
184 | { |
185 | auto thisThreadData = threadData.loadRelaxed(); |
186 | if (extraData && !extraData->runningTimers.isEmpty()) { |
187 | if (Q_LIKELY(thisThreadData->thread.loadAcquire() == QThread::currentThread())) { |
188 | // unregister pending timers |
189 | if (thisThreadData->hasEventDispatcher()) |
190 | thisThreadData->eventDispatcher.loadRelaxed()->unregisterTimers(object: q_ptr); |
191 | |
192 | // release the timer ids back to the pool |
193 | for (int i = 0; i < extraData->runningTimers.size(); ++i) |
194 | QAbstractEventDispatcherPrivate::releaseTimerId(id: extraData->runningTimers.at(i)); |
195 | } else { |
196 | qWarning(msg: "QObject::~QObject: Timers cannot be stopped from another thread" ); |
197 | } |
198 | } |
199 | |
200 | if (postedEvents) |
201 | QCoreApplication::removePostedEvents(receiver: q_ptr, eventType: 0); |
202 | |
203 | thisThreadData->deref(); |
204 | |
205 | if (metaObject) |
206 | metaObject->objectDestroyed(q_ptr); |
207 | |
208 | delete extraData; |
209 | } |
210 | |
211 | /*! |
212 | \internal |
213 | For a given metaobject, compute the signal offset, and the method offset (including signals) |
214 | */ |
215 | static void computeOffsets(const QMetaObject *metaobject, int *signalOffset, int *methodOffset) |
216 | { |
217 | *signalOffset = *methodOffset = 0; |
218 | const QMetaObject *m = metaobject->d.superdata; |
219 | while (m) { |
220 | const QMetaObjectPrivate *d = QMetaObjectPrivate::get(metaobject: m); |
221 | *methodOffset += d->methodCount; |
222 | Q_ASSERT(d->revision >= 4); |
223 | *signalOffset += d->signalCount; |
224 | m = m->d.superdata; |
225 | } |
226 | } |
227 | |
228 | // Used by QAccessibleWidget |
229 | bool QObjectPrivate::isSender(const QObject *receiver, const char *signal) const |
230 | { |
231 | Q_Q(const QObject); |
232 | int signal_index = signalIndex(signalName: signal); |
233 | ConnectionData *cd = connections.loadRelaxed(); |
234 | if (signal_index < 0 || !cd) |
235 | return false; |
236 | QMutexLocker locker(signalSlotLock(o: q)); |
237 | if (signal_index < cd->signalVectorCount()) { |
238 | const QObjectPrivate::Connection *c = cd->signalVector.loadRelaxed()->at(i: signal_index).first.loadRelaxed(); |
239 | |
240 | while (c) { |
241 | if (c->receiver.loadRelaxed() == receiver) |
242 | return true; |
243 | c = c->nextConnectionList.loadRelaxed(); |
244 | } |
245 | } |
246 | return false; |
247 | } |
248 | |
249 | // Used by QAccessibleWidget |
250 | QObjectList QObjectPrivate::receiverList(const char *signal) const |
251 | { |
252 | QObjectList returnValue; |
253 | int signal_index = signalIndex(signalName: signal); |
254 | ConnectionData *cd = connections.loadRelaxed(); |
255 | if (signal_index < 0 || !cd) |
256 | return returnValue; |
257 | if (signal_index < cd->signalVectorCount()) { |
258 | const QObjectPrivate::Connection *c = cd->signalVector.loadRelaxed()->at(i: signal_index).first.loadRelaxed(); |
259 | |
260 | while (c) { |
261 | QObject *r = c->receiver.loadRelaxed(); |
262 | if (r) |
263 | returnValue << r; |
264 | c = c->nextConnectionList.loadRelaxed(); |
265 | } |
266 | } |
267 | return returnValue; |
268 | } |
269 | |
270 | // Used by QAccessibleWidget |
271 | QObjectList QObjectPrivate::senderList() const |
272 | { |
273 | QObjectList returnValue; |
274 | ConnectionData *cd = connections.loadRelaxed(); |
275 | if (cd) { |
276 | QMutexLocker locker(signalSlotLock(o: q_func())); |
277 | for (Connection *c = cd->senders; c; c = c->next) |
278 | returnValue << c->sender; |
279 | } |
280 | return returnValue; |
281 | } |
282 | |
283 | inline void QObjectPrivate::ensureConnectionData() |
284 | { |
285 | if (connections.loadRelaxed()) |
286 | return; |
287 | ConnectionData *cd = new ConnectionData; |
288 | cd->ref.ref(); |
289 | connections.storeRelaxed(newValue: cd); |
290 | } |
291 | |
292 | /*! |
293 | \internal |
294 | Add the connection \a c to the list of connections of the sender's object |
295 | for the specified \a signal |
296 | |
297 | The signalSlotLock() of the sender and receiver must be locked while calling |
298 | this function |
299 | |
300 | Will also add the connection in the sender's list of the receiver. |
301 | */ |
302 | inline void QObjectPrivate::addConnection(int signal, Connection *c) |
303 | { |
304 | Q_ASSERT(c->sender == q_ptr); |
305 | ensureConnectionData(); |
306 | ConnectionData *cd = connections.loadRelaxed(); |
307 | cd->resizeSignalVector(size: signal + 1); |
308 | |
309 | ConnectionList &connectionList = cd->connectionsForSignal(signal); |
310 | if (connectionList.last.loadRelaxed()) { |
311 | Q_ASSERT(connectionList.last.loadRelaxed()->receiver.loadRelaxed()); |
312 | connectionList.last.loadRelaxed()->nextConnectionList.storeRelaxed(newValue: c); |
313 | } else { |
314 | connectionList.first.storeRelaxed(newValue: c); |
315 | } |
316 | c->id = ++cd->currentConnectionId; |
317 | c->prevConnectionList = connectionList.last.loadRelaxed(); |
318 | connectionList.last.storeRelaxed(newValue: c); |
319 | |
320 | QObjectPrivate *rd = QObjectPrivate::get(o: c->receiver.loadRelaxed()); |
321 | rd->ensureConnectionData(); |
322 | |
323 | c->prev = &(rd->connections.loadRelaxed()->senders); |
324 | c->next = *c->prev; |
325 | *c->prev = c; |
326 | if (c->next) |
327 | c->next->prev = &c->next; |
328 | } |
329 | |
330 | void QObjectPrivate::ConnectionData::removeConnection(QObjectPrivate::Connection *c) |
331 | { |
332 | Q_ASSERT(c->receiver.loadRelaxed()); |
333 | ConnectionList &connections = signalVector.loadRelaxed()->at(i: c->signal_index); |
334 | c->receiver.storeRelaxed(newValue: nullptr); |
335 | QThreadData *td = c->receiverThreadData.loadRelaxed(); |
336 | if (td) |
337 | td->deref(); |
338 | c->receiverThreadData.storeRelaxed(newValue: nullptr); |
339 | |
340 | #ifndef QT_NO_DEBUG |
341 | bool found = false; |
342 | for (Connection *cc = connections.first.loadRelaxed(); cc; cc = cc->nextConnectionList.loadRelaxed()) { |
343 | if (cc == c) { |
344 | found = true; |
345 | break; |
346 | } |
347 | } |
348 | Q_ASSERT(found); |
349 | #endif |
350 | |
351 | // remove from the senders linked list |
352 | *c->prev = c->next; |
353 | if (c->next) |
354 | c->next->prev = c->prev; |
355 | c->prev = nullptr; |
356 | |
357 | if (connections.first.loadRelaxed() == c) |
358 | connections.first.storeRelaxed(newValue: c->nextConnectionList.loadRelaxed()); |
359 | if (connections.last.loadRelaxed() == c) |
360 | connections.last.storeRelaxed(newValue: c->prevConnectionList); |
361 | Q_ASSERT(signalVector.loadRelaxed()->at(c->signal_index).first.loadRelaxed() != c); |
362 | Q_ASSERT(signalVector.loadRelaxed()->at(c->signal_index).last.loadRelaxed() != c); |
363 | |
364 | // keep c->nextConnectionList intact, as it might still get accessed by activate |
365 | Connection *n = c->nextConnectionList.loadRelaxed(); |
366 | if (n) |
367 | n->prevConnectionList = c->prevConnectionList; |
368 | if (c->prevConnectionList) |
369 | c->prevConnectionList->nextConnectionList.storeRelaxed(newValue: n); |
370 | c->prevConnectionList = nullptr; |
371 | |
372 | Q_ASSERT(c != static_cast<Connection *>(orphaned.load(std::memory_order_relaxed))); |
373 | // add c to orphanedConnections |
374 | TaggedSignalVector o = nullptr; |
375 | /* No ABA issue here: When adding a node, we only care about the list head, it doesn't |
376 | * matter if the tail changes. |
377 | */ |
378 | o = orphaned.load(m: std::memory_order_acquire); |
379 | do { |
380 | c->nextInOrphanList = o; |
381 | } while (!orphaned.compare_exchange_strong(e&: o, i: TaggedSignalVector(c), m: std::memory_order_release)); |
382 | |
383 | #ifndef QT_NO_DEBUG |
384 | found = false; |
385 | for (Connection *cc = connections.first.loadRelaxed(); cc; cc = cc->nextConnectionList.loadRelaxed()) { |
386 | if (cc == c) { |
387 | found = true; |
388 | break; |
389 | } |
390 | } |
391 | Q_ASSERT(!found); |
392 | #endif |
393 | |
394 | } |
395 | |
396 | void QObjectPrivate::ConnectionData::cleanOrphanedConnectionsImpl(QObject *sender, LockPolicy lockPolicy) |
397 | { |
398 | QBasicMutex *senderMutex = signalSlotLock(o: sender); |
399 | TaggedSignalVector c = nullptr; |
400 | { |
401 | std::unique_lock<QBasicMutex> lock(*senderMutex, std::defer_lock_t{}); |
402 | if (lockPolicy == NeedToLock) |
403 | lock.lock(); |
404 | if (ref.loadAcquire() > 1) |
405 | return; |
406 | |
407 | // Since ref == 1, no activate() is in process since we locked the mutex. That implies, |
408 | // that nothing can reference the orphaned connection objects anymore and they can |
409 | // be safely deleted |
410 | c = orphaned.exchange(i: nullptr, m: std::memory_order_relaxed); |
411 | } |
412 | if (c) { |
413 | // Deleting c might run arbitrary user code, so we must not hold the lock |
414 | if (lockPolicy == AlreadyLockedAndTemporarilyReleasingLock) { |
415 | senderMutex->unlock(); |
416 | deleteOrphaned(o: c); |
417 | senderMutex->lock(); |
418 | } else { |
419 | deleteOrphaned(o: c); |
420 | } |
421 | } |
422 | } |
423 | |
424 | inline void QObjectPrivate::ConnectionData::deleteOrphaned(TaggedSignalVector o) |
425 | { |
426 | while (o) { |
427 | TaggedSignalVector next = nullptr; |
428 | if (SignalVector *v = static_cast<SignalVector *>(o)) { |
429 | next = v->nextInOrphanList; |
430 | free(ptr: v); |
431 | } else { |
432 | QObjectPrivate::Connection *c = static_cast<Connection *>(o); |
433 | next = c->nextInOrphanList; |
434 | Q_ASSERT(!c->receiver.loadRelaxed()); |
435 | Q_ASSERT(!c->prev); |
436 | c->freeSlotObject(); |
437 | c->deref(); |
438 | } |
439 | o = next; |
440 | } |
441 | } |
442 | |
443 | /*! \internal |
444 | |
445 | Returns \c true if the signal with index \a signal_index from object \a sender is connected. |
446 | |
447 | \a signal_index must be the index returned by QObjectPrivate::signalIndex; |
448 | */ |
449 | bool QObjectPrivate::isSignalConnected(uint signalIndex, bool checkDeclarative) const |
450 | { |
451 | if (checkDeclarative && isDeclarativeSignalConnected(signal_index: signalIndex)) |
452 | return true; |
453 | |
454 | ConnectionData *cd = connections.loadRelaxed(); |
455 | if (!cd) |
456 | return false; |
457 | SignalVector *signalVector = cd->signalVector.loadRelaxed(); |
458 | if (!signalVector) |
459 | return false; |
460 | |
461 | if (signalVector->at(i: -1).first.loadRelaxed()) |
462 | return true; |
463 | |
464 | if (signalIndex < uint(cd->signalVectorCount())) { |
465 | const QObjectPrivate::Connection *c = signalVector->at(i: signalIndex).first.loadRelaxed(); |
466 | while (c) { |
467 | if (c->receiver.loadRelaxed()) |
468 | return true; |
469 | c = c->nextConnectionList.loadRelaxed(); |
470 | } |
471 | } |
472 | return false; |
473 | } |
474 | |
475 | bool QObjectPrivate::maybeSignalConnected(uint signalIndex) const |
476 | { |
477 | ConnectionData *cd = connections.loadRelaxed(); |
478 | if (!cd) |
479 | return false; |
480 | SignalVector *signalVector = cd->signalVector.loadRelaxed(); |
481 | if (!signalVector) |
482 | return false; |
483 | |
484 | if (signalVector->at(i: -1).first.loadAcquire()) |
485 | return true; |
486 | |
487 | if (signalIndex < uint(cd->signalVectorCount())) { |
488 | const QObjectPrivate::Connection *c = signalVector->at(i: signalIndex).first.loadAcquire(); |
489 | return c != nullptr; |
490 | } |
491 | return false; |
492 | } |
493 | |
494 | void QObjectPrivate::reinitBindingStorageAfterThreadMove() |
495 | { |
496 | bindingStorage.reinitAfterThreadMove(); |
497 | for (int i = 0; i < children.size(); ++i) |
498 | children[i]->d_func()->reinitBindingStorageAfterThreadMove(); |
499 | } |
500 | |
501 | /*! |
502 | \internal |
503 | */ |
504 | QAbstractMetaCallEvent::~QAbstractMetaCallEvent() |
505 | { |
506 | #if QT_CONFIG(thread) |
507 | if (semaphore_) |
508 | semaphore_->release(); |
509 | #endif |
510 | } |
511 | |
512 | /*! |
513 | \internal |
514 | */ |
515 | inline void QMetaCallEvent::allocArgs() |
516 | { |
517 | if (!d.nargs_) |
518 | return; |
519 | |
520 | constexpr size_t each = sizeof(void*) + sizeof(QMetaType); |
521 | void *const memory = d.nargs_ * each > sizeof(prealloc_) ? |
522 | calloc(nmemb: d.nargs_, size: each) : prealloc_; |
523 | |
524 | Q_CHECK_PTR(memory); |
525 | d.args_ = static_cast<void **>(memory); |
526 | } |
527 | |
528 | /*! |
529 | \internal |
530 | |
531 | Used for blocking queued connections, just passes \a args through without |
532 | allocating any memory. |
533 | */ |
534 | QMetaCallEvent::QMetaCallEvent(ushort method_offset, ushort method_relative, |
535 | QObjectPrivate::StaticMetaCallFunction callFunction, |
536 | const QObject *sender, int signalId, |
537 | void **args, QSemaphore *semaphore) |
538 | : QAbstractMetaCallEvent(sender, signalId, semaphore), |
539 | d({.slotObj_: nullptr, .args_: args, .callFunction_: callFunction, .nargs_: 0, .method_offset_: method_offset, .method_relative_: method_relative}), |
540 | prealloc_() |
541 | { |
542 | } |
543 | |
544 | /*! |
545 | \internal |
546 | |
547 | Used for blocking queued connections, just passes \a args through without |
548 | allocating any memory. |
549 | */ |
550 | QMetaCallEvent::QMetaCallEvent(QtPrivate::QSlotObjectBase *slotO, |
551 | const QObject *sender, int signalId, |
552 | void **args, QSemaphore *semaphore) |
553 | : QAbstractMetaCallEvent(sender, signalId, semaphore), |
554 | d({.slotObj_: QtPrivate::SlotObjUniquePtr{slotO}, .args_: args, .callFunction_: nullptr, .nargs_: 0, .method_offset_: 0, .method_relative_: ushort(-1)}), |
555 | prealloc_() |
556 | { |
557 | if (d.slotObj_) |
558 | d.slotObj_->ref(); |
559 | } |
560 | |
561 | /*! |
562 | \internal |
563 | |
564 | Used for blocking queued connections, just passes \a args through without |
565 | allocating any memory. |
566 | */ |
567 | QMetaCallEvent::QMetaCallEvent(QtPrivate::SlotObjUniquePtr slotO, |
568 | const QObject *sender, int signalId, |
569 | void **args, QSemaphore *semaphore) |
570 | : QAbstractMetaCallEvent(sender, signalId, semaphore), |
571 | d{.slotObj_: std::move(slotO), .args_: args, .callFunction_: nullptr, .nargs_: 0, .method_offset_: 0, .method_relative_: ushort(-1)}, |
572 | prealloc_() |
573 | { |
574 | } |
575 | |
576 | /*! |
577 | \internal |
578 | |
579 | Allocates memory for \a nargs; code creating an event needs to initialize |
580 | the void* and int arrays by accessing \a args() and \a types(), respectively. |
581 | */ |
582 | QMetaCallEvent::QMetaCallEvent(ushort method_offset, ushort method_relative, |
583 | QObjectPrivate::StaticMetaCallFunction callFunction, |
584 | const QObject *sender, int signalId, |
585 | int nargs) |
586 | : QAbstractMetaCallEvent(sender, signalId), |
587 | d({.slotObj_: nullptr, .args_: nullptr, .callFunction_: callFunction, .nargs_: nargs, .method_offset_: method_offset, .method_relative_: method_relative}), |
588 | prealloc_() |
589 | { |
590 | allocArgs(); |
591 | } |
592 | |
593 | /*! |
594 | \internal |
595 | |
596 | Allocates memory for \a nargs; code creating an event needs to initialize |
597 | the void* and int arrays by accessing \a args() and \a types(), respectively. |
598 | */ |
599 | QMetaCallEvent::QMetaCallEvent(QtPrivate::QSlotObjectBase *slotO, |
600 | const QObject *sender, int signalId, |
601 | int nargs) |
602 | : QAbstractMetaCallEvent(sender, signalId), |
603 | d({.slotObj_: QtPrivate::SlotObjUniquePtr(slotO), .args_: nullptr, .callFunction_: nullptr, .nargs_: nargs, .method_offset_: 0, .method_relative_: ushort(-1)}), |
604 | prealloc_() |
605 | { |
606 | if (d.slotObj_) |
607 | d.slotObj_->ref(); |
608 | allocArgs(); |
609 | } |
610 | |
611 | /*! |
612 | \internal |
613 | |
614 | Allocates memory for \a nargs; code creating an event needs to initialize |
615 | the void* and int arrays by accessing \a args() and \a types(), respectively. |
616 | */ |
617 | QMetaCallEvent::QMetaCallEvent(QtPrivate::SlotObjUniquePtr slotO, |
618 | const QObject *sender, int signalId, |
619 | int nargs) |
620 | : QAbstractMetaCallEvent(sender, signalId), |
621 | d{.slotObj_: std::move(slotO), .args_: nullptr, .callFunction_: nullptr, .nargs_: nargs, .method_offset_: 0, .method_relative_: ushort(-1)}, |
622 | prealloc_() |
623 | { |
624 | allocArgs(); |
625 | } |
626 | |
627 | /*! |
628 | \internal |
629 | */ |
630 | QMetaCallEvent::~QMetaCallEvent() |
631 | { |
632 | if (d.nargs_) { |
633 | QMetaType *t = types(); |
634 | for (int i = 0; i < d.nargs_; ++i) { |
635 | if (t[i].isValid() && d.args_[i]) |
636 | t[i].destroy(data: d.args_[i]); |
637 | } |
638 | if (reinterpret_cast<void *>(d.args_) != reinterpret_cast<void *>(prealloc_)) |
639 | free(ptr: d.args_); |
640 | } |
641 | } |
642 | |
643 | /*! |
644 | \internal |
645 | */ |
646 | void QMetaCallEvent::placeMetaCall(QObject *object) |
647 | { |
648 | if (d.slotObj_) { |
649 | d.slotObj_->call(r: object, a: d.args_); |
650 | } else if (d.callFunction_ && d.method_offset_ <= object->metaObject()->methodOffset()) { |
651 | d.callFunction_(object, QMetaObject::InvokeMetaMethod, d.method_relative_, d.args_); |
652 | } else { |
653 | QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, |
654 | d.method_offset_ + d.method_relative_, d.args_); |
655 | } |
656 | } |
657 | |
658 | QMetaCallEvent* QMetaCallEvent::create_impl(QtPrivate::SlotObjUniquePtr slotObj, |
659 | const QObject *sender, int signal_index, |
660 | size_t argc, const void* const argp[], |
661 | const QMetaType metaTypes[]) |
662 | { |
663 | auto metaCallEvent = std::make_unique<QMetaCallEvent>(args: std::move(slotObj), args&: sender, |
664 | args&: signal_index, args: int(argc)); |
665 | |
666 | void **args = metaCallEvent->args(); |
667 | QMetaType *types = metaCallEvent->types(); |
668 | for (size_t i = 0; i < argc; ++i) { |
669 | types[i] = metaTypes[i]; |
670 | args[i] = types[i].create(copy: argp[i]); |
671 | Q_CHECK_PTR(!i || args[i]); |
672 | } |
673 | |
674 | return metaCallEvent.release(); |
675 | } |
676 | |
677 | /*! |
678 | \class QSignalBlocker |
679 | \brief Exception-safe wrapper around QObject::blockSignals(). |
680 | \since 5.3 |
681 | \ingroup objectmodel |
682 | \inmodule QtCore |
683 | |
684 | \reentrant |
685 | |
686 | QSignalBlocker can be used wherever you would otherwise use a |
687 | pair of calls to blockSignals(). It blocks signals in its |
688 | constructor and in the destructor it resets the state to what |
689 | it was before the constructor ran. |
690 | |
691 | \snippet code/src_corelib_kernel_qobject.cpp 53 |
692 | is thus equivalent to |
693 | \snippet code/src_corelib_kernel_qobject.cpp 54 |
694 | |
695 | except the code using QSignalBlocker is safe in the face of |
696 | exceptions. |
697 | |
698 | \sa QMutexLocker, QEventLoopLocker |
699 | */ |
700 | |
701 | /*! |
702 | \fn QSignalBlocker::QSignalBlocker(QObject *object) |
703 | |
704 | Constructor. Calls \a{object}->blockSignals(true). |
705 | */ |
706 | |
707 | /*! |
708 | \fn QSignalBlocker::QSignalBlocker(QObject &object) |
709 | \overload |
710 | |
711 | Calls \a{object}.blockSignals(true). |
712 | */ |
713 | |
714 | /*! |
715 | \fn QSignalBlocker::QSignalBlocker(QSignalBlocker &&other) |
716 | |
717 | Move-constructs a signal blocker from \a other. \a other will have |
718 | a no-op destructor, while responsibility for restoring the |
719 | QObject::signalsBlocked() state is transferred to the new object. |
720 | */ |
721 | |
722 | /*! |
723 | \fn QSignalBlocker &QSignalBlocker::operator=(QSignalBlocker &&other) |
724 | |
725 | Move-assigns this signal blocker from \a other. \a other will have |
726 | a no-op destructor, while responsibility for restoring the |
727 | QObject::signalsBlocked() state is transferred to this object. |
728 | |
729 | The object's signals this signal blocker was blocking prior to |
730 | being moved to, if any, are unblocked \e except in the case where |
731 | both instances block the same object's signals and \c *this is |
732 | unblocked while \a other is not, at the time of the move. |
733 | */ |
734 | |
735 | /*! |
736 | \fn QSignalBlocker::~QSignalBlocker() |
737 | |
738 | Destructor. Restores the QObject::signalsBlocked() state to what it |
739 | was before the constructor ran, unless unblock() has been called |
740 | without a following reblock(), in which case it does nothing. |
741 | */ |
742 | |
743 | /*! |
744 | \fn void QSignalBlocker::reblock() |
745 | |
746 | Re-blocks signals after a previous unblock(). |
747 | |
748 | The numbers of reblock() and unblock() calls are not counted, so |
749 | every reblock() undoes any number of unblock() calls. |
750 | */ |
751 | |
752 | /*! |
753 | \fn void QSignalBlocker::unblock() |
754 | |
755 | Temporarily restores the QObject::signalsBlocked() state to what |
756 | it was before this QSignalBlocker's constructor ran. To undo, use |
757 | reblock(). |
758 | |
759 | The numbers of reblock() and unblock() calls are not counted, so |
760 | every unblock() undoes any number of reblock() calls. |
761 | */ |
762 | |
763 | /*! |
764 | \class QObject |
765 | \inmodule QtCore |
766 | \brief The QObject class is the base class of all Qt objects. |
767 | |
768 | \ingroup objectmodel |
769 | |
770 | \reentrant |
771 | |
772 | QObject is the heart of the Qt \l{Object Model}. The central |
773 | feature in this model is a very powerful mechanism for seamless |
774 | object communication called \l{signals and slots}. You can |
775 | connect a signal to a slot with connect() and destroy the |
776 | connection with disconnect(). To avoid never ending notification |
777 | loops you can temporarily block signals with blockSignals(). The |
778 | protected functions connectNotify() and disconnectNotify() make |
779 | it possible to track connections. |
780 | |
781 | QObjects organize themselves in \l {Object Trees & Ownership} |
782 | {object trees}. When you create a QObject with another object as |
783 | parent, the object will automatically add itself to the parent's |
784 | children() list. The parent takes ownership of the object; i.e., |
785 | it will automatically delete its children in its destructor. You |
786 | can look for an object by name and optionally type using |
787 | findChild() or findChildren(). |
788 | |
789 | Every object has an objectName() and its class name can be found |
790 | via the corresponding metaObject() (see QMetaObject::className()). |
791 | You can determine whether the object's class inherits another |
792 | class in the QObject inheritance hierarchy by using the |
793 | inherits() function. |
794 | |
795 | When an object is deleted, it emits a destroyed() signal. You can |
796 | catch this signal to avoid dangling references to QObjects. |
797 | |
798 | QObjects can receive events through event() and filter the events |
799 | of other objects. See installEventFilter() and eventFilter() for |
800 | details. A convenience handler, childEvent(), can be reimplemented |
801 | to catch child events. |
802 | |
803 | Last but not least, QObject provides the basic timer support in |
804 | Qt; see QTimer for high-level support for timers. |
805 | |
806 | Notice that the Q_OBJECT macro is mandatory for any object that |
807 | implements signals, slots or properties. You also need to run the |
808 | \l{moc}{Meta Object Compiler} on the source file. We strongly |
809 | recommend the use of this macro in all subclasses of QObject |
810 | regardless of whether or not they actually use signals, slots and |
811 | properties, since failure to do so may lead certain functions to |
812 | exhibit strange behavior. |
813 | |
814 | All Qt widgets inherit QObject. The convenience function |
815 | isWidgetType() returns whether an object is actually a widget. It |
816 | is much faster than |
817 | \l{qobject_cast()}{qobject_cast}<QWidget *>(\e{obj}) or |
818 | \e{obj}->\l{inherits()}{inherits}("QWidget"). |
819 | |
820 | Some QObject functions, e.g. children(), return a QObjectList. |
821 | QObjectList is a typedef for QList<QObject *>. |
822 | |
823 | \section1 Thread Affinity |
824 | |
825 | A QObject instance is said to have a \e{thread affinity}, or that |
826 | it \e{lives} in a certain thread. When a QObject receives a |
827 | \l{Qt::QueuedConnection}{queued signal} or a \l{The Event |
828 | System#Sending Events}{posted event}, the slot or event handler |
829 | will run in the thread that the object lives in. |
830 | |
831 | \note If a QObject has no thread affinity (that is, if thread() |
832 | returns zero), or if it lives in a thread that has no running event |
833 | loop, then it cannot receive queued signals or posted events. |
834 | |
835 | By default, a QObject lives in the thread in which it is created. |
836 | An object's thread affinity can be queried using thread() and |
837 | changed using moveToThread(). |
838 | |
839 | All QObjects must live in the same thread as their parent. Consequently: |
840 | |
841 | \list |
842 | \li setParent() will fail if the two QObjects involved live in |
843 | different threads. |
844 | \li When a QObject is moved to another thread, all its children |
845 | will be automatically moved too. |
846 | \li moveToThread() will fail if the QObject has a parent. |
847 | \li If QObjects are created within QThread::run(), they cannot |
848 | become children of the QThread object because the QThread does |
849 | not live in the thread that calls QThread::run(). |
850 | \endlist |
851 | |
852 | \note A QObject's member variables \e{do not} automatically become |
853 | its children. The parent-child relationship must be set by either |
854 | passing a pointer to the child's \l{QObject()}{constructor}, or by |
855 | calling setParent(). Without this step, the object's member variables |
856 | will remain in the old thread when moveToThread() is called. |
857 | |
858 | \target No copy constructor |
859 | \section1 No Copy Constructor or Assignment Operator |
860 | |
861 | QObject has neither a copy constructor nor an assignment operator. |
862 | This is by design. Actually, they are declared, but in a |
863 | \c{private} section with the macro Q_DISABLE_COPY(). In fact, all |
864 | Qt classes derived from QObject (direct or indirect) use this |
865 | macro to declare their copy constructor and assignment operator to |
866 | be private. The reasoning is found in the discussion on |
867 | \l{Identity vs Value} {Identity vs Value} on the Qt \l{Object |
868 | Model} page. |
869 | |
870 | The main consequence is that you should use pointers to QObject |
871 | (or to your QObject subclass) where you might otherwise be tempted |
872 | to use your QObject subclass as a value. For example, without a |
873 | copy constructor, you can't use a subclass of QObject as the value |
874 | to be stored in one of the container classes. You must store |
875 | pointers. |
876 | |
877 | \section1 Auto-Connection |
878 | |
879 | Qt's meta-object system provides a mechanism to automatically connect |
880 | signals and slots between QObject subclasses and their children. As long |
881 | as objects are defined with suitable object names, and slots follow a |
882 | simple naming convention, this connection can be performed at run-time |
883 | by the QMetaObject::connectSlotsByName() function. |
884 | |
885 | \l uic generates code that invokes this function to enable |
886 | auto-connection to be performed between widgets on forms created |
887 | with \e{Qt Designer}. More information about using auto-connection with \e{Qt Designer} is |
888 | given in the \l{Using a Designer UI File in Your Application} section of |
889 | the \e{Qt Designer} manual. |
890 | |
891 | \section1 Dynamic Properties |
892 | |
893 | From Qt 4.2, dynamic properties can be added to and removed from QObject |
894 | instances at run-time. Dynamic properties do not need to be declared at |
895 | compile-time, yet they provide the same advantages as static properties |
896 | and are manipulated using the same API - using property() to read them |
897 | and setProperty() to write them. |
898 | |
899 | From Qt 4.3, dynamic properties are supported by |
900 | \l{Qt Designer's Widget Editing Mode#The Property Editor}{Qt Designer}, |
901 | and both standard Qt widgets and user-created forms can be given dynamic |
902 | properties. |
903 | |
904 | \section1 Internationalization (I18n) |
905 | |
906 | All QObject subclasses support Qt's translation features, making it possible |
907 | to translate an application's user interface into different languages. |
908 | |
909 | To make user-visible text translatable, it must be wrapped in calls to |
910 | the tr() function. This is explained in detail in the |
911 | \l{Writing Source Code for Translation} document. |
912 | |
913 | \sa QMetaObject, QPointer, QObjectCleanupHandler, Q_DISABLE_COPY() |
914 | \sa {Object Trees & Ownership} |
915 | */ |
916 | |
917 | /***************************************************************************** |
918 | QObject member functions |
919 | *****************************************************************************/ |
920 | |
921 | // check the constructor's parent thread argument |
922 | static bool check_parent_thread(QObject *parent, |
923 | QThreadData *parentThreadData, |
924 | QThreadData *currentThreadData) |
925 | { |
926 | if (parent && parentThreadData != currentThreadData) { |
927 | QThread *parentThread = parentThreadData->thread.loadAcquire(); |
928 | QThread *currentThread = currentThreadData->thread.loadAcquire(); |
929 | qWarning(msg: "QObject: Cannot create children for a parent that is in a different thread.\n" |
930 | "(Parent is %s(%p), parent's thread is %s(%p), current thread is %s(%p)" , |
931 | parent->metaObject()->className(), |
932 | parent, |
933 | parentThread ? parentThread->metaObject()->className() : "QThread" , |
934 | parentThread, |
935 | currentThread ? currentThread->metaObject()->className() : "QThread" , |
936 | currentThread); |
937 | return false; |
938 | } |
939 | return true; |
940 | } |
941 | |
942 | /*! |
943 | Constructs an object with parent object \a parent. |
944 | |
945 | The parent of an object may be viewed as the object's owner. For |
946 | instance, a \l{QDialog}{dialog box} is the parent of the \uicontrol{OK} |
947 | and \uicontrol{Cancel} buttons it contains. |
948 | |
949 | The destructor of a parent object destroys all child objects. |
950 | |
951 | Setting \a parent to \nullptr constructs an object with no parent. If the |
952 | object is a widget, it will become a top-level window. |
953 | |
954 | \sa parent(), findChild(), findChildren() |
955 | */ |
956 | |
957 | QObject::QObject(QObject *parent) |
958 | : QObject(*new QObjectPrivate, parent) |
959 | { |
960 | } |
961 | |
962 | /*! |
963 | \internal |
964 | */ |
965 | QObject::QObject(QObjectPrivate &dd, QObject *parent) |
966 | : d_ptr(&dd) |
967 | { |
968 | Q_ASSERT_X(this != parent, Q_FUNC_INFO, "Cannot parent a QObject to itself" ); |
969 | |
970 | Q_D(QObject); |
971 | d_ptr->q_ptr = this; |
972 | auto threadData = (parent && !parent->thread()) ? parent->d_func()->threadData.loadRelaxed() : QThreadData::current(); |
973 | threadData->ref(); |
974 | d->threadData.storeRelaxed(newValue: threadData); |
975 | if (parent) { |
976 | QT_TRY { |
977 | if (!check_parent_thread(parent, parentThreadData: parent ? parent->d_func()->threadData.loadRelaxed() : nullptr, currentThreadData: threadData)) |
978 | parent = nullptr; |
979 | if (d->willBeWidget) { |
980 | if (parent) { |
981 | d->parent = parent; |
982 | d->parent->d_func()->children.append(t: this); |
983 | } |
984 | // no events sent here, this is done at the end of the QWidget constructor |
985 | } else { |
986 | setParent(parent); |
987 | } |
988 | } QT_CATCH(...) { |
989 | threadData->deref(); |
990 | QT_RETHROW; |
991 | } |
992 | } |
993 | if (Q_UNLIKELY(qtHookData[QHooks::AddQObject])) |
994 | reinterpret_cast<QHooks::AddQObjectCallback>(qtHookData[QHooks::AddQObject])(this); |
995 | Q_TRACE(QObject_ctor, this); |
996 | } |
997 | |
998 | void QObjectPrivate::clearBindingStorage() |
999 | { |
1000 | bindingStorage.clear(); |
1001 | } |
1002 | |
1003 | /*! |
1004 | Destroys the object, deleting all its child objects. |
1005 | |
1006 | All signals to and from the object are automatically disconnected, and |
1007 | any pending posted events for the object are removed from the event |
1008 | queue. However, it is often safer to use deleteLater() rather than |
1009 | deleting a QObject subclass directly. |
1010 | |
1011 | \warning All child objects are deleted. If any of these objects |
1012 | are on the stack or global, sooner or later your program will |
1013 | crash. We do not recommend holding pointers to child objects from |
1014 | outside the parent. If you still do, the destroyed() signal gives |
1015 | you an opportunity to detect when an object is destroyed. |
1016 | |
1017 | \warning Deleting a QObject while pending events are waiting to |
1018 | be delivered can cause a crash. You must not delete the QObject |
1019 | directly if it exists in a different thread than the one currently |
1020 | executing. Use deleteLater() instead, which will cause the event |
1021 | loop to delete the object after all pending events have been |
1022 | delivered to it. |
1023 | |
1024 | \sa deleteLater() |
1025 | */ |
1026 | |
1027 | QObject::~QObject() |
1028 | { |
1029 | Q_D(QObject); |
1030 | d->wasDeleted = true; |
1031 | d->blockSig = 0; // unblock signals so we always emit destroyed() |
1032 | |
1033 | if (!d->bindingStorage.isValid()) { |
1034 | // this might be the case after an incomplete thread-move |
1035 | // remove this object from the pending list in that case |
1036 | if (QThread *ownThread = thread()) { |
1037 | auto *privThread = static_cast<QThreadPrivate *>( |
1038 | QObjectPrivate::get(o: ownThread)); |
1039 | privThread->removeObjectWithPendingBindingStatusChange(obj: this); |
1040 | } |
1041 | } |
1042 | |
1043 | // If we reached this point, we need to clear the binding data |
1044 | // as the corresponding properties are no longer useful |
1045 | d->clearBindingStorage(); |
1046 | |
1047 | QtSharedPointer::ExternalRefCountData *sharedRefcount = d->sharedRefcount.loadRelaxed(); |
1048 | if (sharedRefcount) { |
1049 | if (sharedRefcount->strongref.loadRelaxed() > 0) { |
1050 | qWarning(msg: "QObject: shared QObject was deleted directly. The program is malformed and may crash." ); |
1051 | // but continue deleting, it's too late to stop anyway |
1052 | } |
1053 | |
1054 | // indicate to all QWeakPointers that this QObject has now been deleted |
1055 | sharedRefcount->strongref.storeRelaxed(newValue: 0); |
1056 | if (!sharedRefcount->weakref.deref()) |
1057 | delete sharedRefcount; |
1058 | } |
1059 | |
1060 | if (!d->wasWidget && d->isSignalConnected(signalIndex: 0)) { |
1061 | emit destroyed(this); |
1062 | } |
1063 | |
1064 | if (!d->isDeletingChildren && d->declarativeData && QAbstractDeclarativeData::destroyed) |
1065 | QAbstractDeclarativeData::destroyed(d->declarativeData, this); |
1066 | |
1067 | QObjectPrivate::ConnectionData *cd = d->connections.loadRelaxed(); |
1068 | if (cd) { |
1069 | if (cd->currentSender) { |
1070 | cd->currentSender->receiverDeleted(); |
1071 | cd->currentSender = nullptr; |
1072 | } |
1073 | |
1074 | QBasicMutex *signalSlotMutex = signalSlotLock(o: this); |
1075 | QMutexLocker locker(signalSlotMutex); |
1076 | |
1077 | // disconnect all receivers |
1078 | int receiverCount = cd->signalVectorCount(); |
1079 | for (int signal = -1; signal < receiverCount; ++signal) { |
1080 | QObjectPrivate::ConnectionList &connectionList = cd->connectionsForSignal(signal); |
1081 | |
1082 | while (QObjectPrivate::Connection *c = connectionList.first.loadRelaxed()) { |
1083 | Q_ASSERT(c->receiver.loadAcquire()); |
1084 | |
1085 | QBasicMutex *m = signalSlotLock(o: c->receiver.loadRelaxed()); |
1086 | bool needToUnlock = QOrderedMutexLocker::relock(mtx1: signalSlotMutex, mtx2: m); |
1087 | if (c == connectionList.first.loadAcquire() && c->receiver.loadAcquire()) { |
1088 | cd->removeConnection(c); |
1089 | Q_ASSERT(connectionList.first.loadRelaxed() != c); |
1090 | } |
1091 | if (needToUnlock) |
1092 | m->unlock(); |
1093 | } |
1094 | } |
1095 | |
1096 | /* Disconnect all senders: |
1097 | */ |
1098 | while (QObjectPrivate::Connection *node = cd->senders) { |
1099 | Q_ASSERT(node->receiver.loadAcquire()); |
1100 | QObject *sender = node->sender; |
1101 | // Send disconnectNotify before removing the connection from sender's connection list. |
1102 | // This ensures any eventual destructor of sender will block on getting receiver's lock |
1103 | // and not finish until we release it. |
1104 | sender->disconnectNotify(signal: QMetaObjectPrivate::signal(m: sender->metaObject(), signal_index: node->signal_index)); |
1105 | QBasicMutex *m = signalSlotLock(o: sender); |
1106 | bool needToUnlock = QOrderedMutexLocker::relock(mtx1: signalSlotMutex, mtx2: m); |
1107 | //the node has maybe been removed while the mutex was unlocked in relock? |
1108 | if (node != cd->senders) { |
1109 | // We hold the wrong mutex |
1110 | Q_ASSERT(needToUnlock); |
1111 | m->unlock(); |
1112 | continue; |
1113 | } |
1114 | |
1115 | QObjectPrivate::ConnectionData *senderData = sender->d_func()->connections.loadRelaxed(); |
1116 | Q_ASSERT(senderData); |
1117 | |
1118 | QtPrivate::QSlotObjectBase *slotObj = nullptr; |
1119 | if (node->isSlotObject) { |
1120 | slotObj = node->slotObj; |
1121 | node->isSlotObject = false; |
1122 | } |
1123 | |
1124 | senderData->removeConnection(c: node); |
1125 | /* |
1126 | When we unlock, another thread has the chance to delete/modify sender data. |
1127 | Thus we need to call cleanOrphanedConnections before unlocking. We use the |
1128 | variant of the function which assumes that the lock is already held to avoid |
1129 | a deadlock. |
1130 | We need to hold m, the sender lock. Considering that we might execute arbitrary user |
1131 | code, we should already release the signalSlotMutex here – unless they are the same. |
1132 | */ |
1133 | const bool locksAreTheSame = signalSlotMutex == m; |
1134 | if (!locksAreTheSame) |
1135 | locker.unlock(); |
1136 | senderData->cleanOrphanedConnections( |
1137 | sender, |
1138 | lockPolicy: QObjectPrivate::ConnectionData::AlreadyLockedAndTemporarilyReleasingLock |
1139 | ); |
1140 | if (needToUnlock) |
1141 | m->unlock(); |
1142 | |
1143 | if (locksAreTheSame) // otherwise already unlocked |
1144 | locker.unlock(); |
1145 | if (slotObj) |
1146 | slotObj->destroyIfLastRef(); |
1147 | locker.relock(); |
1148 | } |
1149 | |
1150 | // invalidate all connections on the object and make sure |
1151 | // activate() will skip them |
1152 | cd->currentConnectionId.storeRelaxed(newValue: 0); |
1153 | } |
1154 | if (cd && !cd->ref.deref()) |
1155 | delete cd; |
1156 | d->connections.storeRelaxed(newValue: nullptr); |
1157 | |
1158 | if (!d->children.isEmpty()) |
1159 | d->deleteChildren(); |
1160 | |
1161 | if (Q_UNLIKELY(qtHookData[QHooks::RemoveQObject])) |
1162 | reinterpret_cast<QHooks::RemoveQObjectCallback>(qtHookData[QHooks::RemoveQObject])(this); |
1163 | |
1164 | Q_TRACE(QObject_dtor, this); |
1165 | |
1166 | if (d->parent) // remove it from parent object |
1167 | d->setParent_helper(nullptr); |
1168 | } |
1169 | |
1170 | inline QObjectPrivate::Connection::~Connection() |
1171 | { |
1172 | if (ownArgumentTypes) { |
1173 | const int *v = argumentTypes.loadRelaxed(); |
1174 | if (v != &DIRECT_CONNECTION_ONLY) |
1175 | delete[] v; |
1176 | } |
1177 | if (isSlotObject) |
1178 | slotObj->destroyIfLastRef(); |
1179 | } |
1180 | |
1181 | |
1182 | /*! |
1183 | \fn const QMetaObject *QObject::metaObject() const |
1184 | |
1185 | Returns a pointer to the meta-object of this object. |
1186 | |
1187 | A meta-object contains information about a class that inherits |
1188 | QObject, e.g. class name, superclass name, properties, signals and |
1189 | slots. Every QObject subclass that contains the Q_OBJECT macro will have a |
1190 | meta-object. |
1191 | |
1192 | The meta-object information is required by the signal/slot |
1193 | connection mechanism and the property system. The inherits() |
1194 | function also makes use of the meta-object. |
1195 | |
1196 | If you have no pointer to an actual object instance but still |
1197 | want to access the meta-object of a class, you can use \l |
1198 | staticMetaObject. |
1199 | |
1200 | Example: |
1201 | |
1202 | \snippet code/src_corelib_kernel_qobject.cpp 1 |
1203 | |
1204 | \sa staticMetaObject |
1205 | */ |
1206 | |
1207 | /*! |
1208 | \variable QObject::staticMetaObject |
1209 | |
1210 | This variable stores the meta-object for the class. |
1211 | |
1212 | A meta-object contains information about a class that inherits |
1213 | QObject, e.g. class name, superclass name, properties, signals and |
1214 | slots. Every class that contains the Q_OBJECT macro will also have |
1215 | a meta-object. |
1216 | |
1217 | The meta-object information is required by the signal/slot |
1218 | connection mechanism and the property system. The inherits() |
1219 | function also makes use of the meta-object. |
1220 | |
1221 | If you have a pointer to an object, you can use metaObject() to |
1222 | retrieve the meta-object associated with that object. |
1223 | |
1224 | Example: |
1225 | |
1226 | \snippet code/src_corelib_kernel_qobject.cpp 2 |
1227 | |
1228 | \sa metaObject() |
1229 | */ |
1230 | |
1231 | /*! |
1232 | \fn template <class T> T qobject_cast(QObject *object) |
1233 | \fn template <class T> T qobject_cast(const QObject *object) |
1234 | \relates QObject |
1235 | |
1236 | Returns the given \a object cast to type T if the object is of type |
1237 | T (or of a subclass); otherwise returns \nullptr. If \a object is |
1238 | \nullptr then it will also return \nullptr. |
1239 | |
1240 | The class T must inherit (directly or indirectly) QObject and be |
1241 | declared with the \l Q_OBJECT macro. |
1242 | |
1243 | A class is considered to inherit itself. |
1244 | |
1245 | Example: |
1246 | |
1247 | \snippet code/src_corelib_kernel_qobject.cpp 3 |
1248 | |
1249 | The qobject_cast() function behaves similarly to the standard C++ |
1250 | \c dynamic_cast(), with the advantages that it doesn't require |
1251 | RTTI support and it works across dynamic library boundaries. |
1252 | |
1253 | qobject_cast() can also be used in conjunction with interfaces. |
1254 | |
1255 | \warning If T isn't declared with the Q_OBJECT macro, this |
1256 | function's return value is undefined. |
1257 | |
1258 | \sa QObject::inherits() |
1259 | */ |
1260 | |
1261 | /*! |
1262 | \fn bool QObject::inherits(const char *className) const |
1263 | |
1264 | Returns \c true if this object is an instance of a class that |
1265 | inherits \a className or a QObject subclass that inherits \a |
1266 | className; otherwise returns \c false. |
1267 | |
1268 | A class is considered to inherit itself. |
1269 | |
1270 | Example: |
1271 | |
1272 | \snippet code/src_corelib_kernel_qobject.cpp 4 |
1273 | |
1274 | If you need to determine whether an object is an instance of a particular |
1275 | class for the purpose of casting it, consider using qobject_cast<Type *>(object) |
1276 | instead. |
1277 | |
1278 | \sa metaObject(), qobject_cast() |
1279 | */ |
1280 | |
1281 | /*! |
1282 | \property QObject::objectName |
1283 | |
1284 | \brief the name of this object |
1285 | |
1286 | You can find an object by name (and type) using findChild(). |
1287 | You can find a set of objects with findChildren(). |
1288 | |
1289 | \snippet code/src_corelib_kernel_qobject.cpp 5 |
1290 | |
1291 | By default, this property contains an empty string. |
1292 | |
1293 | \sa metaObject(), QMetaObject::className() |
1294 | */ |
1295 | |
1296 | QString QObject::objectName() const |
1297 | { |
1298 | Q_D(const QObject); |
1299 | #if QT_CONFIG(thread) |
1300 | if (QThread::currentThreadId() != d->threadData.loadRelaxed()->threadId.loadRelaxed()) // Unsafe code path |
1301 | return d->extraData ? d->extraData->objectName.valueBypassingBindings() : QString(); |
1302 | #endif |
1303 | if (!d->extraData && QtPrivate::isAnyBindingEvaluating()) { |
1304 | QObjectPrivate *dd = const_cast<QObjectPrivate *>(d); |
1305 | // extraData is mutable, so this should be safe |
1306 | dd->extraData = new QObjectPrivate::ExtraData(dd); |
1307 | } |
1308 | return d->extraData ? d->extraData->objectName : QString(); |
1309 | } |
1310 | |
1311 | /*! |
1312 | \fn void QObject::setObjectName(const QString &name) |
1313 | Sets the object's name to \a name. |
1314 | */ |
1315 | void QObject::doSetObjectName(const QString &name) |
1316 | { |
1317 | Q_D(QObject); |
1318 | |
1319 | d->ensureExtraData(); |
1320 | |
1321 | d->extraData->objectName.removeBindingUnlessInWrapper(); |
1322 | |
1323 | if (d->extraData->objectName.valueBypassingBindings() != name) { |
1324 | d->extraData->objectName.setValueBypassingBindings(name); |
1325 | d->extraData->objectName.notify(); // also emits a signal |
1326 | } |
1327 | } |
1328 | |
1329 | /*! |
1330 | \overload |
1331 | \since 6.4 |
1332 | */ |
1333 | void QObject::setObjectName(QAnyStringView name) |
1334 | { |
1335 | Q_D(QObject); |
1336 | |
1337 | d->ensureExtraData(); |
1338 | |
1339 | d->extraData->objectName.removeBindingUnlessInWrapper(); |
1340 | |
1341 | if (d->extraData->objectName.valueBypassingBindings() != name) { |
1342 | d->extraData->objectName.setValueBypassingBindings(name.toString()); |
1343 | d->extraData->objectName.notify(); // also emits a signal |
1344 | } |
1345 | } |
1346 | |
1347 | QBindable<QString> QObject::bindableObjectName() |
1348 | { |
1349 | Q_D(QObject); |
1350 | |
1351 | d->ensureExtraData(); |
1352 | |
1353 | return QBindable<QString>(&d->extraData->objectName); |
1354 | } |
1355 | |
1356 | /*! \fn void QObject::objectNameChanged(const QString &objectName) |
1357 | |
1358 | This signal is emitted after the object's name has been changed. The new object name is passed as \a objectName. |
1359 | |
1360 | \sa QObject::objectName |
1361 | */ |
1362 | |
1363 | /*! |
1364 | \fn bool QObject::isWidgetType() const |
1365 | |
1366 | Returns \c true if the object is a widget; otherwise returns \c false. |
1367 | |
1368 | Calling this function is equivalent to calling |
1369 | \c{inherits("QWidget")}, except that it is much faster. |
1370 | */ |
1371 | |
1372 | /*! |
1373 | \fn bool QObject::isWindowType() const |
1374 | |
1375 | Returns \c true if the object is a window; otherwise returns \c false. |
1376 | |
1377 | Calling this function is equivalent to calling |
1378 | \c{inherits("QWindow")}, except that it is much faster. |
1379 | */ |
1380 | |
1381 | /*! |
1382 | \fn bool QObject::isQuickItemType() const |
1383 | |
1384 | Returns \c true if the object is a QQuickItem; otherwise returns \c false. |
1385 | |
1386 | Calling this function is equivalent to calling |
1387 | \c{inherits("QQuickItem")}, except that it is much faster. |
1388 | |
1389 | \since 6.4 |
1390 | */ |
1391 | |
1392 | /*! |
1393 | This virtual function receives events to an object and should |
1394 | return true if the event \a e was recognized and processed. |
1395 | |
1396 | The event() function can be reimplemented to customize the |
1397 | behavior of an object. |
1398 | |
1399 | Make sure you call the parent event class implementation |
1400 | for all the events you did not handle. |
1401 | |
1402 | Example: |
1403 | |
1404 | \snippet code/src_corelib_kernel_qobject.cpp 52 |
1405 | |
1406 | \sa installEventFilter(), timerEvent(), QCoreApplication::sendEvent(), |
1407 | QCoreApplication::postEvent() |
1408 | */ |
1409 | |
1410 | bool QObject::event(QEvent *e) |
1411 | { |
1412 | switch (e->type()) { |
1413 | case QEvent::Timer: |
1414 | timerEvent(event: (QTimerEvent *)e); |
1415 | break; |
1416 | |
1417 | case QEvent::ChildAdded: |
1418 | case QEvent::ChildPolished: |
1419 | case QEvent::ChildRemoved: |
1420 | childEvent(event: (QChildEvent *)e); |
1421 | break; |
1422 | |
1423 | case QEvent::DeferredDelete: |
1424 | qDeleteInEventHandler(o: this); |
1425 | break; |
1426 | |
1427 | case QEvent::MetaCall: |
1428 | { |
1429 | QAbstractMetaCallEvent *mce = static_cast<QAbstractMetaCallEvent*>(e); |
1430 | |
1431 | if (!d_func()->connections.loadRelaxed()) { |
1432 | QMutexLocker locker(signalSlotLock(o: this)); |
1433 | d_func()->ensureConnectionData(); |
1434 | } |
1435 | QObjectPrivate::Sender sender(this, const_cast<QObject*>(mce->sender()), mce->signalId()); |
1436 | |
1437 | mce->placeMetaCall(object: this); |
1438 | break; |
1439 | } |
1440 | |
1441 | case QEvent::ThreadChange: { |
1442 | Q_D(QObject); |
1443 | QThreadData *threadData = d->threadData.loadRelaxed(); |
1444 | QAbstractEventDispatcher *eventDispatcher = threadData->eventDispatcher.loadRelaxed(); |
1445 | if (eventDispatcher) { |
1446 | QList<QAbstractEventDispatcher::TimerInfo> timers = eventDispatcher->registeredTimers(object: this); |
1447 | if (!timers.isEmpty()) { |
1448 | // do not to release our timer ids back to the pool (since the timer ids are moving to a new thread). |
1449 | eventDispatcher->unregisterTimers(object: this); |
1450 | QMetaObject::invokeMethod(obj: this, member: "_q_reregisterTimers" , c: Qt::QueuedConnection, |
1451 | Q_ARG(void*, (new QList<QAbstractEventDispatcher::TimerInfo>(timers)))); |
1452 | } |
1453 | } |
1454 | break; |
1455 | } |
1456 | |
1457 | default: |
1458 | if (e->type() >= QEvent::User) { |
1459 | customEvent(event: e); |
1460 | break; |
1461 | } |
1462 | return false; |
1463 | } |
1464 | return true; |
1465 | } |
1466 | |
1467 | /*! |
1468 | \fn void QObject::timerEvent(QTimerEvent *event) |
1469 | |
1470 | This event handler can be reimplemented in a subclass to receive |
1471 | timer events for the object. |
1472 | |
1473 | QTimer provides a higher-level interface to the timer |
1474 | functionality, and also more general information about timers. The |
1475 | timer event is passed in the \a event parameter. |
1476 | |
1477 | \sa startTimer(), killTimer(), event() |
1478 | */ |
1479 | |
1480 | void QObject::timerEvent(QTimerEvent *) |
1481 | { |
1482 | } |
1483 | |
1484 | |
1485 | /*! |
1486 | This event handler can be reimplemented in a subclass to receive |
1487 | child events. The event is passed in the \a event parameter. |
1488 | |
1489 | QEvent::ChildAdded and QEvent::ChildRemoved events are sent to |
1490 | objects when children are added or removed. In both cases you can |
1491 | only rely on the child being a QObject, or if isWidgetType() |
1492 | returns \c true, a QWidget. (This is because, in the |
1493 | \l{QEvent::ChildAdded}{ChildAdded} case, the child is not yet |
1494 | fully constructed, and in the \l{QEvent::ChildRemoved}{ChildRemoved} |
1495 | case it might have been destructed already). |
1496 | |
1497 | QEvent::ChildPolished events are sent to widgets when children |
1498 | are polished, or when polished children are added. If you receive |
1499 | a child polished event, the child's construction is usually |
1500 | completed. However, this is not guaranteed, and multiple polish |
1501 | events may be delivered during the execution of a widget's |
1502 | constructor. |
1503 | |
1504 | For every child widget, you receive one |
1505 | \l{QEvent::ChildAdded}{ChildAdded} event, zero or more |
1506 | \l{QEvent::ChildPolished}{ChildPolished} events, and one |
1507 | \l{QEvent::ChildRemoved}{ChildRemoved} event. |
1508 | |
1509 | The \l{QEvent::ChildPolished}{ChildPolished} event is omitted if |
1510 | a child is removed immediately after it is added. If a child is |
1511 | polished several times during construction and destruction, you |
1512 | may receive several child polished events for the same child, |
1513 | each time with a different virtual table. |
1514 | |
1515 | \sa event() |
1516 | */ |
1517 | |
1518 | void QObject::childEvent(QChildEvent * /* event */) |
1519 | { |
1520 | } |
1521 | |
1522 | |
1523 | /*! |
1524 | This event handler can be reimplemented in a subclass to receive |
1525 | custom events. Custom events are user-defined events with a type |
1526 | value at least as large as the QEvent::User item of the |
1527 | QEvent::Type enum, and is typically a QEvent subclass. The event |
1528 | is passed in the \a event parameter. |
1529 | |
1530 | \sa event(), QEvent |
1531 | */ |
1532 | void QObject::customEvent(QEvent * /* event */) |
1533 | { |
1534 | } |
1535 | |
1536 | |
1537 | |
1538 | /*! |
1539 | Filters events if this object has been installed as an event |
1540 | filter for the \a watched object. |
1541 | |
1542 | In your reimplementation of this function, if you want to filter |
1543 | the \a event out, i.e. stop it being handled further, return |
1544 | true; otherwise return false. |
1545 | |
1546 | Example: |
1547 | \snippet code/src_corelib_kernel_qobject.cpp 6 |
1548 | |
1549 | Notice in the example above that unhandled events are passed to |
1550 | the base class's eventFilter() function, since the base class |
1551 | might have reimplemented eventFilter() for its own internal |
1552 | purposes. |
1553 | |
1554 | Some events, such as \l QEvent::ShortcutOverride must be explicitly |
1555 | accepted (by calling \l {QEvent::}{accept()} on them) in order to prevent |
1556 | propagation. |
1557 | |
1558 | \warning If you delete the receiver object in this function, be |
1559 | sure to return true. Otherwise, Qt will forward the event to the |
1560 | deleted object and the program might crash. |
1561 | |
1562 | \sa installEventFilter() |
1563 | */ |
1564 | |
1565 | bool QObject::eventFilter(QObject * /* watched */, QEvent * /* event */) |
1566 | { |
1567 | return false; |
1568 | } |
1569 | |
1570 | /*! |
1571 | \fn bool QObject::signalsBlocked() const |
1572 | |
1573 | Returns \c true if signals are blocked; otherwise returns \c false. |
1574 | |
1575 | Signals are not blocked by default. |
1576 | |
1577 | \sa blockSignals(), QSignalBlocker |
1578 | */ |
1579 | |
1580 | /*! |
1581 | If \a block is true, signals emitted by this object are blocked |
1582 | (i.e., emitting a signal will not invoke anything connected to it). |
1583 | If \a block is false, no such blocking will occur. |
1584 | |
1585 | The return value is the previous value of signalsBlocked(). |
1586 | |
1587 | Note that the destroyed() signal will be emitted even if the signals |
1588 | for this object have been blocked. |
1589 | |
1590 | Signals emitted while being blocked are not buffered. |
1591 | |
1592 | \sa signalsBlocked(), QSignalBlocker |
1593 | */ |
1594 | |
1595 | bool QObject::blockSignals(bool block) noexcept |
1596 | { |
1597 | Q_D(QObject); |
1598 | bool previous = d->blockSig; |
1599 | d->blockSig = block; |
1600 | return previous; |
1601 | } |
1602 | |
1603 | /*! |
1604 | Returns the thread in which the object lives. |
1605 | |
1606 | \sa moveToThread() |
1607 | */ |
1608 | QThread *QObject::thread() const |
1609 | { |
1610 | return d_func()->threadData.loadRelaxed()->thread.loadAcquire(); |
1611 | } |
1612 | |
1613 | /*! |
1614 | Changes the thread affinity for this object and its children. The |
1615 | object cannot be moved if it has a parent. Event processing will |
1616 | continue in the \a targetThread. |
1617 | |
1618 | To move an object to the main thread, use QApplication::instance() |
1619 | to retrieve a pointer to the current application, and then use |
1620 | QApplication::thread() to retrieve the thread in which the |
1621 | application lives. For example: |
1622 | |
1623 | \snippet code/src_corelib_kernel_qobject.cpp 7 |
1624 | |
1625 | If \a targetThread is \nullptr, all event processing for this object |
1626 | and its children stops, as they are no longer associated with any |
1627 | thread. |
1628 | |
1629 | Note that all active timers for the object will be reset. The |
1630 | timers are first stopped in the current thread and restarted (with |
1631 | the same interval) in the \a targetThread. As a result, constantly |
1632 | moving an object between threads can postpone timer events |
1633 | indefinitely. |
1634 | |
1635 | A QEvent::ThreadChange event is sent to this object just before |
1636 | the thread affinity is changed. You can handle this event to |
1637 | perform any special processing. Note that any new events that are |
1638 | posted to this object will be handled in the \a targetThread, |
1639 | provided it is not \nullptr: when it is \nullptr, no event processing |
1640 | for this object or its children can happen, as they are no longer |
1641 | associated with any thread. |
1642 | |
1643 | \warning This function is \e not thread-safe; the current thread |
1644 | must be same as the current thread affinity. In other words, this |
1645 | function can only "push" an object from the current thread to |
1646 | another thread, it cannot "pull" an object from any arbitrary |
1647 | thread to the current thread. There is one exception to this rule |
1648 | however: objects with no thread affinity can be "pulled" to the |
1649 | current thread. |
1650 | |
1651 | \sa thread() |
1652 | */ |
1653 | void QObject::moveToThread(QThread *targetThread) |
1654 | { |
1655 | Q_D(QObject); |
1656 | |
1657 | if (d->threadData.loadRelaxed()->thread.loadAcquire() == targetThread) { |
1658 | // object is already in this thread |
1659 | return; |
1660 | } |
1661 | |
1662 | if (d->parent != nullptr) { |
1663 | qWarning(msg: "QObject::moveToThread: Cannot move objects with a parent" ); |
1664 | return; |
1665 | } |
1666 | if (d->isWidget) { |
1667 | qWarning(msg: "QObject::moveToThread: Widgets cannot be moved to a new thread" ); |
1668 | return; |
1669 | } |
1670 | if (!d->bindingStorage.isEmpty()) { |
1671 | qWarning(msg: "QObject::moveToThread: Can not move objects that contain bindings or are used in bindings to a new thread." ); |
1672 | return; |
1673 | } |
1674 | |
1675 | QThreadData *currentData = QThreadData::current(); |
1676 | QThreadData *targetData = targetThread ? QThreadData::get2(thread: targetThread) : nullptr; |
1677 | QThreadData *thisThreadData = d->threadData.loadAcquire(); |
1678 | if (!thisThreadData->thread.loadRelaxed() && currentData == targetData) { |
1679 | // one exception to the rule: we allow moving objects with no thread affinity to the current thread |
1680 | currentData = thisThreadData; |
1681 | } else if (thisThreadData != currentData) { |
1682 | qWarning(msg: "QObject::moveToThread: Current thread (%p) is not the object's thread (%p).\n" |
1683 | "Cannot move to target thread (%p)\n" , |
1684 | currentData->thread.loadRelaxed(), thisThreadData->thread.loadRelaxed(), targetData ? targetData->thread.loadRelaxed() : nullptr); |
1685 | |
1686 | #ifdef Q_OS_DARWIN |
1687 | qWarning("You might be loading two sets of Qt binaries into the same process. " |
1688 | "Check that all plugins are compiled against the right Qt binaries. Export " |
1689 | "DYLD_PRINT_LIBRARIES=1 and check that only one set of binaries are being loaded." ); |
1690 | #endif |
1691 | |
1692 | return; |
1693 | } |
1694 | |
1695 | // prepare to move |
1696 | d->moveToThread_helper(); |
1697 | |
1698 | if (!targetData) |
1699 | targetData = new QThreadData(0); |
1700 | |
1701 | // make sure nobody adds/removes connections to this object while we're moving it |
1702 | QMutexLocker l(signalSlotLock(o: this)); |
1703 | |
1704 | QOrderedMutexLocker locker(¤tData->postEventList.mutex, |
1705 | &targetData->postEventList.mutex); |
1706 | |
1707 | // keep currentData alive (since we've got it locked) |
1708 | currentData->ref(); |
1709 | |
1710 | // move the object |
1711 | auto threadPrivate = targetThread |
1712 | ? static_cast<QThreadPrivate *>(QThreadPrivate::get(o: targetThread)) |
1713 | : nullptr; |
1714 | QBindingStatus *bindingStatus = threadPrivate |
1715 | ? threadPrivate->bindingStatus() |
1716 | : nullptr; |
1717 | if (threadPrivate && !bindingStatus) { |
1718 | bindingStatus = threadPrivate->addObjectWithPendingBindingStatusChange(obj: this); |
1719 | } |
1720 | d_func()->setThreadData_helper(currentData, targetData, status: bindingStatus); |
1721 | |
1722 | locker.unlock(); |
1723 | |
1724 | // now currentData can commit suicide if it wants to |
1725 | currentData->deref(); |
1726 | } |
1727 | |
1728 | void QObjectPrivate::moveToThread_helper() |
1729 | { |
1730 | Q_Q(QObject); |
1731 | QEvent e(QEvent::ThreadChange); |
1732 | QCoreApplication::sendEvent(receiver: q, event: &e); |
1733 | bindingStorage.clear(); |
1734 | for (int i = 0; i < children.size(); ++i) { |
1735 | QObject *child = children.at(i); |
1736 | child->d_func()->moveToThread_helper(); |
1737 | } |
1738 | } |
1739 | |
1740 | void QObjectPrivate::setThreadData_helper(QThreadData *currentData, QThreadData *targetData, QBindingStatus *status) |
1741 | { |
1742 | Q_Q(QObject); |
1743 | |
1744 | if (status) { |
1745 | // the new thread is already running |
1746 | this->bindingStorage.bindingStatus = status; |
1747 | } |
1748 | |
1749 | // move posted events |
1750 | int eventsMoved = 0; |
1751 | for (int i = 0; i < currentData->postEventList.size(); ++i) { |
1752 | const QPostEvent &pe = currentData->postEventList.at(i); |
1753 | if (!pe.event) |
1754 | continue; |
1755 | if (pe.receiver == q) { |
1756 | // move this post event to the targetList |
1757 | targetData->postEventList.addEvent(ev: pe); |
1758 | const_cast<QPostEvent &>(pe).event = nullptr; |
1759 | ++eventsMoved; |
1760 | } |
1761 | } |
1762 | if (eventsMoved > 0 && targetData->hasEventDispatcher()) { |
1763 | targetData->canWait = false; |
1764 | targetData->eventDispatcher.loadRelaxed()->wakeUp(); |
1765 | } |
1766 | |
1767 | // the current emitting thread shouldn't restore currentSender after calling moveToThread() |
1768 | ConnectionData *cd = connections.loadRelaxed(); |
1769 | if (cd) { |
1770 | if (cd->currentSender) { |
1771 | cd->currentSender->receiverDeleted(); |
1772 | cd->currentSender = nullptr; |
1773 | } |
1774 | |
1775 | // adjust the receiverThreadId values in the Connections |
1776 | if (cd) { |
1777 | auto *c = cd->senders; |
1778 | while (c) { |
1779 | QObject *r = c->receiver.loadRelaxed(); |
1780 | if (r) { |
1781 | Q_ASSERT(r == q); |
1782 | targetData->ref(); |
1783 | QThreadData *old = c->receiverThreadData.loadRelaxed(); |
1784 | if (old) |
1785 | old->deref(); |
1786 | c->receiverThreadData.storeRelaxed(newValue: targetData); |
1787 | } |
1788 | c = c->next; |
1789 | } |
1790 | } |
1791 | |
1792 | } |
1793 | |
1794 | // set new thread data |
1795 | targetData->ref(); |
1796 | threadData.loadRelaxed()->deref(); |
1797 | |
1798 | // synchronizes with loadAcquire e.g. in QCoreApplication::postEvent |
1799 | threadData.storeRelease(newValue: targetData); |
1800 | |
1801 | for (int i = 0; i < children.size(); ++i) { |
1802 | QObject *child = children.at(i); |
1803 | child->d_func()->setThreadData_helper(currentData, targetData, status); |
1804 | } |
1805 | } |
1806 | |
1807 | void QObjectPrivate::_q_reregisterTimers(void *pointer) |
1808 | { |
1809 | Q_Q(QObject); |
1810 | QList<QAbstractEventDispatcher::TimerInfo> *timerList = reinterpret_cast<QList<QAbstractEventDispatcher::TimerInfo> *>(pointer); |
1811 | QAbstractEventDispatcher *eventDispatcher = threadData.loadRelaxed()->eventDispatcher.loadRelaxed(); |
1812 | for (int i = 0; i < timerList->size(); ++i) { |
1813 | const QAbstractEventDispatcher::TimerInfo &ti = timerList->at(i); |
1814 | eventDispatcher->registerTimer(timerId: ti.timerId, interval: ti.interval, timerType: ti.timerType, object: q); |
1815 | } |
1816 | delete timerList; |
1817 | } |
1818 | |
1819 | |
1820 | // |
1821 | // The timer flag hasTimer is set when startTimer is called. |
1822 | // It is not reset when killing the timer because more than |
1823 | // one timer might be active. |
1824 | // |
1825 | |
1826 | /*! |
1827 | \fn int QObject::startTimer(int interval, Qt::TimerType timerType) |
1828 | |
1829 | This is an overloaded function that will start a timer of type |
1830 | \a timerType and a timeout of \a interval milliseconds. This is |
1831 | equivalent to calling: |
1832 | \code |
1833 | startTimer(std::chrono::milliseconds{interval}, timerType); |
1834 | \endcode |
1835 | |
1836 | \sa timerEvent(), killTimer(), QTimer::singleShot() |
1837 | */ |
1838 | |
1839 | int QObject::startTimer(int interval, Qt::TimerType timerType) |
1840 | { |
1841 | return startTimer(time: std::chrono::milliseconds{interval}, timerType); |
1842 | } |
1843 | |
1844 | /*! |
1845 | \since 5.9 |
1846 | \overload |
1847 | \fn int QObject::startTimer(std::chrono::milliseconds interval, Qt::TimerType timerType) |
1848 | |
1849 | Starts a timer and returns a timer identifier, or returns zero if |
1850 | it could not start a timer. |
1851 | |
1852 | A timer event will occur every \a interval until killTimer() |
1853 | is called. If \a interval is equal to \c{std::chrono::duration::zero()}, |
1854 | then the timer event occurs once every time there are no more window |
1855 | system events to process. |
1856 | |
1857 | The virtual timerEvent() function is called with the QTimerEvent |
1858 | event parameter class when a timer event occurs. Reimplement this |
1859 | function to get timer events. |
1860 | |
1861 | If multiple timers are running, the QTimerEvent::timerId() can be |
1862 | used to find out which timer was activated. |
1863 | |
1864 | Example: |
1865 | |
1866 | \snippet code/src_corelib_kernel_qobject.cpp 8 |
1867 | |
1868 | Note that QTimer's accuracy depends on the underlying operating system and |
1869 | hardware. The \a timerType argument allows you to customize the accuracy of |
1870 | the timer. See Qt::TimerType for information on the different timer types. |
1871 | Most platforms support an accuracy of 20 milliseconds; some provide more. |
1872 | If Qt is unable to deliver the requested number of timer events, it will |
1873 | silently discard some. |
1874 | |
1875 | The QTimer class provides a high-level programming interface with |
1876 | single-shot timers and timer signals instead of events. There is |
1877 | also a QBasicTimer class that is more lightweight than QTimer and |
1878 | less clumsy than using timer IDs directly. |
1879 | |
1880 | \sa timerEvent(), killTimer(), QTimer::singleShot() |
1881 | */ |
1882 | int QObject::startTimer(std::chrono::milliseconds interval, Qt::TimerType timerType) |
1883 | { |
1884 | Q_D(QObject); |
1885 | |
1886 | using namespace std::chrono_literals; |
1887 | |
1888 | if (Q_UNLIKELY(interval < 0ms)) { |
1889 | qWarning(msg: "QObject::startTimer: Timers cannot have negative intervals" ); |
1890 | return 0; |
1891 | } |
1892 | |
1893 | auto thisThreadData = d->threadData.loadRelaxed(); |
1894 | if (Q_UNLIKELY(!thisThreadData->hasEventDispatcher())) { |
1895 | qWarning(msg: "QObject::startTimer: Timers can only be used with threads started with QThread" ); |
1896 | return 0; |
1897 | } |
1898 | if (Q_UNLIKELY(thread() != QThread::currentThread())) { |
1899 | qWarning(msg: "QObject::startTimer: Timers cannot be started from another thread" ); |
1900 | return 0; |
1901 | } |
1902 | |
1903 | auto dispatcher = thisThreadData->eventDispatcher.loadRelaxed(); |
1904 | int timerId = dispatcher->registerTimer(interval: interval.count(), timerType, object: this); |
1905 | d->ensureExtraData(); |
1906 | d->extraData->runningTimers.append(t: timerId); |
1907 | return timerId; |
1908 | } |
1909 | |
1910 | /*! |
1911 | Kills the timer with timer identifier, \a id. |
1912 | |
1913 | The timer identifier is returned by startTimer() when a timer |
1914 | event is started. |
1915 | |
1916 | \sa timerEvent(), startTimer() |
1917 | */ |
1918 | |
1919 | void QObject::killTimer(int id) |
1920 | { |
1921 | Q_D(QObject); |
1922 | if (Q_UNLIKELY(thread() != QThread::currentThread())) { |
1923 | qWarning(msg: "QObject::killTimer: Timers cannot be stopped from another thread" ); |
1924 | return; |
1925 | } |
1926 | if (id) { |
1927 | int at = d->extraData ? d->extraData->runningTimers.indexOf(t: id) : -1; |
1928 | if (at == -1) { |
1929 | // timer isn't owned by this object |
1930 | qWarning(msg: "QObject::killTimer(): Error: timer id %d is not valid for object %p (%s, %ls), timer has not been killed" , |
1931 | id, |
1932 | this, |
1933 | metaObject()->className(), |
1934 | qUtf16Printable(objectName())); |
1935 | return; |
1936 | } |
1937 | |
1938 | auto thisThreadData = d->threadData.loadRelaxed(); |
1939 | if (thisThreadData->hasEventDispatcher()) |
1940 | thisThreadData->eventDispatcher.loadRelaxed()->unregisterTimer(timerId: id); |
1941 | |
1942 | d->extraData->runningTimers.remove(i: at); |
1943 | QAbstractEventDispatcherPrivate::releaseTimerId(id); |
1944 | } |
1945 | } |
1946 | |
1947 | |
1948 | /*! |
1949 | \fn QObject *QObject::parent() const |
1950 | |
1951 | Returns a pointer to the parent object. |
1952 | |
1953 | \sa children() |
1954 | */ |
1955 | |
1956 | /*! |
1957 | \fn const QObjectList &QObject::children() const |
1958 | |
1959 | Returns a list of child objects. |
1960 | The QObjectList class is defined in the \c{<QObject>} header |
1961 | file as the following: |
1962 | |
1963 | \quotefromfile kernel/qobject.h |
1964 | \skipto /typedef .*QObjectList/ |
1965 | \printuntil QObjectList |
1966 | |
1967 | The first child added is the \l{QList::first()}{first} object in |
1968 | the list and the last child added is the \l{QList::last()}{last} |
1969 | object in the list, i.e. new children are appended at the end. |
1970 | |
1971 | Note that the list order changes when QWidget children are |
1972 | \l{QWidget::raise()}{raised} or \l{QWidget::lower()}{lowered}. A |
1973 | widget that is raised becomes the last object in the list, and a |
1974 | widget that is lowered becomes the first object in the list. |
1975 | |
1976 | \sa findChild(), findChildren(), parent(), setParent() |
1977 | */ |
1978 | |
1979 | |
1980 | /*! |
1981 | \fn template<typename T> T *QObject::findChild(const QString &name, Qt::FindChildOptions options) const |
1982 | |
1983 | Returns the child of this object that can be cast into type T and |
1984 | that is called \a name, or \nullptr if there is no such object. |
1985 | Omitting the \a name argument causes all object names to be matched. |
1986 | The search is performed recursively, unless \a options specifies the |
1987 | option FindDirectChildrenOnly. |
1988 | |
1989 | If there is more than one child matching the search, the most |
1990 | direct ancestor is returned. If there are several direct |
1991 | ancestors, it is undefined which one will be returned. In that |
1992 | case, findChildren() should be used. |
1993 | |
1994 | This example returns a child \c{QPushButton} of \c{parentWidget} |
1995 | named \c{"button1"}, even if the button isn't a direct child of |
1996 | the parent: |
1997 | |
1998 | \snippet code/src_corelib_kernel_qobject.cpp 10 |
1999 | |
2000 | This example returns a \c{QListWidget} child of \c{parentWidget}: |
2001 | |
2002 | \snippet code/src_corelib_kernel_qobject.cpp 11 |
2003 | |
2004 | This example returns a child \c{QPushButton} of \c{parentWidget} |
2005 | (its direct parent) named \c{"button1"}: |
2006 | |
2007 | \snippet code/src_corelib_kernel_qobject.cpp 41 |
2008 | |
2009 | This example returns a \c{QListWidget} child of \c{parentWidget}, |
2010 | its direct parent: |
2011 | |
2012 | \snippet code/src_corelib_kernel_qobject.cpp 42 |
2013 | |
2014 | \sa findChildren() |
2015 | */ |
2016 | |
2017 | /*! |
2018 | \fn template<typename T> QList<T> QObject::findChildren(const QString &name, Qt::FindChildOptions options) const |
2019 | |
2020 | Returns all children of this object with the given \a name that can be |
2021 | cast to type T, or an empty list if there are no such objects. |
2022 | A null \a name argument causes all objects to be matched, an empty one |
2023 | only those whose objectName is empty. |
2024 | The search is performed recursively, unless \a options specifies the |
2025 | option FindDirectChildrenOnly. |
2026 | |
2027 | The following example shows how to find a list of child \c{QWidget}s of |
2028 | the specified \c{parentWidget} named \c{widgetname}: |
2029 | |
2030 | \snippet code/src_corelib_kernel_qobject.cpp 12 |
2031 | |
2032 | This example returns all \c{QPushButton}s that are children of \c{parentWidget}: |
2033 | |
2034 | \snippet code/src_corelib_kernel_qobject.cpp 13 |
2035 | |
2036 | This example returns all \c{QPushButton}s that are immediate children of \c{parentWidget}: |
2037 | |
2038 | \snippet code/src_corelib_kernel_qobject.cpp 43 |
2039 | |
2040 | \sa findChild() |
2041 | */ |
2042 | |
2043 | /*! |
2044 | \fn template<typename T> QList<T> QObject::findChildren(Qt::FindChildOptions options) const |
2045 | \overload |
2046 | \since 6.3 |
2047 | |
2048 | Returns all children of this object that can be cast to type T, or |
2049 | an empty list if there are no such objects. |
2050 | The search is performed recursively, unless \a options specifies the |
2051 | option FindDirectChildrenOnly. |
2052 | |
2053 | \sa findChild() |
2054 | */ |
2055 | |
2056 | /*! |
2057 | \fn QList<T> QObject::findChildren(const QRegularExpression &re, Qt::FindChildOptions options) const |
2058 | \overload findChildren() |
2059 | |
2060 | \since 5.0 |
2061 | |
2062 | Returns the children of this object that can be cast to type T |
2063 | and that have names matching the regular expression \a re, |
2064 | or an empty list if there are no such objects. |
2065 | The search is performed recursively, unless \a options specifies the |
2066 | option FindDirectChildrenOnly. |
2067 | */ |
2068 | |
2069 | /*! |
2070 | \fn template<typename T> T qFindChild(const QObject *obj, const QString &name) |
2071 | \relates QObject |
2072 | \overload qFindChildren() |
2073 | \deprecated |
2074 | |
2075 | This function is equivalent to |
2076 | \a{obj}->\l{QObject::findChild()}{findChild}<T>(\a name). |
2077 | |
2078 | \note This function was provided as a workaround for MSVC 6 |
2079 | which did not support member template functions. It is advised |
2080 | to use the other form in new code. |
2081 | |
2082 | \sa QObject::findChild() |
2083 | */ |
2084 | |
2085 | /*! |
2086 | \fn template<typename T> QList<T> qFindChildren(const QObject *obj, const QString &name) |
2087 | \relates QObject |
2088 | \overload qFindChildren() |
2089 | \deprecated |
2090 | |
2091 | This function is equivalent to |
2092 | \a{obj}->\l{QObject::findChildren()}{findChildren}<T>(\a name). |
2093 | |
2094 | \note This function was provided as a workaround for MSVC 6 |
2095 | which did not support member template functions. It is advised |
2096 | to use the other form in new code. |
2097 | |
2098 | \sa QObject::findChildren() |
2099 | */ |
2100 | |
2101 | static void qt_qFindChildren_with_name(const QObject *parent, const QString &name, |
2102 | const QMetaObject &mo, QList<void *> *list, |
2103 | Qt::FindChildOptions options) |
2104 | { |
2105 | Q_ASSERT(parent); |
2106 | Q_ASSERT(list); |
2107 | Q_ASSERT(!name.isNull()); |
2108 | for (QObject *obj : parent->children()) { |
2109 | if (mo.cast(obj) && obj->objectName() == name) |
2110 | list->append(t: obj); |
2111 | if (options & Qt::FindChildrenRecursively) |
2112 | qt_qFindChildren_with_name(parent: obj, name, mo, list, options); |
2113 | } |
2114 | } |
2115 | |
2116 | /*! |
2117 | \internal |
2118 | */ |
2119 | void qt_qFindChildren_helper(const QObject *parent, const QString &name, |
2120 | const QMetaObject &mo, QList<void*> *list, Qt::FindChildOptions options) |
2121 | { |
2122 | if (name.isNull()) |
2123 | return qt_qFindChildren_helper(parent, mo, list, options); |
2124 | else |
2125 | return qt_qFindChildren_with_name(parent, name, mo, list, options); |
2126 | } |
2127 | |
2128 | /*! |
2129 | \internal |
2130 | */ |
2131 | void qt_qFindChildren_helper(const QObject *parent, const QMetaObject &mo, |
2132 | QList<void*> *list, Qt::FindChildOptions options) |
2133 | { |
2134 | Q_ASSERT(parent); |
2135 | Q_ASSERT(list); |
2136 | for (QObject *obj : parent->children()) { |
2137 | if (mo.cast(obj)) |
2138 | list->append(t: obj); |
2139 | if (options & Qt::FindChildrenRecursively) |
2140 | qt_qFindChildren_helper(parent: obj, mo, list, options); |
2141 | } |
2142 | } |
2143 | |
2144 | #if QT_CONFIG(regularexpression) |
2145 | /*! |
2146 | \internal |
2147 | */ |
2148 | void qt_qFindChildren_helper(const QObject *parent, const QRegularExpression &re, |
2149 | const QMetaObject &mo, QList<void*> *list, Qt::FindChildOptions options) |
2150 | { |
2151 | Q_ASSERT(parent); |
2152 | Q_ASSERT(list); |
2153 | for (QObject *obj : parent->children()) { |
2154 | if (mo.cast(obj)) { |
2155 | QRegularExpressionMatch m = re.match(subject: obj->objectName()); |
2156 | if (m.hasMatch()) |
2157 | list->append(t: obj); |
2158 | } |
2159 | if (options & Qt::FindChildrenRecursively) |
2160 | qt_qFindChildren_helper(parent: obj, re, mo, list, options); |
2161 | } |
2162 | } |
2163 | #endif // QT_CONFIG(regularexpression) |
2164 | |
2165 | /*! |
2166 | \internal |
2167 | */ |
2168 | QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo, Qt::FindChildOptions options) |
2169 | { |
2170 | Q_ASSERT(parent); |
2171 | for (QObject *obj : parent->children()) { |
2172 | if (mo.cast(obj) && (name.isNull() || obj->objectName() == name)) |
2173 | return obj; |
2174 | } |
2175 | if (options & Qt::FindChildrenRecursively) { |
2176 | for (QObject *child : parent->children()) { |
2177 | if (QObject *obj = qt_qFindChild_helper(parent: child, name, mo, options)) |
2178 | return obj; |
2179 | } |
2180 | } |
2181 | return nullptr; |
2182 | } |
2183 | |
2184 | /*! |
2185 | Makes the object a child of \a parent. |
2186 | |
2187 | \sa parent(), children() |
2188 | */ |
2189 | void QObject::setParent(QObject *parent) |
2190 | { |
2191 | Q_D(QObject); |
2192 | Q_ASSERT(!d->isWidget); |
2193 | d->setParent_helper(parent); |
2194 | } |
2195 | |
2196 | void QObjectPrivate::deleteChildren() |
2197 | { |
2198 | Q_ASSERT_X(!isDeletingChildren, "QObjectPrivate::deleteChildren()" , "isDeletingChildren already set, did this function recurse?" ); |
2199 | isDeletingChildren = true; |
2200 | // delete children objects |
2201 | // don't use qDeleteAll as the destructor of the child might |
2202 | // delete siblings |
2203 | for (int i = 0; i < children.size(); ++i) { |
2204 | currentChildBeingDeleted = children.at(i); |
2205 | children[i] = nullptr; |
2206 | delete currentChildBeingDeleted; |
2207 | } |
2208 | children.clear(); |
2209 | currentChildBeingDeleted = nullptr; |
2210 | isDeletingChildren = false; |
2211 | } |
2212 | |
2213 | void QObjectPrivate::setParent_helper(QObject *o) |
2214 | { |
2215 | Q_Q(QObject); |
2216 | Q_ASSERT_X(q != o, Q_FUNC_INFO, "Cannot parent a QObject to itself" ); |
2217 | #ifdef QT_DEBUG |
2218 | const auto checkForParentChildLoops = qScopeGuard(f: [&](){ |
2219 | int depth = 0; |
2220 | auto p = parent; |
2221 | while (p) { |
2222 | if (++depth == CheckForParentChildLoopsWarnDepth) { |
2223 | qWarning(msg: "QObject %p (class: '%s', object name: '%s') may have a loop in its parent-child chain; " |
2224 | "this is undefined behavior" , |
2225 | q, q->metaObject()->className(), qPrintable(q->objectName())); |
2226 | } |
2227 | p = p->parent(); |
2228 | } |
2229 | }); |
2230 | #endif |
2231 | |
2232 | if (o == parent) |
2233 | return; |
2234 | |
2235 | if (parent) { |
2236 | QObjectPrivate *parentD = parent->d_func(); |
2237 | if (parentD->isDeletingChildren && wasDeleted |
2238 | && parentD->currentChildBeingDeleted == q) { |
2239 | // don't do anything since QObjectPrivate::deleteChildren() already |
2240 | // cleared our entry in parentD->children. |
2241 | } else { |
2242 | const int index = parentD->children.indexOf(t: q); |
2243 | if (index < 0) { |
2244 | // we're probably recursing into setParent() from a ChildRemoved event, don't do anything |
2245 | } else if (parentD->isDeletingChildren) { |
2246 | parentD->children[index] = nullptr; |
2247 | } else { |
2248 | parentD->children.removeAt(i: index); |
2249 | if (sendChildEvents && parentD->receiveChildEvents) { |
2250 | QChildEvent e(QEvent::ChildRemoved, q); |
2251 | QCoreApplication::sendEvent(receiver: parent, event: &e); |
2252 | } |
2253 | } |
2254 | } |
2255 | } |
2256 | parent = o; |
2257 | if (parent) { |
2258 | // object hierarchies are constrained to a single thread |
2259 | if (threadData.loadRelaxed() != parent->d_func()->threadData.loadRelaxed()) { |
2260 | qWarning(msg: "QObject::setParent: Cannot set parent, new parent is in a different thread" ); |
2261 | parent = nullptr; |
2262 | return; |
2263 | } |
2264 | parent->d_func()->children.append(t: q); |
2265 | if (sendChildEvents && parent->d_func()->receiveChildEvents) { |
2266 | if (!isWidget) { |
2267 | QChildEvent e(QEvent::ChildAdded, q); |
2268 | QCoreApplication::sendEvent(receiver: parent, event: &e); |
2269 | } |
2270 | } |
2271 | } |
2272 | } |
2273 | |
2274 | /*! |
2275 | \fn void QObject::installEventFilter(QObject *filterObj) |
2276 | |
2277 | Installs an event filter \a filterObj on this object. For example: |
2278 | \snippet code/src_corelib_kernel_qobject.cpp 14 |
2279 | |
2280 | An event filter is an object that receives all events that are |
2281 | sent to this object. The filter can either stop the event or |
2282 | forward it to this object. The event filter \a filterObj receives |
2283 | events via its eventFilter() function. The eventFilter() function |
2284 | must return true if the event should be filtered, (i.e. stopped); |
2285 | otherwise it must return false. |
2286 | |
2287 | If multiple event filters are installed on a single object, the |
2288 | filter that was installed last is activated first. |
2289 | |
2290 | Here's a \c KeyPressEater class that eats the key presses of its |
2291 | monitored objects: |
2292 | |
2293 | \snippet code/src_corelib_kernel_qobject.cpp 15 |
2294 | |
2295 | And here's how to install it on two widgets: |
2296 | |
2297 | \snippet code/src_corelib_kernel_qobject.cpp 16 |
2298 | |
2299 | The QShortcut class, for example, uses this technique to intercept |
2300 | shortcut key presses. |
2301 | |
2302 | \warning If you delete the receiver object in your eventFilter() |
2303 | function, be sure to return true. If you return false, Qt sends |
2304 | the event to the deleted object and the program will crash. |
2305 | |
2306 | Note that the filtering object must be in the same thread as this |
2307 | object. If \a filterObj is in a different thread, this function does |
2308 | nothing. If either \a filterObj or this object are moved to a different |
2309 | thread after calling this function, the event filter will not be |
2310 | called until both objects have the same thread affinity again (it |
2311 | is \e not removed). |
2312 | |
2313 | \sa removeEventFilter(), eventFilter(), event() |
2314 | */ |
2315 | |
2316 | void QObject::installEventFilter(QObject *obj) |
2317 | { |
2318 | Q_D(QObject); |
2319 | if (!obj) |
2320 | return; |
2321 | if (d->threadData.loadRelaxed() != obj->d_func()->threadData.loadRelaxed()) { |
2322 | qWarning(msg: "QObject::installEventFilter(): Cannot filter events for objects in a different thread." ); |
2323 | return; |
2324 | } |
2325 | |
2326 | d->ensureExtraData(); |
2327 | |
2328 | // clean up unused items in the list |
2329 | d->extraData->eventFilters.removeAll(t: (QObject *)nullptr); |
2330 | d->extraData->eventFilters.removeAll(t: obj); |
2331 | d->extraData->eventFilters.prepend(t: obj); |
2332 | } |
2333 | |
2334 | /*! |
2335 | Removes an event filter object \a obj from this object. The |
2336 | request is ignored if such an event filter has not been installed. |
2337 | |
2338 | All event filters for this object are automatically removed when |
2339 | this object is destroyed. |
2340 | |
2341 | It is always safe to remove an event filter, even during event |
2342 | filter activation (i.e. from the eventFilter() function). |
2343 | |
2344 | \sa installEventFilter(), eventFilter(), event() |
2345 | */ |
2346 | |
2347 | void QObject::removeEventFilter(QObject *obj) |
2348 | { |
2349 | Q_D(QObject); |
2350 | if (d->extraData) { |
2351 | for (int i = 0; i < d->extraData->eventFilters.size(); ++i) { |
2352 | if (d->extraData->eventFilters.at(i) == obj) |
2353 | d->extraData->eventFilters[i] = nullptr; |
2354 | } |
2355 | } |
2356 | } |
2357 | |
2358 | /*! |
2359 | \fn void QObject::destroyed(QObject *obj) |
2360 | |
2361 | This signal is emitted immediately before the object \a obj is |
2362 | destroyed, after any instances of QPointer have been notified, |
2363 | and cannot be blocked. |
2364 | |
2365 | All the objects's children are destroyed immediately after this |
2366 | signal is emitted. |
2367 | |
2368 | \sa deleteLater(), QPointer |
2369 | */ |
2370 | |
2371 | /*! |
2372 | \threadsafe |
2373 | |
2374 | Schedules this object for deletion. |
2375 | |
2376 | The object will be deleted when control returns to the event |
2377 | loop. If the event loop is not running when this function is |
2378 | called (e.g. deleteLater() is called on an object before |
2379 | QCoreApplication::exec()), the object will be deleted once the |
2380 | event loop is started. If deleteLater() is called after the main event loop |
2381 | has stopped, the object will not be deleted. |
2382 | Since Qt 4.8, if deleteLater() is called on an object that lives in a |
2383 | thread with no running event loop, the object will be destroyed when the |
2384 | thread finishes. |
2385 | |
2386 | Note that entering and leaving a new event loop (e.g., by opening a modal |
2387 | dialog) will \e not perform the deferred deletion; for the object to be |
2388 | deleted, the control must return to the event loop from which deleteLater() |
2389 | was called. This does not apply to objects deleted while a previous, nested |
2390 | event loop was still running: the Qt event loop will delete those objects |
2391 | as soon as the new nested event loop starts. |
2392 | |
2393 | \note It is safe to call this function more than once; when the |
2394 | first deferred deletion event is delivered, any pending events for the |
2395 | object are removed from the event queue. |
2396 | |
2397 | \sa destroyed(), QPointer |
2398 | */ |
2399 | void QObject::deleteLater() |
2400 | { |
2401 | #ifdef QT_DEBUG |
2402 | if (qApp == this) |
2403 | qWarning(msg: "You are deferring the delete of QCoreApplication, this may not work as expected." ); |
2404 | #endif |
2405 | QCoreApplication::postEvent(receiver: this, event: new QDeferredDeleteEvent()); |
2406 | } |
2407 | |
2408 | /*! |
2409 | \fn QString QObject::tr(const char *sourceText, const char *disambiguation, int n) |
2410 | \reentrant |
2411 | |
2412 | Returns a translated version of \a sourceText, optionally based on a |
2413 | \a disambiguation string and value of \a n for strings containing plurals; |
2414 | otherwise returns QString::fromUtf8(\a sourceText) if no appropriate |
2415 | translated string is available. |
2416 | |
2417 | Example: |
2418 | \snippet ../widgets/itemviews/spreadsheet/spreadsheet.cpp implicit tr context |
2419 | \dots |
2420 | |
2421 | If the same \a sourceText is used in different roles within the |
2422 | same context, an additional identifying string may be passed in |
2423 | \a disambiguation (\nullptr by default). In Qt 4.4 and earlier, this was |
2424 | the preferred way to pass comments to translators. |
2425 | |
2426 | Example: |
2427 | |
2428 | \snippet code/src_corelib_kernel_qobject.cpp 17 |
2429 | \dots |
2430 | |
2431 | See \l{Writing Source Code for Translation} for a detailed description of |
2432 | Qt's translation mechanisms in general, and the |
2433 | \l{Writing Source Code for Translation#Disambiguate Identical Text} |
2434 | {Disambiguate Identical Text} section for information on disambiguation. |
2435 | |
2436 | \warning This method is reentrant only if all translators are |
2437 | installed \e before calling this method. Installing or removing |
2438 | translators while performing translations is not supported. Doing |
2439 | so will probably result in crashes or other undesirable behavior. |
2440 | |
2441 | \sa QCoreApplication::translate(), {Internationalization with Qt} |
2442 | */ |
2443 | |
2444 | /***************************************************************************** |
2445 | Signals and slots |
2446 | *****************************************************************************/ |
2447 | |
2448 | namespace { |
2449 | // This class provides (per-thread) storage for qFlagLocation() |
2450 | class FlaggedDebugSignatures |
2451 | { |
2452 | uint idx = 0; |
2453 | std::array<const char *, 2> locations = {}; // one for the SIGNAL, one for the SLOT |
2454 | |
2455 | public: |
2456 | void store(const char* method) noexcept |
2457 | { locations[idx++ % locations.size()] = method; } |
2458 | |
2459 | bool contains(const char *method) const noexcept |
2460 | { return std::find(first: locations.begin(), last: locations.end(), val: method) != locations.end(); } |
2461 | }; |
2462 | |
2463 | Q_CONSTINIT static thread_local FlaggedDebugSignatures flaggedSignatures = {}; |
2464 | } // unnamed namespace |
2465 | |
2466 | const char *qFlagLocation(const char *method) |
2467 | { |
2468 | flaggedSignatures.store(method); |
2469 | return method; |
2470 | } |
2471 | |
2472 | static int (const char *member) |
2473 | { |
2474 | // extract code, ensure QMETHOD_CODE <= code <= QSIGNAL_CODE |
2475 | return (((int)(*member) - '0') & 0x3); |
2476 | } |
2477 | |
2478 | static const char *(const char *member) |
2479 | { |
2480 | if (flaggedSignatures.contains(method: member)) { |
2481 | // signature includes location information after the first null-terminator |
2482 | const char *location = member + qstrlen(str: member) + 1; |
2483 | if (*location != '\0') |
2484 | return location; |
2485 | } |
2486 | return nullptr; |
2487 | } |
2488 | |
2489 | static bool check_signal_macro(const QObject *sender, const char *signal, |
2490 | const char *func, const char *op) |
2491 | { |
2492 | int sigcode = extract_code(member: signal); |
2493 | if (sigcode != QSIGNAL_CODE) { |
2494 | if (sigcode == QSLOT_CODE) |
2495 | qCWarning(lcConnect, "QObject::%s: Attempt to %s non-signal %s::%s" , func, op, |
2496 | sender->metaObject()->className(), signal + 1); |
2497 | else |
2498 | qCWarning(lcConnect, "QObject::%s: Use the SIGNAL macro to %s %s::%s" , func, op, |
2499 | sender->metaObject()->className(), signal); |
2500 | return false; |
2501 | } |
2502 | return true; |
2503 | } |
2504 | |
2505 | static bool check_method_code(int code, const QObject *object, const char *method, const char *func) |
2506 | { |
2507 | if (code != QSLOT_CODE && code != QSIGNAL_CODE) { |
2508 | qCWarning(lcConnect, |
2509 | "QObject::%s: Use the SLOT or SIGNAL macro to " |
2510 | "%s %s::%s" , |
2511 | func, func, object->metaObject()->className(), method); |
2512 | return false; |
2513 | } |
2514 | return true; |
2515 | } |
2516 | |
2517 | Q_DECL_COLD_FUNCTION |
2518 | static void err_method_notfound(const QObject *object, |
2519 | const char *method, const char *func) |
2520 | { |
2521 | const char *type = "method" ; |
2522 | switch (extract_code(member: method)) { |
2523 | case QSLOT_CODE: type = "slot" ; break; |
2524 | case QSIGNAL_CODE: type = "signal" ; break; |
2525 | } |
2526 | const char *loc = extract_location(member: method); |
2527 | if (strchr(s: method, c: ')') == nullptr) // common typing mistake |
2528 | qCWarning(lcConnect, "QObject::%s: Parentheses expected, %s %s::%s%s%s" , func, type, |
2529 | object->metaObject()->className(), method + 1, loc ? " in " : "" , loc ? loc : "" ); |
2530 | else |
2531 | qCWarning(lcConnect, "QObject::%s: No such %s %s::%s%s%s" , func, type, |
2532 | object->metaObject()->className(), method + 1, loc ? " in " : "" , loc ? loc : "" ); |
2533 | } |
2534 | |
2535 | Q_DECL_COLD_FUNCTION |
2536 | static void err_info_about_objects(const char *func, const QObject *sender, const QObject *receiver) |
2537 | { |
2538 | QString a = sender ? sender->objectName() : QString(); |
2539 | QString b = receiver ? receiver->objectName() : QString(); |
2540 | if (!a.isEmpty()) |
2541 | qCWarning(lcConnect, "QObject::%s: (sender name: '%s')" , func, a.toLocal8Bit().data()); |
2542 | if (!b.isEmpty()) |
2543 | qCWarning(lcConnect, "QObject::%s: (receiver name: '%s')" , func, b.toLocal8Bit().data()); |
2544 | } |
2545 | |
2546 | /*! |
2547 | Returns a pointer to the object that sent the signal, if called in |
2548 | a slot activated by a signal; otherwise it returns \nullptr. The pointer |
2549 | is valid only during the execution of the slot that calls this |
2550 | function from this object's thread context. |
2551 | |
2552 | The pointer returned by this function becomes invalid if the |
2553 | sender is destroyed, or if the slot is disconnected from the |
2554 | sender's signal. |
2555 | |
2556 | \warning This function violates the object-oriented principle of |
2557 | modularity. However, getting access to the sender might be useful |
2558 | when many signals are connected to a single slot. |
2559 | |
2560 | \warning As mentioned above, the return value of this function is |
2561 | not valid when the slot is called via a Qt::DirectConnection from |
2562 | a thread different from this object's thread. Do not use this |
2563 | function in this type of scenario. |
2564 | |
2565 | \sa senderSignalIndex() |
2566 | */ |
2567 | |
2568 | QObject *QObject::sender() const |
2569 | { |
2570 | Q_D(const QObject); |
2571 | |
2572 | QMutexLocker locker(signalSlotLock(o: this)); |
2573 | QObjectPrivate::ConnectionData *cd = d->connections.loadRelaxed(); |
2574 | if (!cd || !cd->currentSender) |
2575 | return nullptr; |
2576 | |
2577 | for (QObjectPrivate::Connection *c = cd->senders; c; c = c->next) { |
2578 | if (c->sender == cd->currentSender->sender) |
2579 | return cd->currentSender->sender; |
2580 | } |
2581 | |
2582 | return nullptr; |
2583 | } |
2584 | |
2585 | /*! |
2586 | \since 4.8 |
2587 | |
2588 | Returns the meta-method index of the signal that called the currently |
2589 | executing slot, which is a member of the class returned by sender(). |
2590 | If called outside of a slot activated by a signal, -1 is returned. |
2591 | |
2592 | For signals with default parameters, this function will always return |
2593 | the index with all parameters, regardless of which was used with |
2594 | connect(). For example, the signal \c {destroyed(QObject *obj = \nullptr)} |
2595 | will have two different indexes (with and without the parameter), but |
2596 | this function will always return the index with a parameter. This does |
2597 | not apply when overloading signals with different parameters. |
2598 | |
2599 | \warning This function violates the object-oriented principle of |
2600 | modularity. However, getting access to the signal index might be useful |
2601 | when many signals are connected to a single slot. |
2602 | |
2603 | \warning The return value of this function is not valid when the slot |
2604 | is called via a Qt::DirectConnection from a thread different from this |
2605 | object's thread. Do not use this function in this type of scenario. |
2606 | |
2607 | \sa sender(), QMetaObject::indexOfSignal(), QMetaObject::method() |
2608 | */ |
2609 | |
2610 | int QObject::senderSignalIndex() const |
2611 | { |
2612 | Q_D(const QObject); |
2613 | |
2614 | QMutexLocker locker(signalSlotLock(o: this)); |
2615 | QObjectPrivate::ConnectionData *cd = d->connections.loadRelaxed(); |
2616 | if (!cd || !cd->currentSender) |
2617 | return -1; |
2618 | |
2619 | for (QObjectPrivate::Connection *c = cd->senders; c; c = c->next) { |
2620 | if (c->sender == cd->currentSender->sender) { |
2621 | // Convert from signal range to method range |
2622 | return QMetaObjectPrivate::signal(m: c->sender->metaObject(), signal_index: cd->currentSender->signal).methodIndex(); |
2623 | } |
2624 | } |
2625 | |
2626 | return -1; |
2627 | } |
2628 | |
2629 | /*! |
2630 | Returns the number of receivers connected to the \a signal. |
2631 | |
2632 | Since both slots and signals can be used as receivers for signals, |
2633 | and the same connections can be made many times, the number of |
2634 | receivers is the same as the number of connections made from this |
2635 | signal. |
2636 | |
2637 | When calling this function, you can use the \c SIGNAL() macro to |
2638 | pass a specific signal: |
2639 | |
2640 | \snippet code/src_corelib_kernel_qobject.cpp 21 |
2641 | |
2642 | \warning This function violates the object-oriented principle of |
2643 | modularity. However, it might be useful when you need to perform |
2644 | expensive initialization only if something is connected to a |
2645 | signal. |
2646 | |
2647 | \sa isSignalConnected() |
2648 | */ |
2649 | |
2650 | int QObject::receivers(const char *signal) const |
2651 | { |
2652 | Q_D(const QObject); |
2653 | int receivers = 0; |
2654 | if (signal) { |
2655 | QByteArray signal_name = QMetaObject::normalizedSignature(method: signal); |
2656 | signal = signal_name; |
2657 | #ifndef QT_NO_DEBUG |
2658 | if (!check_signal_macro(sender: this, signal, func: "receivers" , op: "bind" )) |
2659 | return 0; |
2660 | #endif |
2661 | signal++; // skip code |
2662 | int signal_index = d->signalIndex(signalName: signal); |
2663 | if (signal_index < 0) { |
2664 | #ifndef QT_NO_DEBUG |
2665 | err_method_notfound(object: this, method: signal - 1, func: "receivers" ); |
2666 | #endif |
2667 | return 0; |
2668 | } |
2669 | |
2670 | if (!d->isSignalConnected(signalIndex: signal_index)) |
2671 | return receivers; |
2672 | |
2673 | if (!d->isDeletingChildren && d->declarativeData && QAbstractDeclarativeData::receivers) { |
2674 | receivers += QAbstractDeclarativeData::receivers(d->declarativeData, this, |
2675 | signal_index); |
2676 | } |
2677 | |
2678 | QObjectPrivate::ConnectionData *cd = d->connections.loadRelaxed(); |
2679 | QMutexLocker locker(signalSlotLock(o: this)); |
2680 | if (cd && signal_index < cd->signalVectorCount()) { |
2681 | const QObjectPrivate::Connection *c = cd->signalVector.loadRelaxed()->at(i: signal_index).first.loadRelaxed(); |
2682 | while (c) { |
2683 | receivers += c->receiver.loadRelaxed() ? 1 : 0; |
2684 | c = c->nextConnectionList.loadRelaxed(); |
2685 | } |
2686 | } |
2687 | } |
2688 | return receivers; |
2689 | } |
2690 | |
2691 | /*! |
2692 | \since 5.0 |
2693 | Returns \c true if the \a signal is connected to at least one receiver, |
2694 | otherwise returns \c false. |
2695 | |
2696 | \a signal must be a signal member of this object, otherwise the behaviour |
2697 | is undefined. |
2698 | |
2699 | \snippet code/src_corelib_kernel_qobject.cpp 49 |
2700 | |
2701 | As the code snippet above illustrates, you can use this function to avoid |
2702 | expensive initialization or emitting a signal that nobody listens to. |
2703 | However, in a multithreaded application, connections might change after |
2704 | this function returns and before the signal gets emitted. |
2705 | |
2706 | \warning This function violates the object-oriented principle of |
2707 | modularity. In particular, this function must not be called from an |
2708 | override of connectNotify() or disconnectNotify(), as those might get |
2709 | called from any thread. |
2710 | */ |
2711 | bool QObject::isSignalConnected(const QMetaMethod &signal) const |
2712 | { |
2713 | Q_D(const QObject); |
2714 | if (!signal.mobj) |
2715 | return false; |
2716 | |
2717 | Q_ASSERT_X(signal.mobj->cast(this) && signal.methodType() == QMetaMethod::Signal, |
2718 | "QObject::isSignalConnected" , "the parameter must be a signal member of the object" ); |
2719 | uint signalIndex = signal.relativeMethodIndex(); |
2720 | |
2721 | if (signal.data.flags() & MethodCloned) |
2722 | signalIndex = QMetaObjectPrivate::originalClone(obj: signal.mobj, local_method_index: signalIndex); |
2723 | |
2724 | signalIndex += QMetaObjectPrivate::signalOffset(m: signal.mobj); |
2725 | |
2726 | QMutexLocker locker(signalSlotLock(o: this)); |
2727 | return d->isSignalConnected(signalIndex, checkDeclarative: true); |
2728 | } |
2729 | |
2730 | /*! |
2731 | \internal |
2732 | |
2733 | This helper function calculates signal and method index for the given |
2734 | member in the specified class. |
2735 | |
2736 | \list |
2737 | \li If member.mobj is \nullptr then both signalIndex and methodIndex are set to -1. |
2738 | |
2739 | \li If specified member is not a member of obj instance class (or one of |
2740 | its parent classes) then both signalIndex and methodIndex are set to -1. |
2741 | \endlist |
2742 | |
2743 | This function is used by QObject::connect and QObject::disconnect which |
2744 | are working with QMetaMethod. |
2745 | |
2746 | \a signalIndex is set to the signal index of member. If the member |
2747 | specified is not signal this variable is set to -1. |
2748 | |
2749 | \a methodIndex is set to the method index of the member. If the |
2750 | member is not a method of the object specified by the \a obj argument this |
2751 | variable is set to -1. |
2752 | */ |
2753 | void QMetaObjectPrivate::memberIndexes(const QObject *obj, |
2754 | const QMetaMethod &member, |
2755 | int *signalIndex, int *methodIndex) |
2756 | { |
2757 | *signalIndex = -1; |
2758 | *methodIndex = -1; |
2759 | if (!obj || !member.mobj) |
2760 | return; |
2761 | const QMetaObject *m = obj->metaObject(); |
2762 | // Check that member is member of obj class |
2763 | while (m != nullptr && m != member.mobj) |
2764 | m = m->d.superdata; |
2765 | if (!m) |
2766 | return; |
2767 | *signalIndex = *methodIndex = member.relativeMethodIndex(); |
2768 | |
2769 | int signalOffset; |
2770 | int methodOffset; |
2771 | computeOffsets(metaobject: m, signalOffset: &signalOffset, methodOffset: &methodOffset); |
2772 | |
2773 | *methodIndex += methodOffset; |
2774 | if (member.methodType() == QMetaMethod::Signal) { |
2775 | *signalIndex = originalClone(obj: m, local_method_index: *signalIndex); |
2776 | *signalIndex += signalOffset; |
2777 | } else { |
2778 | *signalIndex = -1; |
2779 | } |
2780 | } |
2781 | |
2782 | #ifndef QT_NO_DEBUG |
2783 | static inline void check_and_warn_compat(const QMetaObject *sender, const QMetaMethod &signal, |
2784 | const QMetaObject *receiver, const QMetaMethod &method) |
2785 | { |
2786 | if (signal.attributes() & QMetaMethod::Compatibility) { |
2787 | if (!(method.attributes() & QMetaMethod::Compatibility)) |
2788 | qCWarning(lcConnect, "QObject::connect: Connecting from COMPAT signal (%s::%s)" , |
2789 | sender->className(), signal.methodSignature().constData()); |
2790 | } else if ((method.attributes() & QMetaMethod::Compatibility) |
2791 | && method.methodType() == QMetaMethod::Signal) { |
2792 | qCWarning(lcConnect, "QObject::connect: Connecting from %s::%s to COMPAT slot (%s::%s)" , |
2793 | sender->className(), signal.methodSignature().constData(), receiver->className(), |
2794 | method.methodSignature().constData()); |
2795 | } |
2796 | } |
2797 | #endif |
2798 | |
2799 | /*! |
2800 | \threadsafe |
2801 | |
2802 | Creates a connection of the given \a type from the \a signal in |
2803 | the \a sender object to the \a method in the \a receiver object. |
2804 | Returns a handle to the connection that can be used to disconnect |
2805 | it later. |
2806 | |
2807 | You must use the \c SIGNAL() and \c SLOT() macros when specifying |
2808 | the \a signal and the \a method, for example: |
2809 | |
2810 | \snippet code/src_corelib_kernel_qobject.cpp 22 |
2811 | |
2812 | This example ensures that the label always displays the current |
2813 | scroll bar value. Note that the signal and slots parameters must not |
2814 | contain any variable names, only the type. E.g. the following would |
2815 | not work and return false: |
2816 | |
2817 | \snippet code/src_corelib_kernel_qobject.cpp 23 |
2818 | |
2819 | A signal can also be connected to another signal: |
2820 | |
2821 | \snippet code/src_corelib_kernel_qobject.cpp 24 |
2822 | |
2823 | In this example, the \c MyWidget constructor relays a signal from |
2824 | a private member variable, and makes it available under a name |
2825 | that relates to \c MyWidget. |
2826 | |
2827 | A signal can be connected to many slots and signals. Many signals |
2828 | can be connected to one slot. |
2829 | |
2830 | If a signal is connected to several slots, the slots are activated |
2831 | in the same order in which the connections were made, when the |
2832 | signal is emitted. |
2833 | |
2834 | The function returns a QMetaObject::Connection that represents |
2835 | a handle to a connection if it successfully |
2836 | connects the signal to the slot. The connection handle will be invalid |
2837 | if it cannot create the connection, for example, if QObject is unable |
2838 | to verify the existence of either \a signal or \a method, or if their |
2839 | signatures aren't compatible. |
2840 | You can check if the handle is valid by casting it to a bool. |
2841 | |
2842 | By default, a signal is emitted for every connection you make; |
2843 | two signals are emitted for duplicate connections. You can break |
2844 | all of these connections with a single disconnect() call. |
2845 | If you pass the Qt::UniqueConnection \a type, the connection will only |
2846 | be made if it is not a duplicate. If there is already a duplicate |
2847 | (exact same signal to the exact same slot on the same objects), |
2848 | the connection will fail and connect will return an invalid QMetaObject::Connection. |
2849 | |
2850 | \note Qt::UniqueConnections do not work for lambdas, non-member functions |
2851 | and functors; they only apply to connecting to member functions. |
2852 | |
2853 | The optional \a type parameter describes the type of connection |
2854 | to establish. In particular, it determines whether a particular |
2855 | signal is delivered to a slot immediately or queued for delivery |
2856 | at a later time. If the signal is queued, the parameters must be |
2857 | of types that are known to Qt's meta-object system, because Qt |
2858 | needs to copy the arguments to store them in an event behind the |
2859 | scenes. If you try to use a queued connection and get the error |
2860 | message |
2861 | |
2862 | \snippet code/src_corelib_kernel_qobject.cpp 25 |
2863 | |
2864 | call qRegisterMetaType() to register the data type before you |
2865 | establish the connection. |
2866 | |
2867 | \sa disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE(), |
2868 | {Differences between String-Based and Functor-Based Connections} |
2869 | */ |
2870 | QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, |
2871 | const QObject *receiver, const char *method, |
2872 | Qt::ConnectionType type) |
2873 | { |
2874 | if (sender == nullptr || receiver == nullptr || signal == nullptr || method == nullptr) { |
2875 | qCWarning(lcConnect, "QObject::connect: Cannot connect %s::%s to %s::%s" , |
2876 | sender ? sender->metaObject()->className() : "(nullptr)" , |
2877 | (signal && *signal) ? signal + 1 : "(nullptr)" , |
2878 | receiver ? receiver->metaObject()->className() : "(nullptr)" , |
2879 | (method && *method) ? method + 1 : "(nullptr)" ); |
2880 | return QMetaObject::Connection(nullptr); |
2881 | } |
2882 | QByteArray tmp_signal_name; |
2883 | |
2884 | if (!check_signal_macro(sender, signal, func: "connect" , op: "bind" )) |
2885 | return QMetaObject::Connection(nullptr); |
2886 | const QMetaObject *smeta = sender->metaObject(); |
2887 | const char *signal_arg = signal; |
2888 | ++signal; // skip code |
2889 | QArgumentTypeArray signalTypes; |
2890 | Q_ASSERT(QMetaObjectPrivate::get(smeta)->revision >= 7); |
2891 | QByteArray signalName = QMetaObjectPrivate::decodeMethodSignature(signature: signal, types&: signalTypes); |
2892 | int signal_index = QMetaObjectPrivate::indexOfSignalRelative( |
2893 | baseObject: &smeta, name: signalName, argc: signalTypes.size(), types: signalTypes.constData()); |
2894 | if (signal_index < 0) { |
2895 | // check for normalized signatures |
2896 | tmp_signal_name = QMetaObject::normalizedSignature(method: signal - 1); |
2897 | signal = tmp_signal_name.constData() + 1; |
2898 | |
2899 | signalTypes.clear(); |
2900 | signalName = QMetaObjectPrivate::decodeMethodSignature(signature: signal, types&: signalTypes); |
2901 | smeta = sender->metaObject(); |
2902 | signal_index = QMetaObjectPrivate::indexOfSignalRelative( |
2903 | baseObject: &smeta, name: signalName, argc: signalTypes.size(), types: signalTypes.constData()); |
2904 | } |
2905 | if (signal_index < 0) { |
2906 | err_method_notfound(object: sender, method: signal_arg, func: "connect" ); |
2907 | err_info_about_objects(func: "connect" , sender, receiver); |
2908 | return QMetaObject::Connection(nullptr); |
2909 | } |
2910 | signal_index = QMetaObjectPrivate::originalClone(obj: smeta, local_method_index: signal_index); |
2911 | signal_index += QMetaObjectPrivate::signalOffset(m: smeta); |
2912 | |
2913 | QByteArray tmp_method_name; |
2914 | int membcode = extract_code(member: method); |
2915 | |
2916 | if (!check_method_code(code: membcode, object: receiver, method, func: "connect" )) |
2917 | return QMetaObject::Connection(nullptr); |
2918 | const char *method_arg = method; |
2919 | ++method; // skip code |
2920 | |
2921 | QArgumentTypeArray methodTypes; |
2922 | QByteArray methodName = QMetaObjectPrivate::decodeMethodSignature(signature: method, types&: methodTypes); |
2923 | const QMetaObject *rmeta = receiver->metaObject(); |
2924 | int method_index_relative = -1; |
2925 | Q_ASSERT(QMetaObjectPrivate::get(rmeta)->revision >= 7); |
2926 | switch (membcode) { |
2927 | case QSLOT_CODE: |
2928 | method_index_relative = QMetaObjectPrivate::indexOfSlotRelative( |
2929 | m: &rmeta, name: methodName, argc: methodTypes.size(), types: methodTypes.constData()); |
2930 | break; |
2931 | case QSIGNAL_CODE: |
2932 | method_index_relative = QMetaObjectPrivate::indexOfSignalRelative( |
2933 | baseObject: &rmeta, name: methodName, argc: methodTypes.size(), types: methodTypes.constData()); |
2934 | break; |
2935 | } |
2936 | if (method_index_relative < 0) { |
2937 | // check for normalized methods |
2938 | tmp_method_name = QMetaObject::normalizedSignature(method); |
2939 | method = tmp_method_name.constData(); |
2940 | |
2941 | methodTypes.clear(); |
2942 | methodName = QMetaObjectPrivate::decodeMethodSignature(signature: method, types&: methodTypes); |
2943 | // rmeta may have been modified above |
2944 | rmeta = receiver->metaObject(); |
2945 | switch (membcode) { |
2946 | case QSLOT_CODE: |
2947 | method_index_relative = QMetaObjectPrivate::indexOfSlotRelative( |
2948 | m: &rmeta, name: methodName, argc: methodTypes.size(), types: methodTypes.constData()); |
2949 | break; |
2950 | case QSIGNAL_CODE: |
2951 | method_index_relative = QMetaObjectPrivate::indexOfSignalRelative( |
2952 | baseObject: &rmeta, name: methodName, argc: methodTypes.size(), types: methodTypes.constData()); |
2953 | break; |
2954 | } |
2955 | } |
2956 | |
2957 | if (method_index_relative < 0) { |
2958 | err_method_notfound(object: receiver, method: method_arg, func: "connect" ); |
2959 | err_info_about_objects(func: "connect" , sender, receiver); |
2960 | return QMetaObject::Connection(nullptr); |
2961 | } |
2962 | |
2963 | if (!QMetaObjectPrivate::checkConnectArgs(signalArgc: signalTypes.size(), signalTypes: signalTypes.constData(), |
2964 | methodArgc: methodTypes.size(), methodTypes: methodTypes.constData())) { |
2965 | qCWarning(lcConnect, |
2966 | "QObject::connect: Incompatible sender/receiver arguments" |
2967 | "\n %s::%s --> %s::%s" , |
2968 | sender->metaObject()->className(), signal, receiver->metaObject()->className(), |
2969 | method); |
2970 | return QMetaObject::Connection(nullptr); |
2971 | } |
2972 | |
2973 | int *types = nullptr; |
2974 | if ((type == Qt::QueuedConnection) |
2975 | && !(types = queuedConnectionTypes(argumentTypes: signalTypes.constData(), argc: signalTypes.size()))) { |
2976 | return QMetaObject::Connection(nullptr); |
2977 | } |
2978 | |
2979 | #ifndef QT_NO_DEBUG |
2980 | QMetaMethod smethod = QMetaObjectPrivate::signal(m: smeta, signal_index); |
2981 | QMetaMethod rmethod = rmeta->method(index: method_index_relative + rmeta->methodOffset()); |
2982 | check_and_warn_compat(sender: smeta, signal: smethod, receiver: rmeta, method: rmethod); |
2983 | #endif |
2984 | QMetaObject::Connection handle = QMetaObject::Connection(QMetaObjectPrivate::connect( |
2985 | sender, signal_index, smeta, receiver, method_index_relative, rmeta ,type, types)); |
2986 | return handle; |
2987 | } |
2988 | |
2989 | /*! |
2990 | \since 4.8 |
2991 | |
2992 | Creates a connection of the given \a type from the \a signal in |
2993 | the \a sender object to the \a method in the \a receiver object. |
2994 | Returns a handle to the connection that can be used to disconnect |
2995 | it later. |
2996 | |
2997 | The Connection handle will be invalid if it cannot create the |
2998 | connection, for example, the parameters were invalid. |
2999 | You can check if the QMetaObject::Connection is valid by casting it to a bool. |
3000 | |
3001 | This function works in the same way as |
3002 | \c {connect(const QObject *sender, const char *signal, |
3003 | const QObject *receiver, const char *method, |
3004 | Qt::ConnectionType type)} |
3005 | but it uses QMetaMethod to specify signal and method. |
3006 | |
3007 | \sa connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) |
3008 | */ |
3009 | QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, |
3010 | const QObject *receiver, const QMetaMethod &method, |
3011 | Qt::ConnectionType type) |
3012 | { |
3013 | if (sender == nullptr |
3014 | || receiver == nullptr |
3015 | || signal.methodType() != QMetaMethod::Signal |
3016 | || method.methodType() == QMetaMethod::Constructor) { |
3017 | qCWarning(lcConnect, "QObject::connect: Cannot connect %s::%s to %s::%s" , |
3018 | sender ? sender->metaObject()->className() : "(nullptr)" , |
3019 | signal.methodSignature().constData(), |
3020 | receiver ? receiver->metaObject()->className() : "(nullptr)" , |
3021 | method.methodSignature().constData()); |
3022 | return QMetaObject::Connection(nullptr); |
3023 | } |
3024 | |
3025 | int signal_index; |
3026 | int method_index; |
3027 | { |
3028 | int dummy; |
3029 | QMetaObjectPrivate::memberIndexes(obj: sender, member: signal, signalIndex: &signal_index, methodIndex: &dummy); |
3030 | QMetaObjectPrivate::memberIndexes(obj: receiver, member: method, signalIndex: &dummy, methodIndex: &method_index); |
3031 | } |
3032 | |
3033 | const QMetaObject *smeta = sender->metaObject(); |
3034 | const QMetaObject *rmeta = receiver->metaObject(); |
3035 | if (signal_index == -1) { |
3036 | qCWarning(lcConnect, "QObject::connect: Can't find signal %s on instance of class %s" , |
3037 | signal.methodSignature().constData(), smeta->className()); |
3038 | return QMetaObject::Connection(nullptr); |
3039 | } |
3040 | if (method_index == -1) { |
3041 | qCWarning(lcConnect, "QObject::connect: Can't find method %s on instance of class %s" , |
3042 | method.methodSignature().constData(), rmeta->className()); |
3043 | return QMetaObject::Connection(nullptr); |
3044 | } |
3045 | |
3046 | if (!QMetaObject::checkConnectArgs(signal: signal.methodSignature().constData(), |
3047 | method: method.methodSignature().constData())) { |
3048 | qCWarning(lcConnect, |
3049 | "QObject::connect: Incompatible sender/receiver arguments" |
3050 | "\n %s::%s --> %s::%s" , |
3051 | smeta->className(), signal.methodSignature().constData(), rmeta->className(), |
3052 | method.methodSignature().constData()); |
3053 | return QMetaObject::Connection(nullptr); |
3054 | } |
3055 | |
3056 | int *types = nullptr; |
3057 | if ((type == Qt::QueuedConnection) && !(types = queuedConnectionTypes(method: signal))) |
3058 | return QMetaObject::Connection(nullptr); |
3059 | |
3060 | #ifndef QT_NO_DEBUG |
3061 | check_and_warn_compat(sender: smeta, signal, receiver: rmeta, method); |
3062 | #endif |
3063 | QMetaObject::Connection handle = QMetaObject::Connection(QMetaObjectPrivate::connect( |
3064 | sender, signal_index, smeta: signal.enclosingMetaObject(), receiver, method_index_relative: method_index, rmeta: nullptr, type, types)); |
3065 | return handle; |
3066 | } |
3067 | |
3068 | /*! |
3069 | \fn bool QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type) const |
3070 | \overload connect() |
3071 | \threadsafe |
3072 | |
3073 | Connects \a signal from the \a sender object to this object's \a |
3074 | method. |
3075 | |
3076 | Equivalent to connect(\a sender, \a signal, \c this, \a method, \a type). |
3077 | |
3078 | Every connection you make emits a signal, so duplicate connections emit |
3079 | two signals. You can break a connection using disconnect(). |
3080 | |
3081 | \sa disconnect() |
3082 | */ |
3083 | |
3084 | /*! |
3085 | \threadsafe |
3086 | |
3087 | Disconnects \a signal in object \a sender from \a method in object |
3088 | \a receiver. Returns \c true if the connection is successfully broken; |
3089 | otherwise returns \c false. |
3090 | |
3091 | A signal-slot connection is removed when either of the objects |
3092 | involved are destroyed. |
3093 | |
3094 | disconnect() is typically used in three ways, as the following |
3095 | examples demonstrate. |
3096 | \list 1 |
3097 | \li Disconnect everything connected to an object's signals: |
3098 | |
3099 | \snippet code/src_corelib_kernel_qobject.cpp 26 |
3100 | |
3101 | equivalent to the non-static overloaded function |
3102 | |
3103 | \snippet code/src_corelib_kernel_qobject.cpp 27 |
3104 | |
3105 | \li Disconnect everything connected to a specific signal: |
3106 | |
3107 | \snippet code/src_corelib_kernel_qobject.cpp 28 |
3108 | |
3109 | equivalent to the non-static overloaded function |
3110 | |
3111 | \snippet code/src_corelib_kernel_qobject.cpp 29 |
3112 | |
3113 | \li Disconnect a specific receiver: |
3114 | |
3115 | \snippet code/src_corelib_kernel_qobject.cpp 30 |
3116 | |
3117 | equivalent to the non-static overloaded function |
3118 | |
3119 | \snippet code/src_corelib_kernel_qobject.cpp 31 |
3120 | |
3121 | \endlist |
3122 | |
3123 | \nullptr may be used as a wildcard, meaning "any signal", "any receiving |
3124 | object", or "any slot in the receiving object", respectively. |
3125 | |
3126 | The \a sender may never be \nullptr. (You cannot disconnect signals |
3127 | from more than one object in a single call.) |
3128 | |
3129 | If \a signal is \nullptr, it disconnects \a receiver and \a method from |
3130 | any signal. If not, only the specified signal is disconnected. |
3131 | |
3132 | If \a receiver is \nullptr, it disconnects anything connected to \a |
3133 | signal. If not, slots in objects other than \a receiver are not |
3134 | disconnected. |
3135 | |
3136 | If \a method is \nullptr, it disconnects anything that is connected to \a |
3137 | receiver. If not, only slots named \a method will be disconnected, |
3138 | and all other slots are left alone. The \a method must be \nullptr |
3139 | if \a receiver is left out, so you cannot disconnect a |
3140 | specifically-named slot on all objects. |
3141 | |
3142 | \include includes/qobject.qdocinc disconnect-all |
3143 | |
3144 | \sa connect() |
3145 | */ |
3146 | bool QObject::disconnect(const QObject *sender, const char *signal, |
3147 | const QObject *receiver, const char *method) |
3148 | { |
3149 | if (sender == nullptr || (receiver == nullptr && method != nullptr)) { |
3150 | qCWarning(lcConnect, "QObject::disconnect: Unexpected nullptr parameter" ); |
3151 | return false; |
3152 | } |
3153 | |
3154 | const char *signal_arg = signal; |
3155 | QByteArray signal_name; |
3156 | bool signal_found = false; |
3157 | if (signal) { |
3158 | QT_TRY { |
3159 | signal_name = QMetaObject::normalizedSignature(method: signal); |
3160 | signal = signal_name.constData(); |
3161 | } QT_CATCH (const std::bad_alloc &) { |
3162 | // if the signal is already normalized, we can continue. |
3163 | if (sender->metaObject()->indexOfSignal(signal: signal + 1) == -1) |
3164 | QT_RETHROW; |
3165 | } |
3166 | |
3167 | if (!check_signal_macro(sender, signal, func: "disconnect" , op: "unbind" )) |
3168 | return false; |
3169 | signal++; // skip code |
3170 | } |
3171 | |
3172 | QByteArray method_name; |
3173 | const char *method_arg = method; |
3174 | int membcode = -1; |
3175 | bool method_found = false; |
3176 | if (method) { |
3177 | QT_TRY { |
3178 | method_name = QMetaObject::normalizedSignature(method); |
3179 | method = method_name.constData(); |
3180 | } QT_CATCH(const std::bad_alloc &) { |
3181 | // if the method is already normalized, we can continue. |
3182 | if (receiver->metaObject()->indexOfMethod(method: method + 1) == -1) |
3183 | QT_RETHROW; |
3184 | } |
3185 | |
3186 | membcode = extract_code(member: method); |
3187 | if (!check_method_code(code: membcode, object: receiver, method, func: "disconnect" )) |
3188 | return false; |
3189 | method++; // skip code |
3190 | } |
3191 | |
3192 | /* We now iterate through all the sender's and receiver's meta |
3193 | * objects in order to also disconnect possibly shadowed signals |
3194 | * and slots with the same signature. |
3195 | */ |
3196 | bool res = false; |
3197 | const QMetaObject *smeta = sender->metaObject(); |
3198 | QByteArray signalName; |
3199 | QArgumentTypeArray signalTypes; |
3200 | Q_ASSERT(QMetaObjectPrivate::get(smeta)->revision >= 7); |
3201 | if (signal) |
3202 | signalName = QMetaObjectPrivate::decodeMethodSignature(signature: signal, types&: signalTypes); |
3203 | QByteArray methodName; |
3204 | QArgumentTypeArray methodTypes; |
3205 | Q_ASSERT(!receiver || QMetaObjectPrivate::get(receiver->metaObject())->revision >= 7); |
3206 | if (method) |
3207 | methodName = QMetaObjectPrivate::decodeMethodSignature(signature: method, types&: methodTypes); |
3208 | do { |
3209 | int signal_index = -1; |
3210 | if (signal) { |
3211 | signal_index = QMetaObjectPrivate::indexOfSignalRelative( |
3212 | baseObject: &smeta, name: signalName, argc: signalTypes.size(), types: signalTypes.constData()); |
3213 | if (signal_index < 0) |
3214 | break; |
3215 | signal_index = QMetaObjectPrivate::originalClone(obj: smeta, local_method_index: signal_index); |
3216 | signal_index += QMetaObjectPrivate::signalOffset(m: smeta); |
3217 | signal_found = true; |
3218 | } |
3219 | |
3220 | if (!method) { |
3221 | res |= QMetaObjectPrivate::disconnect(sender, signal_index, smeta, receiver, method_index: -1, slot: nullptr); |
3222 | } else { |
3223 | const QMetaObject *rmeta = receiver->metaObject(); |
3224 | do { |
3225 | int method_index = QMetaObjectPrivate::indexOfMethod( |
3226 | m: rmeta, name: methodName, argc: methodTypes.size(), types: methodTypes.constData()); |
3227 | if (method_index >= 0) |
3228 | while (method_index < rmeta->methodOffset()) |
3229 | rmeta = rmeta->superClass(); |
3230 | if (method_index < 0) |
3231 | break; |
3232 | res |= QMetaObjectPrivate::disconnect(sender, signal_index, smeta, receiver, method_index, slot: nullptr); |
3233 | method_found = true; |
3234 | } while ((rmeta = rmeta->superClass())); |
3235 | } |
3236 | } while (signal && (smeta = smeta->superClass())); |
3237 | |
3238 | if (signal && !signal_found) { |
3239 | err_method_notfound(object: sender, method: signal_arg, func: "disconnect" ); |
3240 | err_info_about_objects(func: "disconnect" , sender, receiver); |
3241 | } else if (method && !method_found) { |
3242 | err_method_notfound(object: receiver, method: method_arg, func: "disconnect" ); |
3243 | err_info_about_objects(func: "disconnect" , sender, receiver); |
3244 | } |
3245 | if (res) { |
3246 | if (!signal) |
3247 | const_cast<QObject *>(sender)->disconnectNotify(signal: QMetaMethod()); |
3248 | } |
3249 | return res; |
3250 | } |
3251 | |
3252 | /*! |
3253 | \since 4.8 |
3254 | |
3255 | Disconnects \a signal in object \a sender from \a method in object |
3256 | \a receiver. Returns \c true if the connection is successfully broken; |
3257 | otherwise returns \c false. |
3258 | |
3259 | This function provides the same possibilities like |
3260 | \c {disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) } |
3261 | but uses QMetaMethod to represent the signal and the method to be disconnected. |
3262 | |
3263 | Additionally this function returns false and no signals and slots disconnected |
3264 | if: |
3265 | \list 1 |
3266 | |
3267 | \li \a signal is not a member of sender class or one of its parent classes. |
3268 | |
3269 | \li \a method is not a member of receiver class or one of its parent classes. |
3270 | |
3271 | \li \a signal instance represents not a signal. |
3272 | |
3273 | \endlist |
3274 | |
3275 | QMetaMethod() may be used as wildcard in the meaning "any signal" or "any slot in receiving object". |
3276 | In the same way \nullptr can be used for \a receiver in the meaning "any receiving object". |
3277 | In this case method should also be QMetaMethod(). \a sender parameter should be never \nullptr. |
3278 | |
3279 | \include includes/qobject.qdocinc disconnect-all |
3280 | |
3281 | \sa disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) |
3282 | */ |
3283 | bool QObject::disconnect(const QObject *sender, const QMetaMethod &signal, |
3284 | const QObject *receiver, const QMetaMethod &method) |
3285 | { |
3286 | if (sender == nullptr || (receiver == nullptr && method.mobj != nullptr)) { |
3287 | qCWarning(lcConnect, "QObject::disconnect: Unexpected nullptr parameter" ); |
3288 | return false; |
3289 | } |
3290 | if (signal.mobj) { |
3291 | if (signal.methodType() != QMetaMethod::Signal) { |
3292 | qCWarning(lcConnect, "QObject::%s: Attempt to %s non-signal %s::%s" , |
3293 | "disconnect" ,"unbind" , |
3294 | sender->metaObject()->className(), signal.methodSignature().constData()); |
3295 | return false; |
3296 | } |
3297 | } |
3298 | if (method.mobj) { |
3299 | if (method.methodType() == QMetaMethod::Constructor) { |
3300 | qCWarning(lcConnect, "QObject::disconnect: cannot use constructor as argument %s::%s" , |
3301 | receiver->metaObject()->className(), method.methodSignature().constData()); |
3302 | return false; |
3303 | } |
3304 | } |
3305 | |
3306 | int signal_index; |
3307 | int method_index; |
3308 | { |
3309 | int dummy; |
3310 | QMetaObjectPrivate::memberIndexes(obj: sender, member: signal, signalIndex: &signal_index, methodIndex: &dummy); |
3311 | QMetaObjectPrivate::memberIndexes(obj: receiver, member: method, signalIndex: &dummy, methodIndex: &method_index); |
3312 | } |
3313 | // If we are here sender is not nullptr. If signal is not nullptr while signal_index |
3314 | // is -1 then this signal is not a member of sender. |
3315 | if (signal.mobj && signal_index == -1) { |
3316 | qCWarning(lcConnect, "QObject::disconnect: signal %s not found on class %s" , |
3317 | signal.methodSignature().constData(), sender->metaObject()->className()); |
3318 | return false; |
3319 | } |
3320 | // If this condition is true then method is not a member of receiver. |
3321 | if (receiver && method.mobj && method_index == -1) { |
3322 | qCWarning(lcConnect, "QObject::disconnect: method %s not found on class %s" , |
3323 | method.methodSignature().constData(), receiver->metaObject()->className()); |
3324 | return false; |
3325 | } |
3326 | |
3327 | if (!QMetaObjectPrivate::disconnect(sender, signal_index, smeta: signal.mobj, receiver, method_index, slot: nullptr)) |
3328 | return false; |
3329 | |
3330 | if (!signal.isValid()) { |
3331 | // The signal is a wildcard, meaning all signals were disconnected. |
3332 | // QMetaObjectPrivate::disconnect() doesn't call disconnectNotify() |
3333 | // per connection in this case. Call it once now, with an invalid |
3334 | // QMetaMethod as argument, as documented. |
3335 | const_cast<QObject *>(sender)->disconnectNotify(signal); |
3336 | } |
3337 | return true; |
3338 | } |
3339 | |
3340 | /*! |
3341 | \threadsafe |
3342 | |
3343 | \fn bool QObject::disconnect(const char *signal, const QObject *receiver, const char *method) const |
3344 | \overload disconnect() |
3345 | |
3346 | Disconnects \a signal from \a method of \a receiver. |
3347 | |
3348 | A signal-slot connection is removed when either of the objects |
3349 | involved are destroyed. |
3350 | |
3351 | \include includes/qobject.qdocinc disconnect-all |
3352 | */ |
3353 | |
3354 | /*! |
3355 | \fn bool QObject::disconnect(const QObject *receiver, const char *method) const |
3356 | \overload disconnect() |
3357 | |
3358 | Disconnects all signals in this object from \a receiver's \a |
3359 | method. |
3360 | |
3361 | A signal-slot connection is removed when either of the objects |
3362 | involved are destroyed. |
3363 | */ |
3364 | |
3365 | |
3366 | /*! |
3367 | \since 5.0 |
3368 | |
3369 | This virtual function is called when something has been connected |
3370 | to \a signal in this object. |
3371 | |
3372 | If you want to compare \a signal with a specific signal, you can |
3373 | use QMetaMethod::fromSignal() as follows: |
3374 | |
3375 | \snippet code/src_corelib_kernel_qobject.cpp 32 |
3376 | |
3377 | \warning This function violates the object-oriented principle of |
3378 | modularity. However, it might be useful when you need to perform |
3379 | expensive initialization only if something is connected to a |
3380 | signal. |
3381 | |
3382 | \warning This function is called from the thread which performs the |
3383 | connection, which may be a different thread from the thread in which |
3384 | this object lives. This function may also be called with a QObject internal |
3385 | mutex locked. It is therefore not allowed to re-enter any QObject |
3386 | functions, including isSignalConnected(), from your reimplementation. If |
3387 | you lock a mutex in your reimplementation, make sure that you don't call |
3388 | QObject functions with that mutex held in other places or it will result in |
3389 | a deadlock. |
3390 | |
3391 | \sa connect(), disconnectNotify() |
3392 | */ |
3393 | |
3394 | void QObject::connectNotify(const QMetaMethod &signal) |
3395 | { |
3396 | Q_UNUSED(signal); |
3397 | } |
3398 | |
3399 | /*! |
3400 | \since 5.0 |
3401 | |
3402 | This virtual function is called when something has been |
3403 | disconnected from \a signal in this object. |
3404 | |
3405 | See connectNotify() for an example of how to compare |
3406 | \a signal with a specific signal. |
3407 | |
3408 | If all signals were disconnected from this object (e.g., the |
3409 | signal argument to disconnect() was \nullptr), disconnectNotify() |
3410 | is only called once, and the \a signal will be an invalid |
3411 | QMetaMethod (QMetaMethod::isValid() returns \c false). |
3412 | |
3413 | \warning This function violates the object-oriented principle of |
3414 | modularity. However, it might be useful for optimizing access to |
3415 | expensive resources. |
3416 | |
3417 | \warning This function is called from the thread which performs the |
3418 | disconnection, which may be a different thread from the thread in which |
3419 | this object lives. This function may also be called with a QObject internal |
3420 | mutex locked. It is therefore not allowed to re-enter any QObject |
3421 | functions, including isSignalConnected(), from your reimplementation. If |
3422 | you lock a mutex in your reimplementation, make sure that you don't call |
3423 | QObject functions with that mutex held in other places or it will result in |
3424 | a deadlock. |
3425 | |
3426 | \sa disconnect(), connectNotify() |
3427 | */ |
3428 | |
3429 | void QObject::disconnectNotify(const QMetaMethod &signal) |
3430 | { |
3431 | Q_UNUSED(signal); |
3432 | } |
3433 | |
3434 | /* |
3435 | \internal |
3436 | convert a signal index from the method range to the signal range |
3437 | */ |
3438 | static int methodIndexToSignalIndex(const QMetaObject **base, int signal_index) |
3439 | { |
3440 | if (signal_index < 0) |
3441 | return signal_index; |
3442 | const QMetaObject *metaObject = *base; |
3443 | while (metaObject && metaObject->methodOffset() > signal_index) |
3444 | metaObject = metaObject->superClass(); |
3445 | |
3446 | if (metaObject) { |
3447 | int signalOffset, methodOffset; |
3448 | computeOffsets(metaobject: metaObject, signalOffset: &signalOffset, methodOffset: &methodOffset); |
3449 | if (signal_index < metaObject->methodCount()) |
3450 | signal_index = QMetaObjectPrivate::originalClone(obj: metaObject, local_method_index: signal_index - methodOffset) + signalOffset; |
3451 | else |
3452 | signal_index = signal_index - methodOffset + signalOffset; |
3453 | *base = metaObject; |
3454 | } |
3455 | return signal_index; |
3456 | } |
3457 | |
3458 | /*! |
3459 | \internal |
3460 | \a types is a 0-terminated vector of meta types for queued |
3461 | connections. |
3462 | |
3463 | if \a signal_index is -1, then we effectively connect *all* signals |
3464 | from the sender to the receiver's slot |
3465 | */ |
3466 | QMetaObject::Connection QMetaObject::connect(const QObject *sender, int signal_index, |
3467 | const QObject *receiver, int method_index, int type, |
3468 | int *types) |
3469 | { |
3470 | const QMetaObject *smeta = sender->metaObject(); |
3471 | signal_index = methodIndexToSignalIndex(base: &smeta, signal_index); |
3472 | return Connection(QMetaObjectPrivate::connect(sender, signal_index, smeta, |
3473 | receiver, method_index_relative: method_index, |
3474 | rmeta: nullptr, //FIXME, we could speed this connection up by computing the relative index |
3475 | type, types)); |
3476 | } |
3477 | |
3478 | /*! |
3479 | \internal |
3480 | Same as the QMetaObject::connect, but \a signal_index must be the result of QObjectPrivate::signalIndex |
3481 | |
3482 | method_index is relative to the rmeta metaobject, if rmeta is \nullptr, then it is absolute index |
3483 | |
3484 | the QObjectPrivate::Connection* has a refcount of 2, so it must be passed to a QMetaObject::Connection |
3485 | */ |
3486 | QObjectPrivate::Connection *QMetaObjectPrivate::connect(const QObject *sender, |
3487 | int signal_index, const QMetaObject *smeta, |
3488 | const QObject *receiver, int method_index, |
3489 | const QMetaObject *rmeta, int type, int *types) |
3490 | { |
3491 | QObject *s = const_cast<QObject *>(sender); |
3492 | QObject *r = const_cast<QObject *>(receiver); |
3493 | |
3494 | int method_offset = rmeta ? rmeta->methodOffset() : 0; |
3495 | Q_ASSERT(!rmeta || QMetaObjectPrivate::get(rmeta)->revision >= 6); |
3496 | QObjectPrivate::StaticMetaCallFunction callFunction = rmeta ? rmeta->d.static_metacall : nullptr; |
3497 | |
3498 | QOrderedMutexLocker locker(signalSlotLock(o: sender), |
3499 | signalSlotLock(o: receiver)); |
3500 | |
3501 | QObjectPrivate::ConnectionData *scd = QObjectPrivate::get(o: s)->connections.loadRelaxed(); |
3502 | if (type & Qt::UniqueConnection && scd) { |
3503 | if (scd->signalVectorCount() > signal_index) { |
3504 | const QObjectPrivate::Connection *c2 = scd->signalVector.loadRelaxed()->at(i: signal_index).first.loadRelaxed(); |
3505 | |
3506 | int method_index_absolute = method_index + method_offset; |
3507 | |
3508 | while (c2) { |
3509 | if (!c2->isSlotObject && c2->receiver.loadRelaxed() == receiver && c2->method() == method_index_absolute) |
3510 | return nullptr; |
3511 | c2 = c2->nextConnectionList.loadRelaxed(); |
3512 | } |
3513 | } |
3514 | } |
3515 | type &= ~Qt::UniqueConnection; |
3516 | |
3517 | const bool isSingleShot = type & Qt::SingleShotConnection; |
3518 | type &= ~Qt::SingleShotConnection; |
3519 | |
3520 | Q_ASSERT(type >= 0); |
3521 | Q_ASSERT(type <= 3); |
3522 | |
3523 | std::unique_ptr<QObjectPrivate::Connection> c{new QObjectPrivate::Connection}; |
3524 | c->sender = s; |
3525 | c->signal_index = signal_index; |
3526 | c->receiver.storeRelaxed(newValue: r); |
3527 | QThreadData *td = r->d_func()->threadData.loadAcquire(); |
3528 | td->ref(); |
3529 | c->receiverThreadData.storeRelaxed(newValue: td); |
3530 | c->method_relative = method_index; |
3531 | c->method_offset = method_offset; |
3532 | c->connectionType = type; |
3533 | c->isSlotObject = false; |
3534 | c->argumentTypes.storeRelaxed(newValue: types); |
3535 | c->callFunction = callFunction; |
3536 | c->isSingleShot = isSingleShot; |
3537 | |
3538 | QObjectPrivate::get(o: s)->addConnection(signal: signal_index, c: c.get()); |
3539 | |
3540 | locker.unlock(); |
3541 | QMetaMethod smethod = QMetaObjectPrivate::signal(m: smeta, signal_index); |
3542 | if (smethod.isValid()) |
3543 | s->connectNotify(signal: smethod); |
3544 | |
3545 | return c.release(); |
3546 | } |
3547 | |
3548 | /*! |
3549 | \internal |
3550 | */ |
3551 | bool QMetaObject::disconnect(const QObject *sender, int signal_index, |
3552 | const QObject *receiver, int method_index) |
3553 | { |
3554 | const QMetaObject *smeta = sender->metaObject(); |
3555 | signal_index = methodIndexToSignalIndex(base: &smeta, signal_index); |
3556 | return QMetaObjectPrivate::disconnect(sender, signal_index, smeta, |
3557 | receiver, method_index, slot: nullptr); |
3558 | } |
3559 | |
3560 | /*! |
3561 | \internal |
3562 | |
3563 | Disconnect a single signal connection. If QMetaObject::connect() has been called |
3564 | multiple times for the same sender, signal_index, receiver and method_index only |
3565 | one of these connections will be removed. |
3566 | */ |
3567 | bool QMetaObject::disconnectOne(const QObject *sender, int signal_index, |
3568 | const QObject *receiver, int method_index) |
3569 | { |
3570 | const QMetaObject *smeta = sender->metaObject(); |
3571 | signal_index = methodIndexToSignalIndex(base: &smeta, signal_index); |
3572 | return QMetaObjectPrivate::disconnect(sender, signal_index, smeta, |
3573 | receiver, method_index, slot: nullptr, |
3574 | QMetaObjectPrivate::DisconnectOne); |
3575 | } |
3576 | |
3577 | /*! |
3578 | \internal |
3579 | Helper function to remove the connection from the senders list and set the receivers to \nullptr |
3580 | */ |
3581 | bool QMetaObjectPrivate::disconnectHelper(QObjectPrivate::ConnectionData *connections, int signalIndex, |
3582 | const QObject *receiver, int method_index, void **slot, |
3583 | QBasicMutex *senderMutex, DisconnectType disconnectType) |
3584 | { |
3585 | bool success = false; |
3586 | |
3587 | auto &connectionList = connections->connectionsForSignal(signal: signalIndex); |
3588 | auto *c = connectionList.first.loadRelaxed(); |
3589 | while (c) { |
3590 | QObject *r = c->receiver.loadRelaxed(); |
3591 | if (r && (receiver == nullptr || (r == receiver |
3592 | && (method_index < 0 || (!c->isSlotObject && c->method() == method_index)) |
3593 | && (slot == nullptr || (c->isSlotObject && c->slotObj->compare(a: slot)))))) { |
3594 | bool needToUnlock = false; |
3595 | QBasicMutex *receiverMutex = nullptr; |
3596 | if (r) { |
3597 | receiverMutex = signalSlotLock(o: r); |
3598 | // need to relock this receiver and sender in the correct order |
3599 | needToUnlock = QOrderedMutexLocker::relock(mtx1: senderMutex, mtx2: receiverMutex); |
3600 | } |
3601 | if (c->receiver.loadRelaxed()) |
3602 | connections->removeConnection(c); |
3603 | |
3604 | if (needToUnlock) |
3605 | receiverMutex->unlock(); |
3606 | |
3607 | success = true; |
3608 | |
3609 | if (disconnectType == DisconnectOne) |
3610 | return success; |
3611 | } |
3612 | c = c->nextConnectionList.loadRelaxed(); |
3613 | } |
3614 | return success; |
3615 | } |
3616 | |
3617 | /*! |
3618 | \internal |
3619 | Same as the QMetaObject::disconnect, but \a signal_index must be the result of QObjectPrivate::signalIndex |
3620 | */ |
3621 | bool QMetaObjectPrivate::disconnect(const QObject *sender, |
3622 | int signal_index, const QMetaObject *smeta, |
3623 | const QObject *receiver, int method_index, void **slot, |
3624 | DisconnectType disconnectType) |
3625 | { |
3626 | if (!sender) |
3627 | return false; |
3628 | |
3629 | QObject *s = const_cast<QObject *>(sender); |
3630 | |
3631 | QBasicMutex *senderMutex = signalSlotLock(o: sender); |
3632 | QMutexLocker locker(senderMutex); |
3633 | |
3634 | QObjectPrivate::ConnectionData *scd = QObjectPrivate::get(o: s)->connections.loadRelaxed(); |
3635 | if (!scd) |
3636 | return false; |
3637 | |
3638 | bool success = false; |
3639 | { |
3640 | // prevent incoming connections changing the connections->receivers while unlocked |
3641 | QObjectPrivate::ConnectionDataPointer connections(scd); |
3642 | |
3643 | if (signal_index < 0) { |
3644 | // remove from all connection lists |
3645 | for (int sig_index = -1; sig_index < scd->signalVectorCount(); ++sig_index) { |
3646 | if (disconnectHelper(connections: connections.data(), signalIndex: sig_index, receiver, method_index, slot, senderMutex, disconnectType)) |
3647 | success = true; |
3648 | } |
3649 | } else if (signal_index < scd->signalVectorCount()) { |
3650 | if (disconnectHelper(connections: connections.data(), signalIndex: signal_index, receiver, method_index, slot, senderMutex, disconnectType)) |
3651 | success = true; |
3652 | } |
3653 | } |
3654 | |
3655 | locker.unlock(); |
3656 | if (success) { |
3657 | scd->cleanOrphanedConnections(sender: s); |
3658 | |
3659 | QMetaMethod smethod = QMetaObjectPrivate::signal(m: smeta, signal_index); |
3660 | if (smethod.isValid()) |
3661 | s->disconnectNotify(signal: smethod); |
3662 | } |
3663 | |
3664 | return success; |
3665 | } |
3666 | |
3667 | // Helpers for formatting the connect statements of connectSlotsByName()'s debug mode |
3668 | static QByteArray formatConnectionSignature(const char *className, const QMetaMethod &method) |
3669 | { |
3670 | const auto signature = method.methodSignature(); |
3671 | Q_ASSERT(signature.endsWith(')')); |
3672 | const int openParen = signature.indexOf(c: '('); |
3673 | const bool hasParameters = openParen >= 0 && openParen < signature.size() - 2; |
3674 | QByteArray result; |
3675 | if (hasParameters) { |
3676 | result += "qOverload<" |
3677 | + signature.mid(index: openParen + 1, len: signature.size() - openParen - 2) + ">(" ; |
3678 | } |
3679 | result += '&'; |
3680 | result += className + QByteArrayLiteral("::" ) + method.name(); |
3681 | if (hasParameters) |
3682 | result += ')'; |
3683 | return result; |
3684 | } |
3685 | |
3686 | static QByteArray msgConnect(const QMetaObject *senderMo, const QByteArray &senderName, |
3687 | const QMetaMethod &signal, const QObject *receiver, int receiverIndex) |
3688 | { |
3689 | const auto receiverMo = receiver->metaObject(); |
3690 | const auto slot = receiverMo->method(index: receiverIndex); |
3691 | QByteArray message = QByteArrayLiteral("QObject::connect(" ) |
3692 | + senderName + ", " + formatConnectionSignature(className: senderMo->className(), method: signal) |
3693 | + ", " + receiver->objectName().toLatin1() + ", " |
3694 | + formatConnectionSignature(className: receiverMo->className(), method: slot) + ");" ; |
3695 | return message; |
3696 | } |
3697 | |
3698 | /*! |
3699 | \fn void QMetaObject::connectSlotsByName(QObject *object) |
3700 | |
3701 | Searches recursively for all child objects of the given \a object, and connects |
3702 | matching signals from them to slots of \a object that follow the following form: |
3703 | |
3704 | \snippet code/src_corelib_kernel_qobject.cpp 33 |
3705 | |
3706 | Let's assume our object has a child object of type \c{QPushButton} with |
3707 | the \l{QObject::objectName}{object name} \c{button1}. The slot to catch the |
3708 | button's \c{clicked()} signal would be: |
3709 | |
3710 | \snippet code/src_corelib_kernel_qobject.cpp 34 |
3711 | |
3712 | If \a object itself has a properly set object name, its own signals are also |
3713 | connected to its respective slots. |
3714 | |
3715 | \sa QObject::setObjectName() |
3716 | */ |
3717 | void QMetaObject::connectSlotsByName(QObject *o) |
3718 | { |
3719 | if (!o) |
3720 | return; |
3721 | const QMetaObject *mo = o->metaObject(); |
3722 | Q_ASSERT(mo); |
3723 | const QObjectList list = // list of all objects to look for matching signals including... |
3724 | o->findChildren<QObject *>() // all children of 'o'... |
3725 | << o; // and the object 'o' itself |
3726 | |
3727 | // for each method/slot of o ... |
3728 | for (int i = 0; i < mo->methodCount(); ++i) { |
3729 | const QByteArray slotSignature = mo->method(index: i).methodSignature(); |
3730 | const char *slot = slotSignature.constData(); |
3731 | Q_ASSERT(slot); |
3732 | |
3733 | // ...that starts with "on_", ... |
3734 | if (slot[0] != 'o' || slot[1] != 'n' || slot[2] != '_') |
3735 | continue; |
3736 | |
3737 | // ...we check each object in our list, ... |
3738 | bool foundIt = false; |
3739 | for (int j = 0; j < list.size(); ++j) { |
3740 | const QObject *co = list.at(i: j); |
3741 | const QByteArray coName = co->objectName().toLatin1(); |
3742 | |
3743 | // ...discarding those whose objectName is not fitting the pattern "on_<objectName>_...", ... |
3744 | if (coName.isEmpty() || qstrncmp(str1: slot + 3, str2: coName.constData(), len: coName.size()) || slot[coName.size()+3] != '_') |
3745 | continue; |
3746 | |
3747 | const char *signal = slot + coName.size() + 4; // the 'signal' part of the slot name |
3748 | |
3749 | // ...for the presence of a matching signal "on_<objectName>_<signal>". |
3750 | const QMetaObject *smeta; |
3751 | int sigIndex = co->d_func()->signalIndex(signalName: signal, meta: &smeta); |
3752 | if (sigIndex < 0) { |
3753 | // if no exactly fitting signal (name + complete parameter type list) could be found |
3754 | // look for just any signal with the correct name and at least the slot's parameter list. |
3755 | // Note: if more than one of those signals exist, the one that gets connected is |
3756 | // chosen 'at random' (order of declaration in source file) |
3757 | QList<QByteArray> compatibleSignals; |
3758 | const QMetaObject *smo = co->metaObject(); |
3759 | int sigLen = int(qstrlen(str: signal)) - 1; // ignore the trailing ')' |
3760 | for (int k = QMetaObjectPrivate::absoluteSignalCount(m: smo)-1; k >= 0; --k) { |
3761 | const QMetaMethod method = QMetaObjectPrivate::signal(m: smo, signal_index: k); |
3762 | if (!qstrncmp(str1: method.methodSignature().constData(), str2: signal, len: sigLen)) { |
3763 | smeta = method.enclosingMetaObject(); |
3764 | sigIndex = k; |
3765 | compatibleSignals.prepend(t: method.methodSignature()); |
3766 | } |
3767 | } |
3768 | if (compatibleSignals.size() > 1) |
3769 | qCWarning(lcConnectSlotsByName) << "QMetaObject::connectSlotsByName: Connecting slot" << slot |
3770 | << "with the first of the following compatible signals:" << compatibleSignals; |
3771 | } |
3772 | |
3773 | if (sigIndex < 0) |
3774 | continue; |
3775 | |
3776 | // we connect it... |
3777 | if (Connection(QMetaObjectPrivate::connect(sender: co, signal_index: sigIndex, smeta, receiver: o, method_index: i))) { |
3778 | foundIt = true; |
3779 | qCDebug(lcConnectSlotsByName, "%s" , |
3780 | msgConnect(smeta, coName, QMetaObjectPrivate::signal(smeta, sigIndex), o, i).constData()); |
3781 | // ...and stop looking for further objects with the same name. |
3782 | // Note: the Designer will make sure each object name is unique in the above |
3783 | // 'list' but other code may create two child objects with the same name. In |
3784 | // this case one is chosen 'at random'. |
3785 | break; |
3786 | } |
3787 | } |
3788 | if (foundIt) { |
3789 | // we found our slot, now skip all overloads |
3790 | while (mo->method(index: i + 1).attributes() & QMetaMethod::Cloned) |
3791 | ++i; |
3792 | } else if (!(mo->method(index: i).attributes() & QMetaMethod::Cloned)) { |
3793 | // check if the slot has the following signature: "on_..._...(..." |
3794 | int iParen = slotSignature.indexOf(c: '('); |
3795 | int iLastUnderscore = slotSignature.lastIndexOf(c: '_', from: iParen - 1); |
3796 | if (iLastUnderscore > 3) |
3797 | qCWarning(lcConnectSlotsByName, |
3798 | "QMetaObject::connectSlotsByName: No matching signal for %s" , slot); |
3799 | } |
3800 | } |
3801 | } |
3802 | |
3803 | /*! |
3804 | \internal |
3805 | A small RAII helper for QSlotObjectBase. |
3806 | Calls ref on construction and destroyLastRef in its dtor. |
3807 | Allows construction from a nullptr in which case it does nothing. |
3808 | */ |
3809 | struct SlotObjectGuard { |
3810 | SlotObjectGuard() = default; |
3811 | // move would be fine, but we do not need it currently |
3812 | Q_DISABLE_COPY_MOVE(SlotObjectGuard) |
3813 | Q_NODISCARD_CTOR explicit SlotObjectGuard(QtPrivate::QSlotObjectBase *slotObject) |
3814 | : m_slotObject(slotObject) |
3815 | { |
3816 | if (m_slotObject) |
3817 | m_slotObject->ref(); |
3818 | } |
3819 | |
3820 | QtPrivate::QSlotObjectBase const *operator->() const |
3821 | { return m_slotObject.get(); } |
3822 | |
3823 | QtPrivate::QSlotObjectBase *operator->() |
3824 | { return m_slotObject.get(); } |
3825 | |
3826 | ~SlotObjectGuard() = default; |
3827 | private: |
3828 | QtPrivate::SlotObjUniquePtr m_slotObject; |
3829 | }; |
3830 | |
3831 | /*! |
3832 | \internal |
3833 | |
3834 | \a signal must be in the signal index range (see QObjectPrivate::signalIndex()). |
3835 | */ |
3836 | static void queued_activate(QObject *sender, int signal, QObjectPrivate::Connection *c, void **argv) |
3837 | { |
3838 | const int *argumentTypes = c->argumentTypes.loadRelaxed(); |
3839 | if (!argumentTypes) { |
3840 | QMetaMethod m = QMetaObjectPrivate::signal(m: sender->metaObject(), signal_index: signal); |
3841 | argumentTypes = queuedConnectionTypes(method: m); |
3842 | if (!argumentTypes) // cannot queue arguments |
3843 | argumentTypes = &DIRECT_CONNECTION_ONLY; |
3844 | if (!c->argumentTypes.testAndSetOrdered(expectedValue: nullptr, newValue: argumentTypes)) { |
3845 | if (argumentTypes != &DIRECT_CONNECTION_ONLY) |
3846 | delete[] argumentTypes; |
3847 | argumentTypes = c->argumentTypes.loadRelaxed(); |
3848 | } |
3849 | } |
3850 | if (argumentTypes == &DIRECT_CONNECTION_ONLY) // cannot activate |
3851 | return; |
3852 | int nargs = 1; // include return type |
3853 | while (argumentTypes[nargs - 1]) |
3854 | ++nargs; |
3855 | |
3856 | QMutexLocker locker(signalSlotLock(o: c->receiver.loadRelaxed())); |
3857 | QObject *receiver = c->receiver.loadRelaxed(); |
3858 | if (!receiver) { |
3859 | // the connection has been disconnected before we got the lock |
3860 | return; |
3861 | } |
3862 | |
3863 | SlotObjectGuard slotObjectGuard { c->isSlotObject ? c->slotObj : nullptr }; |
3864 | locker.unlock(); |
3865 | |
3866 | QMetaCallEvent *ev = c->isSlotObject ? |
3867 | new QMetaCallEvent(c->slotObj, sender, signal, nargs) : |
3868 | new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction, sender, signal, nargs); |
3869 | |
3870 | void **args = ev->args(); |
3871 | QMetaType *types = ev->types(); |
3872 | |
3873 | types[0] = QMetaType(); // return type |
3874 | args[0] = nullptr; // return value |
3875 | |
3876 | if (nargs > 1) { |
3877 | for (int n = 1; n < nargs; ++n) |
3878 | types[n] = QMetaType(argumentTypes[n - 1]); |
3879 | |
3880 | for (int n = 1; n < nargs; ++n) |
3881 | args[n] = types[n].create(copy: argv[n]); |
3882 | } |
3883 | |
3884 | if (c->isSingleShot && !QObjectPrivate::removeConnection(c)) { |
3885 | delete ev; |
3886 | return; |
3887 | } |
3888 | |
3889 | locker.relock(); |
3890 | if (!c->isSingleShot && !c->receiver.loadRelaxed()) { |
3891 | // the connection has been disconnected while we were unlocked |
3892 | locker.unlock(); |
3893 | delete ev; |
3894 | return; |
3895 | } |
3896 | |
3897 | QCoreApplication::postEvent(receiver, event: ev); |
3898 | } |
3899 | |
3900 | template <bool callbacks_enabled> |
3901 | void doActivate(QObject *sender, int signal_index, void **argv) |
3902 | { |
3903 | QObjectPrivate *sp = QObjectPrivate::get(o: sender); |
3904 | |
3905 | if (sp->blockSig) |
3906 | return; |
3907 | |
3908 | Q_TRACE_SCOPE(QMetaObject_activate, sender, signal_index); |
3909 | |
3910 | if (sp->isDeclarativeSignalConnected(signal_index) |
3911 | && QAbstractDeclarativeData::signalEmitted) { |
3912 | Q_TRACE_SCOPE(QMetaObject_activate_declarative_signal, sender, signal_index); |
3913 | QAbstractDeclarativeData::signalEmitted(sp->declarativeData, sender, |
3914 | signal_index, argv); |
3915 | } |
3916 | |
3917 | const QSignalSpyCallbackSet *signal_spy_set = callbacks_enabled ? qt_signal_spy_callback_set.loadAcquire() : nullptr; |
3918 | |
3919 | void *empty_argv[] = { nullptr }; |
3920 | if (!argv) |
3921 | argv = empty_argv; |
3922 | |
3923 | if (!sp->maybeSignalConnected(signalIndex: signal_index)) { |
3924 | // The possible declarative connection is done, and nothing else is connected |
3925 | if (callbacks_enabled && signal_spy_set->signal_begin_callback != nullptr) |
3926 | signal_spy_set->signal_begin_callback(sender, signal_index, argv); |
3927 | if (callbacks_enabled && signal_spy_set->signal_end_callback != nullptr) |
3928 | signal_spy_set->signal_end_callback(sender, signal_index); |
3929 | return; |
3930 | } |
3931 | |
3932 | if (callbacks_enabled && signal_spy_set->signal_begin_callback != nullptr) |
3933 | signal_spy_set->signal_begin_callback(sender, signal_index, argv); |
3934 | |
3935 | bool senderDeleted = false; |
3936 | { |
3937 | Q_ASSERT(sp->connections.loadAcquire()); |
3938 | QObjectPrivate::ConnectionDataPointer connections(sp->connections.loadRelaxed()); |
3939 | QObjectPrivate::SignalVector *signalVector = connections->signalVector.loadRelaxed(); |
3940 | |
3941 | const QObjectPrivate::ConnectionList *list; |
3942 | if (signal_index < signalVector->count()) |
3943 | list = &signalVector->at(i: signal_index); |
3944 | else |
3945 | list = &signalVector->at(i: -1); |
3946 | |
3947 | Qt::HANDLE currentThreadId = QThread::currentThreadId(); |
3948 | bool inSenderThread = currentThreadId == QObjectPrivate::get(o: sender)->threadData.loadRelaxed()->threadId.loadRelaxed(); |
3949 | |
3950 | // We need to check against the highest connection id to ensure that signals added |
3951 | // during the signal emission are not emitted in this emission. |
3952 | uint highestConnectionId = connections->currentConnectionId.loadRelaxed(); |
3953 | do { |
3954 | QObjectPrivate::Connection *c = list->first.loadRelaxed(); |
3955 | if (!c) |
3956 | continue; |
3957 | |
3958 | do { |
3959 | QObject * const receiver = c->receiver.loadRelaxed(); |
3960 | if (!receiver) |
3961 | continue; |
3962 | |
3963 | QThreadData *td = c->receiverThreadData.loadRelaxed(); |
3964 | if (!td) |
3965 | continue; |
3966 | |
3967 | bool receiverInSameThread; |
3968 | if (inSenderThread) { |
3969 | receiverInSameThread = currentThreadId == td->threadId.loadRelaxed(); |
3970 | } else { |
3971 | // need to lock before reading the threadId, because moveToThread() could interfere |
3972 | QMutexLocker lock(signalSlotLock(o: receiver)); |
3973 | receiverInSameThread = currentThreadId == td->threadId.loadRelaxed(); |
3974 | } |
3975 | |
3976 | |
3977 | // determine if this connection should be sent immediately or |
3978 | // put into the event queue |
3979 | if ((c->connectionType == Qt::AutoConnection && !receiverInSameThread) |
3980 | || (c->connectionType == Qt::QueuedConnection)) { |
3981 | queued_activate(sender, signal: signal_index, c, argv); |
3982 | continue; |
3983 | #if QT_CONFIG(thread) |
3984 | } else if (c->connectionType == Qt::BlockingQueuedConnection) { |
3985 | if (receiverInSameThread) { |
3986 | qWarning(msg: "Qt: Dead lock detected while activating a BlockingQueuedConnection: " |
3987 | "Sender is %s(%p), receiver is %s(%p)" , |
3988 | sender->metaObject()->className(), sender, |
3989 | receiver->metaObject()->className(), receiver); |
3990 | } |
3991 | |
3992 | if (c->isSingleShot && !QObjectPrivate::removeConnection(c)) |
3993 | continue; |
3994 | |
3995 | QSemaphore semaphore; |
3996 | { |
3997 | QMutexLocker locker(signalSlotLock(o: receiver)); |
3998 | if (!c->isSingleShot && !c->receiver.loadAcquire()) |
3999 | continue; |
4000 | QMetaCallEvent *ev = c->isSlotObject ? |
4001 | new QMetaCallEvent(c->slotObj, sender, signal_index, argv, &semaphore) : |
4002 | new QMetaCallEvent(c->method_offset, c->method_relative, c->callFunction, |
4003 | sender, signal_index, argv, &semaphore); |
4004 | QCoreApplication::postEvent(receiver, event: ev); |
4005 | } |
4006 | semaphore.acquire(); |
4007 | continue; |
4008 | #endif |
4009 | } |
4010 | |
4011 | if (c->isSingleShot && !QObjectPrivate::removeConnection(c)) |
4012 | continue; |
4013 | |
4014 | QObjectPrivate::Sender senderData(receiverInSameThread ? receiver : nullptr, sender, signal_index); |
4015 | |
4016 | if (c->isSlotObject) { |
4017 | SlotObjectGuard obj{c->slotObj}; |
4018 | |
4019 | { |
4020 | Q_TRACE_SCOPE(QMetaObject_activate_slot_functor, c->slotObj); |
4021 | obj->call(r: receiver, a: argv); |
4022 | } |
4023 | } else if (c->callFunction && c->method_offset <= receiver->metaObject()->methodOffset()) { |
4024 | //we compare the vtable to make sure we are not in the destructor of the object. |
4025 | const int method_relative = c->method_relative; |
4026 | const auto callFunction = c->callFunction; |
4027 | const int methodIndex = (Q_HAS_TRACEPOINTS || callbacks_enabled) ? c->method() : 0; |
4028 | if (callbacks_enabled && signal_spy_set->slot_begin_callback != nullptr) |
4029 | signal_spy_set->slot_begin_callback(receiver, methodIndex, argv); |
4030 | |
4031 | { |
4032 | Q_TRACE_SCOPE(QMetaObject_activate_slot, receiver, methodIndex); |
4033 | callFunction(receiver, |
---|