QVariant QQmlStringConverters::variantFromString(const QString &s, int preferredType, bool *ok) { switch (preferredType) { case QMetaType::Int: return QVariant(int(qRound(s.toDouble(ok)))); case QMetaType::UInt: return QVariant(uint(qRound(s.toDouble(ok)))); #ifndef QT_NO_DATESTRING case QMetaType::QDate: return QVariant::fromValue(dateFromString(s, ok)); case QMetaType::QTime: return QVariant::fromValue(timeFromString(s, ok)); case QMetaType::QDateTime: return QVariant::fromValue(dateTimeFromString(s, ok)); #endif // QT_NO_DATESTRING case QMetaType::QPointF: return QVariant::fromValue(pointFFromString(s, ok)); case QMetaType::QPoint: return QVariant::fromValue(pointFFromString(s, ok).toPoint()); case QMetaType::QSizeF: return QVariant::fromValue(sizeFFromString(s, ok)); case QMetaType::QSize: return QVariant::fromValue(sizeFFromString(s, ok).toSize()); case QMetaType::QRectF: return QVariant::fromValue(rectFFromString(s, ok)); case QMetaType::QRect: return QVariant::fromValue(rectFFromString(s, ok).toRect()); default: return QQml_valueTypeProvider()->createVariantFromString(preferredType, s, ok); } }
void QQmlVMEVariant::ensureValueType(int t) { if (type != t) { cleanup(); type = t; QQml_valueTypeProvider()->initValueType(t, dataPtr(), dataSize()); } }
QT_BEGIN_NAMESPACE QVariant QQmlStringConverters::variantFromString(const QString &s) { if (s.isEmpty()) return QVariant(s); bool ok = false; QRectF r = rectFFromString(s, &ok); if (ok) return QVariant(r); QPointF p = pointFFromString(s, &ok); if (ok) return QVariant(p); QSizeF sz = sizeFFromString(s, &ok); if (ok) return QVariant(sz); return QQml_valueTypeProvider()->createVariantFromString(s); }
void QQmlVMEVariant::cleanup() { if (type == QVariant::Invalid) { } else if (type == QMetaType::Int || type == QMetaType::Bool || type == QMetaType::Double) { type = QVariant::Invalid; } else if (type == QMetaType::QObjectStar) { ((QQmlVMEVariantQObjectPtr*)dataPtr())->~QQmlVMEVariantQObjectPtr(); type = QVariant::Invalid; } else if (type == QMetaType::QString) { ((QString *)dataPtr())->~QString(); type = QVariant::Invalid; } else if (type == QMetaType::QUrl) { ((QUrl *)dataPtr())->~QUrl(); type = QVariant::Invalid; } else if (type == QMetaType::QTime) { ((QTime *)dataPtr())->~QTime(); type = QVariant::Invalid; } else if (type == QMetaType::QDate) { ((QDate *)dataPtr())->~QDate(); type = QVariant::Invalid; } else if (type == QMetaType::QDateTime) { ((QDateTime *)dataPtr())->~QDateTime(); type = QVariant::Invalid; } else if (type == QMetaType::QRectF) { ((QRectF *)dataPtr())->~QRectF(); type = QVariant::Invalid; } else if (type == QMetaType::QPointF) { ((QPointF *)dataPtr())->~QPointF(); type = QVariant::Invalid; } else if (type == QMetaType::QSizeF) { ((QSizeF *)dataPtr())->~QSizeF(); type = QVariant::Invalid; } else if (type == qMetaTypeId<QVariant>()) { ((QVariant *)dataPtr())->~QVariant(); type = QVariant::Invalid; } else if (type == qMetaTypeId<QJSValue>()) { ((QJSValue *)dataPtr())->~QJSValue(); type = QVariant::Invalid; } else { if (QQml_valueTypeProvider()->destroyValueType(type, dataPtr(), dataSize())) { type = QVariant::Invalid; } } }
bool QQmlStringConverters::createFromString(int type, const QString &s, void *data, size_t n) { Q_ASSERT(data); bool ok = false; switch (type) { case QMetaType::Int: { Q_ASSERT(n >= sizeof(int)); int *p = reinterpret_cast<int *>(data); *p = int(qRound(s.toDouble(&ok))); return ok; } case QMetaType::UInt: { Q_ASSERT(n >= sizeof(uint)); uint *p = reinterpret_cast<uint *>(data); *p = uint(qRound(s.toDouble(&ok))); return ok; } #ifndef QT_NO_DATESTRING case QMetaType::QDate: { Q_ASSERT(n >= sizeof(QDate)); QDate *p = reinterpret_cast<QDate *>(data); *p = dateFromString(s, &ok); return ok; } case QMetaType::QTime: { Q_ASSERT(n >= sizeof(QTime)); QTime *p = reinterpret_cast<QTime *>(data); *p = timeFromString(s, &ok); return ok; } case QMetaType::QDateTime: { Q_ASSERT(n >= sizeof(QDateTime)); QDateTime *p = reinterpret_cast<QDateTime *>(data); *p = dateTimeFromString(s, &ok); return ok; } #endif // QT_NO_DATESTRING case QMetaType::QPointF: { Q_ASSERT(n >= sizeof(QPointF)); QPointF *p = reinterpret_cast<QPointF *>(data); *p = pointFFromString(s, &ok); return ok; } case QMetaType::QPoint: { Q_ASSERT(n >= sizeof(QPoint)); QPoint *p = reinterpret_cast<QPoint *>(data); *p = pointFFromString(s, &ok).toPoint(); return ok; } case QMetaType::QSizeF: { Q_ASSERT(n >= sizeof(QSizeF)); QSizeF *p = reinterpret_cast<QSizeF *>(data); *p = sizeFFromString(s, &ok); return ok; } case QMetaType::QSize: { Q_ASSERT(n >= sizeof(QSize)); QSize *p = reinterpret_cast<QSize *>(data); *p = sizeFFromString(s, &ok).toSize(); return ok; } case QMetaType::QRectF: { Q_ASSERT(n >= sizeof(QRectF)); QRectF *p = reinterpret_cast<QRectF *>(data); *p = rectFFromString(s, &ok); return ok; } case QMetaType::QRect: { Q_ASSERT(n >= sizeof(QRect)); QRect *p = reinterpret_cast<QRect *>(data); *p = rectFFromString(s, &ok).toRect(); return ok; } default: return QQml_valueTypeProvider()->createValueFromString(type, s, data, n); } }
int QQmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a) { int id = _id; if (c == QMetaObject::WriteProperty && interceptors && !(*reinterpret_cast<int*>(a[3]) & QQmlPropertyPrivate::BypassInterceptor)) { for (QQmlPropertyValueInterceptor *vi = interceptors; vi; vi = vi->m_next) { if (vi->m_coreIndex != id) continue; int valueIndex = vi->m_valueTypeCoreIndex; int type = QQmlData::get(object)->propertyCache->property(id)->propType; if (type != QVariant::Invalid) { if (valueIndex != -1) { QQmlValueType *valueType = QQmlValueTypeFactory::valueType(type); Q_ASSERT(valueType); // // Consider the following case: // color c = { 0.1, 0.2, 0.3 } // interceptor exists on c.r // write { 0.2, 0.4, 0.6 } // // The interceptor may choose not to update the r component at this // point (for example, a behavior that creates an animation). But we // need to ensure that the g and b components are updated correctly. // // So we need to perform a full write where the value type is: // r = old value, g = new value, b = new value // // And then call the interceptor which may or may not write the // new value to the r component. // // This will ensure that the other components don't contain stale data // and any relevant signals are emitted. // // To achieve this: // (1) Store the new value type as a whole (needed due to // aliasing between a[0] and static storage in value type). // (2) Read the entire existing value type from object -> valueType temp. // (3) Read the previous value of the component being changed // from the valueType temp. // (4) Write the entire new value type into the temp. // (5) Overwrite the component being changed with the old value. // (6) Perform a full write to the value type (which may emit signals etc). // (7) Issue the interceptor call with the new component value. // QMetaProperty valueProp = valueType->metaObject()->property(valueIndex); QVariant newValue(type, a[0]); valueType->read(object, id); QVariant prevComponentValue = valueProp.read(valueType); valueType->setValue(newValue); QVariant newComponentValue = valueProp.read(valueType); // Don't apply the interceptor if the intercepted value has not changed bool updated = false; if (newComponentValue != prevComponentValue) { valueProp.write(valueType, prevComponentValue); valueType->write(object, id, QQmlPropertyPrivate::DontRemoveBinding | QQmlPropertyPrivate::BypassInterceptor); vi->write(newComponentValue); updated = true; } if (updated) return -1; } else { vi->write(QVariant(type, a[0])); return -1; } } } } if (c == QMetaObject::ReadProperty || c == QMetaObject::WriteProperty || c == QMetaObject::ResetProperty) { if (id >= propOffset()) { id -= propOffset(); if (id < metaData->propertyCount) { int t = (metaData->propertyData() + id)->propertyType; bool needActivate = false; if (id >= firstVarPropertyIndex) { Q_ASSERT(t == QMetaType::QVariant); // the context can be null if accessing var properties from cpp after re-parenting an item. QQmlEnginePrivate *ep = (ctxt == 0 || ctxt->engine == 0) ? 0 : QQmlEnginePrivate::get(ctxt->engine); QV8Engine *v8e = (ep == 0) ? 0 : ep->v8engine(); if (v8e) { if (c == QMetaObject::ReadProperty) { *reinterpret_cast<QVariant *>(a[0]) = readPropertyAsVariant(id); } else if (c == QMetaObject::WriteProperty) { writeProperty(id, *reinterpret_cast<QVariant *>(a[0])); } } else if (c == QMetaObject::ReadProperty) { // if the context was disposed, we just return an invalid variant from read. *reinterpret_cast<QVariant *>(a[0]) = QVariant(); } } else { if (c == QMetaObject::ReadProperty) { switch(t) { case QVariant::Int: *reinterpret_cast<int *>(a[0]) = data[id].asInt(); break; case QVariant::Bool: *reinterpret_cast<bool *>(a[0]) = data[id].asBool(); break; case QVariant::Double: *reinterpret_cast<double *>(a[0]) = data[id].asDouble(); break; case QVariant::String: *reinterpret_cast<QString *>(a[0]) = data[id].asQString(); break; case QVariant::Url: *reinterpret_cast<QUrl *>(a[0]) = data[id].asQUrl(); break; case QVariant::Date: *reinterpret_cast<QDate *>(a[0]) = data[id].asQDate(); break; case QVariant::DateTime: *reinterpret_cast<QDateTime *>(a[0]) = data[id].asQDateTime(); break; case QVariant::RectF: *reinterpret_cast<QRectF *>(a[0]) = data[id].asQRectF(); break; case QVariant::SizeF: *reinterpret_cast<QSizeF *>(a[0]) = data[id].asQSizeF(); break; case QVariant::PointF: *reinterpret_cast<QPointF *>(a[0]) = data[id].asQPointF(); break; case QMetaType::QObjectStar: *reinterpret_cast<QObject **>(a[0]) = data[id].asQObject(); break; case QMetaType::QVariant: *reinterpret_cast<QVariant *>(a[0]) = readPropertyAsVariant(id); break; default: QQml_valueTypeProvider()->readValueType(data[id].dataType(), data[id].dataPtr(), data->dataSize(), t, a[0]); break; } if (t == qMetaTypeId<QQmlListProperty<QObject> >()) { int listIndex = data[id].asInt(); const List *list = &listProperties.at(listIndex); *reinterpret_cast<QQmlListProperty<QObject> *>(a[0]) = QQmlListProperty<QObject>(object, (void *)list, list_append, list_count, list_at, list_clear); } } else if (c == QMetaObject::WriteProperty) { switch(t) { case QVariant::Int: needActivate = *reinterpret_cast<int *>(a[0]) != data[id].asInt(); data[id].setValue(*reinterpret_cast<int *>(a[0])); break; case QVariant::Bool: needActivate = *reinterpret_cast<bool *>(a[0]) != data[id].asBool(); data[id].setValue(*reinterpret_cast<bool *>(a[0])); break; case QVariant::Double: needActivate = *reinterpret_cast<double *>(a[0]) != data[id].asDouble(); data[id].setValue(*reinterpret_cast<double *>(a[0])); break; case QVariant::String: needActivate = *reinterpret_cast<QString *>(a[0]) != data[id].asQString(); data[id].setValue(*reinterpret_cast<QString *>(a[0])); break; case QVariant::Url: needActivate = *reinterpret_cast<QUrl *>(a[0]) != data[id].asQUrl(); data[id].setValue(*reinterpret_cast<QUrl *>(a[0])); break; case QVariant::Date: needActivate = *reinterpret_cast<QDate *>(a[0]) != data[id].asQDate(); data[id].setValue(*reinterpret_cast<QDate *>(a[0])); break; case QVariant::DateTime: needActivate = *reinterpret_cast<QDateTime *>(a[0]) != data[id].asQDateTime(); data[id].setValue(*reinterpret_cast<QDateTime *>(a[0])); break; case QVariant::RectF: needActivate = *reinterpret_cast<QRectF *>(a[0]) != data[id].asQRectF(); data[id].setValue(*reinterpret_cast<QRectF *>(a[0])); break; case QVariant::SizeF: needActivate = *reinterpret_cast<QSizeF *>(a[0]) != data[id].asQSizeF(); data[id].setValue(*reinterpret_cast<QSizeF *>(a[0])); break; case QVariant::PointF: needActivate = *reinterpret_cast<QPointF *>(a[0]) != data[id].asQPointF(); data[id].setValue(*reinterpret_cast<QPointF *>(a[0])); break; case QMetaType::QObjectStar: needActivate = *reinterpret_cast<QObject **>(a[0]) != data[id].asQObject(); data[id].setValue(*reinterpret_cast<QObject **>(a[0]), this, id); break; case QMetaType::QVariant: writeProperty(id, *reinterpret_cast<QVariant *>(a[0])); break; default: data[id].ensureValueType(t); needActivate = !QQml_valueTypeProvider()->equalValueType(t, a[0], data[id].dataPtr(), data[id].dataSize()); QQml_valueTypeProvider()->writeValueType(t, a[0], data[id].dataPtr(), data[id].dataSize()); break; } } } if (c == QMetaObject::WriteProperty && needActivate) { activate(object, methodOffset() + id, 0); } return -1; } id -= metaData->propertyCount; if (id < metaData->aliasCount) { QQmlVMEMetaData::AliasData *d = metaData->aliasData() + id; if (d->flags & QML_ALIAS_FLAG_PTR && c == QMetaObject::ReadProperty) *reinterpret_cast<void **>(a[0]) = 0; if (!ctxt) return -1; QQmlContext *context = ctxt->asQQmlContext(); QQmlContextPrivate *ctxtPriv = QQmlContextPrivate::get(context); QObject *target = ctxtPriv->data->idValues[d->contextIdx].data(); if (!target) return -1; connectAlias(id); if (d->isObjectAlias()) { *reinterpret_cast<QObject **>(a[0]) = target; return -1; } // Remove binding (if any) on write if(c == QMetaObject::WriteProperty) { int flags = *reinterpret_cast<int*>(a[3]); if (flags & QQmlPropertyPrivate::RemoveBindingOnAliasWrite) { QQmlData *targetData = QQmlData::get(target); if (targetData && targetData->hasBindingBit(d->propertyIndex())) { QQmlAbstractBinding *binding = QQmlPropertyPrivate::setBinding(target, d->propertyIndex(), d->isValueTypeAlias()?d->valueTypeIndex():-1, 0); if (binding) binding->destroy(); } } } if (d->isValueTypeAlias()) { // Value type property QQmlValueType *valueType = QQmlValueTypeFactory::valueType(d->valueType()); Q_ASSERT(valueType); valueType->read(target, d->propertyIndex()); int rv = QMetaObject::metacall(valueType, c, d->valueTypeIndex(), a); if (c == QMetaObject::WriteProperty) valueType->write(target, d->propertyIndex(), 0x00); return rv; } else { return QMetaObject::metacall(target, c, d->propertyIndex(), a); } } return -1; } } else if(c == QMetaObject::InvokeMetaMethod) { if (id >= methodOffset()) { id -= methodOffset(); int plainSignals = metaData->signalCount + metaData->propertyCount + metaData->aliasCount; if (id < plainSignals) { activate(object, _id, a); return -1; } id -= plainSignals; if (id < metaData->methodCount) { if (!ctxt->engine) return -1; // We can't run the method QQmlEnginePrivate *ep = QQmlEnginePrivate::get(ctxt->engine); ep->referenceScarceResources(); // "hold" scarce resources in memory during evaluation. QV4::Scope scope(ep->v4engine()); QV4::Scoped<QV4::FunctionObject> function(scope, method(id)); if (!function) { // The function was not compiled. There are some exceptional cases which the // expression rewriter does not rewrite properly (e.g., \r-terminated lines // are not rewritten correctly but this bug is deemed out-of-scope to fix for // performance reasons; see QTBUG-24064) and thus compilation will have failed. QQmlError e; e.setDescription(QString(QLatin1String("Exception occurred during compilation of function: %1")). arg(QLatin1String(QMetaObject::method(_id).methodSignature().constData()))); ep->warning(e); return -1; // The dynamic method with that id is not available. } QQmlVMEMetaData::MethodData *data = metaData->methodData() + id; QV4::ScopedCallData callData(scope, data->parameterCount); callData->thisObject = ep->v8engine()->global(); for (int ii = 0; ii < data->parameterCount; ++ii) callData->args[ii] = ep->v8engine()->fromVariant(*(QVariant *)a[ii + 1]); QV4::ScopedValue result(scope); QV4::ExecutionContext *ctx = function->engine()->currentContext(); result = function->call(callData); if (scope.hasException()) { QQmlError error = QV4::ExecutionEngine::catchExceptionAsQmlError(ctx); if (error.isValid()) ep->warning(error); if (a[0]) *(QVariant *)a[0] = QVariant(); } else { if (a[0]) *(QVariant *)a[0] = ep->v8engine()->toVariant(result, 0); } ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete. return -1; } return -1; } } if (parent.isT1()) return parent.asT1()->metaCall(object, c, _id, a); else return object->qt_metacall(c, _id, a); }