968 lines
36 KiB
C++
968 lines
36 KiB
C++
// Copyright (C) 2016 The Qt Company Ltd.
|
|
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
|
|
|
|
#include <qtest.h>
|
|
#include <QtQml/qqmlengine.h>
|
|
#include <QtQml/qqmlcomponent.h>
|
|
#include <QtQuick/qquickview.h>
|
|
#include <private/qquickdesignersupportitems_p.h>
|
|
#include <private/qquickdesignersupportmetainfo_p.h>
|
|
#include <private/qquickdesignersupportproperties_p.h>
|
|
#include <private/qquickdesignersupportstates_p.h>
|
|
#include <private/qquickdesignersupportpropertychanges_p.h>
|
|
#include <private/qquickitem_p.h>
|
|
#include <private/qquickstate_p.h>
|
|
#include <private/qquickstate_p_p.h>
|
|
#include <private/qquickstategroup_p.h>
|
|
#include <private/qquickpropertychanges_p.h>
|
|
#include <private/qquickrectangle_p.h>
|
|
#include <QtQuickTestUtils/private/qmlutils_p.h>
|
|
#include <QtQuickTestUtils/private/visualtestutils_p.h>
|
|
|
|
using namespace QQuickVisualTestUtils;
|
|
|
|
class tst_qquickdesignersupport : public QQmlDataTest
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
tst_qquickdesignersupport() : QQmlDataTest(QT_QMLTEST_DATADIR) {}
|
|
|
|
private slots:
|
|
void customData();
|
|
void customDataBindings();
|
|
void objectProperties();
|
|
void dynamicProperty();
|
|
void createComponent();
|
|
void basicStates();
|
|
void statesPropertyChanges();
|
|
void testNotifyPropertyChangeCallBack();
|
|
void testFixResourcePathsForObjectCallBack();
|
|
void testComponentOnCompleteSignal();
|
|
void testSimpleBindings();
|
|
void testDotProperties();
|
|
void testItemReparenting();
|
|
void testPropertyNames();
|
|
void regressionTestAllProperties();
|
|
void doNotLosePropertyCache();
|
|
};
|
|
|
|
|
|
static bool isList(const QQmlProperty &property)
|
|
{
|
|
return property.propertyTypeCategory() == QQmlProperty::List;
|
|
}
|
|
|
|
static bool isObject(const QQmlProperty &property)
|
|
{
|
|
return property.isValid() && (property.propertyTypeCategory() == QQmlProperty::Object
|
|
|| !strcmp(property.propertyTypeName(), "QVariant"));
|
|
}
|
|
|
|
static QVariant objectToVariant(QObject *object)
|
|
{
|
|
return QVariant::fromValue(object);
|
|
}
|
|
|
|
static QObject *createPrimitiveFromSource(
|
|
const QByteArray &module, const QByteArray &component, QQmlContext *context)
|
|
{
|
|
QQmlComponent c(context->engine());
|
|
c.setData(
|
|
"import " + module + "\n" + component + " {\n" + "}\n",
|
|
context->baseUrl().resolved(QUrl("createCustomParserObject.qml")));
|
|
return c.create(context);
|
|
}
|
|
|
|
static void createNewDynamicProperty(QObject *object, QQmlEngine *engine, const QString &name)
|
|
{
|
|
QQmlProperty qmlProp(object, name, engine->contextForObject(object));
|
|
QVERIFY(!qmlProp.isValid());
|
|
QQuickDesignerSupportProperties::createNewDynamicProperty(object, engine, name);
|
|
}
|
|
|
|
static QVariant expression(QQmlContext *context, QObject *object, const QString &expression)
|
|
{
|
|
return QQmlExpression(context, object, expression).evaluate();
|
|
}
|
|
|
|
static void setBinding(
|
|
const QQmlProperty &property, const QString &expression, QObject *item,
|
|
QQmlContext *context)
|
|
{
|
|
QVERIFY(property.isProperty());
|
|
QQmlAnyBinding binding = QQmlAnyBinding::createFromCodeString(
|
|
property, expression, item, QQmlContextData::get(context), "@designer", 0);
|
|
|
|
binding.installOn(property);
|
|
if (QQmlAbstractBinding *abstractBinding = binding.asAbstractBinding()) {
|
|
// for new style properties, we will evaluate during setBinding anyway
|
|
static_cast<QQmlBinding *>(abstractBinding)->refresh();
|
|
static_cast<QQmlBinding *>(abstractBinding)->update();
|
|
}
|
|
|
|
QVERIFY(!binding.hasError());
|
|
}
|
|
|
|
static void addToNewProperty(QObject *object, QObject *newParent, const QByteArray &newParentProperty)
|
|
{
|
|
QQmlProperty property(newParent, QString::fromUtf8(newParentProperty));
|
|
|
|
if (object)
|
|
object->setParent(newParent);
|
|
|
|
if (isList(property)) {
|
|
QQmlListReference list = qvariant_cast<QQmlListReference>(property.read());
|
|
list.append(object);
|
|
} else if (isObject(property)) {
|
|
property.write(objectToVariant(object));
|
|
|
|
if (QQuickItem *item = qobject_cast<QQuickItem *>(object))
|
|
if (QQuickItem *newParentItem = qobject_cast<QQuickItem *>(newParent))
|
|
item->setParentItem(newParentItem);
|
|
}
|
|
|
|
Q_ASSERT(objectToVariant(object).isValid());
|
|
}
|
|
|
|
static void removeObjectFromList(const QQmlProperty &property, QObject *objectToBeRemoved)
|
|
{
|
|
QQmlListReference listReference(property.object(), property.name().toUtf8());
|
|
|
|
int count = listReference.count();
|
|
|
|
QObjectList objectList;
|
|
|
|
for (int i = 0; i < count; i ++) {
|
|
QObject *listItem = listReference.at(i);
|
|
if (listItem && listItem != objectToBeRemoved)
|
|
objectList.append(listItem);
|
|
}
|
|
|
|
listReference.clear();
|
|
|
|
for (QObject *object : objectList)
|
|
listReference.append(object);
|
|
}
|
|
|
|
|
|
void tst_qquickdesignersupport::customData()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QScopedPointer<QObject> newItemScopedPointer(QQuickDesignerSupportItems::createPrimitive(
|
|
QLatin1String("QtQuick/Item"),
|
|
QTypeRevision::fromVersion(2, 6),
|
|
view->rootContext()));
|
|
QObject *newItem = newItemScopedPointer.data();
|
|
|
|
QVERIFY(newItem);
|
|
QVERIFY(qobject_cast<QQuickItem*>(newItem));
|
|
|
|
QQuickDesignerSupportProperties::registerCustomData(newItem);
|
|
QVERIFY(QQuickDesignerSupportProperties::getResetValue(newItem, "width").isValid());
|
|
int defaultWidth = QQuickDesignerSupportProperties::getResetValue(newItem, "width").toInt();
|
|
QCOMPARE(defaultWidth, 0);
|
|
|
|
newItem->setProperty("width", 200);
|
|
QCOMPARE(newItem->property("width").toInt(), 200);
|
|
|
|
//Check if reseting property does work
|
|
QQuickDesignerSupportProperties::doResetProperty(newItem, view->rootContext(), "width");
|
|
QCOMPARE(newItem->property("width").toInt(), 0);
|
|
|
|
//Setting a binding on width
|
|
QQuickDesignerSupportProperties::setPropertyBinding(newItem,
|
|
view->engine()->contextForObject(newItem),
|
|
"width",
|
|
QLatin1String("Math.max(0, 200)"));
|
|
QCOMPARE(newItem->property("width").toInt(), 200);
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(newItem,
|
|
view->engine()->contextForObject(newItem),
|
|
"width",
|
|
nullptr));
|
|
|
|
//Check if reseting property does work after setting binding
|
|
QQuickDesignerSupportProperties::doResetProperty(newItem, view->rootContext(), "width");
|
|
QCOMPARE(newItem->property("width").toInt(), 0);
|
|
|
|
//No custom data available for the rootItem, because not registered by QQuickDesignerSupportProperties::registerCustomData
|
|
QVERIFY(!QQuickDesignerSupportProperties::getResetValue(rootItem, "width").isValid());
|
|
|
|
newItemScopedPointer.reset(); //Delete the item and check if item gets removed from the hash and an invalid QVariant is returned.
|
|
|
|
QVERIFY(!QQuickDesignerSupportProperties::getResetValue(newItem, "width").isValid());
|
|
}
|
|
|
|
void tst_qquickdesignersupport::customDataBindings()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *testComponent = findItem<QQuickItem>(view->rootObject(), QLatin1String("testComponent"));
|
|
|
|
QVERIFY(testComponent);
|
|
QQuickDesignerSupportProperties::registerCustomData(testComponent);
|
|
QQuickDesignerSupportProperties::hasValidResetBinding(testComponent, "x");
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x",
|
|
nullptr));
|
|
|
|
QCOMPARE(testComponent->property("x").toInt(), 200);
|
|
|
|
|
|
//Set property to 100 and ovveride the default binding
|
|
QQmlProperty property(testComponent, "x", view->engine()->contextForObject(testComponent));
|
|
QVERIFY(property.write(100));
|
|
QCOMPARE(testComponent->property("x").toInt(), 100);
|
|
|
|
QVERIFY(!QQuickDesignerSupportProperties::hasBindingForProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x",
|
|
nullptr));
|
|
|
|
//Reset the binding to the default
|
|
QQuickDesignerSupportProperties::doResetProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x");
|
|
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x",
|
|
nullptr));
|
|
QCOMPARE(testComponent->property("x").toInt(), 200);
|
|
|
|
|
|
|
|
//Set a different binding/expression
|
|
QQuickDesignerSupportProperties::setPropertyBinding(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x",
|
|
QLatin1String("Math.max(0, 300)"));
|
|
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x",
|
|
nullptr));
|
|
|
|
QCOMPARE(testComponent->property("x").toInt(), 300);
|
|
|
|
|
|
|
|
//Reset the binding to the default
|
|
QQuickDesignerSupportProperties::doResetProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x");
|
|
|
|
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(testComponent,
|
|
view->engine()->contextForObject(testComponent),
|
|
"x",
|
|
nullptr));
|
|
QCOMPARE(testComponent->property("x").toInt(), 200);
|
|
}
|
|
|
|
void tst_qquickdesignersupport::objectProperties()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *rectangleItem = findItem<QQuickItem>(view->rootObject(), QLatin1String("rectangleItem"));
|
|
QVERIFY(rectangleItem);
|
|
|
|
|
|
//Read gradient property as QObject
|
|
int propertyIndex = rectangleItem->metaObject()->indexOfProperty("containmentMask");
|
|
QVERIFY(propertyIndex > 0);
|
|
QMetaProperty metaProperty = rectangleItem->metaObject()->property(propertyIndex);
|
|
QVERIFY(metaProperty.isValid());
|
|
|
|
QVERIFY(QQuickDesignerSupportProperties::isPropertyQObject(metaProperty));
|
|
|
|
QObject *containmentItem = QQuickDesignerSupportProperties::readQObjectProperty(metaProperty, rectangleItem);
|
|
QVERIFY(containmentItem);
|
|
|
|
|
|
//The width property is not a QObject
|
|
propertyIndex = rectangleItem->metaObject()->indexOfProperty("width");
|
|
QVERIFY(propertyIndex > 0);
|
|
metaProperty = rectangleItem->metaObject()->property(propertyIndex);
|
|
QVERIFY(metaProperty.isValid());
|
|
QVERIFY(!QQuickDesignerSupportProperties::isPropertyQObject(metaProperty));
|
|
}
|
|
|
|
void tst_qquickdesignersupport::dynamicProperty()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *simpleItem = findItem<QQuickItem>(view->rootObject(), QLatin1String("simpleItem"));
|
|
|
|
QVERIFY(simpleItem);
|
|
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(simpleItem, view->engine());
|
|
QQuickDesignerSupportProperties::getPropertyCache(simpleItem);
|
|
|
|
QQuickDesignerSupportProperties::createNewDynamicProperty(simpleItem, view->engine(), QLatin1String("dynamicProperty"));
|
|
|
|
QQmlProperty property(simpleItem, "dynamicProperty", view->engine()->contextForObject(simpleItem));
|
|
QVERIFY(property.isValid());
|
|
QVERIFY(property.write(QLatin1String("test")));
|
|
|
|
|
|
QCOMPARE(property.read().toString(), QLatin1String("test"));
|
|
|
|
//Force evalutation of all bindings
|
|
QQuickDesignerSupport::refreshExpressions(view->rootContext());
|
|
|
|
//Check if expression to dynamic property gets properly resolved
|
|
property = QQmlProperty(simpleItem, "testProperty", view->engine()->contextForObject(simpleItem));
|
|
QVERIFY(property.isValid());
|
|
QCOMPARE(property.read().toString(), QLatin1String("test"));
|
|
}
|
|
|
|
void tst_qquickdesignersupport::createComponent()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QScopedPointer<QObject> testComponentObject(
|
|
QQuickDesignerSupportItems::createComponent(
|
|
testFileUrl("TestComponent.qml"), view->rootContext()));
|
|
QVERIFY(testComponentObject);
|
|
|
|
QVERIFY(QQuickDesignerSupportMetaInfo::isSubclassOf(
|
|
testComponentObject.data(), "QtQuick/Item"));
|
|
}
|
|
|
|
void tst_qquickdesignersupport::basicStates()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickStateGroup *stateGroup = QQuickItemPrivate::get(rootItem)->_states();
|
|
|
|
QVERIFY(stateGroup);
|
|
|
|
QCOMPARE(stateGroup->states().size(), 2 );
|
|
|
|
QQuickState *state01 = stateGroup->states().first();
|
|
QQuickState *state02 = stateGroup->states().last();
|
|
|
|
QVERIFY(state01);
|
|
QVERIFY(state02);
|
|
|
|
QCOMPARE(state01->property("name").toString(), QLatin1String("state01"));
|
|
QCOMPARE(state02->property("name").toString(), QLatin1String("state02"));
|
|
|
|
QVERIFY(!QQuickDesignerSupportStates::isStateActive(state01, view->rootContext()));
|
|
QVERIFY(!QQuickDesignerSupportStates::isStateActive(state01, view->rootContext()));
|
|
|
|
QQuickDesignerSupportStates::activateState(state01, view->rootContext());
|
|
QVERIFY(QQuickDesignerSupportStates::isStateActive(state01, view->rootContext()));
|
|
|
|
QQuickDesignerSupportStates::activateState(state02, view->rootContext());
|
|
QVERIFY(QQuickDesignerSupportStates::isStateActive(state02, view->rootContext()));
|
|
QVERIFY(!QQuickDesignerSupportStates::isStateActive(state01, view->rootContext()));
|
|
|
|
QQuickDesignerSupportStates::deactivateState(state02);
|
|
QVERIFY(!QQuickDesignerSupportStates::isStateActive(state01, view->rootContext()));
|
|
QVERIFY(!QQuickDesignerSupportStates::isStateActive(state01, view->rootContext()));
|
|
}
|
|
|
|
void tst_qquickdesignersupport::statesPropertyChanges()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *simpleItem = findItem<QQuickItem>(view->rootObject(), QLatin1String("simpleItem"));
|
|
|
|
QVERIFY(simpleItem);
|
|
|
|
QQuickStateGroup *stateGroup = QQuickItemPrivate::get(rootItem)->_states();
|
|
|
|
QVERIFY(stateGroup);
|
|
|
|
QCOMPARE(stateGroup->states().size(), 2 );
|
|
|
|
QQuickState *state01 = stateGroup->states().first();
|
|
QQuickState *state02 = stateGroup->states().last();
|
|
|
|
QVERIFY(state01);
|
|
QVERIFY(state02);
|
|
|
|
QCOMPARE(state01->property("name").toString(), QLatin1String("state01"));
|
|
QCOMPARE(state02->property("name").toString(), QLatin1String("state02"));
|
|
|
|
//PropertyChanges are parsed lazily
|
|
QQuickDesignerSupportStates::activateState(state01, view->rootContext());
|
|
QQuickDesignerSupportStates::deactivateState(state01);
|
|
|
|
QQuickStatePrivate *statePrivate01 = static_cast<QQuickStatePrivate *>(QQuickStatePrivate::get(state01));
|
|
|
|
QCOMPARE(state01->operationCount(), 1);
|
|
|
|
QCOMPARE(statePrivate01->operations.size(), 1);
|
|
|
|
QQuickStateOperation *propertyChange = statePrivate01->operations.at(0).data();
|
|
|
|
QCOMPARE(QQuickDesignerSupportPropertyChanges::stateObject(propertyChange), state01);
|
|
|
|
QQuickDesignerSupportPropertyChanges::changeValue(propertyChange, "width", 300);
|
|
|
|
QCOMPARE(simpleItem->property("width").toInt(), 0);
|
|
QQuickDesignerSupportStates::activateState(state01, view->rootContext());
|
|
QCOMPARE(simpleItem->property("width").toInt(), 300);
|
|
QQuickDesignerSupportStates::deactivateState(state01);
|
|
QCOMPARE(simpleItem->property("width").toInt(), 0);
|
|
|
|
//Set "base state value" in state1 using the revert list
|
|
QQuickDesignerSupportStates::activateState(state01, view->rootContext());
|
|
QQuickDesignerSupportStates::changeValueInRevertList(state01, simpleItem, "width", 200);
|
|
QCOMPARE(simpleItem->property("width").toInt(), 300);
|
|
QQuickDesignerSupportStates::deactivateState(state01);
|
|
QCOMPARE(simpleItem->property("width").toInt(), 200);
|
|
|
|
|
|
//Create new PropertyChanges
|
|
QQuickPropertyChanges *newPropertyChange = new QQuickPropertyChanges();
|
|
newPropertyChange->setParent(state01);
|
|
QQmlListProperty<QQuickStateOperation> changes = state01->changes();
|
|
QQuickStatePrivate::operations_append(&changes, newPropertyChange);
|
|
|
|
newPropertyChange->setObject(rootItem);
|
|
|
|
QQuickDesignerSupportPropertyChanges::attachToState(newPropertyChange);
|
|
|
|
QCOMPARE(rootItem, QQuickDesignerSupportPropertyChanges::targetObject(newPropertyChange));
|
|
|
|
QCOMPARE(state01->operationCount(), 2);
|
|
QCOMPARE(statePrivate01->operations.size(), 2);
|
|
|
|
QCOMPARE(QQuickDesignerSupportPropertyChanges::stateObject(newPropertyChange), state01);
|
|
|
|
//Set color for rootItem in state1
|
|
QQuickDesignerSupportPropertyChanges::changeValue(newPropertyChange, "color", QColor(Qt::red));
|
|
|
|
QQuickDesignerSupportStates::activateState(state01, view->rootContext());
|
|
QCOMPARE(rootItem->property("color").value<QColor>(), QColor(Qt::red));
|
|
QQuickDesignerSupportStates::deactivateState(state01);
|
|
QCOMPARE(rootItem->property("color").value<QColor>(), QColor(Qt::white));
|
|
|
|
QQuickDesignerSupportPropertyChanges::removeProperty(newPropertyChange, "color");
|
|
QQuickDesignerSupportStates::activateState(state01, view->rootContext());
|
|
QCOMPARE(rootItem->property("color").value<QColor>(), QColor(Qt::white));
|
|
|
|
}
|
|
|
|
static QObject * s_object = nullptr;
|
|
static QQuickDesignerSupport::PropertyName s_propertyName;
|
|
|
|
static void notifyPropertyChangeCallBackFunction(QObject *object, const QQuickDesignerSupport::PropertyName &propertyName)
|
|
{
|
|
s_object = object;
|
|
s_propertyName = propertyName;
|
|
}
|
|
|
|
static void (*notifyPropertyChangeCallBackPointer)(QObject *, const QQuickDesignerSupport::PropertyName &) = ¬ifyPropertyChangeCallBackFunction;
|
|
|
|
|
|
void tst_qquickdesignersupport::testNotifyPropertyChangeCallBack()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickRectangle *rectangle = static_cast<QQuickRectangle *>(rootItem);
|
|
QVERIFY(rectangle);
|
|
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(rectangle, view->engine());
|
|
|
|
QQuickGradient *gradient = new QQuickGradient(rectangle);
|
|
|
|
QQuickDesignerSupportMetaInfo::registerNotifyPropertyChangeCallBack(notifyPropertyChangeCallBackPointer);
|
|
|
|
rectangle->setProperty("gradient", QVariant::fromValue<QJSValue>(view->engine()->newQObject(gradient)));
|
|
|
|
QVERIFY(s_object);
|
|
QCOMPARE(s_object, rootItem);
|
|
QCOMPARE(s_propertyName, QQuickDesignerSupport::PropertyName("gradient"));
|
|
}
|
|
|
|
// We have to use this ugly approach, because the signature of
|
|
// registerFixResourcePathsForObjectCallBack doesn't accept
|
|
// a proper lambda with a capture list
|
|
static QVector<QObject*> s_allSubObjects;
|
|
|
|
static void fixResourcePathsForObjectCallBackFunction(QObject *object)
|
|
{
|
|
s_allSubObjects << object;
|
|
}
|
|
|
|
static void (*fixResourcePathsForObjectCallBackPointer)(QObject *) = &fixResourcePathsForObjectCallBackFunction;
|
|
|
|
void tst_qquickdesignersupport::testFixResourcePathsForObjectCallBack()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("test.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
|
|
QQuickItem *rootItem = view->rootObject();
|
|
|
|
QVERIFY(rootItem);
|
|
|
|
s_allSubObjects.clear();
|
|
|
|
QQuickDesignerSupportItems::registerFixResourcePathsForObjectCallBack(fixResourcePathsForObjectCallBackPointer);
|
|
|
|
QQuickItem *simpleItem = findItem<QQuickItem>(view->rootObject(), QLatin1String("simpleItem"));
|
|
|
|
QVERIFY(simpleItem);
|
|
|
|
QQuickDesignerSupportItems::tweakObjects(simpleItem);
|
|
|
|
// Check that the fixResourcePathsForObjectCallBack was called on simpleItem
|
|
// NOTE: more objects are collected now. There is also at least a palette
|
|
// that created on demand.
|
|
QVERIFY(s_allSubObjects.contains(simpleItem));
|
|
|
|
s_allSubObjects.clear();
|
|
}
|
|
|
|
void doComponentCompleteRecursive(QObject *object)
|
|
{
|
|
if (object) {
|
|
QQuickItem *item = qobject_cast<QQuickItem*>(object);
|
|
|
|
if (item && DesignerSupport::isComponentComplete(item))
|
|
return;
|
|
|
|
DesignerSupport::emitComponentCompleteSignalForAttachedProperty(object);
|
|
|
|
QList<QObject*> childList = object->children();
|
|
|
|
if (item) {
|
|
const auto childItems = item->childItems();
|
|
for (QQuickItem *childItem : childItems) {
|
|
if (!childList.contains(childItem))
|
|
childList.append(childItem);
|
|
}
|
|
}
|
|
|
|
for (QObject *child : std::as_const(childList))
|
|
doComponentCompleteRecursive(child);
|
|
|
|
if (item) {
|
|
static_cast<QQmlParserStatus*>(item)->componentComplete();
|
|
} else {
|
|
QQmlParserStatus *qmlParserStatus = dynamic_cast< QQmlParserStatus*>(object);
|
|
if (qmlParserStatus)
|
|
qmlParserStatus->componentComplete();
|
|
}
|
|
}
|
|
}
|
|
|
|
void tst_qquickdesignersupport::testComponentOnCompleteSignal()
|
|
{
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("componentTest.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *item = findItem<QQuickItem>(view->rootObject(), QLatin1String("topLevelComplete"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("red"));
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("implemented"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("blue"));
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("most inner"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("green"));
|
|
}
|
|
|
|
{
|
|
ComponentCompleteDisabler disableComponentComplete;
|
|
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("componentTest.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *item = findItem<QQuickItem>(view->rootObject(), QLatin1String("topLevelComplete"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("white"));
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("implemented"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("white"));
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("most inner"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("white"));
|
|
|
|
doComponentCompleteRecursive(rootItem);
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("topLevelComplete"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("red"));
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("implemented"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("blue"));
|
|
|
|
item = findItem<QQuickItem>(view->rootObject(), QLatin1String("most inner"));
|
|
QVERIFY(item);
|
|
QCOMPARE(item->property("color").value<QColor>(), QColor("green"));
|
|
}
|
|
}
|
|
|
|
|
|
void tst_qquickdesignersupport::testSimpleBindings()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("bindingTest.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *text = findItem<QQuickItem>(rootItem, QLatin1String("text"));
|
|
QVERIFY(text);
|
|
|
|
QQuickItem *item = findItem<QQuickItem>(rootItem, QLatin1String("item"));
|
|
QVERIFY(item);
|
|
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(item, view->engine());
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(text, view->engine());
|
|
|
|
QQuickDesignerSupportProperties::registerCustomData(item);
|
|
QQuickDesignerSupportProperties::registerCustomData(text);
|
|
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(text,
|
|
QQmlEngine::contextForObject(text),
|
|
"text",
|
|
nullptr));
|
|
|
|
QQuickDesignerSupportProperties::doResetProperty(text, QQmlEngine::contextForObject(text), "text");
|
|
|
|
|
|
QQuickDesignerSupportProperties::setPropertyBinding(text,
|
|
QQmlEngine::contextForObject(text),
|
|
"text",
|
|
"qsTr(\"someText\")");
|
|
|
|
QVERIFY(QQuickDesignerSupportProperties::hasBindingForProperty(text,
|
|
QQmlEngine::contextForObject(text),
|
|
"text",
|
|
nullptr));
|
|
}
|
|
|
|
void tst_qquickdesignersupport::testDotProperties()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("bindingTest.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *text = findItem<QQuickItem>(rootItem, QLatin1String("text"));
|
|
QVERIFY(text);
|
|
|
|
QQuickItem *item = findItem<QQuickItem>(rootItem, QLatin1String("item"));
|
|
QVERIFY(item);
|
|
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(item, view->engine());
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(text, view->engine());
|
|
|
|
QQuickDesignerSupportProperties::registerCustomData(item);
|
|
QQuickDesignerSupportProperties::registerCustomData(text);
|
|
|
|
QCOMPARE(text->property("font.bold").value<QColor>(), QColor("true"));
|
|
QCOMPARE(text->property("font.italic").value<QColor>(), QColor("false"));
|
|
QCOMPARE(text->property("font.underline").value<QColor>(), QColor("false"));
|
|
|
|
QQmlProperty property(text, "font.capitalization");
|
|
}
|
|
|
|
void tst_qquickdesignersupport::testItemReparenting()
|
|
{
|
|
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("bindingTest.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickItem *text = findItem<QQuickItem>(rootItem, QLatin1String("text"));
|
|
QVERIFY(text);
|
|
|
|
QQuickItem *item = findItem<QQuickItem>(rootItem, QLatin1String("item"));
|
|
QVERIFY(item);
|
|
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(item, view->engine());
|
|
QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(text, view->engine());
|
|
|
|
QQuickDesignerSupportProperties::registerCustomData(item);
|
|
QQuickDesignerSupportProperties::registerCustomData(text);
|
|
|
|
|
|
QCOMPARE(text->parentItem(), rootItem);
|
|
QQmlProperty childrenProperty(rootItem, "children");
|
|
removeObjectFromList(childrenProperty, text);
|
|
addToNewProperty(text, item, "children");
|
|
QCOMPARE(text->parentItem(), item);
|
|
}
|
|
|
|
void tst_qquickdesignersupport::testPropertyNames()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("propertyNameTest.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QQuickDesignerSupport::PropertyNameList names = QQuickDesignerSupportProperties::allPropertyNames(rootItem);
|
|
QVERIFY(!names.isEmpty());
|
|
QVERIFY(names.contains("width"));
|
|
QVERIFY(names.contains("height"));
|
|
QVERIFY(names.contains("clip"));
|
|
QVERIFY(names.contains("childrenRect"));
|
|
QVERIFY(names.contains("activeFocus"));
|
|
QVERIFY(names.contains("border.width"));
|
|
names = QQuickDesignerSupportProperties::propertyNameListForWritableProperties(rootItem);
|
|
QVERIFY(!names.isEmpty());
|
|
QVERIFY(names.contains("width"));
|
|
QVERIFY(names.contains("height"));
|
|
QVERIFY(names.contains("opacity"));
|
|
QVERIFY(!names.contains("childrenRect"));
|
|
QVERIFY(!names.contains("childrenRect"));
|
|
QVERIFY(!names.contains("activeFocus"));
|
|
QVERIFY(names.contains("border.width"));
|
|
|
|
QQuickItem *recursiveProperty = findItem<QQuickItem>(rootItem, QLatin1String("recursiveProperty"));
|
|
QVERIFY(recursiveProperty);
|
|
names = QQuickDesignerSupportProperties::allPropertyNames(recursiveProperty);
|
|
QVERIFY(!names.isEmpty());
|
|
QVERIFY(names.contains("testProperty"));
|
|
QVERIFY(names.contains("myproperty.testProperty"));
|
|
|
|
names = QQuickDesignerSupportProperties::propertyNameListForWritableProperties(recursiveProperty);
|
|
QVERIFY(!names.isEmpty());
|
|
QVERIFY(!names.contains("testProperty"));
|
|
}
|
|
|
|
void tst_qquickdesignersupport::regressionTestAllProperties()
|
|
{
|
|
QScopedPointer<QQuickView> view(new QQuickView);
|
|
view->engine()->setOutputWarningsToStandardError(false);
|
|
view->setSource(testFileUrl("regTestProperties.qml"));
|
|
|
|
QVERIFY(view->errors().isEmpty());
|
|
QQuickItem *rootItem = view->rootObject();
|
|
QVERIFY(rootItem);
|
|
|
|
QObject *component = rootItem->findChild<QObject*>("testComponent");
|
|
|
|
QVERIFY(component);
|
|
QCOMPARE(component->objectName(), QLatin1String("testComponent"));
|
|
|
|
QVERIFY(component);
|
|
|
|
QQuickDesignerSupport::PropertyNameList names
|
|
= QQuickDesignerSupportProperties::allPropertyNames(component);
|
|
QVERIFY(!names.isEmpty());
|
|
|
|
const QByteArrayList expectedNames = QByteArrayList {
|
|
"objectName", "currentCategory", "materialsNames", "model"
|
|
};
|
|
|
|
QCOMPARE(names, expectedNames);
|
|
names = QQuickDesignerSupportProperties::propertyNameListForWritableProperties(component);
|
|
QVERIFY(!names.isEmpty());
|
|
QCOMPARE(names, expectedNames);
|
|
}
|
|
|
|
void tst_qquickdesignersupport::doNotLosePropertyCache()
|
|
{
|
|
qmlRegisterSingletonType(testFileUrl("Constants.qml"), "TestImport", 1, 0, "Constants");
|
|
|
|
QQmlEngine engine;
|
|
QQmlComponent importComponent(&engine);
|
|
|
|
importComponent.setData(R"(
|
|
import QtQuick
|
|
import TestImport
|
|
Item {}
|
|
)", {});
|
|
|
|
QVERIFY2(importComponent.isReady(), qPrintable(importComponent.errorString()));
|
|
|
|
QScopedPointer<QObject> importComponentObject(importComponent.create());
|
|
QVERIFY(importComponentObject);
|
|
|
|
QQmlContext *importComponentContext
|
|
= QQmlEngine::contextForObject(importComponentObject.data());
|
|
QVERIFY(importComponentContext);
|
|
|
|
QScopedPointer<QObject> rootItem(
|
|
createPrimitiveFromSource("QtQuick", "Item", importComponentContext));
|
|
QVERIFY(rootItem);
|
|
|
|
engine.rootContext()->setContextProperty("root", rootItem.data());
|
|
|
|
rootItem->setProperty("width", 200);
|
|
QCOMPARE(rootItem->property("width"), QVariant::fromValue<qreal>(200));
|
|
|
|
createNewDynamicProperty(rootItem.data(), &engine, "test");
|
|
QQmlProperty qmlProp(rootItem.data(), "test", importComponentContext);
|
|
QVERIFY(qmlProp.isValid());
|
|
|
|
qmlProp.write(77);
|
|
QCOMPARE(qmlProp.read(), QVariant::fromValue(77));
|
|
|
|
const QQmlData *ddata = QQmlData::get(rootItem.data());
|
|
QVERIFY(ddata);
|
|
const QQmlPropertyCache::ConstPtr propCache = ddata->propertyCache;
|
|
QVERIFY(propCache);
|
|
QVERIFY(!propCache->property(QLatin1String("aNewProperty"), nullptr, nullptr));
|
|
|
|
// This _creates_ a new property since we have an open metaobject
|
|
// However, it should _not_ drop the property cache.
|
|
QVariant aNewProperty = rootItem->property("aNewProperty");
|
|
QVERIFY(!aNewProperty.isValid());
|
|
|
|
QCOMPARE(ddata, QQmlData::get(rootItem.data()));
|
|
QCOMPARE(ddata->propertyCache, propCache);
|
|
QVERIFY(propCache->property(QLatin1String("aNewProperty"), nullptr, nullptr));
|
|
|
|
// the same should hold true when a dynamic property is created via
|
|
// inexOfPropery -> QAbstractDynamicMetaObject::createProperty
|
|
int newPropIndex = rootItem->metaObject()->indexOfProperty("anotherNewProperty");
|
|
QCOMPARE_NE(newPropIndex, -1);
|
|
|
|
QCOMPARE(ddata, QQmlData::get(rootItem.data()));
|
|
QCOMPARE(ddata->propertyCache, propCache);
|
|
QVERIFY(propCache->property(QLatin1String("anotherNewProperty"), nullptr, nullptr));
|
|
|
|
createNewDynamicProperty(rootItem.data(), &engine, "test2");
|
|
QQmlProperty qmlProp2(rootItem.data(), "test2", importComponentContext);
|
|
QVERIFY(qmlProp2.isValid());
|
|
setBinding(qmlProp2, "Constants.width", rootItem.data(), importComponentContext);
|
|
|
|
createNewDynamicProperty(rootItem.data(), &engine, "test3");
|
|
QQmlProperty qmlProp3(rootItem.data(), "test3", importComponentContext);
|
|
QVERIFY(qmlProp3.isValid());
|
|
setBinding(qmlProp3, "Constants.width", rootItem.data(), importComponentContext);
|
|
|
|
QScopedPointer<QObject> textItem(
|
|
createPrimitiveFromSource("QtQuick", "Text", importComponentContext));
|
|
QVERIFY(textItem);
|
|
|
|
QScopedPointer<QObject> anotherItem(
|
|
createPrimitiveFromSource("QtQuick", "Item", importComponentContext));
|
|
QVERIFY(anotherItem);
|
|
|
|
QQmlProperty textProp(textItem.data(), "text", importComponentContext);
|
|
QVERIFY(textProp.isValid());
|
|
setBinding(textProp, "root.test3", textItem.data(), importComponentContext);
|
|
engine.rootContext()->setContextProperty("textItem", textItem.data());
|
|
|
|
QCOMPARE(
|
|
expression(importComponentContext, anotherItem.data(), "root.width"),
|
|
QVariant::fromValue<qreal>(200));
|
|
|
|
QCOMPARE(
|
|
expression(importComponentContext, anotherItem.data(), "root.width + Constants.width"),
|
|
QVariant::fromValue<qreal>(2120));
|
|
|
|
QCOMPARE(
|
|
expression(importComponentContext, anotherItem.data(), "root.test + Constants.width"),
|
|
QVariant::fromValue<int>(1997));
|
|
|
|
QCOMPARE(
|
|
expression(importComponentContext, anotherItem.data(), "root.test2"),
|
|
QVariant::fromValue<int>(1920));
|
|
|
|
QCOMPARE(
|
|
expression(importComponentContext, textItem.data(), "textItem.text"),
|
|
QVariant::fromValue(QStringLiteral("1920")));
|
|
}
|
|
|
|
QTEST_MAIN(tst_qquickdesignersupport)
|
|
|
|
#include "tst_qquickdesignersupport.moc"
|