QmlDesigner: removing dependency on private/qdeclarativestringconverters_p.h

PropertyParser takes care of the issue now.

Change-Id: Ib75c47f239fef05cdc3a9032d011d69483c381d5
Reviewed-by: Marco Bubke <marco.bubke@digia.com>

src/plugins/qmldesigner/designercore/designercore.pri

@@ -93,7 +93,7 @@ HEADERS += $$PWD/include/corelib_global.h \
     $$PWD/model/internalnode_p.h \
     $$PWD/model/model_p.h \
     $$PWD/model/painteventfilter_p.h \
-    $$PWD/model/propertyparser.h \
+    $$PWD/include/propertyparser.h \
     $$PWD/pluginmanager/widgetpluginmanager.h \
     $$PWD/pluginmanager/widgetpluginpath.h \
     $$PWD/include/exception.h \

src/plugins/qmldesigner/designercore/model/propertyparser.h → src/plugins/qmldesigner/designercore/include/propertyparser.h

@@ -43,6 +43,7 @@ QVariant read(const QString &typeStr, const QString &str, const MetaInfo &metaIn
 QVariant read(const QString &typeStr, const QString &str);
 QVariant read(int variantType, const QString &str);
 QString write(const QVariant &variant, const MetaInfo &metaInfo);
+QVariant variantFromString(const QString &s);
 
 } // namespace PropertyParser
 } // namespace Internal

src/plugins/qmldesigner/designercore/metainfo/metainfoparser.cpp

@@ -31,7 +31,7 @@
 #include "metainfoparser.h"
 #include "metainfo.h"
 
-#include "model/propertyparser.h"
+#include <propertyparser.h>
 #include <QXmlStreamReader>
 #include <QString>
 #include <QFile>

src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp

@@ -36,6 +36,7 @@
 #include "metainfo.h"
 #include <model.h>
 #include <rewriterview.h>
+#include <propertyparser.h>
 
 #include <QSharedData>
 #include <QDebug>
@@ -50,8 +51,6 @@
 #include <qmljs/qmljsscopechain.h>
 #include <qmljs/parser/qmljsast_p.h>
 #include <languageutils/fakemetaobject.h>
-#include <private/qdeclarativemetatype_p.h>
-#include <private/qdeclarativestringconverters_p.h>
 
 namespace QmlDesigner {
 
@@ -1012,8 +1011,7 @@ QVariant NodeMetaInfo::propertyCastedValue(const QString &propertyName, const QV
         return variant;
     }
 
-    return QDeclarativeStringConverters::variantFromString(variant.toString());
-
+    return Internal::PropertyParser::variantFromString(variant.toString());
 }
 
 QList<NodeMetaInfo> NodeMetaInfo::superClasses() const

src/plugins/qmldesigner/designercore/model/propertyparser.cpp

@@ -33,9 +33,153 @@
 #include <metainfo.h>
 
 #include <QUrl>
+#include <QVector3D>
 #include <QDebug>
 
-#include <private/qdeclarativestringconverters_p.h>
+namespace {
+
+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 uchar fromHex(const QString &s, int idx)
+{
+    uchar c = s.at(idx).toAscii();
+    uchar c2 = s.at(idx + 1).toAscii();
+    return fromHex(c, c2);
+}
+
+QColor colorFromString(const QString &s, bool *ok)
+{
+    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);
+        if (ok) *ok = true;
+        return QColor(r, g, b, a);
+    } else {
+        QColor rv(s);
+        if (ok) *ok = rv.isValid();
+        return rv;
+    }
+}
+
+QPointF pointFFromString(const QString &s, bool *ok)
+{
+    if (s.count(QLatin1Char(',')) != 1) {
+        if (ok)
+            *ok = false;
+        return QPointF();
+    }
+
+    bool xGood, yGood;
+    int index = s.indexOf(QLatin1Char(','));
+    qreal xCoord = s.left(index).toDouble(&xGood);
+    qreal yCoord = s.mid(index+1).toDouble(&yGood);
+    if (!xGood || !yGood) {
+        if (ok)
+            *ok = false;
+        return QPointF();
+    }
+
+    if (ok)
+        *ok = true;
+    return QPointF(xCoord, yCoord);
+}
+
+QRectF rectFFromString(const QString &s, bool *ok)
+{
+    if (s.count(QLatin1Char(',')) != 2 || s.count(QLatin1Char('x')) != 1) {
+        if (ok)
+            *ok = false;
+        return QRectF();
+    }
+
+    bool xGood, yGood, wGood, hGood;
+    int index = s.indexOf(QLatin1Char(','));
+    qreal x = s.left(index).toDouble(&xGood);
+    int index2 = s.indexOf(QLatin1Char(','), index+1);
+    qreal y = s.mid(index+1, index2-index-1).toDouble(&yGood);
+    index = s.indexOf(QLatin1Char('x'), index2+1);
+    qreal width = s.mid(index2+1, index-index2-1).toDouble(&wGood);
+    qreal height = s.mid(index+1).toDouble(&hGood);
+    if (!xGood || !yGood || !wGood || !hGood) {
+        if (ok)
+            *ok = false;
+        return QRectF();
+    }
+
+    if (ok)
+        *ok = true;
+    return QRectF(x, y, width, height);
+}
+
+QSizeF sizeFFromString(const QString &s, bool *ok)
+{
+    if (s.count(QLatin1Char('x')) != 1) {
+        if (ok)
+            *ok = false;
+        return QSizeF();
+    }
+
+    bool wGood, hGood;
+    int index = s.indexOf(QLatin1Char('x'));
+    qreal width = s.left(index).toDouble(&wGood);
+    qreal height = s.mid(index+1).toDouble(&hGood);
+    if (!wGood || !hGood) {
+        if (ok)
+            *ok = false;
+        return QSizeF();
+    }
+
+    if (ok)
+        *ok = true;
+    return QSizeF(width, height);
+}
+
+QVector3D vector3DFromString(const QString &s, bool *ok)
+{
+    if (s.count(QLatin1Char(',')) != 2) {
+        if (ok)
+            *ok = false;
+        return QVector3D();
+    }
+
+    bool xGood, yGood, zGood;
+    int index = s.indexOf(QLatin1Char(','));
+    int index2 = s.indexOf(QLatin1Char(','), index+1);
+    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 = false;
+        return QVector3D();
+    }
+
+    if (ok)
+        *ok = true;
+    return QVector3D(xCoord, yCoord, zCoord);
+}
+
+} //namespace
 
 namespace QmlDesigner {
 namespace Internal {
@@ -66,29 +210,31 @@ QVariant read(int variantType, const QString &str)
     bool conversionOk = true;
     switch (variantType) {
     case QMetaType::QPoint:
-        value = QDeclarativeStringConverters::pointFFromString(str, &conversionOk).toPoint();
+        value = pointFFromString(str, &conversionOk).toPoint();
         break;
     case QMetaType::QPointF:
-        value = QDeclarativeStringConverters::pointFFromString(str, &conversionOk);
+        value = pointFFromString(str, &conversionOk);
         break;
     case QMetaType::QSize:
-        value = QDeclarativeStringConverters::sizeFFromString(str, &conversionOk).toSize();
+        value = sizeFFromString(str, &conversionOk).toSize();
         break;
     case QMetaType::QSizeF:
-        value = QDeclarativeStringConverters::sizeFFromString(str, &conversionOk);
+        value = sizeFFromString(str, &conversionOk);
         break;
     case QMetaType::QRect:
-        value = QDeclarativeStringConverters::rectFFromString(str, &conversionOk).toRect();
+        value = rectFFromString(str, &conversionOk).toRect();
         break;
     case QMetaType::QRectF:
-        value = QDeclarativeStringConverters::rectFFromString(str, &conversionOk);
+        value = rectFFromString(str, &conversionOk);
         break;
     case QMetaType::QUrl:
         value = QVariant(QUrl(str));
         break;
     case QMetaType::QColor:
-        value = QDeclarativeStringConverters::colorFromString(str);
+        value = colorFromString(str, &conversionOk);
         break;
+    case QMetaType::QVector3D:
+        value = vector3DFromString(str, &conversionOk);
     default: {
         value = QVariant(str);
         value.convert(static_cast<QVariant::Type>(variantType));
@@ -103,6 +249,26 @@ QVariant read(int variantType, const QString &str)
     }
 
     return value;
+    return QVariant();
+}
+
+QVariant variantFromString(const QString &s)
+{
+    if (s.isEmpty())
+        return QVariant(s);
+    bool ok = false;
+    QRectF r = rectFFromString(s, &ok);
+    if (ok) return QVariant(r);
+    QColor c = colorFromString(s, &ok);
+    if (ok) return QVariant(c);
+    QPointF p = pointFFromString(s, &ok);
+    if (ok) return QVariant(p);
+    QSizeF sz = sizeFFromString(s, &ok);
+    if (ok) return QVariant(sz);
+    QVector3D v = vector3DFromString(s, &ok);
+    if (ok) return QVariant::fromValue(v);
+
+    return QVariant(s);
 }
 
 QString write(const QVariant &variant)