Qml2Puppet: Use helper functions from Qt 5.6

In Qt 5.6 we do not need to access the private API directly. QmlPrivateGate is forwarded to the helper functions in Qt. Change-Id: I274cb306815824c988b6d79966f007298f6d1e60 Reviewed-by: Tim Jenssen <tim.jenssen@theqtcompany.com>
2015-07-22 15:27:27 +02:00
parent 51ba32bccc
commit 11fcf2842d
2 changed files with 402 additions and 1 deletions
@@ -1,5 +1,14 @@
 INCLUDEPATH += $$PWD/

+minQtVersion(5, 6, 0) {
+HEADERS += \
+    $$PWD/qmlprivategate.h
+
+SOURCES += \
+    $$PWD/qmlprivategate_56.cpp
+
+} else {
+
 HEADERS += \
    $$PWD/qmlprivategate.h \
    $$PWD/metaobject.h \
@@ -9,4 +18,4 @@ SOURCES += \
    $$PWD/qmlprivategate.cpp \
    $$PWD/metaobject.cpp \
    $$PWD/designercustomobjectdata.cpp
-
+}
@@ -0,0 +1,392 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company.  For licensing terms and
+** conditions see http://www.qt.io/terms-conditions.  For further information
+** use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, The Qt Company gives you certain additional
+** rights.  These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+****************************************************************************/
+
+#include "qmlprivategate.h"
+
+#include "metaobject.h"
+#include "designercustomobjectdata.h"
+
+#include <objectnodeinstance.h>
+#include <nodeinstanceserver.h>
+
+#include <QQuickItem>
+#include <QQmlComponent>
+#include <QFileInfo>
+
+#include <private/qquickdesignersupport_p.h>
+#include <private/qquickdesignersupportmetainfo_p.h>
+#include <private/qquickdesignersupportitems_p.h>
+#include <private/qquickdesignersupportproperties_p.h>
+#include <private/qquickdesignersupportpropertychanges_p.h>
+#include <private/qquickdesignersupportstates_p.h>
+
+namespace QmlDesigner {
+
+namespace Internal {
+
+namespace QmlPrivateGate {
+
+bool isPropertyBlackListed(const QmlDesigner::PropertyName &propertyName)
+{
+    return QQuickDesignerSupportProperties::isPropertyBlackListed(propertyName);
+}
+
+PropertyNameList allPropertyNames(QObject *object,
+                                  const PropertyName &baseName,
+                                  QObjectList *inspectedObjects)
+{
+    return QQuickDesignerSupportProperties::allPropertyNames(object, baseName, inspectedObjects);
+}
+
+PropertyNameList propertyNameListForWritableProperties(QObject *object,
+                                                       const PropertyName &baseName,
+                                                       QObjectList *inspectedObjects)
+{
+    return QQuickDesignerSupportProperties::propertyNameListForWritableProperties(object, baseName, inspectedObjects);
+}
+
+static void fixResourcePathsForObject(QObject *object)
+{
+    if (qgetenv("QMLDESIGNER_RC_PATHS").isEmpty())
+        return;
+
+    PropertyNameList propertyNameList = propertyNameListForWritableProperties(object);
+
+    foreach (const PropertyName &propertyName, propertyNameList) {
+        QQmlProperty property(object, propertyName, QQmlEngine::contextForObject(object));
+
+        const QVariant value  = property.read();
+        const QVariant fixedValue = fixResourcePaths(value);
+        if (value != fixedValue) {
+            property.write(fixedValue);
+        }
+    }
+}
+
+void tweakObjects(QObject *object)
+{
+    QQuickDesignerSupportItems::tweakObjects(object);
+}
+
+void createNewDynamicProperty(QObject *object,  QQmlEngine *engine, const QString &name)
+{
+    QQuickDesignerSupportProperties::createNewDynamicProperty(object, engine, name);
+}
+
+void registerNodeInstanceMetaObject(QObject *object, QQmlEngine *engine)
+{
+    QQuickDesignerSupportProperties::registerNodeInstanceMetaObject(object, engine);
+}
+
+QObject *createPrimitive(const QString &typeName, int majorNumber, int minorNumber, QQmlContext *context)
+{
+    return QQuickDesignerSupportItems::createPrimitive(typeName, majorNumber, minorNumber, context);
+}
+
+QVariant fixResourcePaths(const QVariant &value)
+{
+    if (value.type() == QVariant::Url)
+    {
+        const QUrl url = value.toUrl();
+        if (url.scheme() == QLatin1String("qrc")) {
+            const QString path = QLatin1String("qrc:") +  url.path();
+            QString qrcSearchPath = qgetenv("QMLDESIGNER_RC_PATHS");
+            if (!qrcSearchPath.isEmpty()) {
+                const QStringList searchPaths = qrcSearchPath.split(QLatin1Char(';'));
+                foreach (const QString &qrcPath, searchPaths) {
+                    const QStringList qrcDefintion = qrcPath.split(QLatin1Char('='));
+                    if (qrcDefintion.count() == 2) {
+                        QString fixedPath = path;
+                        fixedPath.replace(QLatin1String("qrc:") + qrcDefintion.first(), qrcDefintion.last() + QLatin1Char('/'));
+                        if (QFileInfo(fixedPath).exists()) {
+                            fixedPath.replace(QLatin1String("//"), QLatin1String("/"));
+                            fixedPath.replace(QLatin1Char('\\'), QLatin1Char('/'));
+                            return QUrl(fixedPath);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (value.type() == QVariant::String) {
+        const QString str = value.toString();
+        if (str.contains(QLatin1String("qrc:"))) {
+            QString qrcSearchPath = qgetenv("QMLDESIGNER_RC_PATHS");
+            if (!qrcSearchPath.isEmpty()) {
+                const QStringList searchPaths = qrcSearchPath.split(QLatin1Char(';'));
+                foreach (const QString &qrcPath, searchPaths) {
+                    const QStringList qrcDefintion = qrcPath.split(QLatin1Char('='));
+                    if (qrcDefintion.count() == 2) {
+                        QString fixedPath = str;
+                        fixedPath.replace(QLatin1String("qrc:") + qrcDefintion.first(), qrcDefintion.last() + QLatin1Char('/'));
+                        if (QFileInfo(fixedPath).exists()) {
+                            fixedPath.replace(QLatin1String("//"), QLatin1String("/"));
+                            fixedPath.replace(QLatin1Char('\\'), QLatin1Char('/'));
+                            return fixedPath;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return value;
+}
+
+
+QObject *createComponent(const QUrl &componentUrl, QQmlContext *context)
+{
+    return QQuickDesignerSupportItems::createComponent(componentUrl, context);
+}
+
+bool hasFullImplementedListInterface(const QQmlListReference &list)
+{
+    return list.isValid() && list.canCount() && list.canAt() && list.canAppend() && list.canClear();
+}
+
+void registerCustomData(QObject *object)
+{
+    QQuickDesignerSupportProperties::registerCustomData(object);
+}
+
+QVariant getResetValue(QObject *object, const PropertyName &propertyName)
+{
+   return QQuickDesignerSupportProperties::getResetValue(object, propertyName);
+}
+
+void doResetProperty(QObject *object, QQmlContext *context, const PropertyName &propertyName)
+{
+    QQuickDesignerSupportProperties::doResetProperty(object, context, propertyName);
+}
+
+bool hasValidResetBinding(QObject *object, const PropertyName &propertyName)
+{
+    return QQuickDesignerSupportProperties::hasValidResetBinding(object, propertyName);
+}
+
+bool hasBindingForProperty(QObject *object, QQmlContext *context, const PropertyName &propertyName, bool *hasChanged)
+{
+    return QQuickDesignerSupportProperties::hasBindingForProperty(object, context, propertyName, hasChanged);
+}
+
+void setPropertyBinding(QObject *object, QQmlContext *context, const PropertyName &propertyName, const QString &expression)
+{
+    QQuickDesignerSupportProperties::setPropertyBinding(object, context, propertyName, expression);
+}
+
+void doComponentCompleteRecursive(QObject *object, NodeInstanceServer *nodeInstanceServer)
+{
+    if (object) {
+        QQuickItem *item = qobject_cast<QQuickItem*>(object);
+
+        if (item && DesignerSupport::isComponentComplete(item))
+            return;
+
+        QList<QObject*> childList = object->children();
+
+        if (item) {
+            foreach (QQuickItem *childItem, item->childItems()) {
+                if (!childList.contains(childItem))
+                    childList.append(childItem);
+            }
+        }
+
+        foreach (QObject *child, childList) {
+            if (!nodeInstanceServer->hasInstanceForObject(child))
+                doComponentCompleteRecursive(child, nodeInstanceServer);
+        }
+
+        if (item) {
+            static_cast<QQmlParserStatus*>(item)->componentComplete();
+        } else {
+            QQmlParserStatus *qmlParserStatus = dynamic_cast< QQmlParserStatus*>(object);
+            if (qmlParserStatus)
+                qmlParserStatus->componentComplete();
+        }
+    }
+}
+
+
+void keepBindingFromGettingDeleted(QObject *object, QQmlContext *context, const PropertyName &propertyName)
+{
+    QQuickDesignerSupportProperties::keepBindingFromGettingDeleted(object, context, propertyName);
+}
+
+bool objectWasDeleted(QObject *object)
+{
+    return QQuickDesignerSupportItems::objectWasDeleted(object);
+}
+
+void disableNativeTextRendering(QQuickItem *item)
+{
+    QQuickDesignerSupportItems::disableNativeTextRendering(item);
+}
+
+void disableTextCursor(QQuickItem *item)
+{
+    QQuickDesignerSupportItems::disableTextCursor(item);
+}
+
+void disableTransition(QObject *object)
+{
+    QQuickDesignerSupportItems::disableTransition(object);
+}
+
+void disableBehaivour(QObject *object)
+{
+    QQuickDesignerSupportItems::disableBehaivour(object);
+}
+
+void stopUnifiedTimer()
+{
+    QQuickDesignerSupportItems::stopUnifiedTimer();
+}
+
+bool isPropertyQObject(const QMetaProperty &metaProperty)
+{
+    return QQuickDesignerSupportProperties::isPropertyQObject(metaProperty);
+}
+
+QObject *readQObjectProperty(const QMetaProperty &metaProperty, QObject *object)
+{
+    return QQuickDesignerSupportProperties::readQObjectProperty(metaProperty, object);
+}
+
+namespace States {
+
+bool isStateActive(QObject *object, QQmlContext *context)
+{
+
+    return QQuickDesignerSupportStates::isStateActive(object, context);
+}
+
+void activateState(QObject *object, QQmlContext *context)
+{
+    QQuickDesignerSupportStates::activateState(object, context);
+}
+
+void deactivateState(QObject *object)
+{
+    QQuickDesignerSupportStates::deactivateState(object);
+}
+
+bool changeValueInRevertList(QObject *state, QObject *target, const PropertyName &propertyName, const QVariant &value)
+{
+    return QQuickDesignerSupportStates::changeValueInRevertList(state, target, propertyName, value);
+}
+
+bool updateStateBinding(QObject *state, QObject *target, const PropertyName &propertyName, const QString &expression)
+{
+    return QQuickDesignerSupportStates::updateStateBinding(state, target, propertyName, expression);
+}
+
+bool resetStateProperty(QObject *state, QObject *target, const PropertyName &propertyName, const QVariant &value)
+{
+    return QQuickDesignerSupportStates::resetStateProperty(state, target, propertyName, value);
+}
+
+} //namespace States
+
+namespace PropertyChanges {
+
+void detachFromState(QObject *propertyChanges)
+{
+    return QQuickDesignerSupportPropertyChanges::detachFromState(propertyChanges);
+}
+
+void attachToState(QObject *propertyChanges)
+{
+    return QQuickDesignerSupportPropertyChanges::attachToState(propertyChanges);
+}
+
+QObject *targetObject(QObject *propertyChanges)
+{
+    return QQuickDesignerSupportPropertyChanges::targetObject(propertyChanges);
+}
+
+void removeProperty(QObject *propertyChanges, const PropertyName &propertyName)
+{
+    QQuickDesignerSupportPropertyChanges::removeProperty(propertyChanges, propertyName);
+}
+
+QVariant getProperty(QObject *propertyChanges, const PropertyName &propertyName)
+{
+    return QQuickDesignerSupportPropertyChanges::getProperty(propertyChanges, propertyName);
+}
+
+void changeValue(QObject *propertyChanges, const PropertyName &propertyName, const QVariant &value)
+{
+    QQuickDesignerSupportPropertyChanges::changeValue(propertyChanges, propertyName, value);
+}
+
+void changeExpression(QObject *propertyChanges, const PropertyName &propertyName, const QString &expression)
+{
+    QQuickDesignerSupportPropertyChanges::changeExpression(propertyChanges, propertyName, expression);
+}
+
+QObject *stateObject(QObject *propertyChanges)
+{
+    return QQuickDesignerSupportPropertyChanges::stateObject(propertyChanges);
+}
+
+bool isNormalProperty(const PropertyName &propertyName)
+{
+    return QQuickDesignerSupportPropertyChanges::isNormalProperty(propertyName);
+}
+
+} // namespace PropertyChanges
+
+bool isSubclassOf(QObject *object, const QByteArray &superTypeName)
+{
+    return QQuickDesignerSupportMetaInfo::isSubclassOf(object, superTypeName);
+}
+
+void getPropertyCache(QObject *object, QQmlEngine *engine)
+{
+    QQuickDesignerSupportProperties::getPropertyCache(object, engine);
+}
+
+void registerNotifyPropertyChangeCallBack(void (*callback)(QObject *, const PropertyName &))
+{
+    QQuickDesignerSupportMetaInfo::registerNotifyPropertyChangeCallBack(callback);
+}
+
+ComponentCompleteDisabler::ComponentCompleteDisabler()
+{
+    DesignerSupport::disableComponentComplete();
+}
+
+ComponentCompleteDisabler::~ComponentCompleteDisabler()
+{
+    DesignerSupport::enableComponentComplete();
+}
+
+} // namespace QmlPrivateGate
+} // namespace Internal
+} // namespace QmlDesigner