type = -1;
QQmlEnginePrivate *ep = engine->engine() ? QQmlEnginePrivate::get(engine->engine()) : 0;
- QVariant v = engine->toVariant(value, -1);
+ QVariant v = engine->toVariant(value, -1); // why -1 instead of callType?
if (v.userType() == callType) {
*qvariantPtr = v;
} else if (v.canConvert(callType)) {
*qvariantPtr = v;
qvariantPtr->convert(callType);
+ } else if (engine->sequenceWrapper()->isSequenceType(callType) && v.userType() == qMetaTypeId<QVariantList>()) {
+ // convert the JS array to a sequence of the correct type.
+ QVariant seqV = engine->toVariant(value, callType);
+ *qvariantPtr = seqV;
} else {
QQmlMetaObject mo = ep ? ep->rawMetaObjectForType(callType) : QQmlMetaObject();
if (!mo.isNull()) {
qPersistentDispose(m_constructor);
}
+#define IS_SEQUENCE(unused1, unused2, SequenceType, unused3) \
+ if (sequenceTypeId == qMetaTypeId<SequenceType>()) { \
+ return true; \
+ } else
+
+bool QV8SequenceWrapper::isSequenceType(int sequenceTypeId) const
+{
+ FOREACH_QML_SEQUENCE_TYPE(IS_SEQUENCE) { /* else */ return false; }
+}
+#undef IS_SEQUENCE
+
bool QV8SequenceWrapper::isEqual(QV8ObjectResource *lhs, QV8ObjectResource *rhs)
{
Q_ASSERT(lhs && rhs && lhs->resourceType() == QV8ObjectResource::SequenceType && rhs->resourceType() == QV8ObjectResource::SequenceType);
void init(QV8Engine *);
void destroy();
+ bool isSequenceType(int sequenceTypeId) const;
+
bool isEqual(QV8ObjectResource *lhs, const QVariant &rhs);
bool isEqual(QV8ObjectResource *lhs, QV8ObjectResource *rhs);
quint32 sequenceLength(QV8ObjectResource *);
if (jsIntList == jsIntList2) success = false;
if (jsIntList != jsIntList) success = false;
}
+
+ // this test ensures that copy resource sequences can be passed as parameters
+ function testCopyParameters() {
+ success = false;
+
+ var jsIntList = msco.generateIntSequence();
+ success = msco.parameterEqualsGeneratedIntSequence(jsIntList);
+ if (success == false) return;
+
+ // here we construct something which should be converted to a copy sequence automatically.
+ success = msco.parameterEqualsGeneratedIntSequence([1,2,3]);
+ }
+
+ // this test ensures that reference resource sequences are converted
+ // to copy resource sequences when passed as parameters.
+ function testReferenceParameters() {
+ success = false;
+
+ msco.intListProperty = msco.generateIntSequence();
+ var jsIntList = msco.intListProperty
+ success = msco.parameterEqualsGeneratedIntSequence(jsIntList);
+ if (success == false) return;
+ }
}
{
return stringList;
}
- Q_INVOKABLE QList<int> integers(QVariant v) const
+ Q_INVOKABLE QList<int> integers(QList<int> v) const
{
- QList<int> intList;
- QList<QVariant> vList = v.toList();
- for (int i=0 ; i < vList.size() ; ++i) {
- int iv = vList[i].toInt();
- intList.append(iv);
- }
- return intList;
+ return v;
}
- Q_INVOKABLE QList<qreal> reals(QVariant v) const
+ Q_INVOKABLE QList<qreal> reals(QList<qreal> v) const
{
- QList<qreal> realList;
- QList<QVariant> vList = v.toList();
- for (int i=0 ; i < vList.size() ; ++i) {
- qreal fv = vList[i].toReal();
- realList.append(fv);
- }
- return realList;
+ return v;
}
- Q_INVOKABLE QList<bool> bools(QVariant v) const
+ Q_INVOKABLE QList<bool> bools(QList<bool> v) const
{
- QList<bool> boolList;
- QList<QVariant> vList = v.toList();
- for (int i=0 ; i < vList.size() ; ++i) {
- bool bv = vList[i].toBool();
- boolList.append(bv);
- }
- return boolList;
+ return v;
}
};
Q_INVOKABLE QList<QString> generateStringSequence() const { QList<QString> retn; retn << "one" << "two" << "three"; return retn; }
Q_INVOKABLE QList<QUrl> generateUrlSequence() const { QList<QUrl> retn; retn << QUrl("http://www.example1.com") << QUrl("http://www.example2.com") << QUrl("http://www.example3.com"); return retn; }
Q_INVOKABLE QStringList generateQStringSequence() const { QStringList retn; retn << "one" << "two" << "three"; return retn; }
+ Q_INVOKABLE bool parameterEqualsGeneratedIntSequence(const QList<int>& param) const { return (param == generateIntSequence()); }
// "reference resource" underlying qobject deletion test:
Q_INVOKABLE MySequenceConversionObject *generateTestObject() const { return new MySequenceConversionObject; }
QCOMPARE(object->property("success").toBool(), true);
QMetaObject::invokeMethod(object, "testEqualitySemantics");
QCOMPARE(object->property("success").toBool(), true);
+ QMetaObject::invokeMethod(object, "testCopyParameters");
+ QCOMPARE(object->property("success").toBool(), true);
+ QMetaObject::invokeMethod(object, "testReferenceParameters");
+ QCOMPARE(object->property("success").toBool(), true);
delete object;
}