Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // Copyright (C) 2016 BasysKom GmbH.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include <QtQuick/private/qquickvaluetypes_p.h>
++ #include <QtQuick/private/qquickapplication_p.h>
++ #include <QtQuick/private/qquickstate_p.h>
++ #include <QtQuick/private/qquickpropertychanges_p.h>
++ #include <QtQuick/private/qquickitemsmodule_p.h>
++ #if QT_CONFIG(accessibility)
++ # include <QtQuick/private/qquickaccessiblefactory_p.h>
++ #endif
++ #include <QtGui/QGuiApplication>
++ #include <QtGui/qdesktopservices.h>
++ #include <QtGui/qfontdatabase.h>
++ #include <QtGui/qstylehints.h>
++
++ #include <QtQml/private/qqmlbinding_p.h>
++ #include <QtQml/private/qqmldebugserviceinterfaces_p.h>
++ #include <QtQml/private/qqmldebugstatesdelegate_p.h>
++ #include <QtQml/private/qqmlglobal_p.h>
++ #include <QtQml/private/qv4engine_p.h>
++ #include <QtQml/private/qv4object_p.h>
++ #include <QtQml/private/qqmlanybinding_p.h>
++
++ #include <QtQml/qqmlextensionplugin.h>
++
++ #include <QtCore/qiterable.h>
++ #include <QtCore/qpointer.h>
++
++ #ifdef Q_CC_MSVC
++ // MSVC2010 warns about 'unused variable t', even if it's used in t->~T()
++ # pragma warning( disable : 4189 )
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ #if QT_CONFIG(qml_debug)
++
++ class QQmlQtQuick2DebugStatesDelegate : public QQmlDebugStatesDelegate
++ {
++ public:
++ QQmlQtQuick2DebugStatesDelegate();
++ ~QQmlQtQuick2DebugStatesDelegate();
++ void buildStatesList(bool cleanList, const QList<QPointer<QObject> > &instances) override;
++ void updateBinding(QQmlContext *context,
++ const QQmlProperty &property,
++ const QVariant &expression, bool isLiteralValue,
++ const QString &fileName, int line, int column,
++ bool *isBaseState) override;
++ bool setBindingForInvalidProperty(QObject *object,
++ const QString &propertyName,
++ const QVariant &expression,
++ bool isLiteralValue) override;
++ void resetBindingForInvalidProperty(QObject *object,
++ const QString &propertyName) override;
++
++ private:
++ void buildStatesList(QObject *obj);
++
++ QList<QPointer<QQuickState> > m_allStates;
++ };
++
++ QQmlQtQuick2DebugStatesDelegate::QQmlQtQuick2DebugStatesDelegate()
++ {
++ }
++
++ QQmlQtQuick2DebugStatesDelegate::~QQmlQtQuick2DebugStatesDelegate()
++ {
++ }
++
++ void QQmlQtQuick2DebugStatesDelegate::buildStatesList(bool cleanList,
++ const QList<QPointer<QObject> > &instances)
++ {
++ if (cleanList)
++ m_allStates.clear();
++
++ //only root context has all instances
++ for (int ii = 0; ii < instances.size(); ++ii) {
++ buildStatesList(instances.at(ii));
++ }
++ }
++
++ void QQmlQtQuick2DebugStatesDelegate::buildStatesList(QObject *obj)
++ {
++ if (QQuickState *state = qobject_cast<QQuickState *>(obj)) {
++ m_allStates.append(state);
++ }
++
++ QObjectList children = obj->children();
++ for (int ii = 0; ii < children.size(); ++ii) {
++ buildStatesList(children.at(ii));
++ }
++ }
++
++ void QQmlQtQuick2DebugStatesDelegate::updateBinding(QQmlContext *context,
++ const QQmlProperty &property,
++ const QVariant &expression, bool isLiteralValue,
++ const QString &fileName, int line, int column,
++ bool *inBaseState)
++ {
++ Q_UNUSED(column);
++ typedef QPointer<QQuickState> QuickStatePointer;
++ QObject *object = property.object();
++ QString propertyName = property.name();
++ for (const QuickStatePointer& statePointer : std::as_const(m_allStates)) {
++ if (QQuickState *state = statePointer.data()) {
++ // here we assume that the revert list on itself defines the base state
++ if (state->isStateActive() && state->containsPropertyInRevertList(object, propertyName)) {
++ *inBaseState = false;
++
++ QQmlAnyBinding newBinding;
++ if (!isLiteralValue) {
++ newBinding = QQmlAnyBinding::createFromCodeString(property,
++ expression.toString(), object,
++ QQmlContextData::get(context), fileName,
++ line);
++ }
++ state->changeBindingInRevertList(object, propertyName, newBinding);
++
++ if (isLiteralValue)
++ state->changeValueInRevertList(object, propertyName, expression);
++ }
++ }
++ }
++ }
++
++ bool QQmlQtQuick2DebugStatesDelegate::setBindingForInvalidProperty(QObject *object,
++ const QString &propertyName,
++ const QVariant &expression,
++ bool isLiteralValue)
++ {
++ if (QQuickPropertyChanges *propertyChanges = qobject_cast<QQuickPropertyChanges *>(object)) {
++ if (isLiteralValue)
++ propertyChanges->changeValue(propertyName, expression);
++ else
++ propertyChanges->changeExpression(propertyName, expression.toString());
++ return true;
++ } else {
++ return false;
++ }
++ }
++
++ void QQmlQtQuick2DebugStatesDelegate::resetBindingForInvalidProperty(QObject *object, const QString &propertyName)
++ {
++ if (QQuickPropertyChanges *propertyChanges = qobject_cast<QQuickPropertyChanges *>(object)) {
++ propertyChanges->removeProperty(propertyName);
++ }
++ }
++
++ static QQmlDebugStatesDelegate *statesDelegateFactory()
++ {
++ return new QQmlQtQuick2DebugStatesDelegate;
++ }
++
++ #endif // QT_CONFIG(qml_debug)
++
++ class QQuickColorProvider : public QQmlColorProvider
++ {
++ public:
++ QVariant colorFromString(const QString &s, bool *ok) override
++ {
++ QColor c = QColor::fromString(s);
++ if (c.isValid()) {
++ if (ok) *ok = true;
++ return QVariant(c);
++ }
++
++ if (ok) *ok = false;
++ return QVariant();
++ }
++
++ unsigned rgbaFromString(const QString &s, bool *ok) override
++ {
++ QColor c = QColor::fromString(s);
++ if (c.isValid()) {
++ if (ok) *ok = true;
++ return c.rgba();
++ }
++
++ if (ok) *ok = false;
++ return 0;
++ }
++
++ QString stringFromRgba(unsigned rgba)
++ {
++ QColor c(QColor::fromRgba(rgba));
++ if (c.isValid()) {
++ return QVariant(c).toString();
++ }
++
++ return QString();
++ }
++
++ QVariant fromRgbF(double r, double g, double b, double a) override
++ {
++ return QVariant(QColor::fromRgbF(r, g, b, a));
++ }
++
++ QVariant fromHslF(double h, double s, double l, double a) override
++ {
++ return QVariant(QColor::fromHslF(h, s, l, a));
++ }
++
++ QVariant fromHsvF(double h, double s, double v, double a) override
++ {
++ return QVariant(QColor::fromHsvF(h, s, v, a));
++ }
++
++ QVariant lighter(const QVariant &var, qreal factor) override
++ {
++ return QVariant::fromValue(
++ QQuickColorValueType(var.value<QColor>()).lighter(factor));
++ }
++
++ QVariant darker(const QVariant &var, qreal factor) override
++ {
++ return QVariant::fromValue(
++ QQuickColorValueType(var.value<QColor>()).darker(factor));
++ }
++
++ QVariant alpha(const QVariant &var, qreal value) override
++ {
++ return QVariant::fromValue(
++ QQuickColorValueType(var.value<QColor>()).alpha(value));
++ }
++
++ QVariant tint(const QVariant &baseVar, const QVariant &tintVar) override
++ {
++ return QVariant::fromValue(
++ QQuickColorValueType(baseVar.value<QColor>()).tint(tintVar.value<QColor>()));
++ }
++ };
++
++ class QQuickGuiProvider : public QQmlGuiProvider
++ {
++ public:
++ QQuickApplication *application(QObject *parent) override
++ {
++ return new QQuickApplication(parent);
++ }
++
++ #if QT_CONFIG(im)
++ QInputMethod *inputMethod() override
++ {
++ QInputMethod *im = qGuiApp->inputMethod();
++ QQmlEngine::setObjectOwnership(im, QQmlEngine::CppOwnership);
++ return im;
++ }
++ #endif
++
++ QStyleHints *styleHints() override
++ {
++ QStyleHints *sh = qGuiApp->styleHints();
++ QQmlEngine::setObjectOwnership(sh, QQmlEngine::CppOwnership);
++ return sh;
++ }
++
++ QStringList fontFamilies() override
++ {
++ return QFontDatabase::families();
++ }
++
++ bool openUrlExternally(const QUrl &url) override
++ {
++ #ifndef QT_NO_DESKTOPSERVICES
++ return QDesktopServices::openUrl(url);
++ #else
++ Q_UNUSED(url);
++ return false;
++ #endif
++ }
++
++ QString pluginName() const override
++ {
++ return QGuiApplication::platformName();
++ }
++ };
++
++ static QQuickColorProvider *getColorProvider()
++ {
++ static QQuickColorProvider colorProvider;
++ return &colorProvider;
++ }
++
++ static QQuickGuiProvider *getGuiProvider()
++ {
++ static QQuickGuiProvider guiProvider;
++ return &guiProvider;
++ }
++
++ // Don't let the linker remove the dependency on libQtQmlMeta
++ void qml_register_types_QtQml();
++ Q_GHS_KEEP_REFERENCE(qml_register_types_QtQml);
++
++ void QQuick_initializeModule()
++ {
++ volatile auto qtqml = &qml_register_types_QtQml;
++ Q_ASSERT(qtqml);
++
++ // This is used by QQuickPath, and on macOS it fails to automatically register.
++ qRegisterMetaType<QList<QList<QPointF>>>();
++
++ QQml_setColorProvider(getColorProvider());
++ QQml_setGuiProvider(getGuiProvider());
++
++ QQuickItemsModule::defineModule();
++
++ #if QT_CONFIG(accessibility)
++ QAccessible::installFactory(&qQuickAccessibleFactory);
++ #endif
++
++ #if QT_CONFIG(qml_debug)
++ QQmlEngineDebugService::setStatesDelegateFactory(statesDelegateFactory);
++ #endif
++ }
++
++ Q_CONSTRUCTOR_FUNCTION(QQuick_initializeModule)
++
++ QT_END_NAMESPACE