void QDeclarativeLoaderPrivate::_q_sourceLoaded() { Q_Q(QDeclarativeLoader); if (component) { if (!component->errors().isEmpty()) { QDeclarativeEnginePrivate::warning(qmlEngine(q), component->errors()); emit q->sourceChanged(); emit q->statusChanged(); emit q->progressChanged(); return; } QDeclarativeContext *creationContext = component->creationContext(); if (!creationContext) creationContext = qmlContext(q); QDeclarativeContext *ctxt = new QDeclarativeContext(creationContext); ctxt->setContextObject(q); QDeclarativeGuard<QDeclarativeComponent> c = component; QObject *obj = component->beginCreate(ctxt); if (component != c) { // component->create could trigger a change in source that causes // component to be set to something else. In that case we just // need to cleanup. if (c) c->completeCreate(); delete obj; delete ctxt; return; } if (obj) { item = qobject_cast<QGraphicsObject *>(obj); if (item) { QDeclarative_setParent_noEvent(ctxt, obj); QDeclarative_setParent_noEvent(item, q); item->setParentItem(q); // item->setFocus(true); initResize(); } else { qmlInfo(q) << QDeclarativeLoader::tr("Loader does not support loading non-visual elements."); delete obj; delete ctxt; } } else { if (!component->errors().isEmpty()) QDeclarativeEnginePrivate::warning(qmlEngine(q), component->errors()); delete obj; delete ctxt; source = QUrl(); } component->completeCreate(); emit q->sourceChanged(); emit q->statusChanged(); emit q->progressChanged(); emit q->itemChanged(); emit q->loaded(); } }
void QQuickSprite::startImageLoading() { m_pix.clear(this); if (!m_source.isEmpty()) { QQmlEngine *e = qmlEngine(this); if (!e) { //If not created in QML, you must set the QObject parent to the QML element so this can work e = qmlEngine(parent()); if (!e) qWarning() << "QQuickSprite: Cannot find QQmlEngine - this class is only for use in QML and may not work"; } m_pix.load(e, m_source); } }
QDeclarativeInfo::~QDeclarativeInfo() { if (0 == --d->ref) { QList<QDeclarativeError> errors = d->errors; QDeclarativeEngine *engine = 0; if (!d->buffer.isEmpty()) { QDeclarativeError error; QObject *object = const_cast<QObject *>(d->object); if (object) { engine = qmlEngine(d->object); QString typeName; QDeclarativeType *type = QDeclarativeMetaType::qmlType(object->metaObject()); if (type) { typeName = QLatin1String(type->qmlTypeName()); int lastSlash = typeName.lastIndexOf(QLatin1Char('/')); if (lastSlash != -1) typeName = typeName.mid(lastSlash+1); } else { typeName = QString::fromUtf8(object->metaObject()->className()); int marker = typeName.indexOf(QLatin1String("_QMLTYPE_")); if (marker != -1) typeName = typeName.left(marker); marker = typeName.indexOf(QLatin1String("_QML_")); if (marker != -1) { typeName = typeName.left(marker) + "*"; type = QDeclarativeMetaType::qmlType(QMetaType::type(typeName.toLatin1())); if (type) { typeName = QLatin1String(type->qmlTypeName()); int lastSlash = typeName.lastIndexOf(QLatin1Char('/')); if (lastSlash != -1) typeName = typeName.mid(lastSlash+1); } } } d->buffer.prepend(QLatin1String("QML ") + typeName + QLatin1String(": ")); QDeclarativeData *ddata = QDeclarativeData::get(object, false); if (ddata && ddata->outerContext && !ddata->outerContext->url.isEmpty()) { error.setUrl(ddata->outerContext->url); error.setLine(ddata->lineNumber); error.setColumn(ddata->columnNumber); } } error.setDescription(d->buffer); errors.prepend(error); } QDeclarativeEnginePrivate::warning(engine, errors); delete d; } }
QQuickItem *GlobalFunctions::itemAt(QQuickItem* parent, int x, int y, QJSValue matcher) { if (!parent) return nullptr; QList<QQuickItem *> children = QQuickItemPrivate::get(parent)->paintOrderChildItems(); for (int i = children.count() - 1; i >= 0; --i) { QQuickItem *child = children.at(i); // Map coordinates to the child element's coordinate space QPointF point = parent->mapToItem(child, QPointF(x, y)); if (child->isVisible() && point.x() >= 0 && child->width() >= point.x() && point.y() >= 0 && child->height() >= point.y()) { if (!matcher.isCallable()) return child; QQmlEngine* engine = qmlEngine(child); if (!engine) return child; QJSValue newObj = engine->newQObject(child); if (matcher.call(QJSValueList() << newObj).toBool()) { return child; } } } return nullptr; }
void QQuickLoaderPrivate::incubatorStateChanged(QQmlIncubator::Status status) { Q_Q(QQuickLoader); if (status == QQmlIncubator::Loading || status == QQmlIncubator::Null) return; if (status == QQmlIncubator::Ready) { object = incubator->object(); item = qmlobject_cast<QQuickItem*>(object); emit q->itemChanged(); initResize(); incubator->clear(); } else if (status == QQmlIncubator::Error) { if (!incubator->errors().isEmpty()) QQmlEnginePrivate::warning(qmlEngine(q), incubator->errors()); delete itemContext; itemContext = 0; delete incubator->object(); source = QUrl(); emit q->itemChanged(); } if (loadingFromSource) emit q->sourceChanged(); else emit q->sourceComponentChanged(); emit q->statusChanged(); emit q->progressChanged(); if (status == QQmlIncubator::Ready) emit q->loaded(); disposeInitialPropertyValues(); // cleanup }
void QQuickLoaderPrivate::_q_sourceLoaded() { Q_Q(QQuickLoader); if (!component || !component->errors().isEmpty()) { if (component) QQmlEnginePrivate::warning(qmlEngine(q), component->errors()); if (loadingFromSource) emit q->sourceChanged(); else emit q->sourceComponentChanged(); emit q->statusChanged(); emit q->progressChanged(); emit q->itemChanged(); //Like clearing source, emit itemChanged even if previous item was also null disposeInitialPropertyValues(); // cleanup return; } QQmlContext *creationContext = component->creationContext(); if (!creationContext) creationContext = qmlContext(q); itemContext = new QQmlContext(creationContext); itemContext->setContextObject(q); delete incubator; incubator = new QQuickLoaderIncubator(this, asynchronous ? QQmlIncubator::Asynchronous : QQmlIncubator::AsynchronousIfNested); component->create(*incubator, itemContext); if (incubator && incubator->status() == QQmlIncubator::Loading) emit q->statusChanged(); }
void Quick3DBuffer::initEngines() { if (m_engine == Q_NULLPTR) { m_engine = qmlEngine(parent()); m_v4engine = QQmlEnginePrivate::getV4Engine(m_engine); } }
void QDeclarativeFontLoader::setSource(const QUrl &url) { Q_D(QDeclarativeFontLoader); if (url == d->url) return; d->url = qmlContext(this)->resolvedUrl(url); d->status = Loading; emit statusChanged(); emit sourceChanged(); #ifndef QT_NO_LOCALFILE_OPTIMIZED_QML QString lf = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(d->url); if (!lf.isEmpty()) { int id = QFontDatabase::addApplicationFont(lf); if (id != -1) { d->name = QFontDatabase::applicationFontFamilies(id).at(0); emit nameChanged(); d->status = QDeclarativeFontLoader::Ready; } else { d->status = QDeclarativeFontLoader::Error; qmlInfo(this) << "Cannot load font: \"" << url.toString() << "\""; } emit statusChanged(); } else #endif { QNetworkRequest req(d->url); req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true); d->reply = qmlEngine(this)->networkAccessManager()->get(req); QObject::connect(d->reply, SIGNAL(finished()), this, SLOT(replyFinished())); } }
void QDeclarativeBorderImage::setGridScaledImage(const QDeclarativeGridScaledImage& sci) { Q_D(QDeclarativeBorderImage); if (!sci.isValid()) { d->status = Error; emit statusChanged(d->status); } else { QDeclarativeScaleGrid *sg = border(); sg->setTop(sci.gridTop()); sg->setBottom(sci.gridBottom()); sg->setLeft(sci.gridLeft()); sg->setRight(sci.gridRight()); d->horizontalTileMode = sci.horizontalTileRule(); d->verticalTileMode = sci.verticalTileRule(); d->sciurl = d->url.resolved(QUrl(sci.pixmapUrl())); QDeclarativePixmap::Options options; if (d->async) options |= QDeclarativePixmap::Asynchronous; if (d->cache) options |= QDeclarativePixmap::Cache; d->pix.clear(this); d->pix.load(qmlEngine(this), d->sciurl, options); if (d->pix.isLoading()) { static int thisRequestProgress = -1; static int thisRequestFinished = -1; if (thisRequestProgress == -1) { thisRequestProgress = QDeclarativeBorderImage::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)"); thisRequestFinished = QDeclarativeBorderImage::staticMetaObject.indexOfSlot("requestFinished()"); } d->pix.connectFinished(this, thisRequestFinished); d->pix.connectDownloadProgress(this, thisRequestProgress); } else { QSize impsize = d->pix.implicitSize(); setImplicitWidth(impsize.width()); setImplicitHeight(impsize.height()); if (d->pix.isReady()) { d->status = Ready; } else { d->status = Error; qmlInfo(this) << d->pix.error(); } d->progress = 1.0; emit statusChanged(d->status); emit progressChanged(1.0); update(); } } }
void QQuickOpenGLShaderEffectCommon::lookThroughShaderCode(QQuickItem *item, const QMetaObject *itemMetaObject, Key::ShaderType shaderType, const QByteArray &code) { QQmlPropertyCache *propCache = QQmlData::ensurePropertyCache(qmlEngine(item), item); int index = 0; int typeIndex = -1; int typeLength = 0; int nameIndex = -1; int nameLength = 0; const char *s = code.constData(); VariableQualifier decl = AttributeQualifier; while ((index = qt_search_for_variable(s, code.size(), index, decl, typeIndex, typeLength, nameIndex, nameLength, shaderType)) != -1) { if (decl == AttributeQualifier) { if (shaderType == Key::VertexShader) attributes.append(QByteArray(s + nameIndex, nameLength)); } else { Q_ASSERT(decl == UniformQualifier); const int sampLen = sizeof("sampler2D") - 1; const int sampExtLen = sizeof("samplerExternalOES") - 1; const int opLen = sizeof("qt_Opacity") - 1; const int matLen = sizeof("qt_Matrix") - 1; const int srLen = sizeof("qt_SubRect_") - 1; UniformData d; QtPrivate::MappedSlotObject *mapper = nullptr; d.name = QByteArray(s + nameIndex, nameLength); if (nameLength == opLen && qstrncmp("qt_Opacity", s + nameIndex, opLen) == 0) { d.specialType = UniformData::Opacity; } else if (nameLength == matLen && qstrncmp("qt_Matrix", s + nameIndex, matLen) == 0) { d.specialType = UniformData::Matrix; } else if (nameLength > srLen && qstrncmp("qt_SubRect_", s + nameIndex, srLen) == 0) { d.specialType = UniformData::SubRect; } else { if (QQmlPropertyData *pd = propCache->property(QString::fromUtf8(d.name), nullptr, nullptr)) { if (!pd->isFunction()) d.propertyIndex = pd->coreIndex(); } const int mappedId = uniformData[shaderType].size() | (shaderType << 16); mapper = new QtPrivate::MappedSlotObject([this, mappedId](){ this->mappedPropertyChanged(mappedId); }); if (typeLength == sampLen && qstrncmp("sampler2D", s + typeIndex, sampLen) == 0) d.specialType = UniformData::Sampler; else if (typeLength == sampExtLen && qstrncmp("samplerExternalOES", s + typeIndex, sampExtLen) == 0) d.specialType = UniformData::SamplerExternal; else d.specialType = UniformData::None; d.setValueFromProperty(item, itemMetaObject); } uniformData[shaderType].append(d); signalMappers[shaderType].append(mapper); } } }
void QQuickWebEngineViewPrivate::didRunJavaScript(quint64 requestId, const QVariant &result) { Q_Q(QQuickWebEngineView); QJSValue callback = m_callbacks.take(requestId); QJSValueList args; args.append(qmlEngine(q)->toScriptValue(result)); callback.call(args); }
void QmlCppEngine::notifyEngineRemoteSetupFinished(const RemoteSetupResult &result) { EDEBUG("MASTER REMOTE SETUP FINISHED"); DebuggerEngine::notifyEngineRemoteSetupFinished(result); cppEngine()->notifyEngineRemoteSetupFinished(result); qmlEngine()->notifyEngineRemoteSetupFinished(result); }
void QmlCppEngine::notifyEngineRemoteSetupFailed(const QString &message) { EDEBUG("MASTER REMOTE SETUP FAILED"); DebuggerEngine::notifyEngineRemoteSetupFailed(message); cppEngine()->notifyEngineRemoteSetupFailed(message); qmlEngine()->notifyEngineRemoteSetupFailed(message); }
// get all entries (this is costly call) QJSValue ValueModel::getList() const { QJSValue array = qmlEngine(this)->newArray(m_data.count()); for(int i=0; i<m_data.count(); i++) { array.setProperty(i, m_data.at(i)); } return array; }
void OpdsBookModel::load(const QUrl &source) { QNetworkAccessManager *manager = qmlEngine(QObject::parent())->networkAccessManager(); QNetworkRequest request(source); QNetworkReply *reply = manager->get(request); connect(reply, &QNetworkReply::finished, this, &OpdsBookModel::onReplyFinished); }
void QmlCppEngine::notifyEngineRemoteSetupDone(int gdbServerPort, int qmlPort) { EDEBUG("MASTER REMOTE SETUP DONE"); DebuggerEngine::notifyEngineRemoteSetupDone(gdbServerPort, qmlPort); cppEngine()->notifyEngineRemoteSetupDone(gdbServerPort, qmlPort); qmlEngine()->notifyEngineRemoteSetupDone(gdbServerPort, qmlPort); }
void QDeclarativeAnimatedImage::setSource(const QUrl &url) { Q_D(QDeclarativeAnimatedImage); if (url == d->url) return; delete d->_movie; d->_movie = 0; if (d->reply) { d->reply->deleteLater(); d->reply = 0; } d->url = url; if (url.isEmpty()) { delete d->_movie; d->status = Null; } else { #ifndef QT_NO_LOCALFILE_OPTIMIZED_QML QString lf = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url); if (!lf.isEmpty()) { //### should be unified with movieRequestFinished d->_movie = new QMovie(lf); if (!d->_movie->isValid()){ qmlInfo(this) << "Error Reading Animated Image File " << d->url.toString(); delete d->_movie; d->_movie = 0; return; } connect(d->_movie, SIGNAL(stateChanged(QMovie::MovieState)), this, SLOT(playingStatusChanged())); connect(d->_movie, SIGNAL(frameChanged(int)), this, SLOT(movieUpdate())); d->_movie->setCacheMode(QMovie::CacheAll); if(d->playing) d->_movie->start(); else d->_movie->jumpToFrame(0); if(d->paused) d->_movie->setPaused(true); d->setPixmap(d->_movie->currentPixmap()); d->status = Ready; d->progress = 1.0; emit statusChanged(d->status); emit sourceChanged(d->url); emit progressChanged(d->progress); return; } #endif d->status = Loading; QNetworkRequest req(d->url); req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true); d->reply = qmlEngine(this)->networkAccessManager()->get(req); QObject::connect(d->reply, SIGNAL(finished()), this, SLOT(movieRequestFinished())); }
QObject *CompetitorsPlugin::createCompetitorDocument(QObject *parent) { CompetitorDocument *ret = new CompetitorDocument(parent); if(!parent) { qfWarning() << "Parent is NULL, created class will have QQmlEngine::JavaScriptOwnership."; qmlEngine()->setObjectOwnership(ret, QQmlEngine::JavaScriptOwnership); } return ret; }
QQuickItem * DataSetView::createRowNumber(int row) { //std::cout << "createRowNumber("<<row<<") called!\n" << std::flush; if(_rowNumberDelegate == NULL) { _rowNumberDelegate = new QQmlComponent(qmlEngine(this)); _rowNumberDelegate->setData("import QtQuick 2.10\nItem {\n" "property alias text: tekst.text\n" "Rectangle { color: \"lightGrey\"; anchors.fill: parent }\n" "Text { id: tekst; anchors.centerIn: parent }\n" "}", QUrl()); } QQuickItem * rowNumber = NULL; if(_rowNumberItems.count(row) == 0 || _rowNumberItems[row] == NULL) { if(_rowNumberStorage.size() > 0) { #ifdef DEBUG_VIEWPORT std::cout << "createRowNumber("<<row<<") from storage!\n" << std::flush; #endif rowNumber = _rowNumberStorage.top(); _rowNumberStorage.pop(); } else { #ifdef DEBUG_VIEWPORT std::cout << "createRowNumber("<<row<<") ex nihilo!\n" << std::flush; #endif rowNumber = qobject_cast<QQuickItem*>(_rowNumberDelegate->create()); rowNumber->setParent(this); rowNumber->setParentItem(this); } rowNumber->setProperty("z", 10); rowNumber->setProperty("text", QString::fromStdString(std::to_string(row + 1))); //Nobody wants zero-based rows... rowNumber->setY(_dataRowsMaxHeight * (1 + row)); rowNumber->setZ(-3); rowNumber->setHeight(_dataRowsMaxHeight); rowNumber->setWidth(_rowNumberMaxWidth); rowNumber->setVisible(true); _rowNumberItems[row] = rowNumber; } else rowNumber = _rowNumberItems[row]; rowNumber->setX(_viewportX); return _rowNumberItems[row]; }
QQuickItem * DataSetView::createColumnHeader(int col) { //std::cout << "createColumnHeader("<<col<<") called!\n" << std::flush; if(_columnHeaderDelegate == NULL) { _columnHeaderDelegate = new QQmlComponent(qmlEngine(this)); _columnHeaderDelegate->setData("import QtQuick 2.10\nItem {\n" "property alias text: tekst.text\n" "Rectangle { color: \"lightGrey\"; anchors.fill: parent }\n" "Text { id: tekst; anchors.centerIn: parent }\n" "}", QUrl()); } QQuickItem * columnHeader = NULL; if(_columnHeaderItems.count(col) == 0 || _columnHeaderItems[col] == NULL) { if(_columnHeaderStorage.size() > 0) { #ifdef DEBUG_VIEWPORT std::cout << "createColumnHeader("<<col<<") from storage!\n" << std::flush; #endif columnHeader = _columnHeaderStorage.top(); _columnHeaderStorage.pop(); } else { #ifdef DEBUG_VIEWPORT std::cout << "createColumnHeader("<<col<<") ex nihilo!\n" << std::flush; #endif columnHeader = qobject_cast<QQuickItem*>(_columnHeaderDelegate->create()); columnHeader->setParent(this); columnHeader->setParentItem(this); } columnHeader->setProperty("z", 10); columnHeader->setProperty("text", _model->headerData(col, Qt::Orientation::Horizontal).toString()); columnHeader->setZ(-3); columnHeader->setHeight(_dataRowsMaxHeight); columnHeader->setWidth(_dataColsMaxWidth[col]); columnHeader->setVisible(true); _columnHeaderItems[col] = columnHeader; } else columnHeader = _columnHeaderItems[col]; columnHeader->setX(_colXPositions[col]); columnHeader->setY(_viewportY); return columnHeader; }
void QQmlVMEMetaObject::allocateVarPropertiesArray() { QQmlEngine *qml = qmlEngine(object); assert(qml); QV4::ExecutionEngine *v4 = QV8Engine::getV4(qml->handle()); QV4::Scope scope(v4); varProperties = QV4::ScopedValue(scope, v4->newArrayObject(metaData->varPropertyCount)); varPropertiesInitialized = true; }
void QQuickImageBase::load() { Q_D(QQuickImageBase); if (d->url.isEmpty()) { d->pix.clear(this); if (d->progress != 0.0) { d->progress = 0.0; emit progressChanged(d->progress); } pixmapChange(); d->status = Null; emit statusChanged(d->status); if (sourceSize() != d->oldSourceSize) { d->oldSourceSize = sourceSize(); emit sourceSizeChanged(); } update(); } else { QQuickPixmap::Options options; if (d->async) options |= QQuickPixmap::Asynchronous; if (d->cache) options |= QQuickPixmap::Cache; d->pix.clear(this); d->pix.load(qmlEngine(this), d->url, d->sourcesize, options); if (d->pix.isLoading()) { if (d->progress != 0.0) { d->progress = 0.0; emit progressChanged(d->progress); } if (d->status != Loading) { d->status = Loading; emit statusChanged(d->status); } static int thisRequestProgress = -1; static int thisRequestFinished = -1; if (thisRequestProgress == -1) { thisRequestProgress = QQuickImageBase::staticMetaObject.indexOfSlot("requestProgress(qint64,qint64)"); thisRequestFinished = QQuickImageBase::staticMetaObject.indexOfSlot("requestFinished()"); } d->pix.connectFinished(this, thisRequestFinished); d->pix.connectDownloadProgress(this, thisRequestProgress); update(); //pixmap may have invalidated texture, updatePaintNode needs to be called before the next repaint } else { requestFinished(); } } }
QDeclarativeAction::QDeclarativeAction(QObject *target, const QString &propertyName, const QVariant &value) : restore(true), actionDone(false), reverseEvent(false), deletableToBinding(false), property(target, propertyName, qmlEngine(target)), toValue(value), fromBinding(0), event(0), specifiedObject(target), specifiedProperty(propertyName) { if (property.isValid()) fromValue = property.read(); }
int callerLine(int frameIndex = 0) const { QQmlEngine *engine = qmlEngine(this); QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine->handle()); QVector<QV4::StackFrame> stack = v4->stackTrace(frameIndex + 2); if (stack.size() > frameIndex + 1) return stack.at(frameIndex + 1).line; return -1; }
QtFlickProvider::QtFlickProvider(QQuickWebView* viewItem, QQuickWebPage* pageItem) : QObject(viewItem) { ASSERT(viewItem); ASSERT(pageItem); QDeclarativeEngine* engine = qmlEngine(viewItem); QDeclarativeContext* context = qmlContext(viewItem); ASSERT(engine); ASSERT(context); QDeclarativeComponent component(engine, viewItem); // Create the internal Flickable instance dynamically. // We only use public QML API so that we do not depend // on private API of the QtDeclarative module. component.setData(QByteArrayLiteral("import QtQuick 2.0\nFlickable {}"), QUrl()); m_flickable = qobject_cast<QQuickItem*>(component.create(context)); QMetaProperty content = resolveMetaProperty(m_flickable, "contentItem"); m_contentItem = content.read(m_flickable).value<QQuickItem*>(); ASSERT(m_contentItem); // Resolve meta methods and properties of the Flickable instance. m_returnToBoundsMethod = resolveMetaMethod(m_flickable, "returnToBounds()"); m_cancelFlickMethod = resolveMetaMethod(m_flickable, "cancelFlick()"); m_contentWidth = resolveMetaProperty(m_flickable, "contentWidth"); m_contentHeight = resolveMetaProperty(m_flickable, "contentHeight"); m_contentX = resolveMetaProperty(m_flickable, "contentX"); m_contentY = resolveMetaProperty(m_flickable, "contentY"); m_moving = resolveMetaProperty(m_flickable, "moving"); m_dragging = resolveMetaProperty(m_flickable, "dragging"); m_flicking = resolveMetaProperty(m_flickable, "flicking"); m_flickableData = resolveMetaProperty(m_flickable, "flickableData"); // Set the viewItem as the parent of the flickable instance // and reparent the page so it is placed on the flickable contentItem. m_flickable->setParentItem(viewItem); pageItem->setParentItem(m_contentItem); // Propagate flickable signals. connect(m_flickable, SIGNAL(movementStarted()), SIGNAL(movementStarted()), Qt::DirectConnection); connect(m_flickable, SIGNAL(movementEnded()), SIGNAL(movementEnded()), Qt::DirectConnection); connect(m_flickable, SIGNAL(flickingChanged()), SIGNAL(flickingChanged()), Qt::DirectConnection); connect(m_flickable, SIGNAL(draggingChanged()), SIGNAL(draggingChanged()), Qt::DirectConnection); connect(m_flickable, SIGNAL(contentWidthChanged()), SIGNAL(contentWidthChanged()), Qt::DirectConnection); connect(m_flickable, SIGNAL(contentHeightChanged()), SIGNAL(contentHeightChanged()), Qt::DirectConnection); connect(m_flickable, SIGNAL(contentXChanged()), SIGNAL(contentXChanged()), Qt::DirectConnection); connect(m_flickable, SIGNAL(contentYChanged()), SIGNAL(contentYChanged()), Qt::DirectConnection); }
void QDeclarativeBehavior::setTarget(const QDeclarativeProperty &property) { Q_D(QDeclarativeBehavior); d->property = property; d->currentValue = property.read(); if (d->animation) d->animation->setDefaultTarget(property); QDeclarativeEnginePrivate *engPriv = QDeclarativeEnginePrivate::get(qmlEngine(this)); engPriv->registerFinalizedParserStatusObject(this, this->metaObject()->indexOfSlot("componentFinalized()")); }
void QQuickLoader::componentComplete() { Q_D(QQuickLoader); QQuickItem::componentComplete(); if (active()) { if (d->loadingFromSource) { QQmlComponent::CompilationMode mode = d->asynchronous ? QQmlComponent::Asynchronous : QQmlComponent::PreferSynchronous; d->component = new QQmlComponent(qmlEngine(this), d->source, mode, this); } d->load(); } }
void contextSetObject(QQmlContext_ *context, QObject_ *value) { QQmlContext *qcontext = reinterpret_cast<QQmlContext *>(context); QObject *qvalue = reinterpret_cast<QObject *>(value); // Give qvalue an engine reference if it doesn't yet have one. if (!qmlEngine(qvalue)) { QQmlEngine::setContextForObject(qvalue, qcontext->engine()->rootContext()); } qcontext->setContextObject(qvalue); }
QmlPromise::QmlPromise(QObject* parent) : QObject(parent) { auto engine = qmlEngine(parent); if (engine == nullptr) qFatal("Could not find QML engine. Unable to continue."); QQmlComponent promiserComponent(qmlEngine(parent)); promiserComponent.setData("import QuickPromise 1.0\nPromise {}", QUrl()); internalPromise = promiserComponent.create(); QQmlEngine::setObjectOwnership(internalPromise, QQmlEngine::JavaScriptOwnership); connect(internalPromise, &QObject::destroyed, this, [this] { // Probably won't happen often, if ever, but if it does it could provide useful insights vis a vis debugging qDebug() << "Promise{} was garbage collected while QmlPromise still valid"; internalPromise = nullptr; }); connect(internalPromise, SIGNAL(fulfilled(QVariant)), this, SIGNAL(fulfilled(QVariant))); connect(internalPromise, SIGNAL(rejected(QVariant)), this, SIGNAL(rejected(QVariant))); connect(internalPromise, SIGNAL(settled(QVariant)), this, SIGNAL(settled())); connect(this, &QmlPromise::fulfilled, [this] { wasFulfilled = true; }); connect(this, &QmlPromise::rejected, [this] { wasRejected = true; }); }
QQmlV4Handle callerFile(int frameIndex = 0) const { QQmlEngine *engine = qmlEngine(this); QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine->handle()); QV4::Scope scope(v4); QVector<QV4::StackFrame> stack = v4->stackTrace(frameIndex + 2); if (stack.size() > frameIndex + 1) { QV4::ScopedValue s(scope, v4->newString(stack.at(frameIndex + 1).source)); return QQmlV4Handle(s); } return QQmlV4Handle(); }