Migrate gui dependencies from QtQml to QtQuick.

Ensure that users of declarative that have no need for functionality
provided by the Qt Gui module do not have to link against it.

Any use of QtGui functionality is delegated to providers that can
be installed by another library; QtQuick adds default providers
for this functionality when linked against QtQml.

Task-number: QTBUG-24559
Change-Id: I5e6a58a4198732dc2f8f52f71abfa1152b871aa7
Reviewed-by: Martin Jones <martin.jones@nokia.com>

1 files changed, 530 insertions, 0 deletions

diff --git a/src/quick/util/qquickglobal.cpp b/src/quick/util/qquickglobal.cpp
new file mode 100644
index 0000000000..b99cb7a1d4
--- /dev/null
+++ b/src/quick/util/qquickglobal.cpp
@@ -0,0 +1,530 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qquickvaluetypes_p.h>
+#include <private/qquickapplication_p.h>
+#include <private/qqmlglobal_p.h>
+
+#include <QtGui/QGuiApplication>
+#include <QtGui/qdesktopservices.h>
+#include <QtGui/qfontdatabase.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class QQuickColorProvider : public QQmlColorProvider
+{
+public:
+    static inline QColor QColorFromString(const QString &s)
+    {
+        // Should we also handle #rrggbb here?
+        if (s.length() == 9 && s.startsWith(QLatin1Char('#'))) {
+            uchar a = fromHex(s, 1);
+            uchar r = fromHex(s, 3);
+            uchar g = fromHex(s, 5);
+            uchar b = fromHex(s, 7);
+            return QColor(r, g, b, a);
+        }
+
+        return QColor(s);
+    }
+
+    QVariant colorFromString(const QString &s, bool *ok)
+    {
+        QColor c(QColorFromString(s));
+        if (c.isValid()) {
+            if (ok) *ok = true;
+            return QVariant(c);
+        }
+
+        if (ok) *ok = false;
+        return QVariant();
+    }
+
+    unsigned rgbaFromString(const QString &s, bool *ok)
+    {
+        QColor c(QColorFromString(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)
+    {
+        return QVariant(QColor::fromRgbF(r, g, b, a));
+    }
+
+    QVariant fromHslF(double h, double s, double l, double a)
+    {
+        return QVariant(QColor::fromHslF(h, s, l, a));
+    }
+
+    QVariant lighter(const QVariant &var, qreal factor)
+    {
+        QColor color = var.value<QColor>();
+        color = color.lighter(int(qRound(factor*100.)));
+        return QVariant::fromValue(color);
+    }
+
+    QVariant darker(const QVariant &var, qreal factor)
+    {
+        QColor color = var.value<QColor>();
+        color = color.darker(int(qRound(factor*100.)));
+        return QVariant::fromValue(color);
+    }
+
+    QVariant tint(const QVariant &baseVar, const QVariant &tintVar)
+    {
+        QColor tintColor = tintVar.value<QColor>();
+
+        int tintAlpha = tintColor.alpha();
+        if (tintAlpha == 0xFF) {
+            return tintVar;
+        } else if (tintAlpha == 0x00) {
+            return baseVar;
+        }
+
+        // tint the base color and return the final color
+        QColor baseColor = baseVar.value<QColor>();
+        qreal a = tintColor.alphaF();
+        qreal inv_a = 1.0 - a;
+
+        qreal r = tintColor.redF() * a + baseColor.redF() * inv_a;
+        qreal g = tintColor.greenF() * a + baseColor.greenF() * inv_a;
+        qreal b = tintColor.blueF() * a + baseColor.blueF() * inv_a;
+
+        return QVariant::fromValue(QColor::fromRgbF(r, g, b, a + inv_a * baseColor.alphaF()));
+    }
+
+private:
+    static uchar fromHex(const uchar c, const uchar c2)
+    {
+        uchar rv = 0;
+        if (c >= '0' && c <= '9')
+            rv += (c - '0') * 16;
+        else if (c >= 'A' && c <= 'F')
+            rv += (c - 'A' + 10) * 16;
+        else if (c >= 'a' && c <= 'f')
+            rv += (c - 'a' + 10) * 16;
+
+        if (c2 >= '0' && c2 <= '9')
+            rv += (c2 - '0');
+        else if (c2 >= 'A' && c2 <= 'F')
+            rv += (c2 - 'A' + 10);
+        else if (c2 >= 'a' && c2 <= 'f')
+            rv += (c2 - 'a' + 10);
+
+        return rv;
+    }
+
+    static inline uchar fromHex(const QString &s, int idx)
+    {
+        uchar c = s.at(idx).toAscii();
+        uchar c2 = s.at(idx + 1).toAscii();
+        return fromHex(c, c2);
+    }
+};
+
+
+class QQuickValueTypeProvider : public QQmlValueTypeProvider
+{
+public:
+    static QVector3D vector3DFromString(const QString &s, bool *ok)
+    {
+        if (s.count(QLatin1Char(',')) == 2) {
+            int index = s.indexOf(QLatin1Char(','));
+            int index2 = s.indexOf(QLatin1Char(','), index+1);
+
+            bool xGood, yGood, zGood;
+            qreal xCoord = s.left(index).toDouble(&xGood);
+            qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood);
+            qreal zCoord = s.mid(index2+1).toDouble(&zGood);
+
+            if (xGood && yGood && zGood) {
+                if (ok) *ok = true;
+                return QVector3D(xCoord, yCoord, zCoord);
+            }
+        }
+
+        if (ok) *ok = false;
+        return QVector3D();
+    }
+
+    static QVector4D vector4DFromString(const QString &s, bool *ok)
+    {
+        if (s.count(QLatin1Char(',')) == 3) {
+            int index = s.indexOf(QLatin1Char(','));
+            int index2 = s.indexOf(QLatin1Char(','), index+1);
+            int index3 = s.indexOf(QLatin1Char(','), index2+1);
+
+            bool xGood, yGood, zGood, wGood;
+            qreal xCoord = s.left(index).toDouble(&xGood);
+            qreal yCoord = s.mid(index+1, index2-index-1).toDouble(&yGood);
+            qreal zCoord = s.mid(index2+1, index3-index2-1).toDouble(&zGood);
+            qreal wCoord = s.mid(index3+1).toDouble(&wGood);
+
+            if (xGood && yGood && zGood && wGood) {
+                if (ok) *ok = true;
+                return QVector4D(xCoord, yCoord, zCoord, wCoord);
+            }
+        }
+
+        if (ok) *ok = false;
+        return QVector4D();
+    }
+
+    bool create(int type, QQmlValueType *&v)
+    {
+        switch (type) {
+        case QMetaType::QColor:
+            v = new QQuickColorValueType;
+            return true;
+        case QMetaType::QVector2D:
+            v = new QQuickVector2DValueType;
+            return true;
+        case QMetaType::QVector3D:
+            v = new QQuickVector3DValueType;
+            return true;
+        case QMetaType::QVector4D:
+            v = new QQuickVector4DValueType;
+            return true;
+        case QMetaType::QQuaternion:
+            v = new QQuickQuaternionValueType;
+            return true;
+        case QMetaType::QMatrix4x4:
+            v = new QQuickMatrix4x4ValueType;
+            return true;
+        case QMetaType::QFont:
+            v = new QQuickFontValueType;
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    bool init(int type, void *data, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            QColor *color = reinterpret_cast<QColor *>(data);
+            new (color) QColor();
+            return true;
+        }
+
+        return false;
+    }
+
+    bool destroy(int type, void *data, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            QColor *color = reinterpret_cast<QColor *>(data);
+            color->~QColor();
+            return true;
+        }
+
+        return false;
+    }
+
+    bool copy(int type, const void *src, void *dst, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            const QColor *srcColor = reinterpret_cast<const QColor *>(src);
+            QColor *dstColor = reinterpret_cast<QColor *>(dst);
+            new (dstColor) QColor(*srcColor);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool create(int type, int argc, const void *argv[], QVariant *v)
+    {
+        switch (type) {
+        case QMetaType::QVector3D:
+            if (argc == 1) {
+                const float *xyz = reinterpret_cast<const float*>(argv[0]);
+                QVector3D v3(xyz[0], xyz[1], xyz[2]);
+                *v = QVariant(v3);
+                return true;
+            }
+            break;
+        case QMetaType::QVector4D:
+            if (argc == 1) {
+                const float *xyzw = reinterpret_cast<const float*>(argv[0]);
+                QVector4D v4(xyzw[0], xyzw[1], xyzw[2], xyzw[3]);
+                *v = QVariant(v4);
+                return true;
+            }
+            break;
+        }
+
+        return false;
+    }
+
+    bool createFromString(int type, const QString &s, void *data, size_t n)
+    {
+        bool ok = false;
+
+        switch (type) {
+        case QMetaType::QColor:
+            {
+            Q_ASSERT(n >= sizeof(QColor));
+            QColor *color = reinterpret_cast<QColor *>(data);
+            new (color) QColor(QQuickColorProvider::QColorFromString(s));
+            return true;
+            }
+        case QMetaType::QVector3D:
+            {
+            Q_ASSERT(n >= sizeof(QVector3D));
+            QVector3D *v3 = reinterpret_cast<QVector3D *>(data);
+            new (v3) QVector3D(vector3DFromString(s, &ok));
+            return true;
+            }
+        case QMetaType::QVector4D:
+            {
+            Q_ASSERT(n >= sizeof(QVector4D));
+            QVector4D *v4 = reinterpret_cast<QVector4D *>(data);
+            new (v4) QVector4D(vector4DFromString(s, &ok));
+            return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool createStringFrom(int type, const void *data, QString *s)
+    {
+        if (type == QMetaType::QColor) {
+            const QColor *color = reinterpret_cast<const QColor *>(data);
+            new (s) QString(QVariant(*color).toString());
+            return true;
+        }
+
+        return false;
+    }
+
+    bool variantFromString(const QString &s, QVariant *v)
+    {
+        QColor c(QQuickColorProvider::QColorFromString(s));
+        if (c.isValid()) {
+            *v = QVariant::fromValue(c);
+            return true;
+        }
+
+        bool ok = false;
+
+        QVector3D v3 = vector3DFromString(s, &ok);
+        if (ok) {
+            *v = QVariant::fromValue(v3);
+            return true;
+        }
+
+        QVector4D v4 = vector4DFromString(s, &ok);
+        if (ok) {
+            *v = QVariant::fromValue(v4);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool variantFromString(int type, const QString &s, QVariant *v)
+    {
+        bool ok = false;
+
+        switch (type) {
+        case QMetaType::QColor:
+            {
+            QColor c(QQuickColorProvider::QColorFromString(s));
+            *v = QVariant::fromValue(c);
+            return true;
+            }
+        case QMetaType::QVector3D:
+            *v = QVariant::fromValue(vector3DFromString(s, &ok));
+            return true;
+        case QMetaType::QVector4D:
+            *v = QVariant::fromValue(vector4DFromString(s, &ok));
+            return true;
+        }
+
+        return false;
+    }
+
+    bool store(int type, const void *src, void *dst, size_t n)
+    {
+        switch (type) {
+        case QMetaType::QColor:
+            {
+            Q_ASSERT(n >= sizeof(QColor));
+            const QRgb *rgb = reinterpret_cast<const QRgb *>(src);
+            QColor *color = reinterpret_cast<QColor *>(dst);
+            new (color) QColor(QColor::fromRgba(*rgb));
+            return true;
+            }
+        case QMetaType::QVector3D:
+            {
+            Q_ASSERT(n >= sizeof(QVector3D));
+            const QVector3D *srcVector = reinterpret_cast<const QVector3D *>(src);
+            QVector3D *dstVector = reinterpret_cast<QVector3D *>(dst);
+            new (dstVector) QVector3D(*srcVector);
+            return true;
+            }
+        case QMetaType::QVector4D:
+            {
+            Q_ASSERT(n >= sizeof(QVector4D));
+            const QVector4D *srcVector = reinterpret_cast<const QVector4D *>(src);
+            QVector4D *dstVector = reinterpret_cast<QVector4D *>(dst);
+            new (dstVector) QVector4D(*srcVector);
+            return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool read(int srcType, const void *src, int dstType, void *dst)
+    {
+        if (dstType == QMetaType::QColor) {
+            QColor *dstColor = reinterpret_cast<QColor *>(dst);
+            if (srcType == QMetaType::QColor) {
+                const QColor *srcColor = reinterpret_cast<const QColor *>(src);
+                *dstColor = *srcColor;
+            } else {
+                *dstColor = QColor();
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    bool write(int type, const void *src, void *dst, size_t n)
+    {
+        if (type == QMetaType::QColor) {
+            Q_ASSERT(n >= sizeof(QColor));
+            const QColor *srcColor = reinterpret_cast<const QColor *>(src);
+            QColor *dstColor = reinterpret_cast<QColor *>(dst);
+            if (*dstColor != *srcColor) {
+                *dstColor = *srcColor;
+                return true;
+            }
+        }
+
+        return false;
+    }
+};
+
+
+class QQuickGuiProvider : public QQmlGuiProvider
+{
+public:
+    QQuickApplication *application(QObject *parent)
+    {
+        return new QQuickApplication(parent);
+    }
+
+    QInputMethod *inputMethod()
+    {
+        return qGuiApp->inputMethod();
+    }
+
+    QStringList fontFamilies()
+    {
+        QFontDatabase database;
+        return database.families();
+    }
+
+    bool openUrlExternally(QUrl &url)
+    {
+#ifndef QT_NO_DESKTOPSERVICES
+        return QDesktopServices::openUrl(url);
+#else
+        return false;
+#endif
+    }
+};
+
+
+static QQuickValueTypeProvider *getValueTypeProvider()
+{
+    static QQuickValueTypeProvider valueTypeProvider;
+    return &valueTypeProvider;
+}
+
+static QQuickColorProvider *getColorProvider()
+{
+    static QQuickColorProvider colorProvider;
+    return &colorProvider;
+}
+
+static QQuickGuiProvider *getGuiProvider()
+{
+    static QQuickGuiProvider guiProvider;
+    return &guiProvider;
+}
+
+static bool initializeProviders()
+{
+    QQml_addValueTypeProvider(getValueTypeProvider());
+    QQml_setColorProvider(getColorProvider());
+    QQml_setGuiProvider(getGuiProvider());
+    return true;
+}
+
+static bool initialized = initializeProviders();
+
+QT_END_NAMESPACE