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();
}
