qobject.cpp source code [qtbase/src/corelib/kernel/qobject.cpp]

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(&currentData->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 extract_code(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 extract_location(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,