continue;
}
- QVariant::Type t = (QVariant::Type)QMetaType::type(type.constData());
+ int t = QMetaType::type(type.constData());
if (QQmlMetaType::isQObject(t)) {
types[ii] = QMetaType::QObjectStar;
QMetaPropertyBuilder prop = mob.addProperty(name, "QObject*");
prop.setWritable(false);
} else {
QByteArray propType = type;
- if (t >= QVariant::UserType || t == QVariant::Invalid) {
+ if (t >= int(QVariant::UserType) || t == QMetaType::UnknownType || t == QMetaType::Void) {
QByteArray scope;
QByteArray name;
int scopeIdx = propType.lastIndexOf("::");
}
metaType = QMetaType::type(customTypeName);
- Q_ASSERT(metaType != 0);
+ Q_ASSERT(metaType != QMetaType::UnknownType);
+ Q_ASSERT(metaType != QMetaType::Void);
}
if (p->type == Object::DynamicProperty::Var)
if (typeName.endsWith('*'))
flags |= QML_ALIAS_FLAG_PTR;
- if (!type) {
+ if (type == QMetaType::UnknownType) {
Q_ASSERT(!typeName.isEmpty());
type = QMetaType::type(typeName);
- Q_ASSERT(type != 0);
+ Q_ASSERT(type != QMetaType::UnknownType);
+ Q_ASSERT(type != QMetaType::Void);
}
QQmlVMEMetaData::AliasData aliasData = { idObject->idIndex, propIdx, flags };
return false;
} else if (v.userType() != QVariant::Int && v.userType() != QVariant::UInt) {
int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope() + QByteArray("::") + menum.name()));
- if ((enumMetaTypeId == 0) || (v.userType() != enumMetaTypeId) || !v.constData())
+ if ((enumMetaTypeId == QMetaType::UnknownType) || (v.userType() != enumMetaTypeId) || !v.constData())
return false;
v = QVariant(*reinterpret_cast<const int *>(v.constData()));
}
if (type < QMetaType::User) {
switch (QMetaType::Type(type)) {
+ case QMetaType::UnknownType:
case QMetaType::Void:
return v8::Undefined();
case QMetaType::Bool:
// check if it's one of the types we know
switch (QMetaType::Type(type)) {
+ case QMetaType::UnknownType:
case QMetaType::Void:
return v8::Undefined();
case QMetaType::Bool:
return retn;
}
- if (property.propType == QVariant::Invalid) {
+ if (property.propType == QMetaType::UnknownType) {
QMetaProperty p = object->metaObject()->property(property.coreIndex);
qWarning("QMetaProperty::read: Unable to handle unregistered datatype '%s' for property "
"'%s::%s'", p.typeName(), object->metaObject()->className(), p.name());
if (v.userType() == QVariant::Invalid) valueType = "null";
else valueType = QMetaType::typeName(v.userType());
+ const char *targetTypeName = QMetaType::typeName(property->propType);
+ if (!targetTypeName)
+ targetTypeName = "an unregistered type";
+
QString error = QLatin1String("Cannot assign ") +
QLatin1String(valueType) +
QLatin1String(" to ") +
- QLatin1String(QMetaType::typeName(property->propType));
+ QLatin1String(targetTypeName);
v8::ThrowException(v8::Exception::Error(engine->toString(error)));
}
}
void CallArgument::initAsType(int callType)
{
if (type != 0) { cleanup(); type = 0; }
- if (callType == 0) return;
+ if (callType == QMetaType::UnknownType) return;
if (callType == qMetaTypeId<QJSValue>()) {
qjsValuePtr = new (&allocData) QJSValue();
} else if (callType == qMetaTypeId<QQmlV8Handle>()) {
type = callType;
handlePtr = new (&allocData) QQmlV8Handle;
+ } else if (callType == QMetaType::Void) {
+ type = -1;
+ qvariantPtr = new (&allocData) QVariant();
} else {
type = -1;
qvariantPtr = new (&allocData) QVariant(callType, (void *)0);
} else if (callType == qMetaTypeId<QQmlV8Handle>()) {
handlePtr = new (&allocData) QQmlV8Handle(QQmlV8Handle::fromHandle(value));
type = callType;
+ } else if (callType == QMetaType::Void) {
+ *qvariantPtr = QVariant();
} else {
qvariantPtr = new (&allocData) QVariant();
type = -1;
QVERIFY(seq != 0);
// we haven't registered QList<QPoint> as a sequence type, so writing shouldn't work.
- QString warningOne = qmlFile.toString() + QLatin1String(":16: Error: Cannot assign QVariantList to void");
+ QString warningOne = qmlFile.toString() + QLatin1String(":16: Error: Cannot assign QVariantList to an unregistered type");
QTest::ignoreMessage(QtWarningMsg, warningOne.toAscii().constData());
QMetaObject::invokeMethod(object, "performTest");