19#if QT_CONFIG(regularexpression)
23#include <private/qthread_p.h>
32#include <private/qorderedmutexlocker_p.h>
33#include <private/qhooks_p.h>
34#include <qtcore_tracepoints_p.h>
51Q_TRACE_POINT(qtcore, QMetaObject_activate_slot_functor_entry,
void *slotObject);
78 const auto parameterCount =
method.parameterCount();
79 int *typeIds =
new int[parameterCount + 1];
81 for (
int i = 0;
i < parameterCount; ++
i) {
84 typeIds[
i] = QMetaType::VoidStar;
86 typeIds[
i] = metaType.
id();
87 if (!typeIds[
i] &&
method.parameterTypeName(
i).endsWith(
'*'))
88 typeIds[
i] = QMetaType::VoidStar;
92 "QObject::connect: Cannot queue arguments of type '%s'\n"
93 "(Make sure '%s' is registered using qRegisterMetaType().)",
99 typeIds[parameterCount] = 0;
106 auto types = std::make_unique<int[]>(argc + 1);
107 for (
int i = 0;
i < argc; ++
i) {
111 else if (
type.name().endsWith(
'*'))
112 types[
i] = QMetaType::VoidStar;
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());
126 return types.release();
190 if (thisThreadData->hasEventDispatcher())
191 thisThreadData->eventDispatcher.loadRelaxed()->unregisterTimers(
q_ptr);
197 qWarning(
"QObject::~QObject: Timers cannot be stopped from another thread");
204 thisThreadData->deref();
218 *signalOffset = *methodOffset = 0;
222 *methodOffset +=
d->methodCount;
224 *signalOffset +=
d->signalCount;
235 if (signal_index < 0 || !cd)
237 if (signal_index < cd->signalVectorCount()) {
244 c =
c->nextConnectionList.loadRelaxed();
281 if (connectionList.last.loadRelaxed()) {
282 Q_ASSERT(connectionList.last.loadRelaxed()->receiver.loadRelaxed());
283 connectionList.last.loadRelaxed()->nextConnectionList.storeRelaxed(
c);
285 connectionList.first.storeRelaxed(
c);
288 c->prevConnectionList = connectionList.last.
loadRelaxed();
289 connectionList.last.storeRelaxed(
c);
292 rd->ensureConnectionData();
294 c->prev = &(
rd->connections.loadRelaxed()->senders);
298 c->next->prev = &
c->next;
305 c->receiver.storeRelaxed(
nullptr);
309 c->receiverThreadData.storeRelaxed(
nullptr);
313 for (
Connection *cc =
connections.first.loadRelaxed(); cc; cc = cc->nextConnectionList.loadRelaxed()) {
325 c->next->prev =
c->prev;
329 connections.first.storeRelaxed(
c->nextConnectionList.loadRelaxed());
338 n->prevConnectionList =
c->prevConnectionList;
339 if (
c->prevConnectionList)
340 c->prevConnectionList->nextConnectionList.storeRelaxed(
n);
341 c->prevConnectionList =
nullptr;
349 o =
orphaned.load(std::memory_order_acquire);
351 c->nextInOrphanList =
o;
356 for (
Connection *cc =
connections.first.loadRelaxed(); cc; cc = cc->nextConnectionList.loadRelaxed()) {
370 TaggedSignalVector
c =
nullptr;
372 std::unique_lock<QBasicMutex>
lock(*senderMutex, std::defer_lock_t{});
373 if (lockPolicy == NeedToLock)
375 if (
ref.loadAcquire() > 1)
381 c = orphaned.exchange(
nullptr, std::memory_order_relaxed);
385 if (lockPolicy == AlreadyLockedAndTemporarilyReleasingLock) {
386 senderMutex->unlock();
400 next =
v->nextInOrphanList;
404 next =
c->nextInOrphanList;
432 if (signalVector->
at(-1).
first.loadRelaxed())
438 if (
c->receiver.loadRelaxed())
440 c =
c->nextConnectionList.loadRelaxed();
455 if (signalVector->
at(-1).
first.loadAcquire())
469 children[
i]->d_func()->reinitBindingStorageAfterThreadMove();
479 semaphore_->release();
486inline void QMetaCallEvent::allocArgs()
491 constexpr size_t each =
sizeof(
void*) +
sizeof(
QMetaType);
492 void *
const memory =
d.nargs_ * each >
sizeof(prealloc_) ?
493 calloc(
d.nargs_, each) : prealloc_;
496 d.args_ =
static_cast<void **
>(
memory);
507 const QObject *sender,
int signalId,
510 d({
nullptr,
args, callFunction, 0, method_offset, method_relative}),
522 const QObject *sender,
int signalId,
539 const QObject *sender,
int signalId,
555 const QObject *sender,
int signalId,
558 d({
nullptr,
nullptr, callFunction, nargs, method_offset, method_relative}),
571 const QObject *sender,
int signalId,
589 const QObject *sender,
int signalId,
605 for (
int i = 0;
i < d.nargs_; ++
i) {
606 if (
t[
i].isValid() && d.args_[
i])
607 t[
i].destroy(d.args_[
i]);
609 if (
reinterpret_cast<void *
>(d.args_) !=
reinterpret_cast<void *
>(prealloc_))
620 d.slotObj_->call(
object, d.args_);
621 }
else if (d.callFunction_ && d.method_offset_ <=
object->metaObject()->methodOffset()) {
625 d.method_offset_ + d.method_relative_, d.args_);
630 const QObject *sender,
int signal_index,
631 size_t argc,
const void*
const argp[],
634 auto metaCallEvent = std::make_unique<QMetaCallEvent>(std::move(slotObj),
sender,
635 signal_index,
int(argc));
637 void **
args = metaCallEvent->args();
639 for (
size_t i = 0;
i < argc; ++
i) {
645 return metaCallEvent.release();
905 if (parent && parentThreadData != currentThreadData) {
906 QThread *parentThread = parentThreadData->
thread.loadAcquire();
907 QThread *currentThread = currentThreadData->
thread.loadAcquire();
908 qWarning(
"QObject: Cannot create children for a parent that is in a different thread.\n"
909 "(Parent is %s(%p), parent's thread is %s(%p), current thread is %s(%p)",
910 parent->metaObject()->className(),
912 parentThread ? parentThread->metaObject()->className() :
"QThread",
914 currentThread ? currentThread->metaObject()->className() :
"QThread",
953 d->threadData.storeRelaxed(threadData);
958 if (
d->willBeWidget) {
1009 d->wasDeleted =
true;
1012 if (!
d->bindingStorage.isValid()) {
1024 d->clearBindingStorage();
1027 if (sharedRefcount) {
1029 qWarning(
"QObject: shared QObject was deleted directly. The program is malformed and may crash.");
1036 delete sharedRefcount;
1039 if (!
d->wasWidget &&
d->isSignalConnected(0)) {
1066 if (
c == connectionList.first.loadAcquire() &&
c->receiver.loadAcquire()) {
1068 Q_ASSERT(connectionList.first.loadRelaxed() !=
c);
1078 Q_ASSERT(node->receiver.loadAcquire());
1098 if (node->isSlotObject) {
1099 slotObj = node->slotObj;
1100 node->isSlotObject =
false;
1103 senderData->removeConnection(node);
1112 const bool locksAreTheSame = signalSlotMutex ==
m;
1113 if (!locksAreTheSame)
1115 senderData->cleanOrphanedConnections(
1122 if (locksAreTheSame)
1135 d->connections.storeRelaxed(
nullptr);
1137 if (!
d->children.isEmpty())
1138 d->deleteChildren();
1146 d->setParent_helper(
nullptr);
1278#if QT_CONFIG(thread)
1280 return d->extraData ?
d->extraData->objectName.valueBypassingBindings() :
QString();
1287 return d->extraData ?
d->extraData->objectName :
QString();
1298 d->ensureExtraData();
1300 d->extraData->objectName.removeBindingUnlessInWrapper();
1302 if (
d->extraData->objectName.valueBypassingBindings() !=
name) {
1303 d->extraData->objectName.setValueBypassingBindings(
name);
1304 d->extraData->objectName.notify();
1316 d->ensureExtraData();
1318 d->extraData->objectName.removeBindingUnlessInWrapper();
1320 if (
d->extraData->objectName.valueBypassingBindings() !=
name) {
1321 d->extraData->objectName.setValueBypassingBindings(
name.toString());
1322 d->extraData->objectName.notify();
1330 d->ensureExtraData();
1332 return QBindable<QString>(&
d->extraData->objectName);
1391 switch (e->
type()) {
1403 qCDebug(lcDeleteLater) <<
"Deferred deleting" <<
this;
1414 d_func()->ensureConnectionData();
1415 connections = d_func()->connections.loadRelaxed();
1419 mce->placeMetaCall(
this);
1427 if (eventDispatcher) {
1428 QList<QAbstractEventDispatcher::TimerInfoV2> timers = eventDispatcher->
timersForObject(
this);
1429 if (!timers.isEmpty()) {
1433 "QAbstractEventDispatcher::unregisterTimers() returned false,"
1434 " but there are timers associated with this object.");
1435 auto reRegisterTimers = [
this, timers = std::move(timers)]() {
1437 d_func()->threadData.loadRelaxed()->eventDispatcher.loadRelaxed();
1438 for (
const auto &ti : timers)
1439 eventDispatcher->
registerTimer(ti.timerId, ti.interval, ti.timerType,
this);
1588 bool previous =
d->blockSig;
1589 d->blockSig = block;
1600 return d_func()->threadData.loadRelaxed()->
thread.loadAcquire();
1647 if (
d->threadData.loadRelaxed()->thread.loadAcquire() == targetThread) {
1652 if (
d->parent !=
nullptr) {
1653 qWarning(
"QObject::moveToThread: Cannot move objects with a parent");
1657 qWarning(
"QObject::moveToThread: Widgets cannot be moved to a new thread");
1660 if (!
d->bindingStorage.isEmpty()) {
1661 qWarning(
"QObject::moveToThread: Can not move objects that contain bindings or are used in bindings to a new thread.");
1667 QThreadData *thisThreadData =
d->threadData.loadAcquire();
1668 if (!thisThreadData->thread.loadRelaxed() && currentData == targetData) {
1670 currentData = thisThreadData;
1671 }
else if (thisThreadData != currentData) {
1672 qWarning(
"QObject::moveToThread: Current thread (%p) is not the object's thread (%p).\n"
1673 "Cannot move to target thread (%p)\n",
1674 currentData->
thread.
loadRelaxed(), thisThreadData->thread.loadRelaxed(), targetData ? targetData->thread.loadRelaxed() :
nullptr);
1677 qWarning(
"You might be loading two sets of Qt binaries into the same process. "
1678 "Check that all plugins are compiled against the right Qt binaries. Export "
1679 "DYLD_PRINT_LIBRARIES=1 and check that only one set of binaries are being loaded.");
1686 d->moveToThread_helper();
1695 &targetData->postEventList.mutex);
1701 auto threadPrivate = targetThread
1705 ? threadPrivate->bindingStatus()
1708 bindingStatus = threadPrivate->addObjectWithPendingBindingStatusChange(
this);
1710 d_func()->setThreadData_helper(currentData, targetData,
bindingStatus);
1715 currentData->
deref();
1727 child->d_func()->moveToThread_helper();
1741 int eventsMoved = 0;
1746 if (pe.receiver ==
q) {
1748 targetData->postEventList.addEvent(pe);
1753 if (eventsMoved > 0 && targetData->hasEventDispatcher()) {
1754 targetData->canWait =
false;
1755 targetData->eventDispatcher.loadRelaxed()->wakeUp();
1774 QThreadData *old =
c->receiverThreadData.loadRelaxed();
1777 c->receiverThreadData.storeRelaxed(targetData);
1794 child->d_func()->setThreadData_helper(currentData, targetData, status);
1821 return startTimer(std::chrono::milliseconds{interval}, timerType);
1879 using namespace std::chrono_literals;
1882 qWarning(
"QObject::startTimer: Timers cannot have negative intervals");
1886 auto thisThreadData =
d->threadData.loadRelaxed();
1887 if (
Q_UNLIKELY(!thisThreadData->hasEventDispatcher())) {
1888 qWarning(
"QObject::startTimer: Timers can only be used with threads started with QThread");
1892 qWarning(
"QObject::startTimer: Timers cannot be started from another thread");
1896 auto dispatcher = thisThreadData->eventDispatcher.loadRelaxed();
1897 Qt::TimerId timerId = dispatcher->registerTimer(interval, timerType,
this);
1898 d->ensureExtraData();
1899 d->extraData->runningTimers.append(timerId);
1900 return int(timerId);
1925 qWarning(
"QObject::killTimer: Timers cannot be stopped from another thread");
1929 int at =
d->extraData ?
d->extraData->runningTimers.indexOf(
id) : -1;
1932 qWarning(
"QObject::killTimer(): Error: timer id %d is not valid for object %p (%s, %ls), timer has not been killed",
1940 auto thisThreadData =
d->threadData.loadRelaxed();
1941 if (thisThreadData->hasEventDispatcher())
1942 thisThreadData->eventDispatcher.loadRelaxed()->unregisterTimer(
id);
1944 d->extraData->runningTimers.remove(
at);
2130 return ext ->objectName.valueBypassingBindings() ==
name;
2131 return name.isEmpty();
2150#if QT_CONFIG(regularexpression)
2224 const auto checkForParentChildLoops =
qScopeGuard([&](){
2228 if (++
depth == CheckForParentChildLoopsWarnDepth) {
2229 qWarning(
"QObject %p (class: '%s', object name: '%s') may have a loop in its parent-child chain; "
2230 "this is undefined behavior",
2231 q,
q->metaObject()->className(),
qPrintable(
q->objectName()));
2243 if (parentD->isDeletingChildren &&
wasDeleted
2244 && parentD->currentChildBeingDeleted ==
q) {
2251 }
else if (parentD->isDeletingChildren) {
2252 parentD->children[
index] =
nullptr;
2254 parentD->children.removeAt(
index);
2274 qWarning(
"QObject::setParent: Cannot set parent, new parent is in a different thread");
2344 if (
d->threadData.loadRelaxed() !=
obj->d_func()->threadData.loadRelaxed()) {
2345 qWarning(
"QObject::installEventFilter(): Cannot filter events for objects in a different thread.");
2349 d->ensureExtraData();
2352 auto isNullOrEquals = [](
auto obj) {
return [
obj](
const auto &
p) {
return !
p ||
p ==
obj; }; };
2353 d->extraData->eventFilters.removeIf(isNullOrEquals(
obj));
2354 d->extraData->eventFilters.prepend(
obj);
2374 for (
auto &
filter :
d->extraData->eventFilters) {
2439 qWarning(
"You are deferring the delete of QCoreApplication, this may not work as expected.");
2447 if (!eventListLocker.threadData)
2455 if (
d->deleteLaterCalled) {
2456 qCDebug(lcDeleteLater) <<
"Skipping deleteLater for already deferred object" <<
this;
2460 d->deleteLaterCalled =
true;
2465 auto *objectThreadData = eventListLocker.threadData;
2477 loopLevel = objectThreadData->loopLevel;
2478 scopeLevel = objectThreadData->scopeLevel;
2484 if (scopeLevel == 0 && loopLevel != 0) {
2485 qCDebug(lcDeleteLater) <<
"Delete later called with scope level 0"
2486 <<
"but loop level is > 0. Assuming scope is 1";
2491 qCDebug(lcDeleteLater) <<
"Posting deferred delete for" <<
this
2492 <<
"with loop level" << loopLevel <<
"and scope level" << scopeLevel;
2494 eventListLocker.unlock();
2540class FlaggedDebugSignatures
2543 std::array<const char *, 2>
locations = {};
2546 void store(
const char*
method)
noexcept
2553Q_CONSTINIT
static thread_local FlaggedDebugSignatures flaggedSignatures = {};
2558 flaggedSignatures.store(
method);
2565 return (((
int)(*member) -
'0') & 0x3);
2570 if (flaggedSignatures.contains(member)) {
2580 const char *
func,
const char *op)
2585 qCWarning(lcConnect,
"QObject::%s: Attempt to %s non-signal %s::%s",
func, op,
2586 sender->metaObject()->className(),
signal + 1);
2588 qCWarning(lcConnect,
"QObject::%s: Use the SIGNAL macro to %s %s::%s",
func, op,
2589 sender->metaObject()->className(),
signal);
2599 "QObject::%s: Use the SLOT or SIGNAL macro to "
2611 const char *
type =
"method";
2617 if (strchr(
method,
')') ==
nullptr)
2618 qCWarning(lcConnect,
"QObject::%s: Parentheses expected, %s %s::%s%s%s",
func,
type,
2619 object->metaObject()->className(),
method + 1, loc ?
" in " :
"", loc ? loc :
"");
2622 object->metaObject()->className(),
method + 1, loc ?
" in " :
"", loc ? loc :
"");
2631 qCWarning(lcConnect,
"QObject::%s: (sender name: '%s')",
func,
a.toLocal8Bit().data());
2633 qCWarning(lcConnect,
"QObject::%s: (receiver name: '%s')",
func,
b.toLocal8Bit().data());
2752 int signal_index =
d->signalIndex(
signal);
2753 if (signal_index < 0) {
2760 if (!
d->isSignalConnected(signal_index))
2770 if (cd && signal_index < cd->signalVectorCount()) {
2773 receivers +=
c->receiver.loadRelaxed() ? 1 : 0;
2774 c =
c->nextConnectionList.loadRelaxed();
2808 "QObject::isSignalConnected" ,
"the parameter must be a signal member of the object");
2853 while (
m !=
nullptr &&
m != member.
mobj)
2863 *methodIndex += methodOffset;
2878 qCWarning(lcConnect,
"QObject::connect: Connecting from COMPAT signal (%s::%s)",
2882 qCWarning(lcConnect,
"QObject::connect: Connecting from %s::%s to COMPAT slot (%s::%s)",
2884 method.methodSignature().constData());
2964 if (sender ==
nullptr || receiver ==
nullptr ||
signal ==
nullptr ||
method ==
nullptr) {
2965 qCWarning(lcConnect,
"QObject::connect: Cannot connect %s::%s to %s::%s",
2966 sender ? sender->metaObject()->className() :
"(nullptr)",
2968 receiver ? receiver->metaObject()->className() :
"(nullptr)",
2977 const char *signal_arg =
signal;
2983 &smeta, signalName, signalTypes.size(), signalTypes.constData());
2984 if (signal_index < 0) {
2987 signal = tmp_signal_name.constData() + 1;
2989 signalTypes.clear();
2991 smeta = sender->metaObject();
2993 &smeta, signalName, signalTypes.size(), signalTypes.constData());
2995 if (signal_index < 0) {
3008 const char *method_arg =
method;
3013 const QMetaObject *rmeta = receiver->metaObject();
3014 int method_index_relative = -1;
3019 &rmeta,
methodName, methodTypes.size(), methodTypes.constData());
3023 &rmeta,
methodName, methodTypes.size(), methodTypes.constData());
3026 if (method_index_relative < 0) {
3029 method = tmp_method_name.constData();
3031 methodTypes.clear();
3034 rmeta = receiver->metaObject();
3038 &rmeta,
methodName, methodTypes.size(), methodTypes.constData());
3042 &rmeta,
methodName, methodTypes.size(), methodTypes.constData());
3047 if (method_index_relative < 0) {
3054 methodTypes.size(), methodTypes.constData())) {
3056 "QObject::connect: Incompatible sender/receiver arguments"
3057 "\n %s::%s --> %s::%s",
3058 sender->metaObject()->className(),
signal, receiver->metaObject()->className(),
3063 int *
types =
nullptr;
3071 QMetaMethod rmethod = rmeta->method(method_index_relative + rmeta->methodOffset());
3075 sender, signal_index, smeta, receiver, method_index_relative, rmeta ,
type,
types));
3103 if (sender ==
nullptr
3104 || receiver ==
nullptr
3107 qCWarning(lcConnect,
"QObject::connect: Cannot connect %s::%s to %s::%s",
3108 sender ? sender->metaObject()->className() :
"(nullptr)",
3109 signal.methodSignature().constData(),
3110 receiver ? receiver->metaObject()->className() :
"(nullptr)",
3111 method.methodSignature().constData());
3124 const QMetaObject *rmeta = receiver->metaObject();
3125 if (signal_index == -1) {
3126 qCWarning(lcConnect,
"QObject::connect: Can't find signal %s on instance of class %s",
3127 signal.methodSignature().constData(), smeta->className());
3130 if (method_index == -1) {
3131 qCWarning(lcConnect,
"QObject::connect: Can't find method %s on instance of class %s",
3132 method.methodSignature().constData(), rmeta->className());
3137 method.methodSignature().constData())) {
3139 "QObject::connect: Incompatible sender/receiver arguments"
3140 "\n %s::%s --> %s::%s",
3141 smeta->className(),
signal.methodSignature().constData(), rmeta->className(),
3142 method.methodSignature().constData());
3146 int *
types =
nullptr;
3154 sender, signal_index,
signal.enclosingMetaObject(), receiver, method_index,
nullptr,
type,
types));
3239 if (sender ==
nullptr || (receiver ==
nullptr &&
method !=
nullptr)) {
3240 qCWarning(lcConnect,
"QObject::disconnect: Unexpected nullptr parameter");
3244 const char *signal_arg =
signal;
3246 bool signal_found =
false;
3250 signal = signal_name.constData();
3251 }
QT_CATCH (
const std::bad_alloc &) {
3253 if (sender->metaObject()->indexOfSignal(
signal + 1) == -1)
3263 const char *method_arg =
method;
3265 bool method_found =
false;
3270 }
QT_CATCH(
const std::bad_alloc &) {
3272 if (receiver->metaObject()->indexOfMethod(
method + 1) == -1)
3299 int signal_index = -1;
3302 &smeta, signalName, signalTypes.size(), signalTypes.constData());
3303 if (signal_index < 0)
3307 signal_found =
true;
3313 const QMetaObject *rmeta = receiver->metaObject();
3316 rmeta,
methodName, methodTypes.size(), methodTypes.constData());
3317 if (method_index >= 0)
3318 while (method_index < rmeta->methodOffset())
3319 rmeta = rmeta->superClass();
3320 if (method_index < 0)
3323 method_found =
true;
3324 }
while ((rmeta = rmeta->superClass()));
3326 }
while (
signal && (smeta = smeta->superClass()));
3328 if (
signal && !signal_found) {
3331 }
else if (
method && !method_found) {
3376 if (sender ==
nullptr || (receiver ==
nullptr &&
method.mobj !=
nullptr)) {
3377 qCWarning(lcConnect,
"QObject::disconnect: Unexpected nullptr parameter");
3382 qCWarning(lcConnect,
"QObject::%s: Attempt to %s non-signal %s::%s",
3383 "disconnect",
"unbind",
3384 sender->metaObject()->className(),
signal.methodSignature().constData());
3390 qCWarning(lcConnect,
"QObject::disconnect: cannot use constructor as argument %s::%s",
3391 receiver->metaObject()->className(),
method.methodSignature().constData());
3405 if (
signal.mobj && signal_index == -1) {
3406 qCWarning(lcConnect,
"QObject::disconnect: signal %s not found on class %s",
3407 signal.methodSignature().constData(), sender->metaObject()->className());
3411 if (receiver &&
method.mobj && method_index == -1) {
3412 qCWarning(lcConnect,
"QObject::disconnect: method %s not found on class %s",
3413 method.methodSignature().constData(), receiver->metaObject()->className());
3530 if (signal_index < 0)
3531 return signal_index;
3537 int signalOffset, methodOffset;
3539 if (signal_index < metaObject->methodCount())
3542 signal_index = signal_index - methodOffset + signalOffset;
3545 return signal_index;
3557 const QObject *receiver,
int method_index,
int type,
3563 receiver, method_index,
3578 const QObject *receiver,
int method_index,
3584 int method_offset = rmeta ? rmeta->methodOffset() : 0;
3593 if (scd->signalVectorCount() > signal_index) {
3596 int method_index_absolute = method_index + method_offset;
3599 if (!
c2->isSlotObject &&
c2->receiver.loadRelaxed() == receiver &&
c2->method() == method_index_absolute)
3601 c2 =
c2->nextConnectionList.loadRelaxed();
3605 type &=
~Qt::UniqueConnection;
3608 type &=
~Qt::SingleShotConnection;
3615 c->signal_index = signal_index;
3616 c->receiver.storeRelaxed(
r);
3617 QThreadData *td =
r->d_func()->threadData.loadAcquire();
3619 c->receiverThreadData.storeRelaxed(td);
3620 c->method_relative = method_index;
3621 c->method_offset = method_offset;
3622 c->connectionType =
type;
3623 c->isSlotObject =
false;
3624 c->argumentTypes.storeRelaxed(
types);
3625 c->callFunction = callFunction;
3626 c->isSingleShot = isSingleShot;
3632 if (smethod.isValid())
3633 s->connectNotify(smethod);
3642 const QObject *receiver,
int method_index)
3647 receiver, method_index,
nullptr);
3658 const QObject *receiver,
int method_index)
3663 receiver, method_index,
nullptr,
3672 const QObject *receiver,
int method_index,
void **slot,
3675 bool success =
false;
3678 auto *
c = connectionList.first.loadRelaxed();
3681 if (
r && (receiver ==
nullptr || (
r == receiver
3682 && (method_index < 0 || (!
c->isSlotObject &&
c->method() == method_index))
3683 && (slot ==
nullptr || (
c->isSlotObject &&
c->slotObj->compare(slot)))))) {
3684 bool needToUnlock =
false;
3691 if (
c->receiver.loadRelaxed())
3695 receiverMutex->unlock();
3699 if (disconnectType == DisconnectOne)
3702 c =
c->nextConnectionList.loadRelaxed();
3713 const QObject *receiver,
int method_index,
void **slot,
3728 bool success =
false;
3733 if (signal_index < 0) {
3735 for (
int sig_index = -1; sig_index < scd->signalVectorCount(); ++sig_index) {
3736 if (disconnectHelper(
connections.data(), sig_index, receiver, method_index, slot, senderMutex, disconnectType))
3739 }
else if (signal_index < scd->signalVectorCount()) {
3740 if (disconnectHelper(
connections.data(), signal_index, receiver, method_index, slot, senderMutex, disconnectType))
3747 scd->cleanOrphanedConnections(
s);
3750 if (smethod.isValid())
3751 s->disconnectNotify(smethod);
3760 const auto signature =
method.methodSignature();
3762 const int openParen = signature.indexOf(
'(');
3763 const bool hasParameters = openParen >= 0 && openParen < signature.size() - 2;
3765 if (hasParameters) {
3767 + signature.mid(openParen + 1, signature.size() - openParen - 2) +
">(";
3779 const auto receiverMo = receiver->metaObject();
3780 const auto slot = receiverMo->method(receiverIndex);
3818 for (
int i = 0;
i <
mo->methodCount(); ++
i) {
3819 const QByteArray slotSignature =
mo->method(
i).methodSignature();
3820 const char *slot = slotSignature.constData();
3824 if (slot[0] !=
'o' || slot[1] !=
'n' || slot[2] !=
'_')
3828 bool foundIt =
false;
3831 const QByteArray coName = co->objectName().toLatin1();
3834 if (coName.isEmpty() ||
qstrncmp(slot + 3, coName.constData(), coName.size()) || slot[coName.size()+3] !=
'_')
3837 const char *
signal = slot + coName.size() + 4;
3841 int sigIndex = co->d_func()->signalIndex(
signal, &smeta);
3847 QList<QByteArray> compatibleSignals;
3853 smeta =
method.enclosingMetaObject();
3855 compatibleSignals.prepend(
method.methodSignature());
3858 if (compatibleSignals.size() > 1)
3859 qCWarning(lcConnectSlotsByName) <<
"QMetaObject::connectSlotsByName: Connecting slot" << slot
3860 <<
"with the first of the following compatible signals:" << compatibleSignals;
3869 qCDebug(lcConnectSlotsByName,
"%s",
3884 int iParen = slotSignature.indexOf(
'(');
3885 int iLastUnderscore = slotSignature.lastIndexOf(
'_', iParen - 1);
3886 if (iLastUnderscore > 3)
3888 "QMetaObject::connectSlotsByName: No matching signal for %s", slot);
3904 : m_slotObject(slotObject)
3907 m_slotObject->
ref();
3911 {
return m_slotObject.get(); }
3914 {
return m_slotObject.get(); }
3928 const int *argumentTypes =
c->argumentTypes.loadRelaxed();
3929 if (!argumentTypes) {
3934 if (!
c->argumentTypes.testAndSetOrdered(
nullptr, argumentTypes)) {
3936 delete[] argumentTypes;
3937 argumentTypes =
c->argumentTypes.loadRelaxed();
3943 while (argumentTypes[nargs - 1])
3947 QObject *receiver =
c->receiver.loadRelaxed();
3960 void **
args = ev->args();
3967 for (
int n = 1;
n < nargs; ++
n)
3970 for (
int n = 1;
n < nargs; ++
n)
3980 if (!
c->isSingleShot && !
c->receiver.loadRelaxed()) {
3990template <
bool callbacks_enabled>
4000 if (
sp->isDeclarativeSignalConnected(signal_index)
4002 Q_TRACE_SCOPE(QMetaObject_activate_declarative_signal, sender, signal_index);
4004 signal_index, argv);
4009 void *empty_argv[] = {
nullptr };
4013 if (!
sp->maybeSignalConnected(signal_index)) {
4015 if (callbacks_enabled && signal_spy_set->signal_begin_callback !=
nullptr)
4016 signal_spy_set->signal_begin_callback(sender, signal_index, argv);
4017 if (callbacks_enabled && signal_spy_set->signal_end_callback !=
nullptr)
4018 signal_spy_set->signal_end_callback(sender, signal_index);
4022 if (callbacks_enabled && signal_spy_set->signal_begin_callback !=
nullptr)
4023 signal_spy_set->signal_begin_callback(sender, signal_index, argv);
4025 bool senderDeleted =
false;
4032 if (signal_index < signalVector->
count())
4033 list = &signalVector->
at(signal_index);
4035 list = &signalVector->
at(-1);
4038 bool inSenderThread = currentThreadId ==
QObjectPrivate::get(sender)->threadData.loadRelaxed()->threadId.loadRelaxed();
4042 uint highestConnectionId =
connections->currentConnectionId.loadRelaxed();
4049 QObject *
const receiver =
c->receiver.loadRelaxed();
4057 bool receiverInSameThread;
4058 if (inSenderThread) {
4073#if QT_CONFIG(thread)
4075 if (receiverInSameThread) {
4076 qWarning(
"Qt: Dead lock detected while activating a BlockingQueuedConnection: "
4077 "Sender is %s(%p), receiver is %s(%p)",
4078 sender->metaObject()->className(), sender,
4079 receiver->metaObject()->className(), receiver);
4088 if (!
c->isSingleShot && !
c->receiver.loadAcquire())
4091 new QMetaCallEvent(
c->slotObj, sender, signal_index, argv, &semaphore) :
4093 sender, signal_index, argv, &semaphore);
4105 receiverInSameThread ? receiver :
nullptr, sender, signal_index,
4106 receiverInSameThread ?
QObjectPrivate::get(receiver)->connections.loadAcquire() :
nullptr);
4108 if (
c->isSlotObject) {
4113 obj->call(receiver, argv);
4115 }
else if (
c->callFunction &&
c->method_offset <= receiver->metaObject()->methodOffset()) {
4117 const int method_relative =
c->method_relative;
4118 const auto callFunction =
c->callFunction;
4120 if (callbacks_enabled && signal_spy_set->slot_begin_callback !=
nullptr)
4121 signal_spy_set->slot_begin_callback(receiver, methodIndex, argv);
4124 Q_TRACE_SCOPE(QMetaObject_activate_slot, receiver, methodIndex);
4128 if (callbacks_enabled && signal_spy_set->slot_end_callback !=
nullptr)
4129 signal_spy_set->slot_end_callback(receiver, methodIndex);
4131 const int method =
c->method_relative +
c->method_offset;
4133 if (callbacks_enabled && signal_spy_set->slot_begin_callback !=
nullptr) {
4134 signal_spy_set->slot_begin_callback(receiver,
method, argv);
4142 if (callbacks_enabled && signal_spy_set->slot_end_callback !=
nullptr)
4143 signal_spy_set->slot_end_callback(receiver,
method);
4145 }
while ((
c =
c->nextConnectionList.loadRelaxed()) !=
nullptr &&
c->id <= highestConnectionId);
4147 }
while (
list != &signalVector->
at(-1) &&
4149 ((
list = &signalVector->
at(-1)),
true));
4151 if (
connections->currentConnectionId.loadRelaxed() == 0)
4152 senderDeleted =
true;
4154 if (!senderDeleted) {
4155 sp->connections.loadAcquire()->cleanOrphanedConnections(sender);
4157 if (callbacks_enabled && signal_spy_set->signal_end_callback !=
nullptr)
4158 signal_spy_set->signal_end_callback(sender, signal_index);
4171 doActivate<true>(sender, signal_index, argv);
4173 doActivate<false>(sender, signal_index, argv);
4181 int signal_index = signalOffset + local_signal_index;
4184 doActivate<true>(sender, signal_index, argv);
4186 doActivate<false>(sender, signal_index, argv);
4196 while (
mo->methodOffset() > signal_index)
4197 mo =
mo->superClass();
4198 activate(sender,
mo, signal_index -
mo->methodOffset(), argv);
4220 if (relative_index < 0)
4221 return relative_index;
4265 const auto &
value =*lvalue;
4272 d->ensureExtraData();
4274 const int idx =
d->extraData->propertyNames.indexOf(
name);
4276 if (!
value.isValid()) {
4279 d->extraData->propertyNames.removeAt(idx);
4280 d->extraData->propertyValues.removeAt(idx);
4283 d->extraData->propertyNames.append(
name);
4285 d->extraData->propertyValues.append(std::move(*rvalue));
4287 d->extraData->propertyValues.append(*lvalue);
4289 if (
value.userType() ==
d->extraData->propertyValues.at(idx).userType()
4290 &&
value ==
d->extraData->propertyValues.at(idx))
4293 d->extraData->propertyValues[idx] = std::move(*rvalue);
4295 d->extraData->propertyValues[idx] = *lvalue;
4306 if (!
p.isWritable())
4307 qWarning(
"%s::setProperty: Property \"%s\" invalid,"
4310 return rvalue ?
p.write(
this, std::move(*rvalue)) :
p.write(
this, *lvalue);
4334 const int i =
d->extraData->propertyNames.indexOf(
name);
4335 return d->extraData->propertyValues.value(
i);
4339 if (!
p.isReadable())
4340 qWarning(
"%s::property: Property \"%s\" invalid or does not exist",
4343 return p.read(
this);
4356 return d->extraData->propertyNames;
4357 return QList<QByteArray>();
4372 const int indent =
level * 4;
4373 qDebug(
"%*s%s::%ls %s", indent,
"",
object->metaObject()->className(),
4376 for (
auto child :
object->children())
4407 objectName().isEmpty() ?
"unnamed" : objectName().toLocal8Bit().data());
4418 for (
int signal_index = 0; signal_index < signalVector->
count(); ++signal_index) {
4423 qDebug(
" signal: %s",
signal.methodSignature().constData());
4427 if (!
c->receiver.loadRelaxed()) {
4428 qDebug(
" <Disconnected receiver>");
4429 c =
c->nextConnectionList.loadRelaxed();
4432 if (
c->isSlotObject) {
4433 qDebug(
" <functor or function pointer>");
4434 c =
c->nextConnectionList.loadRelaxed();
4437 const QMetaObject *receiverMetaObject =
c->receiver.loadRelaxed()->metaObject();
4440 receiverMetaObject->className(),
4441 c->receiver.loadRelaxed()->objectName().isEmpty() ?
"unnamed" :
qPrintable(
c->receiver.loadRelaxed()->objectName()),
4442 method.methodSignature().constData());
4443 c =
c->nextConnectionList.loadRelaxed();
4456 if (!
s->isSlotObject) {
4461 s->sender->metaObject()->className(),
4462 s->sender->objectName().isEmpty() ?
"unnamed" :
qPrintable(
s->sender->objectName()),
4471#ifndef QT_NO_DEBUG_STREAM
4475 dbg.nospace() <<
q->metaObject()->className() <<
'(' << (
const void *)
q;
4476 if (!
q->objectName().isEmpty())
4477 dbg <<
", name = " <<
q->objectName();
4485 return dbg <<
"QObject(0x0)";
4488 d->writeToDebugStream(dbg);
5196 const QObject *receiver,
void **slot,
5202 qCWarning(lcConnect,
"QObject::connect: invalid nullptr parameter");
5206 int signal_index = -1;
5208 for (; senderMetaObject && signal_index < 0; senderMetaObject = senderMetaObject->superClass()) {
5213 if (!senderMetaObject) {
5214 qCWarning(lcConnect,
"QObject::connect: signal not found in %s", sender->metaObject()->className());
5226 const char *senderString = sender ? sender->metaObject()->className()
5227 : senderMetaObject ? senderMetaObject->className()
5229 const char *receiverString = receiver ? receiver->metaObject()->className()
5231 qCWarning(lcConnect,
"QObject::connect(%s, %s): %s", senderString, receiverString,
message);
5242 const QObject *receiver,
void **slot,
5248 if (!sender || !receiver || !slotObj || !senderMetaObject) {
5249 connectWarning(sender, senderMetaObject, receiver,
"invalid nullptr parameter");
5254 connectWarning(sender, senderMetaObject, receiver,
"unique connections require a pointer to member function of a QObject subclass");
5270 if (
c2->receiver.loadRelaxed() == receiver &&
c2->isSlotObject &&
c2->slotObj->compare(slot))
5272 c2 =
c2->nextConnectionList.loadRelaxed();
5276 type &=
~Qt::UniqueConnection;
5279 type &=
~Qt::SingleShotConnection;
5286 c->signal_index = signal_index;
5287 QThreadData *td =
r->d_func()->threadData.loadAcquire();
5289 c->receiverThreadData.storeRelaxed(td);
5290 c->receiver.storeRelaxed(
r);
5291 c->connectionType =
type;
5292 c->isSlotObject =
true;
5293 c->slotObj = slotObj.release();
5295 c->argumentTypes.storeRelaxed(
types);
5296 c->ownArgumentTypes =
false;
5298 c->isSingleShot = isSingleShot;
5327 return disconnected;
5393 if (sender ==
nullptr || (receiver ==
nullptr && slot !=
nullptr)) {
5394 qCWarning(lcConnect,
"QObject::disconnect: Unexpected nullptr parameter");
5398 int signal_index = -1;
5401 for (; senderMetaObject && signal_index < 0; senderMetaObject = senderMetaObject->superClass()) {
5406 if (!senderMetaObject) {
5407 qCWarning(lcConnect,
"QObject::disconnect: signal not found in %s", sender->metaObject()->className());
5447 qCWarning(lcConnect,
"QObject::connect: invalid nullptr parameter");
5450 const QMetaObject *senderMetaObject = sender->metaObject();
5453 return connectImpl(sender, signal_index, receiver,
nullptr, slotObj.release(),
5454 type,
nullptr, senderMetaObject);
5485 const QMetaObject *senderMetaObject = sender->metaObject();
5500 QObject *receiver =
c->receiver.loadRelaxed();
5512 receiver =
c->receiver.loadRelaxed();
5524 if (receiverMutex != senderMutex) {
5525 receiverMutex->unlock();
5528 senderMutex->unlock();
5547 if (signal_index >= conns->signalVectorCount())
5549 const auto &connectionList = conns->connectionsForSignal(signal_index);
5550 for (
auto c = connectionList.first.loadRelaxed();
c;
5551 c =
c->nextConnectionList.loadRelaxed()) {
5552 if (
c->isSlotObject) {
5588 if (
other.d_ptr != d_ptr) {
5591 d_ptr =
other.d_ptr;
5602QMetaObject::Connection::Connection() : d_ptr(
nullptr) {}
5607QMetaObject::Connection::~Connection()
5614bool QMetaObject::Connection::isConnected_helper()
const
5635#include "moc_qobject.cpp"
static bool(* isSignalConnected)(QAbstractDeclarativeData *, const QObject *, int)
static int(* receivers)(QAbstractDeclarativeData *, const QObject *, int)
static void(* destroyed)(QAbstractDeclarativeData *, QObject *)
static void(* signalEmitted)(QAbstractDeclarativeData *, QObject *, int, void **)
static void(* setWidgetParent)(QObject *, QObject *)
static void releaseTimerId(int id)
virtual QList< TimerInfoV2 > timersForObject(QObject *object) const =0
virtual bool unregisterTimers(QObject *object)=0
Unregisters all the timers associated with the given object.
Qt::TimerId registerTimer(Duration interval, Qt::TimerType timerType, QObject *object)
void storeRelaxed(T newValue) noexcept
T loadRelaxed() const noexcept
Type loadRelaxed() const noexcept
void storeRelease(Type newValue) noexcept
const char * constData() const noexcept
Returns a pointer to the const data stored in the byte array.
static QPostEventListLocker lockThreadPostEventList(QObject *object)
static bool sendEvent(QObject *receiver, QEvent *event)
Sends event event directly to receiver receiver, using the notify() function.
static void removePostedEvents(QObject *receiver, int eventType=0)
static void postEvent(QObject *receiver, QEvent *event, int priority=Qt::NormalEventPriority)
Type type() const
Returns the event type.
qsizetype size() const noexcept
bool isEmpty() const noexcept
const_reference at(qsizetype i) const noexcept
void append(parameter_type t)
void unlock() noexcept
Unlocks this mutex locker.
void relock() noexcept
Relocks an unlocked mutex locker.
QDynamicMetaObjectData * metaObject
QMetaObject * dynamicMetaObject() const
QBindingStorage bindingStorage
static QMetaObject::Connection connectImpl(const QObject *sender, int signal_index, const QObject *receiver, void **slot, QtPrivate::QSlotObjectBase *slotObj, int type, const int *types, const QMetaObject *senderMetaObject)
bool isSignalConnected(uint signalIdx, bool checkDeclarative=true) const
void ensureConnectionData()
void moveToThread_helper()
void checkForIncompatibleLibraryVersion(int version) const
void setThreadData_helper(QThreadData *currentData, QThreadData *targetData, QBindingStatus *status)
QObjectPrivate(int version=QObjectPrivateVersion)
QAtomicPointer< ConnectionData > connections
static QObjectPrivate * get(QObject *o)
static QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer< Func1 >::Object *sender, Func1 signal, const typename QtPrivate::FunctionPointer< Func2 >::Object *receiverPrivate, Func2 slot, Qt::ConnectionType type=Qt::AutoConnection)
void(* StaticMetaCallFunction)(QObject *, QMetaObject::Call, int, void **)
void addConnection(int signal, Connection *c)
QObject * currentChildBeingDeleted
void clearBindingStorage()
virtual void writeToDebugStream(QDebug &) const
QObjectList receiverList(const char *signal) const
virtual ~QObjectPrivate()
void setParent_helper(QObject *)
void reinitBindingStorageAfterThreadMove()
static bool disconnect(const typename QtPrivate::FunctionPointer< Func1 >::Object *sender, Func1 signal, const typename QtPrivate::FunctionPointer< Func2 >::Object *receiverPrivate, Func2 slot)
void disconnectNotify(const QMetaMethod &signal)
virtual std::string flagsForDumping() const
bool maybeSignalConnected(uint signalIndex) const
QExplicitlySharedDataPointer< ConnectionData > ConnectionDataPointer
QtPrivate::QPropertyAdaptorSlotObject * getPropertyAdaptorSlotObject(const QMetaProperty &property)
int signalIndex(const char *signalName, const QMetaObject **meta=nullptr) const
QAtomicPointer< QThreadData > threadData
static bool removeConnection(Connection *c)
bool isDeclarativeSignalConnected(uint signalIdx) const
int senderSignalIndex() const
int startTimer(int interval, Qt::TimerType timerType=Qt::CoarseTimer)
This is an overloaded function that will start a timer of type timerType and a timeout of interval mi...
Q_INVOKABLE QObject(QObject *parent=nullptr)
Constructs an object with parent object parent.
bool isSignalConnected(const QMetaMethod &signal) const
virtual ~QObject()
Destroys the object, deleting all its child objects.
void installEventFilter(QObject *filterObj)
Installs an event filter filterObj on this object.
const QObjectList & children() const
Returns a list of child objects.
void dumpObjectTree() const
Dumps a tree of children to the debug output.
virtual void connectNotify(const QMetaMethod &signal)
void dumpObjectInfo() const
Dumps information about signal connections, etc.
QObject * parent() const
Returns a pointer to the parent object.
static QMetaObject::Connection connect(const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
\threadsafe
QObject * sender() const
Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; othe...
virtual void childEvent(QChildEvent *event)
This event handler can be reimplemented in a subclass to receive child events.
QString objectName
the name of this object
virtual bool event(QEvent *event)
This virtual function receives events to an object and should return true if the event e was recogniz...
void setParent(QObject *parent)
Makes the object a child of parent.
virtual bool eventFilter(QObject *watched, QEvent *event)
Filters events if this object has been installed as an event filter for the watched object.
static bool disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *member)
\threadsafe
void removeEventFilter(QObject *obj)
Removes an event filter object obj from this object.
virtual void timerEvent(QTimerEvent *event)
This event handler can be reimplemented in a subclass to receive timer events for the object.
QThread * thread() const
Returns the thread in which the object lives.
QScopedPointer< QObjectData > d_ptr
bool moveToThread(QThread *thread QT6_DECL_NEW_OVERLOAD_TAIL)
Changes the thread affinity for this object and its children and returns true on success.
bool blockSignals(bool b) noexcept
If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke...
QList< QByteArray > dynamicPropertyNames() const
int receivers(const char *signal) const
Returns the number of receivers connected to the signal.
QVariant property(const char *name) const
Returns the value of the object's name property.
Q_WEAK_OVERLOAD void setObjectName(const QString &name)
Sets the object's name to name.
QBindable< QString > bindableObjectName()
void destroyed(QObject *=nullptr)
This signal is emitted immediately before the object obj is destroyed, after any instances of QPointe...
void killTimer(int id)
Kills the timer with timer identifier, id.
void deleteLater()
\threadsafe
virtual void disconnectNotify(const QMetaMethod &signal)
virtual void customEvent(QEvent *event)
This event handler can be reimplemented in a subclass to receive custom events.
\inmodule QtCore \reentrant
\inmodule QtCore \reentrant
void acquire(int n=1)
Tries to acquire n resources guarded by the semaphore.
\macro QT_RESTRICTED_CAST_FROM_ASCII
QByteArray toLatin1() const &
static Q_AUTOTEST_EXPORT QThreadData * current(bool createIfNecessary=true)
QAtomicPointer< void > threadId
static QThreadData * get2(QThread *thread)
QPostEventList postEventList
QAtomicPointer< QThread > thread
void removeObjectWithPendingBindingStatusChange(QObject *)
static Qt::HANDLE currentThreadId() noexcept Q_DECL_PURE_FUNCTION
static QThread * currentThread()
static QPropertyAdaptorSlotObject * cast(QSlotObjectBase *ptr, int propertyIndex)
void destroyIfLastRef() noexcept
void(* AddQObjectCallback)(QObject *)
void(* RemoveQObjectCallback)(QObject *)
Combined button and popup list for selecting options.
bool isAnyBindingEvaluating()
std::unique_ptr< QSlotObjectBase, QSlotObjectBase::Deleter > SlotObjUniquePtr
@ FindChildrenRecursively
@ BlockingQueuedConnection
#define Q_BASIC_ATOMIC_INITIALIZER(a)
#define QByteArrayLiteral(str)
size_t qstrlen(const char *str)
int qstrncmp(const char *str1, const char *str2, size_t len)
#define Q_DECL_COLD_FUNCTION
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char return DBusMessage dbus_bool_t return DBusMessage dbus_uint32_t return DBusMessage void
DBusConnection * connection
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char * method
static QString methodName(const QDBusIntrospection::Method &method)
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
QT_BEGIN_NAMESPACE quintptr Q_CORE_EXPORT qtHookData[]
#define Q_LOGGING_CATEGORY(name,...)
#define qCWarning(category,...)
#define qCDebug(category,...)
static QByteArray msgConnect(const QMetaObject *senderMo, const QByteArray &senderName, const QMetaMethod &signal, const QObject *receiver, int receiverIndex)
static void check_and_warn_compat(const QMetaObject *sender, const QMetaMethod &signal, const QMetaObject *receiver, const QMetaMethod &method)
void qt_qFindChildren_helper(const QObject *parent, QAnyStringView name, const QMetaObject &mo, QList< void * > *list, Qt::FindChildOptions options)
static void dumpRecursive(int level, const QObject *object)
static int methodIndexToSignalIndex(const QMetaObject **base, int signal_index)
QObject * qt_qFindChild_helper(const QObject *parent, QAnyStringView name, const QMetaObject &mo, Qt::FindChildOptions options)
static const char * extract_location(const char *member)
Q_CORE_EXPORT QBasicAtomicPointer< QSignalSpyCallbackSet > qt_signal_spy_callback_set
static bool check_parent_thread(QObject *parent, QThreadData *parentThreadData, QThreadData *currentThreadData)
static int DIRECT_CONNECTION_ONLY
static int * queuedConnectionTypes(const QMetaMethod &method)
static void computeOffsets(const QMetaObject *metaobject, int *signalOffset, int *methodOffset)
static QBasicMutex * signalSlotLock(const QObject *o)
void doActivate(QObject *sender, int signal_index, void **argv)
static Q_DECL_COLD_FUNCTION void err_method_notfound(const QObject *object, const char *method, const char *func)
static bool check_method_code(int code, const QObject *object, const char *method, const char *func)
void qt_register_signal_spy_callbacks(QSignalSpyCallbackSet *callback_set)
static Q_CONSTINIT QBasicMutex _q_ObjectMutexPool[131]
static bool matches_objectName_non_null(QObject *obj, QAnyStringView name)
static int extract_code(const char *member)
static QByteArray formatConnectionSignature(const char *className, const QMetaMethod &method)
static void connectWarning(const QObject *sender, const QMetaObject *senderMetaObject, const QObject *receiver, const char *message)
const char * qFlagLocation(const char *method)
static void queued_activate(QObject *sender, int signal, QObjectPrivate::Connection *c, void **argv)
static bool check_signal_macro(const QObject *sender, const char *signal, const char *func, const char *op)
static Q_DECL_COLD_FUNCTION void err_info_about_objects(const char *func, const QObject *sender, const QObject *receiver)
Q_CORE_EXPORT QBasicAtomicPointer< QSignalSpyCallbackSet > qt_signal_spy_callback_set
static bool contains(const QJsonArray &haystack, unsigned needle)
GLboolean GLboolean GLboolean b
GLsizei const GLfloat * v
[13]
GLuint64 GLenum void * handle
GLint GLenum GLsizei GLsizei GLsizei depth
GLenum GLuint GLint level
GLboolean GLboolean GLboolean GLboolean a
[7]
GLsizei GLenum GLenum * types
GLenum GLenum GLsizei count
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
GLuint GLsizei const GLchar * message
GLsizei GLenum GLsizei GLsizei GLuint memory
GLdouble GLdouble GLdouble GLdouble q
GLuint const GLint * locations
static Q_CONSTINIT thread_local QBindingStatus bindingStatus
#define Q_ASSERT_X(cond, x, msg)
QScopeGuard< typename std::decay< F >::type > qScopeGuard(F &&f)
[qScopeGuard]
#define qPrintable(string)
#define qUtf16Printable(string)
#define Q_HAS_TRACEPOINTS
#define Q_TRACE_SCOPE(x,...)
#define Q_TRACE_POINT(provider, tracepoint,...)
QT_BEGIN_NAMESPACE constexpr std::underlying_type_t< Enum > qToUnderlying(Enum e) noexcept
#define QT6_IMPL_NEW_OVERLOAD_TAIL
const char className[16]
[1]
Q_CHECK_PTR(a=new int[80])
QRandomGenerator64 rd
[10]
connect(quitButton, &QPushButton::clicked, &app, &QCoreApplication::quit, Qt::QueuedConnection)
qsizetype indexOf(const AT &t, qsizetype from=0) const noexcept
std::atomic< TaggedSignalVector > orphaned
QAtomicInteger< uint > currentConnectionId
@ AlreadyLockedAndTemporarilyReleasingLock
ConnectionList & connectionsForSignal(int signal)
int signalVectorCount() const
void removeConnection(Connection *c)
void resizeSignalVector(uint size)
static void deleteOrphaned(TaggedSignalVector o)
void cleanOrphanedConnectionsImpl(QObject *sender, LockPolicy lockPolicy)
QAtomicPointer< SignalVector > signalVector
QAtomicPointer< Connection > first
QAtomicPointer< const int > argumentTypes
QAtomicPointer< Connection > nextConnectionList
QAtomicPointer< QObject > receiver
QtPrivate::QSlotObjectBase * slotObj
ConnectionList & at(int i)
QBasicAtomicInt strongref
QtPrivate::QSlotObjectBase * operator->()
~SlotObjectGuard()=default
QtPrivate::QSlotObjectBase const * operator->() const
SlotObjectGuard()=default