void QNodePrivate::propertyChanged(int propertyIndex) { // Bail out early if we can to avoid the cost below if (m_blockNotifications) return; Q_Q(QNode); const QMetaProperty property = q->metaObject()->property(propertyIndex); const QVariant data = property.read(q); if (data.canConvert<QNode*>()) { QNode *node = data.value<QNode*>(); // Ensure the node has issued a node creation change. We can end // up here if a newly created node with a parent is immediately set // as a property on another node. In this case the deferred call to // _q_postConstructorInit() will not have happened yet as the event // loop will still be blocked. So force it here and we catch this // eventuality in the _q_postConstructorInit() function so that we // do not repeat the creation and new child scene change events. if (node) QNodePrivate::get(node)->_q_postConstructorInit(); const QNodeId id = node ? node->id() : QNodeId(); notifyPropertyChange(property.name(), QVariant::fromValue(id)); } else { notifyPropertyChange(property.name(), data); } }
/*! * \internal * * Reparents the public QNode to \a parent. If the new parent is nullptr then this * QNode is no longer part of the scene and so we notify the backend of its removal * from its parent's list of children, and then send a QNodeDestroyedChange to the * aspects so that the corresponding backend node is destroyed. * * If \a parent is not null, then we must tell its new parent about this QNode now * being a child of it on the backend. If this QNode did not have a parent upon * entry to this function, then we must first send a QNodeCreatedChange to the backend * prior to sending the QPropertyNodeAddedChange to its parent. * * Note: This function should never be called from the ctor directly as the type may * not be fully created yet and creating creation changes involves calling a virtual * function on QNode. The function _q_notifyCreationAndChildChanges() is used * for sending initial notification when a parent is passed to the QNode ctor. * That function does a subset of this function with the assumption that the new object * had no parent before (must be true as it is newly constructed). */ void QNodePrivate::_q_setParentHelper(QNode *parent) { Q_Q(QNode); QNode *oldParentNode = q->parentNode(); // We may get the situation where the QML engine has set the QObject // parent but we have not yet set up the QNode parent requirements. // This check handles this and means we propagate the scene and arbiter // from the parent in the code below. const bool needsSceneInit = !oldParentNode || (oldParentNode && m_parentId != oldParentNode->id()); // If we had a parent, we let him know that we are about to change // parent if (oldParentNode && m_hasBackendNode) { QNodePrivate::get(oldParentNode)->_q_removeChild(q); // If we have an old parent but the new parent is null // the backend node needs to be destroyed if (!parent) notifyDestructionChangesAndRemoveFromScene(); } // Flag that we need to notify any new parent m_notifiedParent = false; // Basically QObject::setParent but for QObjectPrivate QObjectPrivate::setParent_helper(parent); QNode *newParentNode = q->parentNode(); if (newParentNode) { // If we had no parent but are about to set one, // we need to send a QNodeCreatedChange if (needsSceneInit) { QNodePrivate *newParentPrivate = QNodePrivate::get(newParentNode); // Set the scene helper / arbiter if (newParentPrivate->m_scene) { QNodeVisitor visitor; visitor.traverse(q, newParentNode->d_func(), &QNodePrivate::setSceneHelper); } // We want to make sure that subTreeRoot is always created before // child. // Given a case such as below // QEntity *subTreeRoot = new QEntity(someGlobalExisitingRoot) // QEntity *child = new QEntity(); // child->setParent(subTreeRoot) // We need to take into account that subTreeRoot needs to be // created in the backend before the child. // Therefore we only call notifyCreationChanges if the parent // hasn't been created yet as we know that when the parent will be // fully created, it will also send the changes for all of its // children if (QNodePrivate::get(newParentNode)->m_hasBackendNode) notifyCreationChange(); } // If we have a valid new parent, we let him know that we are its child QNodePrivate::get(newParentNode)->_q_addChild(q); } }