From 73d1476fb1397948a4d806bd921fce372bd8d63b Mon Sep 17 00:00:00 2001 From: Olivier Goffart Date: Mon, 2 Dec 2019 17:54:48 +0100 Subject: Replace most use of QVariant::type and occurrences of QVariant::Type I made a clazy automated check that replaced the use of QVariant::Type by the equivalent in QMetaType. This has been deprecated since Qt 5.0, but many uses were not yet removed. In addition, there was some manual changes to fix the compilation errors. Adapted the Private API of QDateTimeParser and QMimeDataPrivate and adjust QDateTimeEdit and QSpinBox. QVariant(QVariant::Invalid) in qstylesheet made no sense. But note that in QVariant::save, we actually wanted to use the non-user type. In the SQL module, many changes were actually reverted because the API still expects QVarient::Type. Change-Id: I98c368490e4ee465ed3a3b63bda8b8eaa50ea67e Reviewed-by: Lars Knoll --- .../serialization/convert/cborconverter.cpp | 4 +- .../serialization/convert/datastreamconverter.cpp | 6 +- .../serialization/convert/textconverter.cpp | 6 +- .../corelib/serialization/convert/xmlconverter.cpp | 20 +- examples/network/torrent/trackerclient.cpp | 2 +- .../itemviews/coloreditorfactory/window.cpp | 2 +- .../mysortfilterproxymodel.cpp | 2 +- .../widgets/tools/settingseditor/settingstree.cpp | 2 +- .../tools/settingseditor/variantdelegate.cpp | 132 +++--- .../widgets/tools/settingseditor/variantdelegate.h | 2 +- src/corelib/animation/qpropertyanimation.cpp | 6 +- src/corelib/io/qsettings.cpp | 34 +- src/corelib/itemmodels/qabstractitemmodel.cpp | 40 +- src/corelib/kernel/qmetaobject.cpp | 12 +- src/corelib/kernel/qmimedata.cpp | 72 +-- src/corelib/kernel/qvariant.cpp | 492 ++++++++++----------- src/corelib/kernel/qvariant_p.h | 4 +- src/corelib/serialization/qjsoncbor.cpp | 38 +- src/corelib/serialization/qjsondocument.cpp | 10 +- src/corelib/serialization/qjsonvalue.cpp | 26 +- src/corelib/text/qlocale.cpp | 6 +- src/corelib/text/qlocale_unix.cpp | 12 +- src/corelib/time/qdatetime.cpp | 6 +- src/corelib/time/qdatetimeparser.cpp | 24 +- src/corelib/time/qdatetimeparser_p.h | 4 +- src/dbus/qdbusabstractinterface.cpp | 2 +- src/dbus/qdbusargument.h | 4 +- src/dbus/qdbusintegrator.cpp | 4 +- src/dbus/qdbusinterface.cpp | 18 +- src/dbus/qdbusmarshaller.cpp | 10 +- src/dbus/qdbusmessage.cpp | 2 +- src/dbus/qdbusmetaobject.cpp | 20 +- src/dbus/qdbusmetatype.cpp | 38 +- src/dbus/qdbusutil.cpp | 8 +- src/dbus/qdbusxmlgenerator.cpp | 6 +- src/gui/image/qbitmap.cpp | 2 +- src/gui/image/qicon.cpp | 2 +- src/gui/image/qimage.cpp | 2 +- src/gui/image/qpixmap.cpp | 2 +- src/gui/itemmodels/qstandarditemmodel.cpp | 2 +- src/gui/kernel/qcursor.cpp | 2 +- src/gui/kernel/qguivariant.cpp | 62 +-- src/gui/kernel/qinternalmimedata.cpp | 13 +- src/gui/kernel/qkeysequence.cpp | 2 +- src/gui/kernel/qpalette.cpp | 2 +- src/gui/math3d/qmatrix4x4.cpp | 2 +- src/gui/math3d/qquaternion.cpp | 2 +- src/gui/math3d/qvector2d.cpp | 2 +- src/gui/math3d/qvector3d.cpp | 2 +- src/gui/math3d/qvector4d.cpp | 2 +- src/gui/painting/qbrush.cpp | 2 +- src/gui/painting/qcolor.cpp | 2 +- src/gui/painting/qmatrix.cpp | 2 +- src/gui/painting/qpen.cpp | 2 +- src/gui/painting/qpolygon.cpp | 2 +- src/gui/painting/qregion.cpp | 2 +- src/gui/painting/qtransform.cpp | 2 +- src/gui/text/qcssparser.cpp | 20 +- src/gui/text/qfont.cpp | 2 +- src/gui/text/qplatformfontdatabase.cpp | 2 +- src/gui/text/qtextdocument.cpp | 6 +- src/gui/text/qtextdocumentlayout.cpp | 2 +- src/gui/text/qtextformat.cpp | 52 +-- src/gui/text/qtexthtmlparser.cpp | 12 +- src/gui/text/qtextimagehandler.cpp | 8 +- src/gui/text/qtextodfwriter.cpp | 4 +- .../accessibility/qaccessiblebridgeutils.cpp | 2 +- .../linuxaccessibility/atspiadaptor.cpp | 2 +- .../themes/genericunix/qgenericunixthemes.cpp | 2 +- src/plugins/generic/tuiotouch/qtuiohandler.cpp | 40 +- src/plugins/platforms/xcb/qxcbclipboard.cpp | 3 +- src/plugins/platforms/xcb/qxcbdrag.cpp | 6 +- src/plugins/platforms/xcb/qxcbmime.cpp | 8 +- src/plugins/platforms/xcb/qxcbmime.h | 4 +- src/plugins/sqldrivers/ibase/qsql_ibase.cpp | 4 +- src/plugins/sqldrivers/mysql/qsql_mysql.cpp | 116 ++--- src/plugins/sqldrivers/odbc/qsql_odbc.cpp | 6 +- src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp | 2 +- src/sql/kernel/qsqldriver.cpp | 22 +- src/sql/kernel/qsqlfield.cpp | 11 +- src/sql/kernel/qsqlfield.h | 2 +- src/sql/kernel/qsqlresult.cpp | 4 +- src/testlib/qtest.h | 2 +- src/testlib/qtestlog.cpp | 4 +- src/tools/qdbuscpp2xml/qdbuscpp2xml.cpp | 6 +- src/tools/qdbusxml2cpp/qdbusxml2cpp.cpp | 2 +- src/widgets/dialogs/qsidebar.cpp | 2 +- src/widgets/graphicsview/qgraphicsitem.cpp | 8 +- src/widgets/graphicsview/qgraphicsproxywidget.cpp | 10 +- src/widgets/graphicsview/qgraphicsscene.cpp | 8 +- src/widgets/graphicsview/qgraphicsview.cpp | 8 +- src/widgets/itemviews/qabstractitemdelegate.cpp | 18 +- src/widgets/itemviews/qabstractitemview.cpp | 2 +- src/widgets/itemviews/qheaderview.cpp | 2 +- src/widgets/itemviews/qitemdelegate.cpp | 22 +- src/widgets/itemviews/qitemeditorfactory.cpp | 34 +- src/widgets/itemviews/qstyleditemdelegate.cpp | 10 +- src/widgets/kernel/qsizepolicy.cpp | 2 +- src/widgets/kernel/qwidgetsvariant.cpp | 12 +- src/widgets/styles/qstylesheetstyle.cpp | 31 +- src/widgets/widgets/qabstractspinbox.cpp | 70 +-- src/widgets/widgets/qabstractspinbox_p.h | 2 +- src/widgets/widgets/qcombobox.cpp | 8 +- src/widgets/widgets/qdatetimeedit.cpp | 32 +- src/widgets/widgets/qdatetimeedit.h | 3 + src/widgets/widgets/qplaintextedit.cpp | 20 +- src/widgets/widgets/qspinbox.cpp | 4 +- src/widgets/widgets/qtextbrowser.cpp | 4 +- src/widgets/widgets/qtextedit.cpp | 24 +- 109 files changed, 947 insertions(+), 936 deletions(-) diff --git a/examples/corelib/serialization/convert/cborconverter.cpp b/examples/corelib/serialization/convert/cborconverter.cpp index 60410ed26a..77df367e50 100644 --- a/examples/corelib/serialization/convert/cborconverter.cpp +++ b/examples/corelib/serialization/convert/cborconverter.cpp @@ -134,7 +134,7 @@ static QVariant convertCborValue(const QCborValue &value) enum TrimFloatingPoint { Double, Float, Float16 }; static QCborValue convertFromVariant(const QVariant &v, TrimFloatingPoint fpTrimming) { - if (v.userType() == QVariant::List) { + if (v.userType() == QMetaType::QVariantList) { const QVariantList list = v.toList(); QCborArray array; for (const QVariant &v : list) @@ -152,7 +152,7 @@ static QCborValue convertFromVariant(const QVariant &v, TrimFloatingPoint fpTrim return map; } - if (v.userType() == QVariant::Double && fpTrimming != Double) { + if (v.userType() == QMetaType::Double && fpTrimming != Double) { float f = float(v.toDouble()); if (fpTrimming == Float16) return float(qfloat16(f)); diff --git a/examples/corelib/serialization/convert/datastreamconverter.cpp b/examples/corelib/serialization/convert/datastreamconverter.cpp index 7e9f5e1bdc..6f0ca41ff5 100644 --- a/examples/corelib/serialization/convert/datastreamconverter.cpp +++ b/examples/corelib/serialization/convert/datastreamconverter.cpp @@ -96,8 +96,8 @@ static QString dumpVariant(const QVariant &v, const QString &indent = QLatin1Str QString indented = indent + QLatin1String(" "); int type = v.userType(); - if (type == qMetaTypeId() || type == QVariant::Map) { - const auto map = (type == QVariant::Map) ? + if (type == qMetaTypeId() || type == QMetaType::QVariantMap) { + const auto map = (type == QMetaType::QVariantMap) ? VariantOrderedMap(v.toMap()) : qvariant_cast(v); result = QLatin1String("Map {"); @@ -109,7 +109,7 @@ static QString dumpVariant(const QVariant &v, const QString &indent = QLatin1Str } result.chop(1); // remove comma result += indent + QLatin1String("},"); - } else if (type == QVariant::List) { + } else if (type == QMetaType::QVariantList) { const QVariantList list = v.toList(); result = QLatin1String("List ["); diff --git a/examples/corelib/serialization/convert/textconverter.cpp b/examples/corelib/serialization/convert/textconverter.cpp index 7aed08f96c..ae03b9a334 100644 --- a/examples/corelib/serialization/convert/textconverter.cpp +++ b/examples/corelib/serialization/convert/textconverter.cpp @@ -56,21 +56,21 @@ static void dumpVariant(QTextStream &out, const QVariant &v) { switch (v.userType()) { - case QVariant::List: { + case QMetaType::QVariantList: { const QVariantList list = v.toList(); for (const QVariant &item : list) dumpVariant(out, item); break; } - case QVariant::String: { + case QMetaType::QString: { const QStringList list = v.toStringList(); for (const QString &s : list) out << s << Qt::endl; break; } - case QVariant::Map: { + case QMetaType::QVariantMap: { const QVariantMap map = v.toMap(); for (auto it = map.begin(); it != map.end(); ++it) { out << it.key() << " => "; diff --git a/examples/corelib/serialization/convert/xmlconverter.cpp b/examples/corelib/serialization/convert/xmlconverter.cpp index d9e724dfe1..42cb10100a 100644 --- a/examples/corelib/serialization/convert/xmlconverter.cpp +++ b/examples/corelib/serialization/convert/xmlconverter.cpp @@ -284,18 +284,18 @@ static QVariant variantFromXml(QXmlStreamReader &xml, Converter::Options options ba.resize(n); result = ba; } else { - int id = QVariant::Invalid; + int id = QMetaType::UnknownType; if (type == QLatin1String("datetime")) - id = QVariant::DateTime; + id = QMetaType::QDateTime; else if (type == QLatin1String("url")) - id = QVariant::Url; + id = QMetaType::QUrl; else if (type == QLatin1String("uuid")) - id = QVariant::Uuid; + id = QMetaType::QUuid; else if (type == QLatin1String("regex")) - id = QVariant::RegularExpression; + id = QMetaType::QRegularExpression; else id = QMetaType::type(type.toLatin1()); - if (id == QVariant::Invalid) { + if (id == QMetaType::UnknownType) { fprintf(stderr, "%lld:%lld: Invalid XML: unknown type '%s'.\n", xml.lineNumber(), xml.columnNumber(), qPrintable(type.toString())); exit(EXIT_FAILURE); @@ -327,14 +327,14 @@ static QVariant variantFromXml(QXmlStreamReader &xml, Converter::Options options static void variantToXml(QXmlStreamWriter &xml, const QVariant &v) { int type = v.userType(); - if (type == QVariant::List) { + if (type == QMetaType::QVariantList) { QVariantList list = v.toList(); xml.writeStartElement("list"); for (const QVariant &v : list) variantToXml(xml, v); xml.writeEndElement(); - } else if (type == QVariant::Map || type == qMetaTypeId()) { - const VariantOrderedMap map = (type == QVariant::Map) ? + } else if (type == QMetaType::QVariantMap || type == qMetaTypeId()) { + const VariantOrderedMap map = (type == QMetaType::QVariantMap) ? VariantOrderedMap(v.toMap()) : qvariant_cast(v); @@ -433,7 +433,7 @@ static void variantToXml(QXmlStreamWriter &xml, const QVariant &v) // does this convert to string? const char *typeName = v.typeName(); QVariant copy = v; - if (copy.convert(QVariant::String)) { + if (copy.convert(QMetaType::QString)) { xml.writeAttribute(typeString, QString::fromLatin1(typeName)); xml.writeCharacters(copy.toString()); } else { diff --git a/examples/network/torrent/trackerclient.cpp b/examples/network/torrent/trackerclient.cpp index 540ab31557..a50a49fd64 100644 --- a/examples/network/torrent/trackerclient.cpp +++ b/examples/network/torrent/trackerclient.cpp @@ -209,7 +209,7 @@ void TrackerClient::httpRequestDone(QNetworkReply *reply) // store it peers.clear(); QVariant peerEntry = dict.value("peers"); - if (peerEntry.type() == QVariant::List) { + if (peerEntry.userType() == QMetaType::QVariantList) { QList peerTmp = peerEntry.toList(); for (int i = 0; i < peerTmp.size(); ++i) { TorrentPeer tmp; diff --git a/examples/widgets/itemviews/coloreditorfactory/window.cpp b/examples/widgets/itemviews/coloreditorfactory/window.cpp index e4a9379d8f..25e196a80c 100644 --- a/examples/widgets/itemviews/coloreditorfactory/window.cpp +++ b/examples/widgets/itemviews/coloreditorfactory/window.cpp @@ -61,7 +61,7 @@ Window::Window() QItemEditorCreatorBase *colorListCreator = new QStandardItemEditorCreator(); - factory->registerEditor(QVariant::Color, colorListCreator); + factory->registerEditor(QMetaType::QColor, colorListCreator); QItemEditorFactory::setDefaultFactory(factory); diff --git a/examples/widgets/itemviews/customsortfiltermodel/mysortfilterproxymodel.cpp b/examples/widgets/itemviews/customsortfiltermodel/mysortfilterproxymodel.cpp index 4753d04d9b..b0b4017e62 100644 --- a/examples/widgets/itemviews/customsortfiltermodel/mysortfilterproxymodel.cpp +++ b/examples/widgets/itemviews/customsortfiltermodel/mysortfilterproxymodel.cpp @@ -98,7 +98,7 @@ bool MySortFilterProxyModel::lessThan(const QModelIndex &left, //! [4] //! [6] - if (leftData.type() == QVariant::DateTime) { + if (leftData.userType() == QMetaType::QDateTime) { return leftData.toDateTime() < rightData.toDateTime(); } else { static const QRegularExpression emailPattern("[\\w\\.]*@[\\w\\.]*"); diff --git a/examples/widgets/tools/settingseditor/settingstree.cpp b/examples/widgets/tools/settingseditor/settingstree.cpp index 49d299bf72..9132368e4a 100644 --- a/examples/widgets/tools/settingseditor/settingstree.cpp +++ b/examples/widgets/tools/settingseditor/settingstree.cpp @@ -208,7 +208,7 @@ void SettingsTree::updateChildItems(QTreeWidgetItem *parent) } QVariant value = settings->value(key); - if (value.type() == QVariant::Invalid) { + if (value.userType() == QMetaType::UnknownType) { child->setText(1, "Invalid"); } else { child->setText(1, value.typeName()); diff --git a/examples/widgets/tools/settingseditor/variantdelegate.cpp b/examples/widgets/tools/settingseditor/variantdelegate.cpp index 9772fe8a41..eb822f0dc2 100644 --- a/examples/widgets/tools/settingseditor/variantdelegate.cpp +++ b/examples/widgets/tools/settingseditor/variantdelegate.cpp @@ -81,7 +81,7 @@ void VariantDelegate::paint(QPainter *painter, { if (index.column() == 2) { QVariant value = index.model()->data(index, Qt::UserRole); - if (!isSupportedType(value.type())) { + if (!isSupportedType(value.userType())) { QStyleOptionViewItem myOption = option; myOption.state &= ~QStyle::State_Enabled; QStyledItemDelegate::paint(painter, myOption, index); @@ -100,7 +100,7 @@ QWidget *VariantDelegate::createEditor(QWidget *parent, return nullptr; QVariant originalValue = index.model()->data(index, Qt::UserRole); - if (!isSupportedType(originalValue.type())) + if (!isSupportedType(originalValue.userType())) return nullptr; QLineEdit *lineEdit = new QLineEdit(parent); @@ -108,46 +108,46 @@ QWidget *VariantDelegate::createEditor(QWidget *parent, QRegularExpression regExp; - switch (originalValue.type()) { - case QVariant::Bool: + switch (originalValue.userType()) { + case QMetaType::Bool: regExp = boolExp; break; - case QVariant::ByteArray: + case QMetaType::QByteArray: regExp = byteArrayExp; break; - case QVariant::Char: + case QMetaType::QChar: regExp = charExp; break; - case QVariant::Color: + case QMetaType::QColor: regExp = colorExp; break; - case QVariant::Date: + case QMetaType::QDate: regExp = dateExp; break; - case QVariant::DateTime: + case QMetaType::QDateTime: regExp = dateTimeExp; break; - case QVariant::Double: + case QMetaType::Double: regExp = doubleExp; break; - case QVariant::Int: - case QVariant::LongLong: + case QMetaType::Int: + case QMetaType::LongLong: regExp = signedIntegerExp; break; - case QVariant::Point: + case QMetaType::QPoint: regExp = pointExp; break; - case QVariant::Rect: + case QMetaType::QRect: regExp = rectExp; break; - case QVariant::Size: + case QMetaType::QSize: regExp = sizeExp; break; - case QVariant::Time: + case QMetaType::QTime: regExp = timeExp; break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: regExp = unsignedIntegerExp; break; default: @@ -189,18 +189,18 @@ void VariantDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, QVariant value; QRegularExpressionMatch match; - switch (originalValue.type()) { - case QVariant::Char: + switch (originalValue.userType()) { + case QMetaType::QChar: value = text.at(0); break; - case QVariant::Color: + case QMetaType::QColor: match = colorExp.match(text); value = QColor(qMin(match.captured(1).toInt(), 255), qMin(match.captured(2).toInt(), 255), qMin(match.captured(3).toInt(), 255), qMin(match.captured(4).toInt(), 255)); break; - case QVariant::Date: + case QMetaType::QDate: { QDate date = QDate::fromString(text, Qt::ISODate); if (!date.isValid()) @@ -208,7 +208,7 @@ void VariantDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, value = date; } break; - case QVariant::DateTime: + case QMetaType::QDateTime: { QDateTime dateTime = QDateTime::fromString(text, Qt::ISODate); if (!dateTime.isValid()) @@ -216,23 +216,23 @@ void VariantDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, value = dateTime; } break; - case QVariant::Point: + case QMetaType::QPoint: match = pointExp.match(text); value = QPoint(match.captured(1).toInt(), match.captured(2).toInt()); break; - case QVariant::Rect: + case QMetaType::QRect: match = rectExp.match(text); value = QRect(match.captured(1).toInt(), match.captured(2).toInt(), match.captured(3).toInt(), match.captured(4).toInt()); break; - case QVariant::Size: + case QMetaType::QSize: match = sizeExp.match(text); value = QSize(match.captured(1).toInt(), match.captured(2).toInt()); break; - case QVariant::StringList: + case QMetaType::QStringList: value = text.split(','); break; - case QVariant::Time: + case QMetaType::QTime: { QTime time = QTime::fromString(text, Qt::ISODate); if (!time.isValid()) @@ -242,33 +242,33 @@ void VariantDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, break; default: value = text; - value.convert(originalValue.type()); + value.convert(originalValue.userType()); } model->setData(index, displayText(value), Qt::DisplayRole); model->setData(index, value, Qt::UserRole); } -bool VariantDelegate::isSupportedType(QVariant::Type type) +bool VariantDelegate::isSupportedType(int type) { switch (type) { - case QVariant::Bool: - case QVariant::ByteArray: - case QVariant::Char: - case QVariant::Color: - case QVariant::Date: - case QVariant::DateTime: - case QVariant::Double: - case QVariant::Int: - case QVariant::LongLong: - case QVariant::Point: - case QVariant::Rect: - case QVariant::Size: - case QVariant::String: - case QVariant::StringList: - case QVariant::Time: - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::Bool: + case QMetaType::QByteArray: + case QMetaType::QChar: + case QMetaType::QColor: + case QMetaType::QDate: + case QMetaType::QDateTime: + case QMetaType::Double: + case QMetaType::Int: + case QMetaType::LongLong: + case QMetaType::QPoint: + case QMetaType::QRect: + case QMetaType::QSize: + case QMetaType::QString: + case QMetaType::QStringList: + case QMetaType::QTime: + case QMetaType::UInt: + case QMetaType::ULongLong: return true; default: return false; @@ -277,50 +277,50 @@ bool VariantDelegate::isSupportedType(QVariant::Type type) QString VariantDelegate::displayText(const QVariant &value) { - switch (value.type()) { - case QVariant::Bool: - case QVariant::ByteArray: - case QVariant::Char: - case QVariant::Double: - case QVariant::Int: - case QVariant::LongLong: - case QVariant::String: - case QVariant::UInt: - case QVariant::ULongLong: + switch (value.userType()) { + case QMetaType::Bool: + case QMetaType::QByteArray: + case QMetaType::QChar: + case QMetaType::Double: + case QMetaType::Int: + case QMetaType::LongLong: + case QMetaType::QString: + case QMetaType::UInt: + case QMetaType::ULongLong: return value.toString(); - case QVariant::Color: + case QMetaType::QColor: { QColor color = qvariant_cast(value); return QString("(%1,%2,%3,%4)") .arg(color.red()).arg(color.green()) .arg(color.blue()).arg(color.alpha()); } - case QVariant::Date: + case QMetaType::QDate: return value.toDate().toString(Qt::ISODate); - case QVariant::DateTime: + case QMetaType::QDateTime: return value.toDateTime().toString(Qt::ISODate); - case QVariant::Invalid: + case QMetaType::UnknownType: return ""; - case QVariant::Point: + case QMetaType::QPoint: { QPoint point = value.toPoint(); return QString("(%1,%2)").arg(point.x()).arg(point.y()); } - case QVariant::Rect: + case QMetaType::QRect: { QRect rect = value.toRect(); return QString("(%1,%2,%3,%4)") .arg(rect.x()).arg(rect.y()) .arg(rect.width()).arg(rect.height()); } - case QVariant::Size: + case QMetaType::QSize: { QSize size = value.toSize(); return QString("(%1,%2)").arg(size.width()).arg(size.height()); } - case QVariant::StringList: + case QMetaType::QStringList: return value.toStringList().join(','); - case QVariant::Time: + case QMetaType::QTime: return value.toTime().toString(Qt::ISODate); default: break; diff --git a/examples/widgets/tools/settingseditor/variantdelegate.h b/examples/widgets/tools/settingseditor/variantdelegate.h index 68f21fa3f6..96e44fd181 100644 --- a/examples/widgets/tools/settingseditor/variantdelegate.h +++ b/examples/widgets/tools/settingseditor/variantdelegate.h @@ -69,7 +69,7 @@ public: void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override; - static bool isSupportedType(QVariant::Type type); + static bool isSupportedType(int type); static QString displayText(const QVariant &value); private: diff --git a/src/corelib/animation/qpropertyanimation.cpp b/src/corelib/animation/qpropertyanimation.cpp index c71a77e073..d014b5c441 100644 --- a/src/corelib/animation/qpropertyanimation.cpp +++ b/src/corelib/animation/qpropertyanimation.cpp @@ -92,7 +92,7 @@ QT_BEGIN_NAMESPACE void QPropertyAnimationPrivate::updateMetaProperty() { if (!target || propertyName.isEmpty()) { - propertyType = QVariant::Invalid; + propertyType = QMetaType::UnknownType; propertyIndex = -1; return; } @@ -102,11 +102,11 @@ void QPropertyAnimationPrivate::updateMetaProperty() propertyType = targetValue->property(propertyName).userType(); propertyIndex = targetValue->metaObject()->indexOfProperty(propertyName); - if (propertyType != QVariant::Invalid) + if (propertyType != QMetaType::UnknownType) convertValues(propertyType); if (propertyIndex == -1) { //there is no Q_PROPERTY on the object - propertyType = QVariant::Invalid; + propertyType = QMetaType::UnknownType; if (!targetValue->dynamicPropertyNames().contains(propertyName)) qWarning("QPropertyAnimation: you're trying to animate a non-existing property %s of your QObject", propertyName.constData()); } else if (!targetValue->metaObject()->property(propertyIndex).isWritable()) { diff --git a/src/corelib/io/qsettings.cpp b/src/corelib/io/qsettings.cpp index 9fc45e307d..b191397e7e 100644 --- a/src/corelib/io/qsettings.cpp +++ b/src/corelib/io/qsettings.cpp @@ -396,12 +396,12 @@ QString QSettingsPrivate::variantToString(const QVariant &v) { QString result; - switch (v.type()) { - case QVariant::Invalid: + switch (v.userType()) { + case QMetaType::UnknownType: result = QLatin1String("@Invalid()"); break; - case QVariant::ByteArray: { + case QMetaType::QByteArray: { QByteArray a = v.toByteArray(); result = QLatin1String("@ByteArray(") + QLatin1String(a.constData(), a.size()) @@ -409,14 +409,14 @@ QString QSettingsPrivate::variantToString(const QVariant &v) break; } - case QVariant::String: - case QVariant::LongLong: - case QVariant::ULongLong: - case QVariant::Int: - case QVariant::UInt: - case QVariant::Bool: - case QVariant::Double: - case QVariant::KeySequence: { + case QMetaType::QString: + case QMetaType::LongLong: + case QMetaType::ULongLong: + case QMetaType::Int: + case QMetaType::UInt: + case QMetaType::Bool: + case QMetaType::Double: + case QMetaType::QKeySequence: { result = v.toString(); if (result.contains(QChar::Null)) result = QLatin1String("@String(") + result + QLatin1Char(')'); @@ -425,17 +425,17 @@ QString QSettingsPrivate::variantToString(const QVariant &v) break; } #ifndef QT_NO_GEOM_VARIANT - case QVariant::Rect: { + case QMetaType::QRect: { QRect r = qvariant_cast(v); result = QString::asprintf("@Rect(%d %d %d %d)", r.x(), r.y(), r.width(), r.height()); break; } - case QVariant::Size: { + case QMetaType::QSize: { QSize s = qvariant_cast(v); result = QString::asprintf("@Size(%d %d)", s.width(), s.height()); break; } - case QVariant::Point: { + case QMetaType::QPoint: { QPoint p = qvariant_cast(v); result = QString::asprintf("@Point(%d %d)", p.x(), p.y()); break; @@ -446,7 +446,7 @@ QString QSettingsPrivate::variantToString(const QVariant &v) #ifndef QT_NO_DATASTREAM QDataStream::Version version; const char *typeSpec; - if (v.type() == QVariant::DateTime) { + if (v.userType() == QMetaType::QDateTime) { version = QDataStream::Qt_5_6; typeSpec = "@DateTime("; } else { @@ -1888,8 +1888,8 @@ bool QConfFileSettingsPrivate::writeIniFile(QIODevice &device, const ParsedSetti QVariant(QString("foo")).toList() returns an empty list, not a list containing "foo". */ - if (value.type() == QVariant::StringList - || (value.type() == QVariant::List && value.toList().size() != 1)) { + if (value.userType() == QMetaType::QStringList + || (value.userType() == QMetaType::QVariantList && value.toList().size() != 1)) { iniEscapedStringList(variantListToStringList(value.toList()), block, iniCodec); } else { iniEscapedString(variantToString(value), block, iniCodec); diff --git a/src/corelib/itemmodels/qabstractitemmodel.cpp b/src/corelib/itemmodels/qabstractitemmodel.cpp index 46ac703615..608407c136 100644 --- a/src/corelib/itemmodels/qabstractitemmodel.cpp +++ b/src/corelib/itemmodels/qabstractitemmodel.cpp @@ -552,32 +552,32 @@ const QHash &QAbstractItemModelPrivate::defaultRoleNames() bool QAbstractItemModelPrivate::isVariantLessThan(const QVariant &left, const QVariant &right, Qt::CaseSensitivity cs, bool isLocaleAware) { - if (left.userType() == QVariant::Invalid) + if (left.userType() == QMetaType::UnknownType) return false; - if (right.userType() == QVariant::Invalid) + if (right.userType() == QMetaType::UnknownType) return true; switch (left.userType()) { - case QVariant::Int: + case QMetaType::Int: return left.toInt() < right.toInt(); - case QVariant::UInt: + case QMetaType::UInt: return left.toUInt() < right.toUInt(); - case QVariant::LongLong: + case QMetaType::LongLong: return left.toLongLong() < right.toLongLong(); - case QVariant::ULongLong: + case QMetaType::ULongLong: return left.toULongLong() < right.toULongLong(); case QMetaType::Float: return left.toFloat() < right.toFloat(); - case QVariant::Double: + case QMetaType::Double: return left.toDouble() < right.toDouble(); - case QVariant::Char: + case QMetaType::QChar: return left.toChar() < right.toChar(); - case QVariant::Date: + case QMetaType::QDate: return left.toDate() < right.toDate(); - case QVariant::Time: + case QMetaType::QTime: return left.toTime() < right.toTime(); - case QVariant::DateTime: + case QMetaType::QDateTime: return left.toDateTime() < right.toDateTime(); - case QVariant::String: + case QMetaType::QString: default: if (isLocaleAware) return left.toString().localeAwareCompare(right.toString()) < 0; @@ -591,19 +591,19 @@ static uint typeOfVariant(const QVariant &value) { //return 0 for integer, 1 for floating point and 2 for other switch (value.userType()) { - case QVariant::Bool: - case QVariant::Int: - case QVariant::UInt: - case QVariant::LongLong: - case QVariant::ULongLong: - case QVariant::Char: + case QMetaType::Bool: + case QMetaType::Int: + case QMetaType::UInt: + case QMetaType::LongLong: + case QMetaType::ULongLong: + case QMetaType::QChar: case QMetaType::Short: case QMetaType::UShort: case QMetaType::UChar: case QMetaType::ULong: case QMetaType::Long: return 0; - case QVariant::Double: + case QMetaType::Double: case QMetaType::Float: return 1; default: @@ -2379,7 +2379,7 @@ QModelIndexList QAbstractItemModel::match(const QModelIndex &start, int role, } else { // QString or regular expression based matching if (matchType == Qt::MatchRegularExpression) { if (rx.pattern().isEmpty()) { - if (value.type() == QVariant::RegularExpression) { + if (value.userType() == QMetaType::QRegularExpression) { rx = value.toRegularExpression(); } else { rx.setPattern(value.toString()); diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp index fad47eee13..347fb1eb87 100644 --- a/src/corelib/kernel/qmetaobject.cpp +++ b/src/corelib/kernel/qmetaobject.cpp @@ -2982,7 +2982,7 @@ int QMetaProperty::userType() const if (type == QMetaType::UnknownType) { type = registerPropertyType(); if (type == QMetaType::UnknownType) - return QVariant::Int; // Match behavior of QMetaType::type() + return QMetaType::Int; // Match behavior of QMetaType::type() } return type; } @@ -3100,7 +3100,7 @@ QVariant QMetaProperty::read(const QObject *object) const if (!object || !mobj) return QVariant(); - uint t = QVariant::Int; + uint t = QMetaType::Int; if (isEnumType()) { /* try to create a QVariant that can be converted to this enum @@ -3177,9 +3177,9 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const return false; QVariant v = value; - uint t = QVariant::Invalid; + uint t = QMetaType::UnknownType; if (isEnumType()) { - if (v.type() == QVariant::String) { + if (v.userType() == QMetaType::QString) { bool ok; if (isFlagType()) v = QVariant(menum.keysToValue(value.toByteArray(), &ok)); @@ -3187,13 +3187,13 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const v = QVariant(menum.keyToValue(value.toByteArray(), &ok)); if (!ok) return false; - } else if (v.type() != QVariant::Int && v.type() != QVariant::UInt) { + } else if (v.userType() != QMetaType::Int && v.userType() != QMetaType::UInt) { int enumMetaTypeId = QMetaType::type(qualifiedName(menum)); if ((enumMetaTypeId == QMetaType::UnknownType) || (v.userType() != enumMetaTypeId) || !v.constData()) return false; v = QVariant(*reinterpret_cast(v.constData())); } - v.convert(QVariant::Int); + v.convert(QMetaType::Int); } else { int handle = priv(mobj->d.data)->propertyData + 3*idx; const char *typeName = nullptr; diff --git a/src/corelib/kernel/qmimedata.cpp b/src/corelib/kernel/qmimedata.cpp index 00e5183eb1..fca258c9e3 100644 --- a/src/corelib/kernel/qmimedata.cpp +++ b/src/corelib/kernel/qmimedata.cpp @@ -70,7 +70,7 @@ public: void setData(const QString &format, const QVariant &data); QVariant getData(const QString &format) const; - QVariant retrieveTypedData(const QString &format, QVariant::Type type) const; + QVariant retrieveTypedData(const QString &format, QMetaType::Type type) const; QVector dataList; }; @@ -108,23 +108,23 @@ QVariant QMimeDataPrivate::getData(const QString &format) const return data; } -QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Type type) const +QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QMetaType::Type type) const { Q_Q(const QMimeData); - QVariant data = q->retrieveData(format, type); + QVariant data = q->retrieveData(format, QVariant::Type(type)); // Text data requested: fallback to URL data if available if (format == QLatin1String("text/plain") && !data.isValid()) { - data = retrieveTypedData(textUriListLiteral(), QVariant::List); - if (data.type() == QVariant::Url) { + data = retrieveTypedData(textUriListLiteral(), QMetaType::QVariantList); + if (data.userType() == QMetaType::QUrl) { data = QVariant(data.toUrl().toDisplayString()); - } else if (data.type() == QVariant::List) { + } else if (data.userType() == QMetaType::QVariantList) { QString text; int numUrls = 0; const QList list = data.toList(); for (int i = 0; i < list.size(); ++i) { - if (list.at(i).type() == QVariant::Url) { + if (list.at(i).userType() == QMetaType::QUrl) { text += list.at(i).toUrl().toDisplayString() + QLatin1Char('\n'); ++numUrls; } @@ -135,26 +135,26 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty } } - if (data.type() == type || !data.isValid()) + if (data.userType() == type || !data.isValid()) return data; // provide more conversion possiblities than just what QVariant provides // URLs can be lists as well... - if ((type == QVariant::Url && data.type() == QVariant::List) - || (type == QVariant::List && data.type() == QVariant::Url)) + if ((type == QMetaType::QUrl && data.userType() == QMetaType::QVariantList) + || (type == QMetaType::QVariantList && data.userType() == QMetaType::QUrl)) return data; // images and pixmaps are interchangeable - if ((type == QVariant::Pixmap && data.type() == QVariant::Image) - || (type == QVariant::Image && data.type() == QVariant::Pixmap)) + if ((type == QMetaType::QPixmap && data.userType() == QMetaType::QImage) + || (type == QMetaType::QImage && data.userType() == QMetaType::QPixmap)) return data; - if (data.type() == QVariant::ByteArray) { + if (data.userType() == QMetaType::QByteArray) { // see if we can convert to the requested type switch(type) { #if QT_CONFIG(textcodec) - case QVariant::String: { + case QMetaType::QString: { const QByteArray ba = data.toByteArray(); QTextCodec *codec = QTextCodec::codecForName("utf-8"); if (format == QLatin1String("text/html")) @@ -162,17 +162,17 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty return codec->toUnicode(ba); } #endif // textcodec - case QVariant::Color: { + case QMetaType::QColor: { QVariant newData = data; - newData.convert(QVariant::Color); + newData.convert(QMetaType::QColor); return newData; } - case QVariant::List: { + case QMetaType::QVariantList: { if (format != QLatin1String("text/uri-list")) break; Q_FALLTHROUGH(); } - case QVariant::Url: { + case QMetaType::QUrl: { QByteArray ba = data.toByteArray(); // Qt 3.x will send text/uri-list with a trailing // null-terminator (that is *not* sent for any other @@ -193,23 +193,23 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty break; } - } else if (type == QVariant::ByteArray) { + } else if (type == QMetaType::QByteArray) { // try to convert to bytearray - switch(data.type()) { - case QVariant::ByteArray: - case QVariant::Color: + switch (data.userType()) { + case QMetaType::QByteArray: + case QMetaType::QColor: return data.toByteArray(); - case QVariant::String: + case QMetaType::QString: return data.toString().toUtf8(); - case QVariant::Url: + case QMetaType::QUrl: return data.toUrl().toEncoded(); - case QVariant::List: { + case QMetaType::QVariantList: { // has to be list of URLs QByteArray result; QList list = data.toList(); for (int i = 0; i < list.size(); ++i) { - if (list.at(i).type() == QVariant::Url) { + if (list.at(i).userType() == QMetaType::QUrl) { result += list.at(i).toUrl().toEncoded(); result += "\r\n"; } @@ -340,14 +340,14 @@ QMimeData::~QMimeData() QList QMimeData::urls() const { Q_D(const QMimeData); - QVariant data = d->retrieveTypedData(textUriListLiteral(), QVariant::List); + QVariant data = d->retrieveTypedData(textUriListLiteral(), QMetaType::QVariantList); QList urls; - if (data.type() == QVariant::Url) + if (data.userType() == QMetaType::QUrl) urls.append(data.toUrl()); - else if (data.type() == QVariant::List) { + else if (data.userType() == QMetaType::QVariantList) { QList list = data.toList(); for (int i = 0; i < list.size(); ++i) { - if (list.at(i).type() == QVariant::Url) + if (list.at(i).userType() == QMetaType::QUrl) urls.append(list.at(i).toUrl()); } } @@ -400,11 +400,11 @@ bool QMimeData::hasUrls() const QString QMimeData::text() const { Q_D(const QMimeData); - QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QVariant::String); + QVariant utf8Text = d->retrieveTypedData(textPlainUtf8Literal(), QMetaType::QString); if (!utf8Text.isNull()) return utf8Text.toString(); - QVariant data = d->retrieveTypedData(textPlainLiteral(), QVariant::String); + QVariant data = d->retrieveTypedData(textPlainLiteral(), QMetaType::QString); return data.toString(); } @@ -440,7 +440,7 @@ bool QMimeData::hasText() const QString QMimeData::html() const { Q_D(const QMimeData); - QVariant data = d->retrieveTypedData(textHtmlLiteral(), QVariant::String); + QVariant data = d->retrieveTypedData(textHtmlLiteral(), QMetaType::QString); return data.toString(); } @@ -482,7 +482,7 @@ bool QMimeData::hasHtml() const QVariant QMimeData::imageData() const { Q_D(const QMimeData); - return d->retrieveTypedData(applicationXQtImageLiteral(), QVariant::Image); + return d->retrieveTypedData(applicationXQtImageLiteral(), QMetaType::QImage); } /*! @@ -529,7 +529,7 @@ bool QMimeData::hasImage() const QVariant QMimeData::colorData() const { Q_D(const QMimeData); - return d->retrieveTypedData(applicationXColorLiteral(), QVariant::Color); + return d->retrieveTypedData(applicationXColorLiteral(), QMetaType::QColor); } /*! @@ -564,7 +564,7 @@ bool QMimeData::hasColor() const QByteArray QMimeData::data(const QString &mimeType) const { Q_D(const QMimeData); - QVariant data = d->retrieveTypedData(mimeType, QVariant::ByteArray); + QVariant data = d->retrieveTypedData(mimeType, QMetaType::QByteArray); return data.toByteArray(); } diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index f3ac3fcdba..b417683d2a 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -168,7 +168,7 @@ static qlonglong qMetaTypeNumber(const QVariant::Private *d) return qlonglong(d->data.l); case QMetaType::Float: return qRound64(d->data.f); - case QVariant::Double: + case QMetaType::Double: return qRound64(d->data.d); #ifndef QT_BOOTSTRAPPED case QMetaType::QJsonValue: @@ -184,9 +184,9 @@ static qlonglong qMetaTypeNumber(const QVariant::Private *d) static qulonglong qMetaTypeUNumber(const QVariant::Private *d) { switch (d->type) { - case QVariant::UInt: + case QMetaType::UInt: return d->data.u; - case QVariant::ULongLong: + case QMetaType::ULongLong: return d->data.ull; case QMetaType::UChar: return d->data.uc; @@ -204,13 +204,13 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok) *ok = true; switch (uint(d->type)) { - case QVariant::String: + case QMetaType::QString: return v_cast(d)->toLongLong(ok); - case QVariant::Char: + case QMetaType::QChar: return v_cast(d)->unicode(); - case QVariant::ByteArray: + case QMetaType::QByteArray: return v_cast(d)->toLongLong(ok); - case QVariant::Bool: + case QMetaType::Bool: return qlonglong(d->data.b); #ifndef QT_BOOTSTRAPPED case QMetaType::QCborValue: @@ -222,8 +222,8 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok) break; Q_FALLTHROUGH(); #endif - case QVariant::Double: - case QVariant::Int: + case QMetaType::Double: + case QMetaType::Int: case QMetaType::Char: case QMetaType::SChar: case QMetaType::Short: @@ -231,8 +231,8 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok) case QMetaType::Float: case QMetaType::LongLong: return qMetaTypeNumber(d); - case QVariant::ULongLong: - case QVariant::UInt: + case QMetaType::ULongLong: + case QMetaType::UInt: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -262,12 +262,12 @@ static qreal qConvertToRealNumber(const QVariant::Private *d, bool *ok) { *ok = true; switch (uint(d->type)) { - case QVariant::Double: + case QMetaType::Double: return qreal(d->data.d); case QMetaType::Float: return qreal(d->data.f); - case QVariant::ULongLong: - case QVariant::UInt: + case QMetaType::ULongLong: + case QMetaType::UInt: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -289,13 +289,13 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok) *ok = true; switch (uint(d->type)) { - case QVariant::String: + case QMetaType::QString: return v_cast(d)->toULongLong(ok); - case QVariant::Char: + case QMetaType::QChar: return v_cast(d)->unicode(); - case QVariant::ByteArray: + case QMetaType::QByteArray: return v_cast(d)->toULongLong(ok); - case QVariant::Bool: + case QMetaType::Bool: return qulonglong(d->data.b); #ifndef QT_BOOTSTRAPPED case QMetaType::QCborValue: @@ -309,8 +309,8 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok) break; Q_FALLTHROUGH(); #endif - case QVariant::Double: - case QVariant::Int: + case QMetaType::Double: + case QMetaType::Int: case QMetaType::Char: case QMetaType::SChar: case QMetaType::Short: @@ -318,8 +318,8 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok) case QMetaType::Float: case QMetaType::LongLong: return qulonglong(qMetaTypeNumber(d)); - case QVariant::ULongLong: - case QVariant::UInt: + case QMetaType::ULongLong: + case QMetaType::UInt: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -406,9 +406,9 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) switch (uint(t)) { #ifndef QT_BOOTSTRAPPED - case QVariant::Url: + case QMetaType::QUrl: switch (d->type) { - case QVariant::String: + case QMetaType::QString: *static_cast(result) = QUrl(*v_cast(d)); break; case QMetaType::QCborValue: @@ -423,18 +423,18 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; #endif // QT_BOOTSTRAPPED #if QT_CONFIG(itemmodel) - case QVariant::ModelIndex: + case QMetaType::QModelIndex: switch (d->type) { - case QVariant::PersistentModelIndex: + case QMetaType::QPersistentModelIndex: *static_cast(result) = QModelIndex(*v_cast(d)); break; default: return false; } break; - case QVariant::PersistentModelIndex: + case QMetaType::QPersistentModelIndex: switch (d->type) { - case QVariant::ModelIndex: + case QMetaType::QModelIndex: *static_cast(result) = QPersistentModelIndex(*v_cast(d)); break; default: @@ -442,10 +442,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } break; #endif // QT_CONFIG(itemmodel) - case QVariant::String: { + case QMetaType::QString: { QString *str = static_cast(result); switch (d->type) { - case QVariant::Char: + case QMetaType::QChar: *str = *v_cast(d); break; case QMetaType::Char: @@ -455,12 +455,12 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; case QMetaType::Short: case QMetaType::Long: - case QVariant::Int: - case QVariant::LongLong: + case QMetaType::Int: + case QMetaType::LongLong: *str = QString::number(qMetaTypeNumber(d)); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: case QMetaType::UShort: case QMetaType::ULong: *str = QString::number(qMetaTypeUNumber(d)); @@ -468,32 +468,32 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::Float: *str = QString::number(d->data.f, 'g', QLocale::FloatingPointShortest); break; - case QVariant::Double: + case QMetaType::Double: *str = QString::number(d->data.d, 'g', QLocale::FloatingPointShortest); break; #if QT_CONFIG(datestring) - case QVariant::Date: + case QMetaType::QDate: *str = v_cast(d)->toString(Qt::ISODate); break; - case QVariant::Time: + case QMetaType::QTime: *str = v_cast(d)->toString(Qt::ISODateWithMs); break; - case QVariant::DateTime: + case QMetaType::QDateTime: *str = v_cast(d)->toString(Qt::ISODateWithMs); break; #endif - case QVariant::Bool: + case QMetaType::Bool: *str = d->data.b ? QStringLiteral("true") : QStringLiteral("false"); break; - case QVariant::ByteArray: + case QMetaType::QByteArray: *str = QString::fromUtf8(v_cast(d)->constData()); break; - case QVariant::StringList: + case QMetaType::QStringList: if (v_cast(d)->count() == 1) *str = v_cast(d)->at(0); break; #ifndef QT_BOOTSTRAPPED - case QVariant::Url: + case QMetaType::QUrl: *str = v_cast(d)->toString(); break; case QMetaType::QJsonValue: @@ -508,7 +508,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) *str = v_cast(d)->toVariant().toString(); break; #endif - case QVariant::Uuid: + case QMetaType::QUuid: *str = v_cast(d)->toString(); break; case QMetaType::Nullptr: @@ -528,11 +528,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } break; } - case QVariant::Char: { + case QMetaType::QChar: { QChar *c = static_cast(result); switch (d->type) { - case QVariant::Int: - case QVariant::LongLong: + case QMetaType::Int: + case QMetaType::LongLong: case QMetaType::Char: case QMetaType::SChar: case QMetaType::Short: @@ -540,8 +540,8 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::Float: *c = QChar(ushort(qMetaTypeNumber(d))); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -553,10 +553,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; } #ifndef QT_NO_GEOM_VARIANT - case QVariant::Size: { + case QMetaType::QSize: { QSize *s = static_cast(result); switch (d->type) { - case QVariant::SizeF: + case QMetaType::QSizeF: *s = v_cast(d)->toSize(); break; default: @@ -565,10 +565,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; } - case QVariant::SizeF: { + case QMetaType::QSizeF: { QSizeF *s = static_cast(result); switch (d->type) { - case QVariant::Size: + case QMetaType::QSize: *s = QSizeF(*(v_cast(d))); break; default: @@ -577,10 +577,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; } - case QVariant::Line: { + case QMetaType::QLine: { QLine *s = static_cast(result); switch (d->type) { - case QVariant::LineF: + case QMetaType::QLineF: *s = v_cast(d)->toLine(); break; default: @@ -589,10 +589,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; } - case QVariant::LineF: { + case QMetaType::QLineF: { QLineF *s = static_cast(result); switch (d->type) { - case QVariant::Line: + case QMetaType::QLine: *s = QLineF(*(v_cast(d))); break; default: @@ -601,27 +601,27 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; } #endif - case QVariant::StringList: - if (d->type == QVariant::List) { + case QMetaType::QStringList: + if (d->type == QMetaType::QVariantList) { QStringList *slst = static_cast(result); const QVariantList *list = v_cast(d); const int size = list->size(); slst->reserve(size); for (int i = 0; i < size; ++i) slst->append(list->at(i).toString()); - } else if (d->type == QVariant::String) { + } else if (d->type == QMetaType::QString) { QStringList *slst = static_cast(result); *slst = QStringList(*v_cast(d)); } else { return false; } break; - case QVariant::Date: { + case QMetaType::QDate: { QDate *dt = static_cast(result); - if (d->type == QVariant::DateTime) + if (d->type == QMetaType::QDateTime) *dt = v_cast(d)->date(); #if QT_CONFIG(datestring) - else if (d->type == QVariant::String) + else if (d->type == QMetaType::QString) *dt = QDate::fromString(*v_cast(d), Qt::ISODate); #endif else @@ -629,14 +629,14 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) return dt->isValid(); } - case QVariant::Time: { + case QMetaType::QTime: { QTime *t = static_cast(result); switch (d->type) { - case QVariant::DateTime: + case QMetaType::QDateTime: *t = v_cast(d)->time(); break; #if QT_CONFIG(datestring) - case QVariant::String: + case QMetaType::QString: *t = QTime::fromString(*v_cast(d), Qt::ISODate); break; #endif @@ -645,11 +645,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } return t->isValid(); } - case QVariant::DateTime: { + case QMetaType::QDateTime: { QDateTime *dt = static_cast(result); switch (d->type) { #if QT_CONFIG(datestring) - case QVariant::String: + case QMetaType::QString: *dt = QDateTime::fromString(*v_cast(d), Qt::ISODate); break; # ifndef QT_BOOTSTRAPPED @@ -661,7 +661,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; # endif #endif - case QVariant::Date: + case QMetaType::QDate: *dt = QDateTime(*v_cast(d)); break; default: @@ -669,13 +669,13 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } return dt->isValid(); } - case QVariant::ByteArray: { + case QMetaType::QByteArray: { QByteArray *ba = static_cast(result); switch (d->type) { - case QVariant::String: + case QMetaType::QString: *ba = v_cast(d)->toUtf8(); break; - case QVariant::Double: + case QMetaType::Double: *ba = QByteArray::number(d->data.d, 'g', QLocale::FloatingPointShortest); break; case QMetaType::Float: @@ -686,22 +686,22 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::UChar: *ba = QByteArray(1, d->data.c); break; - case QVariant::Int: - case QVariant::LongLong: + case QMetaType::Int: + case QMetaType::LongLong: case QMetaType::Short: case QMetaType::Long: *ba = QByteArray::number(qMetaTypeNumber(d)); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: case QMetaType::UShort: case QMetaType::ULong: *ba = QByteArray::number(qMetaTypeUNumber(d)); break; - case QVariant::Bool: + case QMetaType::Bool: *ba = QByteArray(d->data.b ? "true" : "false"); break; - case QVariant::Uuid: + case QMetaType::QUuid: *ba = v_cast(d)->toByteArray(); break; case QMetaType::Nullptr: @@ -741,16 +741,16 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::ULong: *static_cast(result) = ulong(qConvertToUnsignedNumber(d, ok)); return *ok; - case QVariant::Int: + case QMetaType::Int: *static_cast(result) = int(qConvertToNumber(d, ok)); return *ok; - case QVariant::UInt: + case QMetaType::UInt: *static_cast(result) = uint(qConvertToUnsignedNumber(d, ok)); return *ok; - case QVariant::LongLong: + case QMetaType::LongLong: *static_cast(result) = qConvertToNumber(d, ok); return *ok; - case QVariant::ULongLong: { + case QMetaType::ULongLong: { *static_cast(result) = qConvertToUnsignedNumber(d, ok); return *ok; } @@ -763,21 +763,21 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) *static_cast(result) = qConvertToUnsignedNumber(d, ok); return *ok; } - case QVariant::Bool: { + case QMetaType::Bool: { bool *b = static_cast(result); switch(d->type) { - case QVariant::ByteArray: + case QMetaType::QByteArray: *b = qt_convertToBool(d); break; - case QVariant::String: + case QMetaType::QString: *b = qt_convertToBool(d); break; - case QVariant::Char: + case QMetaType::QChar: *b = !v_cast(d)->isNull(); break; - case QVariant::Double: - case QVariant::Int: - case QVariant::LongLong: + case QMetaType::Double: + case QMetaType::Int: + case QMetaType::LongLong: case QMetaType::Char: case QMetaType::SChar: case QMetaType::Short: @@ -785,8 +785,8 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::Float: *b = qMetaTypeNumber(d) != Q_INT64_C(0); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -810,31 +810,31 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } break; } - case QVariant::Double: { + case QMetaType::Double: { double *f = static_cast(result); switch (d->type) { - case QVariant::String: + case QMetaType::QString: *f = v_cast(d)->toDouble(ok); break; - case QVariant::ByteArray: + case QMetaType::QByteArray: *f = v_cast(d)->toDouble(ok); break; - case QVariant::Bool: + case QMetaType::Bool: *f = double(d->data.b); break; case QMetaType::Float: *f = double(d->data.f); break; - case QVariant::LongLong: - case QVariant::Int: + case QMetaType::LongLong: + case QMetaType::Int: case QMetaType::Char: case QMetaType::SChar: case QMetaType::Short: case QMetaType::Long: *f = double(qMetaTypeNumber(d)); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -861,28 +861,28 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::Float: { float *f = static_cast(result); switch (d->type) { - case QVariant::String: + case QMetaType::QString: *f = v_cast(d)->toFloat(ok); break; - case QVariant::ByteArray: + case QMetaType::QByteArray: *f = v_cast(d)->toFloat(ok); break; - case QVariant::Bool: + case QMetaType::Bool: *f = float(d->data.b); break; - case QVariant::Double: + case QMetaType::Double: *f = float(d->data.d); break; - case QVariant::LongLong: - case QVariant::Int: + case QMetaType::LongLong: + case QMetaType::Int: case QMetaType::Char: case QMetaType::SChar: case QMetaType::Short: case QMetaType::Long: *f = float(qMetaTypeNumber(d)); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: case QMetaType::UChar: case QMetaType::UShort: case QMetaType::ULong: @@ -906,8 +906,8 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } break; } - case QVariant::List: - if (d->type == QVariant::StringList) { + case QMetaType::QVariantList: + if (d->type == QMetaType::QStringList) { QVariantList *lst = static_cast(result); const QStringList *slist = v_cast(d); const int size = slist->size(); @@ -935,11 +935,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) return false; } break; - case QVariant::Map: + case QMetaType::QVariantMap: if (qstrcmp(QMetaType::typeName(d->type), "QMap") == 0) { *static_cast(result) = *static_cast *>(d->data.shared->ptr); - } else if (d->type == QVariant::Hash) { + } else if (d->type == QMetaType::QVariantHash) { QVariantMap *map = static_cast(result); const QVariantHash *hash = v_cast(d); const auto end = hash->end(); @@ -963,11 +963,11 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) return false; } break; - case QVariant::Hash: + case QMetaType::QVariantHash: if (qstrcmp(QMetaType::typeName(d->type), "QHash") == 0) { *static_cast(result) = *static_cast *>(d->data.shared->ptr); - } else if (d->type == QVariant::Map) { + } else if (d->type == QMetaType::QVariantMap) { QVariantHash *hash = static_cast(result); const QVariantMap *map = v_cast(d); const auto end = map->end(); @@ -992,26 +992,26 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) } break; #ifndef QT_NO_GEOM_VARIANT - case QVariant::Rect: - if (d->type == QVariant::RectF) + case QMetaType::QRect: + if (d->type == QMetaType::QRectF) *static_cast(result) = (v_cast(d))->toRect(); else return false; break; - case QVariant::RectF: - if (d->type == QVariant::Rect) + case QMetaType::QRectF: + if (d->type == QMetaType::QRect) *static_cast(result) = *v_cast(d); else return false; break; - case QVariant::PointF: - if (d->type == QVariant::Point) + case QMetaType::QPointF: + if (d->type == QMetaType::QPoint) *static_cast(result) = *v_cast(d); else return false; break; - case QVariant::Point: - if (d->type == QVariant::PointF) + case QMetaType::QPoint: + if (d->type == QMetaType::QPointF) *static_cast(result) = (v_cast(d))->toPoint(); else return false; @@ -1022,12 +1022,12 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) return *ok; } #endif - case QVariant::Uuid: + case QMetaType::QUuid: switch (d->type) { - case QVariant::String: + case QMetaType::QString: *static_cast(result) = QUuid(*v_cast(d)); break; - case QVariant::ByteArray: + case QMetaType::QByteArray: *static_cast(result) = QUuid(*v_cast(d)); break; #ifndef QT_BOOTSTRAPPED @@ -1067,7 +1067,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::Nullptr: *static_cast(result) = QJsonValue(QJsonValue::Null); break; - case QVariant::Bool: + case QMetaType::Bool: *static_cast(result) = QJsonValue(d->data.b); break; case QMetaType::Int: @@ -1086,19 +1086,19 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) *static_cast(result) = QJsonValue(qConvertToRealNumber(d, ok)); Q_ASSERT(ok); break; - case QVariant::String: + case QMetaType::QString: *static_cast(result) = QJsonValue(*v_cast(d)); break; - case QVariant::StringList: + case QMetaType::QStringList: *static_cast(result) = QJsonValue(QJsonArray::fromStringList(*v_cast(d))); break; - case QVariant::List: + case QMetaType::QVariantList: *static_cast(result) = QJsonValue(QJsonArray::fromVariantList(*v_cast(d))); break; - case QVariant::Map: + case QMetaType::QVariantMap: *static_cast(result) = QJsonValue(QJsonObject::fromVariantMap(*v_cast(d))); break; - case QVariant::Hash: + case QMetaType::QVariantHash: *static_cast(result) = QJsonValue(QJsonObject::fromVariantHash(*v_cast(d))); break; case QMetaType::QJsonObject: @@ -1128,10 +1128,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; case QMetaType::QJsonArray: switch (d->type) { - case QVariant::StringList: + case QMetaType::QStringList: *static_cast(result) = QJsonArray::fromStringList(*v_cast(d)); break; - case QVariant::List: + case QMetaType::QVariantList: *static_cast(result) = QJsonArray::fromVariantList(*v_cast(d)); break; case QMetaType::QJsonValue: @@ -1158,10 +1158,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; case QMetaType::QJsonObject: switch (d->type) { - case QVariant::Map: + case QMetaType::QVariantMap: *static_cast(result) = QJsonObject::fromVariantMap(*v_cast(d)); break; - case QVariant::Hash: + case QMetaType::QVariantHash: *static_cast(result) = QJsonObject::fromVariantHash(*v_cast(d)); break; case QMetaType::QJsonValue: @@ -1197,7 +1197,7 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) case QMetaType::Nullptr: *static_cast(result) = QCborValue(QCborValue::Null); break; - case QVariant::Bool: + case QMetaType::Bool: *static_cast(result) = QCborValue(d->data.b); break; case QMetaType::Int: @@ -1219,39 +1219,39 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) *static_cast(result) = QCborValue(qConvertToRealNumber(d, ok)); Q_ASSERT(ok); break; - case QVariant::String: + case QMetaType::QString: *static_cast(result) = *v_cast(d); break; - case QVariant::StringList: + case QMetaType::QStringList: *static_cast(result) = QCborArray::fromStringList(*v_cast(d)); break; - case QVariant::ByteArray: + case QMetaType::QByteArray: *static_cast(result) = *v_cast(d); break; - case QVariant::Date: + case QMetaType::QDate: *static_cast(result) = QCborValue(QDateTime(*v_cast(d))); break; - case QVariant::DateTime: + case QMetaType::QDateTime: *static_cast(result) = QCborValue(*v_cast(d)); break; - case QVariant::Url: + case QMetaType::QUrl: *static_cast(result) = QCborValue(*v_cast(d)); break; #if QT_CONFIG(regularexpression) - case QVariant::RegularExpression: + case QMetaType::QRegularExpression: *static_cast(result) = QCborValue(*v_cast(d)); break; #endif - case QVariant::Uuid: + case QMetaType::QUuid: *static_cast(result) = QCborValue(*v_cast(d)); break; - case QVariant::List: + case QMetaType::QVariantList: *static_cast(result) = QCborArray::fromVariantList(*v_cast(d)); break; - case QVariant::Map: + case QMetaType::QVariantMap: *static_cast(result) = QCborMap::fromVariantMap(*v_cast(d)); break; - case QVariant::Hash: + case QMetaType::QVariantHash: *static_cast(result) = QCborMap::fromVariantHash(*v_cast(d)); break; case QMetaType::QJsonValue: @@ -1287,10 +1287,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; case QMetaType::QCborArray: switch (d->type) { - case QVariant::StringList: + case QMetaType::QStringList: *static_cast(result) = QCborArray::fromStringList(*v_cast(d)); break; - case QVariant::List: + case QMetaType::QVariantList: *static_cast(result) = QCborArray::fromVariantList(*v_cast(d)); break; case QMetaType::QCborValue: @@ -1317,10 +1317,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) break; case QMetaType::QCborMap: switch (d->type) { - case QVariant::Map: + case QMetaType::QVariantMap: *static_cast(result) = QCborMap::fromVariantMap(*v_cast(d)); break; - case QVariant::Hash: + case QMetaType::QVariantHash: *static_cast(result) = QCborMap::fromVariantHash(*v_cast(d)); break; case QMetaType::QCborValue: @@ -1349,10 +1349,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) default: #ifndef QT_NO_QOBJECT - if (d->type == QVariant::String || d->type == QVariant::ByteArray) { + if (d->type == QMetaType::QString || d->type == QMetaType::QByteArray) { QMetaEnum en = metaEnumFromType(t); if (en.isValid()) { - QByteArray keys = (d->type == QVariant::String) ? v_cast(d)->toUtf8() : *v_cast(d); + QByteArray keys = (d->type == QMetaType::QString) ? v_cast(d)->toUtf8() : *v_cast(d); int value = en.keysToValue(keys.constData(), ok); if (*ok) { switch (QMetaType::sizeOf(t)) { @@ -1457,7 +1457,7 @@ static void customConstruct(QVariant::Private *d, const void *copy) const uint size = type.sizeOf(); if (!size) { qWarning("Trying to construct an instance of an invalid type, type id: %i", d->type); - d->type = QVariant::Invalid; + d->type = QMetaType::UnknownType; return; } @@ -2438,43 +2438,43 @@ QVariant::Type QVariant::nameToType(const char *name) enum { MapFromThreeCount = 36 }; static const ushort mapIdFromQt3ToCurrent[MapFromThreeCount] = { - QVariant::Invalid, - QVariant::Map, - QVariant::List, - QVariant::String, - QVariant::StringList, - QVariant::Font, - QVariant::Pixmap, - QVariant::Brush, - QVariant::Rect, - QVariant::Size, - QVariant::Color, - QVariant::Palette, + QMetaType::UnknownType, + QMetaType::QVariantMap, + QMetaType::QVariantList, + QMetaType::QString, + QMetaType::QStringList, + QMetaType::QFont, + QMetaType::QPixmap, + QMetaType::QBrush, + QMetaType::QRect, + QMetaType::QSize, + QMetaType::QColor, + QMetaType::QPalette, 0, // ColorGroup - QVariant::Icon, - QVariant::Point, - QVariant::Image, - QVariant::Int, - QVariant::UInt, - QVariant::Bool, - QVariant::Double, + QMetaType::QIcon, + QMetaType::QPoint, + QMetaType::QImage, + QMetaType::Int, + QMetaType::UInt, + QMetaType::Bool, + QMetaType::Double, 0, // Buggy ByteArray, QByteArray never had id == 20 - QVariant::Polygon, - QVariant::Region, - QVariant::Bitmap, - QVariant::Cursor, - QVariant::SizePolicy, - QVariant::Date, - QVariant::Time, - QVariant::DateTime, - QVariant::ByteArray, - QVariant::BitArray, - QVariant::KeySequence, - QVariant::Pen, - QVariant::LongLong, - QVariant::ULongLong, + QMetaType::QPolygon, + QMetaType::QRegion, + QMetaType::QBitmap, + QMetaType::QCursor, + QMetaType::QSizePolicy, + QMetaType::QDate, + QMetaType::QTime, + QMetaType::QDateTime, + QMetaType::QByteArray, + QMetaType::QBitArray, + QMetaType::QKeySequence, + QMetaType::QPen, + QMetaType::LongLong, + QMetaType::ULongLong, #if QT_CONFIG(easingcurve) - QVariant::EasingCurve + QMetaType::QEasingCurve #endif }; @@ -2551,7 +2551,7 @@ void QVariant::load(QDataStream &s) */ void QVariant::save(QDataStream &s) const { - quint32 typeId = type(); + quint32 typeId = d.type >= QMetaType::User ? QMetaType::User : userType(); bool fakeUserType = false; if (s.version() < QDataStream::Qt_4_0) { int i; @@ -3294,80 +3294,80 @@ QVariantList QVariant::toList() const } -static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] = +static const quint32 qCanConvertMatrix[QMetaType::LastCoreType + 1] = { /*Invalid*/ 0, -/*Bool*/ 1 << QVariant::Double | 1 << QVariant::Int | 1 << QVariant::UInt - | 1 << QVariant::LongLong | 1 << QVariant::ULongLong | 1 << QVariant::ByteArray - | 1 << QVariant::String | 1 << QVariant::Char, +/*Bool*/ 1 << QMetaType::Double | 1 << QMetaType::Int | 1 << QMetaType::UInt + | 1 << QMetaType::LongLong | 1 << QMetaType::ULongLong | 1 << QMetaType::QByteArray + | 1 << QMetaType::QString | 1 << QMetaType::QChar, -/*Int*/ 1 << QVariant::UInt | 1 << QVariant::String | 1 << QVariant::Double - | 1 << QVariant::Bool | 1 << QVariant::LongLong | 1 << QVariant::ULongLong - | 1 << QVariant::Char | 1 << QVariant::ByteArray | 1 << QVariant::Int, +/*Int*/ 1 << QMetaType::UInt | 1 << QMetaType::QString | 1 << QMetaType::Double + | 1 << QMetaType::Bool | 1 << QMetaType::LongLong | 1 << QMetaType::ULongLong + | 1 << QMetaType::QChar | 1 << QMetaType::QByteArray | 1 << QMetaType::Int, -/*UInt*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double - | 1 << QVariant::Bool | 1 << QVariant::LongLong | 1 << QVariant::ULongLong - | 1 << QVariant::Char | 1 << QVariant::ByteArray, +/*UInt*/ 1 << QMetaType::Int | 1 << QMetaType::QString | 1 << QMetaType::Double + | 1 << QMetaType::Bool | 1 << QMetaType::LongLong | 1 << QMetaType::ULongLong + | 1 << QMetaType::QChar | 1 << QMetaType::QByteArray, -/*LLong*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double - | 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::ULongLong - | 1 << QVariant::Char | 1 << QVariant::ByteArray, +/*LLong*/ 1 << QMetaType::Int | 1 << QMetaType::QString | 1 << QMetaType::Double + | 1 << QMetaType::Bool | 1 << QMetaType::UInt | 1 << QMetaType::ULongLong + | 1 << QMetaType::QChar | 1 << QMetaType::QByteArray, -/*ULlong*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::Double - | 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::LongLong - | 1 << QVariant::Char | 1 << QVariant::ByteArray, +/*ULlong*/ 1 << QMetaType::Int | 1 << QMetaType::QString | 1 << QMetaType::Double + | 1 << QMetaType::Bool | 1 << QMetaType::UInt | 1 << QMetaType::LongLong + | 1 << QMetaType::QChar | 1 << QMetaType::QByteArray, -/*double*/ 1 << QVariant::Int | 1 << QVariant::String | 1 << QVariant::ULongLong - | 1 << QVariant::Bool | 1 << QVariant::UInt | 1 << QVariant::LongLong - | 1 << QVariant::ByteArray, +/*double*/ 1 << QMetaType::Int | 1 << QMetaType::QString | 1 << QMetaType::ULongLong + | 1 << QMetaType::Bool | 1 << QMetaType::UInt | 1 << QMetaType::LongLong + | 1 << QMetaType::QByteArray, -/*QChar*/ 1 << QVariant::Int | 1 << QVariant::UInt | 1 << QVariant::LongLong - | 1 << QVariant::ULongLong, +/*QChar*/ 1 << QMetaType::Int | 1 << QMetaType::UInt | 1 << QMetaType::LongLong + | 1 << QMetaType::ULongLong, /*QMap*/ 0, -/*QList*/ 1 << QVariant::StringList, +/*QList*/ 1 << QMetaType::QStringList, -/*QString*/ 1 << QVariant::StringList | 1 << QVariant::ByteArray | 1 << QVariant::Int - | 1 << QVariant::UInt | 1 << QVariant::Bool | 1 << QVariant::Double - | 1 << QVariant::Date | 1 << QVariant::Time | 1 << QVariant::DateTime - | 1 << QVariant::LongLong | 1 << QVariant::ULongLong | 1 << QVariant::Char - | 1 << QVariant::Url | 1 << QVariant::Uuid, +/*QString*/ 1 << QMetaType::QStringList | 1 << QMetaType::QByteArray | 1 << QMetaType::Int + | 1 << QMetaType::UInt | 1 << QMetaType::Bool | 1 << QMetaType::Double + | 1 << QMetaType::QDate | 1 << QMetaType::QTime | 1 << QMetaType::QDateTime + | 1 << QMetaType::LongLong | 1 << QMetaType::ULongLong | 1 << QMetaType::QChar + | 1 << QMetaType::QUrl | 1 << QMetaType::QUuid, -/*QStringList*/ 1 << QVariant::List | 1 << QVariant::String, +/*QStringList*/ 1 << QMetaType::QVariantList | 1 << QMetaType::QString, -/*QByteArray*/ 1 << QVariant::String | 1 << QVariant::Int | 1 << QVariant::UInt | 1 << QVariant::Bool - | 1 << QVariant::Double | 1 << QVariant::LongLong | 1 << QVariant::ULongLong - | 1 << QVariant::Uuid, +/*QByteArray*/ 1 << QMetaType::QString | 1 << QMetaType::Int | 1 << QMetaType::UInt | 1 << QMetaType::Bool + | 1 << QMetaType::Double | 1 << QMetaType::LongLong | 1 << QMetaType::ULongLong + | 1 << QMetaType::QUuid, /*QBitArray*/ 0, -/*QDate*/ 1 << QVariant::String | 1 << QVariant::DateTime, +/*QDate*/ 1 << QMetaType::QString | 1 << QMetaType::QDateTime, -/*QTime*/ 1 << QVariant::String | 1 << QVariant::DateTime, +/*QTime*/ 1 << QMetaType::QString | 1 << QMetaType::QDateTime, -/*QDateTime*/ 1 << QVariant::String | 1 << QVariant::Date, +/*QDateTime*/ 1 << QMetaType::QString | 1 << QMetaType::QDate, -/*QUrl*/ 1 << QVariant::String, +/*QUrl*/ 1 << QMetaType::QString, /*QLocale*/ 0, -/*QRect*/ 1 << QVariant::RectF, +/*QRect*/ 1 << QMetaType::QRectF, -/*QRectF*/ 1 << QVariant::Rect, +/*QRectF*/ 1 << QMetaType::QRect, -/*QSize*/ 1 << QVariant::SizeF, +/*QSize*/ 1 << QMetaType::QSizeF, -/*QSizeF*/ 1 << QVariant::Size, +/*QSizeF*/ 1 << QMetaType::QSize, -/*QLine*/ 1 << QVariant::LineF, +/*QLine*/ 1 << QMetaType::QLineF, -/*QLineF*/ 1 << QVariant::Line, +/*QLineF*/ 1 << QMetaType::QLine, -/*QPoint*/ 1 << QVariant::PointF, +/*QPoint*/ 1 << QMetaType::QPointF, -/*QPointF*/ 1 << QVariant::Point, +/*QPointF*/ 1 << QMetaType::QPoint, /*QRegExp*/ 0, @@ -3375,7 +3375,7 @@ static const quint32 qCanConvertMatrix[QVariant::LastCoreType + 1] = /*QEasingCurve*/ 0, -/*QUuid*/ 1 << QVariant::String | 1 << QVariant::ByteArray, +/*QUuid*/ 1 << QMetaType::QString | 1 << QMetaType::QByteArray, }; static const size_t qCanConvertMatrixMaximumTargetType = 8 * sizeof(*qCanConvertMatrix); @@ -3915,7 +3915,7 @@ static bool qIsNumericType(uint tp) static bool qIsFloatingPoint(uint tp) { - return tp == QVariant::Double || tp == QMetaType::Float; + return tp == QMetaType::Double || tp == QMetaType::Float; } static int normalizeLowerRanks(uint tp) @@ -3927,13 +3927,13 @@ static int normalizeLowerRanks(uint tp) Q_UINT64_C(1) << QMetaType::UChar | Q_UINT64_C(1) << QMetaType::Short | Q_UINT64_C(1) << QMetaType::UShort; - return numericTypeBits & (Q_UINT64_C(1) << tp) ? QVariant::Int : tp; + return numericTypeBits & (Q_UINT64_C(1) << tp) ? uint(QMetaType::Int) : tp; } static int normalizeLong(uint tp) { - const uint IntType = sizeof(long) == sizeof(int) ? QVariant::Int : QVariant::LongLong; - const uint UIntType = sizeof(ulong) == sizeof(uint) ? QVariant::UInt : QVariant::ULongLong; + const uint IntType = sizeof(long) == sizeof(int) ? QMetaType::Int : QMetaType::LongLong; + const uint UIntType = sizeof(ulong) == sizeof(uint) ? QMetaType::UInt : QMetaType::ULongLong; return tp == QMetaType::Long ? IntType : tp == QMetaType::ULong ? UIntType : tp; } @@ -3975,13 +3975,13 @@ static int numericTypePromotion(uint t1, uint t2) // if any of the two is ULongLong, then it wins (highest rank, unsigned) // otherwise, if one of the two is LongLong, then the other is either LongLong too or lower-ranked // otherwise, if one of the two is UInt, then the other is either UInt too or Int - if (t1 == QVariant::ULongLong || t2 == QVariant::ULongLong) - return QVariant::ULongLong; - if (t1 == QVariant::LongLong || t2 == QVariant::LongLong) - return QVariant::LongLong; - if (t1 == QVariant::UInt || t2 == QVariant::UInt) - return QVariant::UInt; - return QVariant::Int; + if (t1 == QMetaType::ULongLong || t2 == QMetaType::ULongLong) + return QMetaType::ULongLong; + if (t1 == QMetaType::LongLong || t2 == QMetaType::LongLong) + return QMetaType::LongLong; + if (t1 == QMetaType::UInt || t2 == QMetaType::UInt) + return QMetaType::UInt; + return QMetaType::Int; } static int integralCompare(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2) @@ -3994,13 +3994,13 @@ static int integralCompare(uint promotedType, const QVariant::Private *d1, const qlonglong l2 = qConvertToNumber(d2, &ok); Q_ASSERT(ok); - if (promotedType == QVariant::Int) + if (promotedType == QMetaType::Int) return int(l1) < int(l2) ? -1 : int(l1) == int(l2) ? 0 : 1; - if (promotedType == QVariant::UInt) + if (promotedType == QMetaType::UInt) return uint(l1) < uint(l2) ? -1 : uint(l1) == uint(l2) ? 0 : 1; - if (promotedType == QVariant::LongLong) + if (promotedType == QMetaType::LongLong) return l1 < l2 ? -1 : l1 == l2 ? 0 : 1; - if (promotedType == QVariant::ULongLong) + if (promotedType == QMetaType::ULongLong) return qulonglong(l1) < qulonglong(l2) ? -1 : qulonglong(l1) == qulonglong(l2) ? 0 : 1; Q_UNREACHABLE(); diff --git a/src/corelib/kernel/qvariant_p.h b/src/corelib/kernel/qvariant_p.h index b8b63b5e6f..94781a9957 100644 --- a/src/corelib/kernel/qvariant_p.h +++ b/src/corelib/kernel/qvariant_p.h @@ -362,7 +362,7 @@ class QVariantConstructor FilteredConstructor(const QVariantConstructor &tc) { // ignore types that lives outside of the current library - tc.m_x->type = QVariant::Invalid; + tc.m_x->type = QMetaType::UnknownType; } }; public: @@ -430,7 +430,7 @@ public: {} ~QVariantDestructor() { - m_d->type = QVariant::Invalid; + m_d->type = QMetaType::UnknownType; m_d->is_null = true; m_d->is_shared = false; } diff --git a/src/corelib/serialization/qjsoncbor.cpp b/src/corelib/serialization/qjsoncbor.cpp index 5097f4eb81..ee4dd90416 100644 --- a/src/corelib/serialization/qjsoncbor.cpp +++ b/src/corelib/serialization/qjsoncbor.cpp @@ -640,9 +640,9 @@ static void appendVariant(QCborContainerPrivate *d, const QVariant &variant) // Handle strings and byte arrays directly, to avoid creating a temporary // dummy container to hold their data. int type = variant.userType(); - if (type == QVariant::String) { + if (type == QMetaType::QString) { d->append(variant.toString()); - } else if (type == QVariant::ByteArray) { + } else if (type == QMetaType::QByteArray) { QByteArray ba = variant.toByteArray(); d->appendByteData(ba.constData(), ba.size(), QCborValue::ByteArray); } else { @@ -703,45 +703,45 @@ static void appendVariant(QCborContainerPrivate *d, const QVariant &variant) QCborValue QCborValue::fromVariant(const QVariant &variant) { switch (variant.userType()) { - case QVariant::Invalid: + case QMetaType::UnknownType: return {}; case QMetaType::Nullptr: return nullptr; - case QVariant::Bool: + case QMetaType::Bool: return variant.toBool(); case QMetaType::Short: case QMetaType::UShort: - case QVariant::Int: - case QVariant::LongLong: - case QVariant::ULongLong: - case QVariant::UInt: + case QMetaType::Int: + case QMetaType::LongLong: + case QMetaType::ULongLong: + case QMetaType::UInt: return variant.toLongLong(); case QMetaType::Float: - case QVariant::Double: + case QMetaType::Double: return variant.toDouble(); - case QVariant::String: + case QMetaType::QString: return variant.toString(); - case QVariant::StringList: + case QMetaType::QStringList: return QCborArray::fromStringList(variant.toStringList()); - case QVariant::ByteArray: + case QMetaType::QByteArray: return variant.toByteArray(); - case QVariant::DateTime: + case QMetaType::QDateTime: return QCborValue(variant.toDateTime()); #ifndef QT_BOOTSTRAPPED - case QVariant::Url: + case QMetaType::QUrl: return QCborValue(variant.toUrl()); #endif - case QVariant::Uuid: + case QMetaType::QUuid: return QCborValue(variant.toUuid()); - case QVariant::List: + case QMetaType::QVariantList: return QCborArray::fromVariantList(variant.toList()); - case QVariant::Map: + case QMetaType::QVariantMap: return QCborMap::fromVariantMap(variant.toMap()); - case QVariant::Hash: + case QMetaType::QVariantHash: return QCborMap::fromVariantHash(variant.toHash()); #ifndef QT_BOOTSTRAPPED #if QT_CONFIG(regularexpression) - case QVariant::RegularExpression: + case QMetaType::QRegularExpression: return QCborValue(variant.toRegularExpression()); #endif case QMetaType::QJsonValue: diff --git a/src/corelib/serialization/qjsondocument.cpp b/src/corelib/serialization/qjsondocument.cpp index fe0500bdef..0be0fc020d 100644 --- a/src/corelib/serialization/qjsondocument.cpp +++ b/src/corelib/serialization/qjsondocument.cpp @@ -405,17 +405,17 @@ QJsonDocument QJsonDocument::fromVariant(const QVariant &variant) { QJsonDocument doc; - switch (variant.type()) { - case QVariant::Map: + switch (variant.userType()) { + case QMetaType::QVariantMap: doc.setObject(QJsonObject::fromVariantMap(variant.toMap())); break; - case QVariant::Hash: + case QMetaType::QVariantHash: doc.setObject(QJsonObject::fromVariantHash(variant.toHash())); break; - case QVariant::List: + case QMetaType::QVariantList: doc.setArray(QJsonArray::fromVariantList(variant.toList())); break; - case QVariant::StringList: + case QMetaType::QStringList: doc.d = qt_make_unique(); doc.d->value = QCborArray::fromStringList(variant.toStringList()); break; diff --git a/src/corelib/serialization/qjsonvalue.cpp b/src/corelib/serialization/qjsonvalue.cpp index 7b6728d525..caf81c79ef 100644 --- a/src/corelib/serialization/qjsonvalue.cpp +++ b/src/corelib/serialization/qjsonvalue.cpp @@ -447,29 +447,29 @@ QJsonValue QJsonValue::fromVariant(const QVariant &variant) switch (variant.userType()) { case QMetaType::Nullptr: return QJsonValue(Null); - case QVariant::Bool: + case QMetaType::Bool: return QJsonValue(variant.toBool()); - case QVariant::Int: + case QMetaType::Int: case QMetaType::Float: - case QVariant::Double: - case QVariant::LongLong: - case QVariant::ULongLong: - case QVariant::UInt: + case QMetaType::Double: + case QMetaType::LongLong: + case QMetaType::ULongLong: + case QMetaType::UInt: return QJsonValue(variant.toDouble()); - case QVariant::String: + case QMetaType::QString: return QJsonValue(variant.toString()); - case QVariant::StringList: + case QMetaType::QStringList: return QJsonValue(QJsonArray::fromStringList(variant.toStringList())); - case QVariant::List: + case QMetaType::QVariantList: return QJsonValue(QJsonArray::fromVariantList(variant.toList())); - case QVariant::Map: + case QMetaType::QVariantMap: return QJsonValue(QJsonObject::fromVariantMap(variant.toMap())); - case QVariant::Hash: + case QMetaType::QVariantHash: return QJsonValue(QJsonObject::fromVariantHash(variant.toHash())); #ifndef QT_BOOTSTRAPPED - case QVariant::Url: + case QMetaType::QUrl: return QJsonValue(variant.toUrl().toString(QUrl::FullyEncoded)); - case QVariant::Uuid: + case QMetaType::QUuid: return variant.toUuid().toString(QUuid::WithoutBraces); case QMetaType::QJsonValue: return variant.toJsonValue(); diff --git a/src/corelib/text/qlocale.cpp b/src/corelib/text/qlocale.cpp index 93a8abb1ce..fb45b82967 100644 --- a/src/corelib/text/qlocale.cpp +++ b/src/corelib/text/qlocale.cpp @@ -2430,7 +2430,7 @@ QTime QLocale::toTime(const QString &string, const QString &format, QCalendar ca { QTime time; #if QT_CONFIG(datetimeparser) - QDateTimeParser dt(QVariant::Time, QDateTimeParser::FromString, cal); + QDateTimeParser dt(QMetaType::QTime, QDateTimeParser::FromString, cal); dt.setDefaultLocale(*this); if (dt.parseFormat(format)) dt.fromString(string, nullptr, &time); @@ -2469,7 +2469,7 @@ QDate QLocale::toDate(const QString &string, const QString &format, QCalendar ca { QDate date; #if QT_CONFIG(datetimeparser) - QDateTimeParser dt(QVariant::Date, QDateTimeParser::FromString, cal); + QDateTimeParser dt(QMetaType::QDate, QDateTimeParser::FromString, cal); dt.setDefaultLocale(*this); if (dt.parseFormat(format)) dt.fromString(string, &date, nullptr); @@ -2510,7 +2510,7 @@ QDateTime QLocale::toDateTime(const QString &string, const QString &format, QCal QTime time; QDate date; - QDateTimeParser dt(QVariant::DateTime, QDateTimeParser::FromString, cal); + QDateTimeParser dt(QMetaType::QDateTime, QDateTimeParser::FromString, cal); dt.setDefaultLocale(*this); if (dt.parseFormat(format) && dt.fromString(string, &date, &time)) return QDateTime(date, time); diff --git a/src/corelib/text/qlocale_unix.cpp b/src/corelib/text/qlocale_unix.cpp index 5e1e47eae7..207331b8ac 100644 --- a/src/corelib/text/qlocale_unix.cpp +++ b/src/corelib/text/qlocale_unix.cpp @@ -234,16 +234,16 @@ QVariant QSystemLocale::query(QueryType type, QVariant in) const case CurrencySymbol: return lc_monetary.currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt())); case CurrencyToString: { - switch (in.type()) { - case QVariant::Int: + switch (in.userType()) { + case QMetaType::Int: return lc_monetary.toCurrencyString(in.toInt()); - case QVariant::UInt: + case QMetaType::UInt: return lc_monetary.toCurrencyString(in.toUInt()); - case QVariant::Double: + case QMetaType::Double: return lc_monetary.toCurrencyString(in.toDouble()); - case QVariant::LongLong: + case QMetaType::LongLong: return lc_monetary.toCurrencyString(in.toLongLong()); - case QVariant::ULongLong: + case QMetaType::ULongLong: return lc_monetary.toCurrencyString(in.toULongLong()); default: break; diff --git a/src/corelib/time/qdatetime.cpp b/src/corelib/time/qdatetime.cpp index 67d37f19d8..80751e60a0 100644 --- a/src/corelib/time/qdatetime.cpp +++ b/src/corelib/time/qdatetime.cpp @@ -1791,7 +1791,7 @@ QDate QDate::fromString(const QString &string, const QString &format, QCalendar { QDate date; #if QT_CONFIG(datetimeparser) - QDateTimeParser dt(QVariant::Date, QDateTimeParser::FromString, cal); + QDateTimeParser dt(QMetaType::QDate, QDateTimeParser::FromString, cal); // dt.setDefaultLocale(QLocale::c()); ### Qt 6 if (dt.parseFormat(format)) dt.fromString(string, &date, nullptr); @@ -2537,7 +2537,7 @@ QTime QTime::fromString(const QString &string, const QString &format) { QTime time; #if QT_CONFIG(datetimeparser) - QDateTimeParser dt(QVariant::Time, QDateTimeParser::FromString, QCalendar()); + QDateTimeParser dt(QMetaType::QTime, QDateTimeParser::FromString, QCalendar()); // dt.setDefaultLocale(QLocale::c()); ### Qt 6 if (dt.parseFormat(format)) dt.fromString(string, nullptr, &time); @@ -5482,7 +5482,7 @@ QDateTime QDateTime::fromString(const QString &string, const QString &format, QC QTime time; QDate date; - QDateTimeParser dt(QVariant::DateTime, QDateTimeParser::FromString, cal); + QDateTimeParser dt(QMetaType::QDateTime, QDateTimeParser::FromString, cal); // dt.setDefaultLocale(QLocale::c()); ### Qt 6 if (dt.parseFormat(format) && dt.fromString(string, &date, &time)) return QDateTime(date, time); diff --git a/src/corelib/time/qdatetimeparser.cpp b/src/corelib/time/qdatetimeparser.cpp index 31d8e6cc20..70460ae632 100644 --- a/src/corelib/time/qdatetimeparser.cpp +++ b/src/corelib/time/qdatetimeparser.cpp @@ -425,7 +425,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) switch (sect) { case 'H': case 'h': - if (parserType != QVariant::Date) { + if (parserType != QMetaType::QDate) { const Section hour = (sect == 'h') ? Hour12Section : Hour24Section; const SectionNode sn = { hour, i - add, countRepeat(newFormat, i, 2), 0 }; newSectionNodes.append(sn); @@ -436,7 +436,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) } break; case 'm': - if (parserType != QVariant::Date) { + if (parserType != QMetaType::QDate) { const SectionNode sn = { MinuteSection, i - add, countRepeat(newFormat, i, 2), 0 }; newSectionNodes.append(sn); appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote); @@ -446,7 +446,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) } break; case 's': - if (parserType != QVariant::Date) { + if (parserType != QMetaType::QDate) { const SectionNode sn = { SecondSection, i - add, countRepeat(newFormat, i, 2), 0 }; newSectionNodes.append(sn); appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote); @@ -457,7 +457,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) break; case 'z': - if (parserType != QVariant::Date) { + if (parserType != QMetaType::QDate) { const SectionNode sn = { MSecSection, i - add, countRepeat(newFormat, i, 3) < 3 ? 1 : 3, 0 }; newSectionNodes.append(sn); appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote); @@ -468,7 +468,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) break; case 'A': case 'a': - if (parserType != QVariant::Date) { + if (parserType != QMetaType::QDate) { const bool cap = (sect == 'A'); const SectionNode sn = { AmPmSection, i - add, (cap ? 1 : 0), 0 }; newSectionNodes.append(sn); @@ -482,7 +482,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) } break; case 'y': - if (parserType != QVariant::Time) { + if (parserType != QMetaType::QTime) { const int repeat = countRepeat(newFormat, i, 4); if (repeat >= 2) { const SectionNode sn = { repeat == 4 ? YearSection : YearSection2Digits, @@ -496,7 +496,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) } break; case 'M': - if (parserType != QVariant::Time) { + if (parserType != QMetaType::QTime) { const SectionNode sn = { MonthSection, i - add, countRepeat(newFormat, i, 4), 0 }; newSectionNodes.append(sn); newSeparators.append(unquote(newFormat.midRef(index, i - index))); @@ -506,7 +506,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) } break; case 'd': - if (parserType != QVariant::Time) { + if (parserType != QMetaType::QTime) { const int repeat = countRepeat(newFormat, i, 4); const Section sectionType = (repeat == 4 ? DayOfWeekSectionLong : (repeat == 3 ? DayOfWeekSectionShort : DaySection)); @@ -519,7 +519,7 @@ bool QDateTimeParser::parseFormat(const QString &newFormat) } break; case 't': - if (parserType != QVariant::Time) { + if (parserType != QMetaType::QTime) { const SectionNode sn = { TimeZoneSection, i - add, countRepeat(newFormat, i, 4), 0 }; newSectionNodes.append(sn); appendSeparator(&newSeparators, newFormat, index, i - index, lastQuote); @@ -1252,7 +1252,7 @@ QDateTimeParser::scanString(const QDateTime &defaultValue, return StateNode(); } - if (parserType != QVariant::Time) { + if (parserType != QMetaType::QTime) { if (year % 100 != year2digits && (isSet & YearSection2Digits)) { if (!(isSet & YearSection)) { year = (year / 100) * 100; @@ -1322,7 +1322,7 @@ QDateTimeParser::scanString(const QDateTime &defaultValue, } } - if (parserType != QVariant::Date) { + if (parserType != QMetaType::QDate) { if (isSet & Hour12Section) { const bool hasHour = isSet & Hour24Section; if (ampm == -1) { @@ -1360,7 +1360,7 @@ QDateTimeParser::scanString(const QDateTime &defaultValue, // If hour wasn't specified, check the default we're using exists on the // given date (which might be a spring-forward, skipping an hour). - if (parserType == QVariant::DateTime && !(isSet & HourSectionMask) && !when.isValid()) { + if (parserType == QMetaType::QDateTime && !(isSet & HourSectionMask) && !when.isValid()) { qint64 msecs = when.toMSecsSinceEpoch(); // Fortunately, that gets a useful answer, even though when is invalid ... const QDateTime replace = diff --git a/src/corelib/time/qdatetimeparser_p.h b/src/corelib/time/qdatetimeparser_p.h index ec4e4e4df2..5c612ef6a4 100644 --- a/src/corelib/time/qdatetimeparser_p.h +++ b/src/corelib/time/qdatetimeparser_p.h @@ -83,7 +83,7 @@ public: FromString, DateTimeEdit }; - QDateTimeParser(QVariant::Type t, Context ctx, const QCalendar &cal = QCalendar()) + QDateTimeParser(QMetaType::Type t, Context ctx, const QCalendar &cal = QCalendar()) : currentSectionIndex(-1), cachedDay(-1), parserType(t), fixday(false), spec(Qt::LocalTime), context(ctx), calendar(cal) { @@ -295,7 +295,7 @@ protected: // for the benefit of QDateTimeEditPrivate QStringList separators; QString displayFormat; QLocale defaultLocale; - QVariant::Type parserType; + QMetaType::Type parserType; bool fixday; Qt::TimeSpec spec; // spec if used by QDateTimeEdit Context context; diff --git a/src/dbus/qdbusabstractinterface.cpp b/src/dbus/qdbusabstractinterface.cpp index 8a11767140..d603264a1e 100644 --- a/src/dbus/qdbusabstractinterface.cpp +++ b/src/dbus/qdbusabstractinterface.cpp @@ -157,7 +157,7 @@ bool QDBusAbstractInterfacePrivate::property(const QMetaProperty &mp, void *retu const int type = mp.userType(); // is this metatype registered? const char *expectedSignature = ""; - if (int(mp.type()) != QMetaType::QVariant) { + if (int(mp.userType()) != QMetaType::QVariant) { expectedSignature = QDBusMetaType::typeToSignature(type); if (expectedSignature == nullptr) { qWarning("QDBusAbstractInterface: type %s must be registered with Qt D-Bus before it can be " diff --git a/src/dbus/qdbusargument.h b/src/dbus/qdbusargument.h index 477bd1e8fd..339f8c5dc8 100644 --- a/src/dbus/qdbusargument.h +++ b/src/dbus/qdbusargument.h @@ -330,7 +330,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &arg, QMap &m inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantMap &map) { - arg.beginMap(QVariant::String, qMetaTypeId()); + arg.beginMap(QMetaType::QString, qMetaTypeId()); QVariantMap::ConstIterator it = map.constBegin(); QVariantMap::ConstIterator end = map.constEnd(); for ( ; it != end; ++it) { @@ -379,7 +379,7 @@ inline const QDBusArgument &operator>>(const QDBusArgument &arg, QHash & inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantHash &map) { - arg.beginMap(QVariant::String, qMetaTypeId()); + arg.beginMap(QMetaType::QString, qMetaTypeId()); QVariantHash::ConstIterator it = map.constBegin(); QVariantHash::ConstIterator end = map.constEnd(); for ( ; it != end; ++it) { diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp index bca02be59e..669b330f1d 100644 --- a/src/dbus/qdbusintegrator.cpp +++ b/src/dbus/qdbusintegrator.cpp @@ -1822,7 +1822,7 @@ void QDBusConnectionPrivate::setConnection(DBusConnection *dbc, const QDBusError hook.service = QDBusUtil::dbusService(); hook.path.clear(); // no matching hook.obj = this; - hook.params << QMetaType::Void << QVariant::String; // both functions take a QString as parameter and return void + hook.params << QMetaType::Void << QMetaType::QString; // both functions take a QString as parameter and return void hook.midx = staticMetaObject.indexOfSlot("registerServiceNoLock(QString)"); Q_ASSERT(hook.midx != -1); @@ -1836,7 +1836,7 @@ void QDBusConnectionPrivate::setConnection(DBusConnection *dbc, const QDBusError // we don't use connectSignal here because the rules are added by connectSignal on a per-need basis hook.params.clear(); hook.params.reserve(4); - hook.params << QMetaType::Void << QVariant::String << QVariant::String << QVariant::String; + hook.params << QMetaType::Void << QMetaType::QString << QMetaType::QString << QMetaType::QString; hook.midx = staticMetaObject.indexOfSlot("serviceOwnerChangedNoLock(QString,QString,QString)"); Q_ASSERT(hook.midx != -1); signalHooks.insert(QLatin1String("NameOwnerChanged:" DBUS_INTERFACE_DBUS), hook); diff --git a/src/dbus/qdbusinterface.cpp b/src/dbus/qdbusinterface.cpp index fb958a8954..c1b0feea37 100644 --- a/src/dbus/qdbusinterface.cpp +++ b/src/dbus/qdbusinterface.cpp @@ -55,7 +55,7 @@ static void copyArgument(void *to, int id, const QVariant &arg) { if (id == arg.userType()) { switch (id) { - case QVariant::Bool: + case QMetaType::Bool: *reinterpret_cast(to) = arg.toBool(); return; @@ -71,35 +71,35 @@ static void copyArgument(void *to, int id, const QVariant &arg) *reinterpret_cast(to) = qvariant_cast(arg); return; - case QVariant::Int: + case QMetaType::Int: *reinterpret_cast(to) = arg.toInt(); return; - case QVariant::UInt: + case QMetaType::UInt: *reinterpret_cast(to) = arg.toUInt(); return; - case QVariant::LongLong: + case QMetaType::LongLong: *reinterpret_cast(to) = arg.toLongLong(); return; - case QVariant::ULongLong: + case QMetaType::ULongLong: *reinterpret_cast(to) = arg.toULongLong(); return; - case QVariant::Double: + case QMetaType::Double: *reinterpret_cast(to) = arg.toDouble(); return; - case QVariant::String: + case QMetaType::QString: *reinterpret_cast(to) = arg.toString(); return; - case QVariant::ByteArray: + case QMetaType::QByteArray: *reinterpret_cast(to) = arg.toByteArray(); return; - case QVariant::StringList: + case QMetaType::QStringList: *reinterpret_cast(to) = arg.toStringList(); return; } diff --git a/src/dbus/qdbusmarshaller.cpp b/src/dbus/qdbusmarshaller.cpp index 46b41d1c07..c80131f41d 100644 --- a/src/dbus/qdbusmarshaller.cpp +++ b/src/dbus/qdbusmarshaller.cpp @@ -190,7 +190,7 @@ inline bool QDBusMarshaller::append(const QDBusVariant &arg) const QVariant &value = arg.variant(); int id = value.userType(); - if (id == QVariant::Invalid) { + if (id == QMetaType::UnknownType) { qWarning("QDBusMarshaller: cannot add a null QDBusVariant"); error(QLatin1String("Variant containing QVariant::Invalid passed in arguments")); return false; @@ -384,7 +384,7 @@ void QDBusMarshaller::error(const QString &msg) bool QDBusMarshaller::appendVariantInternal(const QVariant &arg) { int id = arg.userType(); - if (id == QVariant::Invalid) { + if (id == QMetaType::UnknownType) { qWarning("QDBusMarshaller: cannot add an invalid QVariant"); error(QLatin1String("Variant containing QVariant::Invalid passed in arguments")); return false; @@ -485,12 +485,12 @@ bool QDBusMarshaller::appendVariantInternal(const QVariant &arg) case DBUS_TYPE_ARRAY: // could be many things // find out what kind of array it is - switch (arg.type()) { - case QVariant::StringList: + switch (arg.userType()) { + case QMetaType::QStringList: append( arg.toStringList() ); return true; - case QVariant::ByteArray: + case QMetaType::QByteArray: append( arg.toByteArray() ); return true; diff --git a/src/dbus/qdbusmessage.cpp b/src/dbus/qdbusmessage.cpp index 71cdec93ca..10d2f07d4d 100644 --- a/src/dbus/qdbusmessage.cpp +++ b/src/dbus/qdbusmessage.cpp @@ -276,7 +276,7 @@ QDBusMessage QDBusMessagePrivate::makeLocal(const QDBusConnectionPrivate &conn, for ( ; it != end; ++it) { int id = it->userType(); const char *signature = QDBusMetaType::typeToSignature(id); - if ((id != QVariant::StringList && id != QVariant::ByteArray && + if ((id != QMetaType::QStringList && id != QMetaType::QByteArray && qstrlen(signature) != 1) || id == qMetaTypeId()) { // yes, we are // we must marshall and demarshall again so as to create QDBusArgument diff --git a/src/dbus/qdbusmetaobject.cpp b/src/dbus/qdbusmetaobject.cpp index 3c529ab755..5265568f42 100644 --- a/src/dbus/qdbusmetaobject.cpp +++ b/src/dbus/qdbusmetaobject.cpp @@ -158,10 +158,10 @@ QDBusMetaObjectGenerator::findType(const QByteArray &signature, const char *direction, int id) { Type result; - result.id = QVariant::Invalid; + result.id = QMetaType::UnknownType; int type = QDBusMetaType::signatureToType(signature); - if (type == QVariant::Invalid && !qt_dbus_metaobject_skip_annotations) { + if (type == QMetaType::UnknownType && !qt_dbus_metaobject_skip_annotations) { // it's not a type normally handled by our meta type system // it must contain an annotation QString annotationName = QString::fromLatin1("org.qtproject.QtDBus.QtTypeName"); @@ -189,7 +189,7 @@ QDBusMetaObjectGenerator::findType(const QByteArray &signature, type = QMetaType::type(typeName); } - if (type == QVariant::Invalid || signature != QDBusMetaType::typeToSignature(type)) { + if (type == QMetaType::UnknownType || signature != QDBusMetaType::typeToSignature(type)) { // type is still unknown or doesn't match back to the signature that it // was expected to, so synthesize a fake type typeName = "QDBusRawType<0x" + signature.toHex() + ">*"; @@ -197,16 +197,16 @@ QDBusMetaObjectGenerator::findType(const QByteArray &signature, } result.name = typeName; - } else if (type == QVariant::Invalid) { + } else if (type == QMetaType::UnknownType) { // this case is used only by the qdbus command-line tool // invalid, let's create an impossible type that contains the signature if (signature == "av") { result.name = "QVariantList"; - type = QVariant::List; + type = QMetaType::QVariantList; } else if (signature == "a{sv}") { result.name = "QVariantMap"; - type = QVariant::Map; + type = QMetaType::QVariantMap; } else if (signature == "a{ss}") { result.name = "QMap"; type = qMetaTypeId >(); @@ -246,7 +246,7 @@ void QDBusMetaObjectGenerator::parseMethods() const QDBusIntrospection::Argument &arg = m.inputArgs.at(i); Type type = findType(arg.type.toLatin1(), m.annotations, "In", i); - if (type.id == QVariant::Invalid) { + if (type.id == QMetaType::UnknownType) { ok = false; break; } @@ -265,7 +265,7 @@ void QDBusMetaObjectGenerator::parseMethods() const QDBusIntrospection::Argument &arg = m.outputArgs.at(i); Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i); - if (type.id == QVariant::Invalid) { + if (type.id == QMetaType::UnknownType) { ok = false; break; } @@ -322,7 +322,7 @@ void QDBusMetaObjectGenerator::parseSignals() const QDBusIntrospection::Argument &arg = s.outputArgs.at(i); Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i); - if (type.id == QVariant::Invalid) { + if (type.id == QMetaType::UnknownType) { ok = false; break; } @@ -358,7 +358,7 @@ void QDBusMetaObjectGenerator::parseProperties() const QDBusIntrospection::Property &p = *prop_it; Property mp; Type type = findType(p.type.toLatin1(), p.annotations); - if (type.id == QVariant::Invalid) + if (type.id == QMetaType::UnknownType) continue; QByteArray name = p.name.toLatin1(); diff --git a/src/dbus/qdbusmetatype.cpp b/src/dbus/qdbusmetatype.cpp index e3804f74f8..bcbb22fba6 100644 --- a/src/dbus/qdbusmetatype.cpp +++ b/src/dbus/qdbusmetatype.cpp @@ -325,7 +325,7 @@ int QDBusMetaType::signatureToType(const char *signature) switch (signature[0]) { case DBUS_TYPE_BOOLEAN: - return QVariant::Bool; + return QMetaType::Bool; case DBUS_TYPE_BYTE: return QMetaType::UChar; @@ -337,22 +337,22 @@ int QDBusMetaType::signatureToType(const char *signature) return QMetaType::UShort; case DBUS_TYPE_INT32: - return QVariant::Int; + return QMetaType::Int; case DBUS_TYPE_UINT32: - return QVariant::UInt; + return QMetaType::UInt; case DBUS_TYPE_INT64: - return QVariant::LongLong; + return QMetaType::LongLong; case DBUS_TYPE_UINT64: - return QVariant::ULongLong; + return QMetaType::ULongLong; case DBUS_TYPE_DOUBLE: - return QVariant::Double; + return QMetaType::Double; case DBUS_TYPE_STRING: - return QVariant::String; + return QMetaType::QString; case DBUS_TYPE_OBJECT_PATH: return QDBusMetaTypeId::objectpath(); @@ -369,13 +369,13 @@ int QDBusMetaType::signatureToType(const char *signature) case DBUS_TYPE_ARRAY: // special case switch (signature[1]) { case DBUS_TYPE_BYTE: - return QVariant::ByteArray; + return QMetaType::QByteArray; case DBUS_TYPE_STRING: - return QVariant::StringList; + return QMetaType::QStringList; case DBUS_TYPE_VARIANT: - return QVariant::List; + return QMetaType::QVariantList; case DBUS_TYPE_OBJECT_PATH: return qMetaTypeId >(); @@ -409,7 +409,7 @@ const char *QDBusMetaType::typeToSignature(int type) case QMetaType::UChar: return DBUS_TYPE_BYTE_AS_STRING; - case QVariant::Bool: + case QMetaType::Bool: return DBUS_TYPE_BOOLEAN_AS_STRING; case QMetaType::Short: @@ -418,29 +418,29 @@ const char *QDBusMetaType::typeToSignature(int type) case QMetaType::UShort: return DBUS_TYPE_UINT16_AS_STRING; - case QVariant::Int: + case QMetaType::Int: return DBUS_TYPE_INT32_AS_STRING; - case QVariant::UInt: + case QMetaType::UInt: return DBUS_TYPE_UINT32_AS_STRING; - case QVariant::LongLong: + case QMetaType::LongLong: return DBUS_TYPE_INT64_AS_STRING; - case QVariant::ULongLong: + case QMetaType::ULongLong: return DBUS_TYPE_UINT64_AS_STRING; - case QVariant::Double: + case QMetaType::Double: return DBUS_TYPE_DOUBLE_AS_STRING; - case QVariant::String: + case QMetaType::QString: return DBUS_TYPE_STRING_AS_STRING; - case QVariant::StringList: + case QMetaType::QStringList: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING; // as - case QVariant::ByteArray: + case QMetaType::QByteArray: return DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING; // ay } diff --git a/src/dbus/qdbusutil.cpp b/src/dbus/qdbusutil.cpp index 09311d1ad4..b4ee6811ac 100644 --- a/src/dbus/qdbusutil.cpp +++ b/src/dbus/qdbusutil.cpp @@ -82,7 +82,7 @@ static bool variantToString(const QVariant &arg, QString &out) { int argType = arg.userType(); - if (argType == QVariant::StringList) { + if (argType == QMetaType::QStringList) { out += QLatin1Char('{'); const QStringList list = arg.toStringList(); for (const QString &item : list) @@ -90,7 +90,7 @@ static bool variantToString(const QVariant &arg, QString &out) if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); - } else if (argType == QVariant::ByteArray) { + } else if (argType == QMetaType::QByteArray) { out += QLatin1Char('{'); QByteArray list = arg.toByteArray(); for (int i = 0; i < list.count(); ++i) { @@ -100,7 +100,7 @@ static bool variantToString(const QVariant &arg, QString &out) if (!list.isEmpty()) out.chop(2); out += QLatin1Char('}'); - } else if (argType == QVariant::List) { + } else if (argType == QMetaType::QVariantList) { out += QLatin1Char('{'); const QList list = arg.toList(); for (const QVariant &item : list) { @@ -148,7 +148,7 @@ static bool variantToString(const QVariant &arg, QString &out) if (!variantToString(v, out)) return false; out += QLatin1Char(']'); - } else if (arg.canConvert(QVariant::String)) { + } else if (arg.canConvert(QMetaType::QString)) { out += QLatin1Char('\"') + arg.toString() + QLatin1Char('\"'); } else { out += QLatin1Char('['); diff --git a/src/dbus/qdbusxmlgenerator.cpp b/src/dbus/qdbusxmlgenerator.cpp index c6b3b90508..7370ce0de3 100644 --- a/src/dbus/qdbusxmlgenerator.cpp +++ b/src/dbus/qdbusxmlgenerator.cpp @@ -113,7 +113,7 @@ static QString generateInterfaceXml(const QMetaObject *mo, int flags, int method QLatin1String(signature), accessAsString(mp.isReadable(), mp.isWritable())); - if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { + if (QDBusMetaType::signatureToType(signature) == QMetaType::UnknownType) { const char *typeName = QMetaType::typeName(typeId); retval += QLatin1String(">\n \n \n") .arg(typeNameToXml(typeName)); @@ -161,7 +161,7 @@ static QString generateInterfaceXml(const QMetaObject *mo, int flags, int method .arg(typeNameToXml(typeName)); // do we need to describe this argument? - if (QDBusMetaType::signatureToType(typeName) == QVariant::Invalid) + if (QDBusMetaType::signatureToType(typeName) == QMetaType::UnknownType) xml += QLatin1String(" \n") .arg(typeNameToXml(QMetaType::typeName(typeId))); } else { @@ -208,7 +208,7 @@ static QString generateInterfaceXml(const QMetaObject *mo, int flags, int method qUtf16Printable(name), signature, isOutput ? "out" : "in"); // do we need to describe this argument? - if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { + if (QDBusMetaType::signatureToType(signature) == QMetaType::UnknownType) { const char *typeName = QMetaType::typeName(types.at(j)); xml += QString::fromLatin1(" \n") .arg(isOutput ? QLatin1String("Out") : QLatin1String("In")) diff --git a/src/gui/image/qbitmap.cpp b/src/gui/image/qbitmap.cpp index 455045eb57..a44f7151b1 100644 --- a/src/gui/image/qbitmap.cpp +++ b/src/gui/image/qbitmap.cpp @@ -218,7 +218,7 @@ QBitmap::~QBitmap() */ QBitmap::operator QVariant() const { - return QVariant(QVariant::Bitmap, this); + return QVariant(QMetaType::QBitmap, this); } static QBitmap makeBitmap(QImage &&image, Qt::ImageConversionFlags flags) diff --git a/src/gui/image/qicon.cpp b/src/gui/image/qicon.cpp index 19be066d23..38285dd827 100644 --- a/src/gui/image/qicon.cpp +++ b/src/gui/image/qicon.cpp @@ -782,7 +782,7 @@ QIcon &QIcon::operator=(const QIcon &other) */ QIcon::operator QVariant() const { - return QVariant(QVariant::Icon, this); + return QVariant(QMetaType::QIcon, this); } /*! \fn int QIcon::serialNumber() const diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp index 3ddc52bed4..62d2d0e948 100644 --- a/src/gui/image/qimage.cpp +++ b/src/gui/image/qimage.cpp @@ -1067,7 +1067,7 @@ int QImage::devType() const */ QImage::operator QVariant() const { - return QVariant(QVariant::Image, this); + return QVariant(QMetaType::QImage, this); } /*! diff --git a/src/gui/image/qpixmap.cpp b/src/gui/image/qpixmap.cpp index 3fce64cb20..e914d7697f 100644 --- a/src/gui/image/qpixmap.cpp +++ b/src/gui/image/qpixmap.cpp @@ -402,7 +402,7 @@ QPixmap &QPixmap::operator=(const QPixmap &pixmap) */ QPixmap::operator QVariant() const { - return QVariant(QVariant::Pixmap, this); + return QVariant(QMetaType::QPixmap, this); } /*! diff --git a/src/gui/itemmodels/qstandarditemmodel.cpp b/src/gui/itemmodels/qstandarditemmodel.cpp index 9bdc22b49e..fc9424763e 100644 --- a/src/gui/itemmodels/qstandarditemmodel.cpp +++ b/src/gui/itemmodels/qstandarditemmodel.cpp @@ -926,7 +926,7 @@ void QStandardItem::setData(const QVariant &value, int role) for (it = d->values.begin(); it != d->values.end(); ++it) { if ((*it).role == role) { if (value.isValid()) { - if ((*it).value.type() == value.type() && (*it).value == value) + if ((*it).value.userType() == value.userType() && (*it).value == value) return; (*it).value = value; } else { diff --git a/src/gui/kernel/qcursor.cpp b/src/gui/kernel/qcursor.cpp index f5a794b642..339284aa30 100644 --- a/src/gui/kernel/qcursor.cpp +++ b/src/gui/kernel/qcursor.cpp @@ -657,7 +657,7 @@ QCursor &QCursor::operator=(const QCursor &c) */ QCursor::operator QVariant() const { - return QVariant(QVariant::Cursor, this); + return QVariant(QMetaType::QCursor, this); } #ifndef QT_NO_DEBUG_STREAM diff --git a/src/gui/kernel/qguivariant.cpp b/src/gui/kernel/qguivariant.cpp index 4ed9d032f6..596b7e44fd 100644 --- a/src/gui/kernel/qguivariant.cpp +++ b/src/gui/kernel/qguivariant.cpp @@ -178,25 +178,25 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) { switch (t) { - case QVariant::ByteArray: - if (d->type == QVariant::Color) { + case QMetaType::QByteArray: + if (d->type == QMetaType::QColor) { const QColor *c = v_cast(d); *static_cast(result) = c->name(c->alpha() != 255 ? QColor::HexArgb : QColor::HexRgb).toLatin1(); return true; } break; - case QVariant::String: { + case QMetaType::QString: { QString *str = static_cast(result); switch (d->type) { #ifndef QT_NO_SHORTCUT - case QVariant::KeySequence: + case QMetaType::QKeySequence: *str = (*v_cast(d)).toString(QKeySequence::NativeText); return true; #endif - case QVariant::Font: + case QMetaType::QFont: *str = v_cast(d)->toString(); return true; - case QVariant::Color: { + case QMetaType::QColor: { const QColor *c = v_cast(d); *str = c->name(c->alpha() != 255 ? QColor::HexArgb : QColor::HexRgb); return true; @@ -206,85 +206,85 @@ static bool convert(const QVariant::Private *d, int t, } break; } - case QVariant::Pixmap: - if (d->type == QVariant::Image) { + case QMetaType::QPixmap: + if (d->type == QMetaType::QImage) { *static_cast(result) = QPixmap::fromImage(*v_cast(d)); return true; - } else if (d->type == QVariant::Bitmap) { + } else if (d->type == QMetaType::QBitmap) { *static_cast(result) = *v_cast(d); return true; - } else if (d->type == QVariant::Brush) { + } else if (d->type == QMetaType::QBrush) { if (v_cast(d)->style() == Qt::TexturePattern) { *static_cast(result) = v_cast(d)->texture(); return true; } } break; - case QVariant::Image: - if (d->type == QVariant::Pixmap) { + case QMetaType::QImage: + if (d->type == QMetaType::QPixmap) { *static_cast(result) = v_cast(d)->toImage(); return true; - } else if (d->type == QVariant::Bitmap) { + } else if (d->type == QMetaType::QBitmap) { *static_cast(result) = v_cast(d)->toImage(); return true; } break; - case QVariant::Bitmap: - if (d->type == QVariant::Pixmap) { + case QMetaType::QBitmap: + if (d->type == QMetaType::QPixmap) { *static_cast(result) = *v_cast(d); return true; - } else if (d->type == QVariant::Image) { + } else if (d->type == QMetaType::QImage) { *static_cast(result) = QBitmap::fromImage(*v_cast(d)); return true; } break; #ifndef QT_NO_SHORTCUT - case QVariant::Int: - if (d->type == QVariant::KeySequence) { + case QMetaType::Int: + if (d->type == QMetaType::QKeySequence) { const QKeySequence &seq = *v_cast(d); *static_cast(result) = seq.isEmpty() ? 0 : seq[0]; return true; } break; #endif - case QVariant::Font: - if (d->type == QVariant::String) { + case QMetaType::QFont: + if (d->type == QMetaType::QString) { QFont *f = static_cast(result); f->fromString(*v_cast(d)); return true; } break; - case QVariant::Color: - if (d->type == QVariant::String) { + case QMetaType::QColor: + if (d->type == QMetaType::QString) { static_cast(result)->setNamedColor(*v_cast(d)); return static_cast(result)->isValid(); - } else if (d->type == QVariant::ByteArray) { + } else if (d->type == QMetaType::QByteArray) { static_cast(result)->setNamedColor(QLatin1String(*v_cast(d))); return true; - } else if (d->type == QVariant::Brush) { + } else if (d->type == QMetaType::QBrush) { if (v_cast(d)->style() == Qt::SolidPattern) { *static_cast(result) = v_cast(d)->color(); return true; } } break; - case QVariant::Brush: - if (d->type == QVariant::Color) { + case QMetaType::QBrush: + if (d->type == QMetaType::QColor) { *static_cast(result) = QBrush(*v_cast(d)); return true; - } else if (d->type == QVariant::Pixmap) { + } else if (d->type == QMetaType::QPixmap) { *static_cast(result) = QBrush(*v_cast(d)); return true; } break; #ifndef QT_NO_SHORTCUT - case QVariant::KeySequence: { + case QMetaType::QKeySequence: { QKeySequence *seq = static_cast(result); switch (d->type) { - case QVariant::String: + case QMetaType::QString: *seq = QKeySequence(*v_cast(d)); return true; - case QVariant::Int: + case QMetaType::Int: *seq = QKeySequence(d->data.i); return true; default: @@ -294,7 +294,7 @@ static bool convert(const QVariant::Private *d, int t, } #endif #ifndef QT_NO_ICON - case QVariant::Icon: { + case QMetaType::QIcon: { if (ok) *ok = false; return false; diff --git a/src/gui/kernel/qinternalmimedata.cpp b/src/gui/kernel/qinternalmimedata.cpp index 8f4da1afb5..d5cdc743ee 100644 --- a/src/gui/kernel/qinternalmimedata.cpp +++ b/src/gui/kernel/qinternalmimedata.cpp @@ -112,22 +112,23 @@ QVariant QInternalMimeData::retrieveData(const QString &mimeType, QVariant::Type { QVariant data = retrieveData_sys(mimeType, type); if (mimeType == QLatin1String("application/x-qt-image")) { - if (data.isNull() || (data.type() == QVariant::ByteArray && data.toByteArray().isEmpty())) { + if (data.isNull() || (data.userType() == QMetaType::QByteArray && data.toByteArray().isEmpty())) { // try to find an image QStringList imageFormats = imageReadMimeFormats(); for (int i = 0; i < imageFormats.size(); ++i) { data = retrieveData_sys(imageFormats.at(i), type); - if (data.isNull() || (data.type() == QVariant::ByteArray && data.toByteArray().isEmpty())) + if (data.isNull() || (data.userType() == QMetaType::QByteArray && data.toByteArray().isEmpty())) continue; break; } } + int typeId = type; // we wanted some image type, but all we got was a byte array. Convert it to an image. - if (data.type() == QVariant::ByteArray - && (type == QVariant::Image || type == QVariant::Pixmap || type == QVariant::Bitmap)) + if (data.userType() == QMetaType::QByteArray + && (typeId == QMetaType::QImage || typeId == QMetaType::QPixmap || typeId == QMetaType::QBitmap)) data = QImage::fromData(data.toByteArray()); - } else if (mimeType == QLatin1String("application/x-color") && data.type() == QVariant::ByteArray) { + } else if (mimeType == QLatin1String("application/x-color") && data.userType() == QMetaType::QByteArray) { QColor c; QByteArray ba = data.toByteArray(); if (ba.size() == 8) { @@ -140,7 +141,7 @@ QVariant QInternalMimeData::retrieveData(const QString &mimeType, QVariant::Type } else { qWarning("Qt: Invalid color format"); } - } else if (data.type() != type && data.type() == QVariant::ByteArray) { + } else if (data.userType() != int(type) && data.userType() == QMetaType::QByteArray) { // try to use mime data's internal conversion stuf. QInternalMimeData *that = const_cast(this); that->setData(mimeType, data.toByteArray()); diff --git a/src/gui/kernel/qkeysequence.cpp b/src/gui/kernel/qkeysequence.cpp index e1244e1006..3a3dd42cae 100644 --- a/src/gui/kernel/qkeysequence.cpp +++ b/src/gui/kernel/qkeysequence.cpp @@ -1404,7 +1404,7 @@ QKeySequence::SequenceMatch QKeySequence::matches(const QKeySequence &seq) const */ QKeySequence::operator QVariant() const { - return QVariant(QVariant::KeySequence, this); + return QVariant(QMetaType::QKeySequence, this); } /*! \fn QKeySequence::operator int () const diff --git a/src/gui/kernel/qpalette.cpp b/src/gui/kernel/qpalette.cpp index fc063bc72c..397c50f3dc 100644 --- a/src/gui/kernel/qpalette.cpp +++ b/src/gui/kernel/qpalette.cpp @@ -714,7 +714,7 @@ QPalette &QPalette::operator=(const QPalette &p) */ QPalette::operator QVariant() const { - return QVariant(QVariant::Palette, this); + return QVariant(QMetaType::QPalette, this); } /*! diff --git a/src/gui/math3d/qmatrix4x4.cpp b/src/gui/math3d/qmatrix4x4.cpp index ad4cdfdbf4..6666eb037f 100644 --- a/src/gui/math3d/qmatrix4x4.cpp +++ b/src/gui/math3d/qmatrix4x4.cpp @@ -2007,7 +2007,7 @@ void QMatrix4x4::optimize() */ QMatrix4x4::operator QVariant() const { - return QVariant(QVariant::Matrix4x4, this); + return QVariant(QMetaType::QMatrix4x4, this); } #ifndef QT_NO_DEBUG_STREAM diff --git a/src/gui/math3d/qquaternion.cpp b/src/gui/math3d/qquaternion.cpp index 899ec12eb3..5f15949c5b 100644 --- a/src/gui/math3d/qquaternion.cpp +++ b/src/gui/math3d/qquaternion.cpp @@ -983,7 +983,7 @@ QQuaternion QQuaternion::nlerp */ QQuaternion::operator QVariant() const { - return QVariant(QVariant::Quaternion, this); + return QVariant(QMetaType::QQuaternion, this); } #ifndef QT_NO_DEBUG_STREAM diff --git a/src/gui/math3d/qvector2d.cpp b/src/gui/math3d/qvector2d.cpp index c04f8b1cbf..5f651cf376 100644 --- a/src/gui/math3d/qvector2d.cpp +++ b/src/gui/math3d/qvector2d.cpp @@ -531,7 +531,7 @@ QVector4D QVector2D::toVector4D() const */ QVector2D::operator QVariant() const { - return QVariant(QVariant::Vector2D, this); + return QVariant(QMetaType::QVector2D, this); } #ifndef QT_NO_DEBUG_STREAM diff --git a/src/gui/math3d/qvector3d.cpp b/src/gui/math3d/qvector3d.cpp index 4f72c1da66..08c3de99d2 100644 --- a/src/gui/math3d/qvector3d.cpp +++ b/src/gui/math3d/qvector3d.cpp @@ -706,7 +706,7 @@ QVector4D QVector3D::toVector4D() const */ QVector3D::operator QVariant() const { - return QVariant(QVariant::Vector3D, this); + return QVariant(QMetaType::QVector3D, this); } /*! diff --git a/src/gui/math3d/qvector4d.cpp b/src/gui/math3d/qvector4d.cpp index 3a68bd6cb7..070ea7454e 100644 --- a/src/gui/math3d/qvector4d.cpp +++ b/src/gui/math3d/qvector4d.cpp @@ -608,7 +608,7 @@ QVector3D QVector4D::toVector3DAffine() const */ QVector4D::operator QVariant() const { - return QVariant(QVariant::Vector4D, this); + return QVariant(QMetaType::QVector4D, this); } #ifndef QT_NO_DEBUG_STREAM diff --git a/src/gui/painting/qbrush.cpp b/src/gui/painting/qbrush.cpp index 83032bdc4f..e84916e063 100644 --- a/src/gui/painting/qbrush.cpp +++ b/src/gui/painting/qbrush.cpp @@ -672,7 +672,7 @@ QBrush &QBrush::operator=(const QBrush &b) */ QBrush::operator QVariant() const { - return QVariant(QVariant::Brush, this); + return QVariant(QMetaType::QBrush, this); } /*! diff --git a/src/gui/painting/qcolor.cpp b/src/gui/painting/qcolor.cpp index 8780cce223..917706e8cf 100644 --- a/src/gui/painting/qcolor.cpp +++ b/src/gui/painting/qcolor.cpp @@ -2980,7 +2980,7 @@ bool QColor::operator!=(const QColor &color) const noexcept */ QColor::operator QVariant() const { - return QVariant(QVariant::Color, this); + return QVariant(QMetaType::QColor, this); } /*! \internal diff --git a/src/gui/painting/qmatrix.cpp b/src/gui/painting/qmatrix.cpp index b1f01332b6..890b0079de 100644 --- a/src/gui/painting/qmatrix.cpp +++ b/src/gui/painting/qmatrix.cpp @@ -1087,7 +1087,7 @@ QMatrix &QMatrix::operator=(const QMatrix &matrix) noexcept */ QMatrix::operator QVariant() const { - return QVariant(QVariant::Matrix, this); + return QVariant(QMetaType::QMatrix, this); } Q_GUI_EXPORT QPainterPath operator *(const QPainterPath &p, const QMatrix &m) diff --git a/src/gui/painting/qpen.cpp b/src/gui/painting/qpen.cpp index 1a940443d1..01e581d2ed 100644 --- a/src/gui/painting/qpen.cpp +++ b/src/gui/painting/qpen.cpp @@ -408,7 +408,7 @@ QPen &QPen::operator=(const QPen &p) noexcept */ QPen::operator QVariant() const { - return QVariant(QVariant::Pen, this); + return QVariant(QMetaType::QPen, this); } /*! diff --git a/src/gui/painting/qpolygon.cpp b/src/gui/painting/qpolygon.cpp index 3bf6004fcc..20337477b7 100644 --- a/src/gui/painting/qpolygon.cpp +++ b/src/gui/painting/qpolygon.cpp @@ -716,7 +716,7 @@ QPolygon QPolygonF::toPolygon() const */ QPolygon::operator QVariant() const { - return QVariant(QVariant::Polygon, this); + return QVariant(QMetaType::QPolygon, this); } /***************************************************************************** diff --git a/src/gui/painting/qregion.cpp b/src/gui/painting/qregion.cpp index 783b02fb93..44ee038194 100644 --- a/src/gui/painting/qregion.cpp +++ b/src/gui/painting/qregion.cpp @@ -599,7 +599,7 @@ QRegion& QRegion::operator^=(const QRegion &r) */ QRegion::operator QVariant() const { - return QVariant(QVariant::Region, this); + return QVariant(QMetaType::QRegion, this); } /*! diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp index d75b66c50b..279a817ff1 100644 --- a/src/gui/painting/qtransform.cpp +++ b/src/gui/painting/qtransform.cpp @@ -2155,7 +2155,7 @@ QTransform::TransformationType QTransform::type() const */ QTransform::operator QVariant() const { - return QVariant(QVariant::Transform, this); + return QVariant(QMetaType::QTransform, this); } diff --git a/src/gui/text/qcssparser.cpp b/src/gui/text/qcssparser.cpp index c0b0071e4d..a12eb98528 100644 --- a/src/gui/text/qcssparser.cpp +++ b/src/gui/text/qcssparser.cpp @@ -707,7 +707,7 @@ static Qt::Alignment parseAlignment(const QCss::Value *values, int count) static ColorData parseColorValue(QCss::Value v) { if (v.type == Value::Identifier || v.type == Value::String) { - v.variant.convert(QVariant::Color); + v.variant.convert(QMetaType::QColor); v.type = Value::Color; } @@ -1143,7 +1143,7 @@ static bool setFontSizeFromValue(QCss::Value value, QFont *font, int *fontSizeAd } else if (s.endsWith(QLatin1String("px"), Qt::CaseInsensitive)) { s.chop(2); value.variant = s; - if (value.variant.convert(QVariant::Int)) { + if (value.variant.convert(QMetaType::Int)) { font->setPixelSize(value.variant.toInt()); valid = true; } @@ -1420,9 +1420,9 @@ QColor Declaration::colorValue(const QPalette &pal) const return QColor(); if (d->parsed.isValid()) { - if (d->parsed.type() == QVariant::Color) + if (d->parsed.userType() == QMetaType::QColor) return qvariant_cast(d->parsed); - if (d->parsed.type() == QVariant::Int) + if (d->parsed.userType() == QMetaType::Int) return pal.color((QPalette::ColorRole)(d->parsed.toInt())); } @@ -1442,9 +1442,9 @@ QBrush Declaration::brushValue(const QPalette &pal) const return QBrush(); if (d->parsed.isValid()) { - if (d->parsed.type() == QVariant::Brush) + if (d->parsed.userType() == QMetaType::QBrush) return qvariant_cast(d->parsed); - if (d->parsed.type() == QVariant::Int) + if (d->parsed.userType() == QMetaType::Int) return pal.color((QPalette::ColorRole)(d->parsed.toInt())); } @@ -1469,9 +1469,9 @@ void Declaration::brushValues(QBrush *c, const QPalette &pal) const needParse = 0; QList v = d->parsed.toList(); for (i = 0; i < qMin(v.count(), 4); i++) { - if (v.at(i).type() == QVariant::Brush) { + if (v.at(i).userType() == QMetaType::QBrush) { c[i] = qvariant_cast(v.at(i)); - } else if (v.at(i).type() == QVariant::Int) { + } else if (v.at(i).userType() == QMetaType::Int) { c[i] = pal.color((QPalette::ColorRole)(v.at(i).toInt())); } else { needParse |= (1<parsed.isValid()) { QList v = d->parsed.toList(); for (i = 0; i < qMin(d->values.count(), 4); i++) { - if (v.at(i).type() == QVariant::Color) { + if (v.at(i).userType() == QMetaType::QColor) { c[i] = qvariant_cast(v.at(i)); } else { c[i] = pal.color((QPalette::ColorRole)(v.at(i).toInt())); @@ -2723,7 +2723,7 @@ bool Parser::parseTerm(Value *value) switch (lookup()) { case NUMBER: value->type = Value::Number; - value->variant.convert(QVariant::Double); + value->variant.convert(QMetaType::Double); break; case PERCENTAGE: value->type = Value::Percentage; diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp index 2e7d898a70..8f0d7d9d38 100644 --- a/src/gui/text/qfont.cpp +++ b/src/gui/text/qfont.cpp @@ -1753,7 +1753,7 @@ bool QFont::operator!=(const QFont &f) const */ QFont::operator QVariant() const { - return QVariant(QVariant::Font, this); + return QVariant(QMetaType::QFont, this); } /*! diff --git a/src/gui/text/qplatformfontdatabase.cpp b/src/gui/text/qplatformfontdatabase.cpp index 02e25bb6af..48ba8987f3 100644 --- a/src/gui/text/qplatformfontdatabase.cpp +++ b/src/gui/text/qplatformfontdatabase.cpp @@ -82,7 +82,7 @@ void QPlatformFontDatabase::registerQPF2Font(const QByteArray &dataArray, void * if (!fontName.isEmpty() && pixelSize) { QFont::Weight fontWeight = QFont::Normal; - if (weight.type() == QVariant::Int || weight.type() == QVariant::UInt) + if (weight.userType() == QMetaType::Int || weight.userType() == QMetaType::UInt) fontWeight = QFont::Weight(weight.toInt()); QFont::Style fontStyle = static_cast(style.toInt()); diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp index 2d7f2bb844..46cfc79643 100644 --- a/src/gui/text/qtextdocument.cpp +++ b/src/gui/text/qtextdocument.cpp @@ -2234,7 +2234,7 @@ QVariant QTextDocument::loadResource(int type, const QUrl &name) } if (!r.isNull()) { - if (type == ImageResource && r.type() == QVariant::ByteArray) { + if (type == ImageResource && r.userType() == QMetaType::QByteArray) { if (qApp->thread() != QThread::currentThread()) { // must use images in non-GUI threads QImage image; @@ -3049,12 +3049,12 @@ QString QTextHtmlExporter::findUrlForImage(const QTextDocument *doc, qint64 cach for (; it != priv->cachedResources.constEnd(); ++it) { const QVariant &v = it.value(); - if (v.type() == QVariant::Image && !isPixmap) { + if (v.userType() == QMetaType::QImage && !isPixmap) { if (qvariant_cast(v).cacheKey() == cacheKey) break; } - if (v.type() == QVariant::Pixmap && isPixmap) { + if (v.userType() == QMetaType::QPixmap && isPixmap) { if (qvariant_cast(v).cacheKey() == cacheKey) break; } diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp index e21a8d8d52..9d70873590 100644 --- a/src/gui/text/qtextdocumentlayout.cpp +++ b/src/gui/text/qtextdocumentlayout.cpp @@ -248,7 +248,7 @@ public: if (v.isNull()) { return cellPadding; } else { - Q_ASSERT(v.userType() == QVariant::Double || v.userType() == QMetaType::Float); + Q_ASSERT(v.userType() == QMetaType::Double || v.userType() == QMetaType::Float); return QFixed::fromReal(v.toReal() * deviceScale); } } diff --git a/src/gui/text/qtextformat.cpp b/src/gui/text/qtextformat.cpp index e3bd49a15e..10b8ade117 100644 --- a/src/gui/text/qtextformat.cpp +++ b/src/gui/text/qtextformat.cpp @@ -144,7 +144,7 @@ QT_BEGIN_NAMESPACE */ QTextLength::operator QVariant() const { - return QVariant(QVariant::TextLength, this); + return QVariant(QMetaType::QTextLength, this); } #ifndef QT_NO_DATASTREAM @@ -288,20 +288,20 @@ static inline uint variantHash(const QVariant &variant) { // simple and fast hash functions to differentiate between type and value switch (variant.userType()) { // sorted by occurrence frequency - case QVariant::String: return qHash(variant.toString()); - case QVariant::Double: return qHash(variant.toDouble()); - case QVariant::Int: return 0x811890 + variant.toInt(); - case QVariant::Brush: + case QMetaType::QString: return qHash(variant.toString()); + case QMetaType::Double: return qHash(variant.toDouble()); + case QMetaType::Int: return 0x811890 + variant.toInt(); + case QMetaType::QBrush: return 0x01010101 + hash(qvariant_cast(variant)); - case QVariant::Bool: return 0x371818 + variant.toBool(); - case QVariant::Pen: return 0x02020202 + hash(qvariant_cast(variant)); - case QVariant::List: + case QMetaType::Bool: return 0x371818 + variant.toBool(); + case QMetaType::QPen: return 0x02020202 + hash(qvariant_cast(variant)); + case QMetaType::QVariantList: return 0x8377 + qvariant_cast(variant).count(); - case QVariant::Color: return hash(qvariant_cast(variant)); - case QVariant::TextLength: + case QMetaType::QColor: return hash(qvariant_cast(variant)); + case QMetaType::QTextLength: return 0x377 + hash(qvariant_cast(variant).rawValue()); case QMetaType::Float: return qHash(variant.toFloat()); - case QVariant::Invalid: return 0; + case QMetaType::UnknownType: return 0; default: break; } return qHash(variant.typeName()); @@ -874,7 +874,7 @@ QTextFormat::~QTextFormat() */ QTextFormat::operator QVariant() const { - return QVariant(QVariant::TextFormat, this); + return QVariant(QMetaType::QTextFormat, this); } /*! @@ -984,7 +984,7 @@ bool QTextFormat::boolProperty(int propertyId) const if (!d) return false; const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::Bool) + if (prop.userType() != QMetaType::Bool) return false; return prop.toBool(); } @@ -1004,7 +1004,7 @@ int QTextFormat::intProperty(int propertyId) const if (!d) return def; const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::Int) + if (prop.userType() != QMetaType::Int) return def; return prop.toInt(); } @@ -1022,7 +1022,7 @@ qreal QTextFormat::doubleProperty(int propertyId) const if (!d) return 0.; const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::Double && prop.userType() != QMetaType::Float) + if (prop.userType() != QMetaType::Double && prop.userType() != QMetaType::Float) return 0.; return qvariant_cast(prop); } @@ -1040,7 +1040,7 @@ QString QTextFormat::stringProperty(int propertyId) const if (!d) return QString(); const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::String) + if (prop.userType() != QMetaType::QString) return QString(); return prop.toString(); } @@ -1058,7 +1058,7 @@ QColor QTextFormat::colorProperty(int propertyId) const if (!d) return QColor(); const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::Color) + if (prop.userType() != QMetaType::QColor) return QColor(); return qvariant_cast(prop); } @@ -1076,7 +1076,7 @@ QPen QTextFormat::penProperty(int propertyId) const if (!d) return QPen(Qt::NoPen); const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::Pen) + if (prop.userType() != QMetaType::QPen) return QPen(Qt::NoPen); return qvariant_cast(prop); } @@ -1094,7 +1094,7 @@ QBrush QTextFormat::brushProperty(int propertyId) const if (!d) return QBrush(Qt::NoBrush); const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::Brush) + if (prop.userType() != QMetaType::QBrush) return QBrush(Qt::NoBrush); return qvariant_cast(prop); } @@ -1126,13 +1126,13 @@ QVector QTextFormat::lengthVectorProperty(int propertyId) const if (!d) return vector; const QVariant prop = d->property(propertyId); - if (prop.userType() != QVariant::List) + if (prop.userType() != QMetaType::QVariantList) return vector; QList propertyList = prop.toList(); for (int i=0; i(var)); } @@ -1222,7 +1222,7 @@ int QTextFormat::objectIndex() const if (!d) return -1; const QVariant prop = d->property(ObjectIndex); - if (prop.userType() != QVariant::Int) // #### + if (prop.userType() != QMetaType::Int) // #### return -1; return prop.toInt(); } @@ -1859,9 +1859,9 @@ void QTextCharFormat::setUnderlineStyle(UnderlineStyle style) QString QTextCharFormat::anchorName() const { QVariant prop = property(AnchorName); - if (prop.userType() == QVariant::StringList) + if (prop.userType() == QMetaType::QStringList) return prop.toStringList().value(0); - else if (prop.userType() != QVariant::String) + else if (prop.userType() != QMetaType::QString) return QString(); return prop.toString(); } @@ -1878,9 +1878,9 @@ QString QTextCharFormat::anchorName() const QStringList QTextCharFormat::anchorNames() const { QVariant prop = property(AnchorName); - if (prop.userType() == QVariant::StringList) + if (prop.userType() == QMetaType::QStringList) return prop.toStringList(); - else if (prop.userType() != QVariant::String) + else if (prop.userType() != QMetaType::QString) return QStringList(); return QStringList(prop.toString()); } diff --git a/src/gui/text/qtexthtmlparser.cpp b/src/gui/text/qtexthtmlparser.cpp index 3b9f2d253e..f003544391 100644 --- a/src/gui/text/qtexthtmlparser.cpp +++ b/src/gui/text/qtexthtmlparser.cpp @@ -1451,19 +1451,19 @@ void QTextHtmlParserNode::applyBackgroundImage(const QString &url, const QTextDo if (QCoreApplication::instance()->thread() != QThread::currentThread()) { // must use images in non-GUI threads - if (val.type() == QVariant::Image) { + if (val.userType() == QMetaType::QImage) { QImage image = qvariant_cast(val); charFormat.setBackground(image); - } else if (val.type() == QVariant::ByteArray) { + } else if (val.userType() == QMetaType::QByteArray) { QImage image; if (image.loadFromData(val.toByteArray())) { charFormat.setBackground(image); } } } else { - if (val.type() == QVariant::Image || val.type() == QVariant::Pixmap) { + if (val.userType() == QMetaType::QImage || val.userType() == QMetaType::QPixmap) { charFormat.setBackground(qvariant_cast(val)); - } else if (val.type() == QVariant::ByteArray) { + } else if (val.userType() == QMetaType::QByteArray) { QPixmap pm; if (pm.loadFromData(val.toByteArray())) { charFormat.setBackground(pm); @@ -1907,9 +1907,9 @@ void QTextHtmlParser::importStyleSheet(const QString &href) QVariant res = resourceProvider->resource(QTextDocument::StyleSheetResource, href); QString css; - if (res.type() == QVariant::String) { + if (res.userType() == QMetaType::QString) { css = res.toString(); - } else if (res.type() == QVariant::ByteArray) { + } else if (res.userType() == QMetaType::QByteArray) { // #### detect @charset css = QString::fromUtf8(res.toByteArray()); } diff --git a/src/gui/text/qtextimagehandler.cpp b/src/gui/text/qtextimagehandler.cpp index 14018f34da..0d87a2135d 100644 --- a/src/gui/text/qtextimagehandler.cpp +++ b/src/gui/text/qtextimagehandler.cpp @@ -88,9 +88,9 @@ static QPixmap getPixmap(QTextDocument *doc, const QTextImageFormat &format, con qreal sourcePixelRatio = 1.0; name = resolveFileName(name, &url, devicePixelRatio, &sourcePixelRatio); const QVariant data = doc->resource(QTextDocument::ImageResource, url); - if (data.type() == QVariant::Pixmap || data.type() == QVariant::Image) { + if (data.userType() == QMetaType::QPixmap || data.userType() == QMetaType::QImage) { pm = qvariant_cast(data); - } else if (data.type() == QVariant::ByteArray) { + } else if (data.userType() == QMetaType::QByteArray) { pm.loadFromData(data.toByteArray()); } @@ -170,9 +170,9 @@ static QImage getImage(QTextDocument *doc, const QTextImageFormat &format, const qreal sourcePixelRatio = 1.0; name = resolveFileName(name, &url, devicePixelRatio, &sourcePixelRatio); const QVariant data = doc->resource(QTextDocument::ImageResource, url); - if (data.type() == QVariant::Image) { + if (data.userType() == QMetaType::QImage) { image = qvariant_cast(data); - } else if (data.type() == QVariant::ByteArray) { + } else if (data.userType() == QMetaType::QByteArray) { image.loadFromData(data.toByteArray()); } diff --git a/src/gui/text/qtextodfwriter.cpp b/src/gui/text/qtextodfwriter.cpp index 408e3ec167..155ec43c50 100644 --- a/src/gui/text/qtextodfwriter.cpp +++ b/src/gui/text/qtextodfwriter.cpp @@ -455,9 +455,9 @@ void QTextOdfWriter::writeInlineCharacter(QXmlStreamWriter &writer, const QTextF name.prepend(QLatin1String("qrc")); QUrl url = QUrl(name); const QVariant variant = m_document->resource(QTextDocument::ImageResource, url); - if (variant.type() == QVariant::Image) { + if (variant.userType() == QMetaType::QImage) { image = qvariant_cast(variant); - } else if (variant.type() == QVariant::ByteArray) { + } else if (variant.userType() == QMetaType::QByteArray) { data = variant.toByteArray(); QBuffer buffer(&data); diff --git a/src/platformsupport/accessibility/qaccessiblebridgeutils.cpp b/src/platformsupport/accessibility/qaccessiblebridgeutils.cpp index f280e65c29..a15b93e31e 100644 --- a/src/platformsupport/accessibility/qaccessiblebridgeutils.cpp +++ b/src/platformsupport/accessibility/qaccessiblebridgeutils.cpp @@ -93,7 +93,7 @@ bool performEffectiveAction(QAccessibleInterface *iface, const QString &actionNa if (!success) return false; stepSize = (max - min) / 10; // this is pretty arbitrary, we just need to provide something - const int typ = currentVariant.type(); + const int typ = currentVariant.userType(); if (typ != QMetaType::Float && typ != QMetaType::Double) { // currentValue is an integer. Round it up to ensure stepping in case it was below 1 stepSize = qCeil(stepSize); diff --git a/src/platformsupport/linuxaccessibility/atspiadaptor.cpp b/src/platformsupport/linuxaccessibility/atspiadaptor.cpp index 0f34e1a4ca..012edc82e4 100644 --- a/src/platformsupport/linuxaccessibility/atspiadaptor.cpp +++ b/src/platformsupport/linuxaccessibility/atspiadaptor.cpp @@ -2250,7 +2250,7 @@ bool AtSpiAdaptor::valueInterface(QAccessibleInterface *interface, const QString qCDebug(lcAccessibilityAtspi) << "WARNING: AtSpiAdaptor::valueInterface does not implement " << function << message.path(); return false; } - if (!value.canConvert(QVariant::Double)) { + if (!value.canConvert(QMetaType::Double)) { qCDebug(lcAccessibilityAtspi) << "AtSpiAdaptor::valueInterface: Could not convert to double: " << function; } diff --git a/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp b/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp index 70d5616075..36d9e4e065 100644 --- a/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp +++ b/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp @@ -517,7 +517,7 @@ QFont *QKdeThemePrivate::kdeFont(const QVariant &fontValue) // causing recursion. QString fontDescription; QString fontFamily; - if (fontValue.type() == QVariant::StringList) { + if (fontValue.userType() == QMetaType::QStringList) { const QStringList list = fontValue.toStringList(); if (!list.isEmpty()) { fontFamily = list.first(); diff --git a/src/plugins/generic/tuiotouch/qtuiohandler.cpp b/src/plugins/generic/tuiotouch/qtuiohandler.cpp index cb82672acd..6ad4597b19 100644 --- a/src/plugins/generic/tuiotouch/qtuiohandler.cpp +++ b/src/plugins/generic/tuiotouch/qtuiohandler.cpp @@ -226,7 +226,7 @@ void QTuioHandler::process2DCurSource(const QOscMessage &message) return; } - if (QMetaType::Type(arguments.at(1).type()) != QMetaType::QByteArray) { + if (QMetaType::Type(arguments.at(1).userType()) != QMetaType::QByteArray) { qCWarning(lcTuioSource, "Ignoring malformed TUIO source message (bad argument type)"); return; } @@ -248,7 +248,7 @@ void QTuioHandler::process2DCurAlive(const QOscMessage &message) QMap newActiveCursors; for (int i = 1; i < arguments.count(); ++i) { - if (QMetaType::Type(arguments.at(i).type()) != QMetaType::Int) { + if (QMetaType::Type(arguments.at(i).userType()) != QMetaType::Int) { qCWarning(lcTuioHandler) << "Ignoring malformed TUIO alive message (bad argument on position" << i << arguments << ')'; return; } @@ -293,12 +293,12 @@ void QTuioHandler::process2DCurSet(const QOscMessage &message) return; } - if (QMetaType::Type(arguments.at(1).type()) != QMetaType::Int || - QMetaType::Type(arguments.at(2).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(3).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(4).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(5).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(6).type()) != QMetaType::Float + if (QMetaType::Type(arguments.at(1).userType()) != QMetaType::Int || + QMetaType::Type(arguments.at(2).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(3).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(4).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(5).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(6).userType()) != QMetaType::Float ) { qCWarning(lcTuioSet) << "Ignoring malformed TUIO set message with bad types: " << arguments; return; @@ -391,7 +391,7 @@ void QTuioHandler::process2DObjSource(const QOscMessage &message) return; } - if (QMetaType::Type(arguments.at(1).type()) != QMetaType::QByteArray) { + if (QMetaType::Type(arguments.at(1).userType()) != QMetaType::QByteArray) { qCWarning(lcTuioSource, "Ignoring malformed TUIO source message (bad argument type)"); return; } @@ -413,7 +413,7 @@ void QTuioHandler::process2DObjAlive(const QOscMessage &message) QMap newActiveTokens; for (int i = 1; i < arguments.count(); ++i) { - if (QMetaType::Type(arguments.at(i).type()) != QMetaType::Int) { + if (QMetaType::Type(arguments.at(i).userType()) != QMetaType::Int) { qCWarning(lcTuioHandler) << "Ignoring malformed TUIO alive message (bad argument on position" << i << arguments << ')'; return; } @@ -458,16 +458,16 @@ void QTuioHandler::process2DObjSet(const QOscMessage &message) return; } - if (QMetaType::Type(arguments.at(1).type()) != QMetaType::Int || - QMetaType::Type(arguments.at(2).type()) != QMetaType::Int || - QMetaType::Type(arguments.at(3).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(4).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(5).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(6).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(7).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(8).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(9).type()) != QMetaType::Float || - QMetaType::Type(arguments.at(10).type()) != QMetaType::Float) { + if (QMetaType::Type(arguments.at(1).userType()) != QMetaType::Int || + QMetaType::Type(arguments.at(2).userType()) != QMetaType::Int || + QMetaType::Type(arguments.at(3).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(4).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(5).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(6).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(7).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(8).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(9).userType()) != QMetaType::Float || + QMetaType::Type(arguments.at(10).userType()) != QMetaType::Float) { qCWarning(lcTuioSet) << "Ignoring malformed TUIO set message with bad types: " << arguments; return; } diff --git a/src/plugins/platforms/xcb/qxcbclipboard.cpp b/src/plugins/platforms/xcb/qxcbclipboard.cpp index c2d9d060fb..fe9ddfece7 100644 --- a/src/plugins/platforms/xcb/qxcbclipboard.cpp +++ b/src/plugins/platforms/xcb/qxcbclipboard.cpp @@ -123,8 +123,9 @@ protected: return list.contains(format); } - QVariant retrieveData_sys(const QString &fmt, QVariant::Type requestedType) const override + QVariant retrieveData_sys(const QString &fmt, QVariant::Type type) const override { + auto requestedType = QMetaType::Type(type); if (fmt.isEmpty() || isEmpty()) return QByteArray(); diff --git a/src/plugins/platforms/xcb/qxcbdrag.cpp b/src/plugins/platforms/xcb/qxcbdrag.cpp index 47d58fa880..e76fc8bd40 100644 --- a/src/plugins/platforms/xcb/qxcbdrag.cpp +++ b/src/plugins/platforms/xcb/qxcbdrag.cpp @@ -114,7 +114,7 @@ protected: QStringList formats_sys() const override; QVariant retrieveData_sys(const QString &mimeType, QVariant::Type type) const override; - QVariant xdndObtainData(const QByteArray &format, QVariant::Type requestedType) const; + QVariant xdndObtainData(const QByteArray &format, QMetaType::Type requestedType) const; QXcbDrag *drag; }; @@ -1248,11 +1248,11 @@ QXcbDropData::~QXcbDropData() QVariant QXcbDropData::retrieveData_sys(const QString &mimetype, QVariant::Type requestedType) const { QByteArray mime = mimetype.toLatin1(); - QVariant data = xdndObtainData(mime, requestedType); + QVariant data = xdndObtainData(mime, QMetaType::Type(requestedType)); return data; } -QVariant QXcbDropData::xdndObtainData(const QByteArray &format, QVariant::Type requestedType) const +QVariant QXcbDropData::xdndObtainData(const QByteArray &format, QMetaType::Type requestedType) const { QByteArray result; diff --git a/src/plugins/platforms/xcb/qxcbmime.cpp b/src/plugins/platforms/xcb/qxcbmime.cpp index d611f86a9c..0b3219f792 100644 --- a/src/plugins/platforms/xcb/qxcbmime.cpp +++ b/src/plugins/platforms/xcb/qxcbmime.cpp @@ -159,7 +159,7 @@ QVector QXcbMime::mimeAtomsForFormat(QXcbConnection *connection, con } QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, const QByteArray &d, const QString &format, - QVariant::Type requestedType, const QByteArray &encoding) + QMetaType::Type requestedType, const QByteArray &encoding) { QByteArray data = d; QString atomName = mimeAtomToString(connection, a); @@ -169,7 +169,7 @@ QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, && atomName == format + QLatin1String(";charset=") + QLatin1String(encoding)) { #if QT_CONFIG(textcodec) - if (requestedType == QVariant::String) { + if (requestedType == QMetaType::QString) { QTextCodec *codec = QTextCodec::codecForName(encoding); if (codec) return codec->toUnicode(data); @@ -264,7 +264,7 @@ QVariant QXcbMime::mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, return QVariant(); } -xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString &format, QVariant::Type requestedType, +xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString &format, QMetaType::Type requestedType, const QVector &atoms, QByteArray *requestedEncoding) { requestedEncoding->clear(); @@ -297,7 +297,7 @@ xcb_atom_t QXcbMime::mimeAtomForFormat(QXcbConnection *connection, const QString // for string/text requests try to use a format with a well-defined charset // first to avoid encoding problems - if (requestedType == QVariant::String + if (requestedType == QMetaType::QString && format.startsWith(QLatin1String("text/")) && !format.contains(QLatin1String("charset="))) { diff --git a/src/plugins/platforms/xcb/qxcbmime.h b/src/plugins/platforms/xcb/qxcbmime.h index f2136ec9f4..dcb4f6b6c6 100644 --- a/src/plugins/platforms/xcb/qxcbmime.h +++ b/src/plugins/platforms/xcb/qxcbmime.h @@ -60,8 +60,8 @@ public: static bool mimeDataForAtom(QXcbConnection *connection, xcb_atom_t a, QMimeData *mimeData, QByteArray *data, xcb_atom_t *atomFormat, int *dataFormat); static QVariant mimeConvertToFormat(QXcbConnection *connection, xcb_atom_t a, const QByteArray &data, const QString &format, - QVariant::Type requestedType, const QByteArray &encoding); - static xcb_atom_t mimeAtomForFormat(QXcbConnection *connection, const QString &format, QVariant::Type requestedType, + QMetaType::Type requestedType, const QByteArray &encoding); + static xcb_atom_t mimeAtomForFormat(QXcbConnection *connection, const QString &format, QMetaType::Type requestedType, const QVector &atoms, QByteArray *requestedEncoding); }; diff --git a/src/plugins/sqldrivers/ibase/qsql_ibase.cpp b/src/plugins/sqldrivers/ibase/qsql_ibase.cpp index d0928fe6ab..7bacb59994 100644 --- a/src/plugins/sqldrivers/ibase/qsql_ibase.cpp +++ b/src/plugins/sqldrivers/ibase/qsql_ibase.cpp @@ -730,7 +730,7 @@ static char* createArrayBuffer(char *buffer, const QList &list, if (curDim != dim) { for(i = 0; i < list.size(); ++i) { - if (list.at(i).type() != QVariant::List) { // dimensions mismatch + if (list.at(i).userType() != QVariant::List) { // dimensions mismatch error = QLatin1String("Array dimensons mismatch. Fieldname: %1"); return 0; } @@ -1162,7 +1162,7 @@ bool QIBaseResult::gotoNext(QSqlCachedResult::ValueCache& row, int rowIdx) // null value QVariant v; v.convert(qIBaseTypeName2(d->sqlda->sqlvar[i].sqltype, d->sqlda->sqlvar[i].sqlscale < 0)); - if(v.type() == QVariant::Double) { + if (v.userType() == QVariant::Double) { switch(numericalPrecisionPolicy()) { case QSql::LowPrecisionInt32: v.convert(QVariant::Int); diff --git a/src/plugins/sqldrivers/mysql/qsql_mysql.cpp b/src/plugins/sqldrivers/mysql/qsql_mysql.cpp index 0e195cfdb4..90a810d516 100644 --- a/src/plugins/sqldrivers/mysql/qsql_mysql.cpp +++ b/src/plugins/sqldrivers/mysql/qsql_mysql.cpp @@ -223,13 +223,13 @@ public: { QMyField() : outField(0), nullIndicator(false), bufLength(0ul), - myField(0), type(QVariant::Invalid) + myField(0), type(QMetaType::UnknownType) {} char *outField; my_bool nullIndicator; ulong bufLength; MYSQL_FIELD *myField; - QVariant::Type type; + QMetaType::Type type; }; QVector fields; @@ -263,25 +263,25 @@ static QSqlError qMakeError(const QString& err, QSqlError::ErrorType type, } -static QVariant::Type qDecodeMYSQLType(int mysqltype, uint flags) +static QMetaType::Type qDecodeMYSQLType(int mysqltype, uint flags) { - QVariant::Type type; + QMetaType::Type type; switch (mysqltype) { case FIELD_TYPE_TINY : - type = static_cast((flags & UNSIGNED_FLAG) ? QMetaType::UChar : QMetaType::Char); + type = (flags & UNSIGNED_FLAG) ? QMetaType::UChar : QMetaType::Char; break; case FIELD_TYPE_SHORT : - type = static_cast((flags & UNSIGNED_FLAG) ? QMetaType::UShort : QMetaType::Short); + type = (flags & UNSIGNED_FLAG) ? QMetaType::UShort : QMetaType::Short; break; case FIELD_TYPE_LONG : case FIELD_TYPE_INT24 : - type = (flags & UNSIGNED_FLAG) ? QVariant::UInt : QVariant::Int; + type = (flags & UNSIGNED_FLAG) ? QMetaType::UInt : QMetaType::Int; break; case FIELD_TYPE_YEAR : - type = QVariant::Int; + type = QMetaType::Int; break; case FIELD_TYPE_LONGLONG : - type = (flags & UNSIGNED_FLAG) ? QVariant::ULongLong : QVariant::LongLong; + type = (flags & UNSIGNED_FLAG) ? QMetaType::ULongLong : QMetaType::LongLong; break; case FIELD_TYPE_FLOAT : case FIELD_TYPE_DOUBLE : @@ -289,19 +289,19 @@ static QVariant::Type qDecodeMYSQLType(int mysqltype, uint flags) #if defined(FIELD_TYPE_NEWDECIMAL) case FIELD_TYPE_NEWDECIMAL: #endif - type = QVariant::Double; + type = QMetaType::Double; break; case FIELD_TYPE_DATE : - type = QVariant::Date; + type = QMetaType::QDate; break; case FIELD_TYPE_TIME : // A time field can be within the range '-838:59:59' to '838:59:59' so // use QString instead of QTime since QTime is limited to 24 hour clock - type = QVariant::String; + type = QMetaType::QString; break; case FIELD_TYPE_DATETIME : case FIELD_TYPE_TIMESTAMP : - type = QVariant::DateTime; + type = QMetaType::QDateTime; break; case FIELD_TYPE_STRING : case FIELD_TYPE_VAR_STRING : @@ -309,12 +309,12 @@ static QVariant::Type qDecodeMYSQLType(int mysqltype, uint flags) case FIELD_TYPE_TINY_BLOB : case FIELD_TYPE_MEDIUM_BLOB : case FIELD_TYPE_LONG_BLOB : - type = (flags & BINARY_FLAG) ? QVariant::ByteArray : QVariant::String; + type = (flags & BINARY_FLAG) ? QMetaType::QByteArray : QMetaType::QString; break; default: case FIELD_TYPE_ENUM : case FIELD_TYPE_SET : - type = QVariant::String; + type = QMetaType::QString; break; } return type; @@ -323,7 +323,7 @@ static QVariant::Type qDecodeMYSQLType(int mysqltype, uint flags) static QSqlField qToField(MYSQL_FIELD *field, QTextCodec *tc) { QSqlField f(toUnicode(tc, field->name), - qDecodeMYSQLType(int(field->type), field->flags), + QVariant::Type(qDecodeMYSQLType(int(field->type), field->flags)), toUnicode(tc, field->table)); f.setRequired(IS_NOT_NULL(field->flags)); f.setLength(field->length); @@ -610,7 +610,7 @@ QVariant QMYSQLResult::data(int field) QString val; if (d->preparedQuery) { if (f.nullIndicator) - return QVariant(f.type); + return QVariant(QVariant::Type(f.type)); if (qIsInteger(f.type)) { QVariant variant(f.type, f.outField); @@ -622,34 +622,34 @@ QVariant QMYSQLResult::data(int field) return variant; } - if (f.type != QVariant::ByteArray) + if (f.type != QMetaType::QByteArray) val = toUnicode(d->drv_d_func()->tc, f.outField, f.bufLength); } else { if (d->row[field] == NULL) { // NULL value - return QVariant(f.type); + return QVariant(QVariant::Type(f.type)); } fieldLength = mysql_fetch_lengths(d->result)[field]; - if (f.type != QVariant::ByteArray) + if (f.type != QMetaType::QByteArray) val = toUnicode(d->drv_d_func()->tc, d->row[field], fieldLength); } switch (static_cast(f.type)) { - case QVariant::LongLong: + case QMetaType::LongLong: return QVariant(val.toLongLong()); - case QVariant::ULongLong: + case QMetaType::ULongLong: return QVariant(val.toULongLong()); case QMetaType::Char: case QMetaType::Short: - case QVariant::Int: + case QMetaType::Int: return QVariant(val.toInt()); case QMetaType::UChar: case QMetaType::UShort: - case QVariant::UInt: + case QMetaType::UInt: return QVariant(val.toUInt()); - case QVariant::Double: { + case QMetaType::Double: { QVariant v; bool ok=false; double dbl = val.toDouble(&ok); @@ -673,13 +673,13 @@ QVariant QMYSQLResult::data(int field) return v; return QVariant(); } - case QVariant::Date: + case QMetaType::QDate: return qDateFromString(val); - case QVariant::Time: + case QMetaType::QTime: return qTimeFromString(val); - case QVariant::DateTime: + case QMetaType::QDateTime: return qDateTimeFromString(val); - case QVariant::ByteArray: { + case QMetaType::QByteArray: { QByteArray ba; if (d->preparedQuery) { @@ -689,7 +689,7 @@ QVariant QMYSQLResult::data(int field) } return QVariant(ba); } - case QVariant::String: + case QMetaType::QString: default: return QVariant(val); } @@ -867,21 +867,21 @@ void QMYSQLResult::virtual_hook(int id, void *data) QSqlResult::virtual_hook(id, data); } -static MYSQL_TIME *toMySqlDate(QDate date, QTime time, QVariant::Type type) +static MYSQL_TIME *toMySqlDate(QDate date, QTime time, int type) { - Q_ASSERT(type == QVariant::Time || type == QVariant::Date - || type == QVariant::DateTime); + Q_ASSERT(type == QMetaType::QTime || type == QMetaType::QDate + || type == QMetaType::QDateTime); MYSQL_TIME *myTime = new MYSQL_TIME; memset(myTime, 0, sizeof(MYSQL_TIME)); - if (type == QVariant::Time || type == QVariant::DateTime) { + if (type == QMetaType::QTime || type == QMetaType::QDateTime) { myTime->hour = time.hour(); myTime->minute = time.minute(); myTime->second = time.second(); myTime->second_part = time.msec() * 1000; } - if (type == QVariant::Date || type == QVariant::DateTime) { + if (type == QMetaType::QDate || type == QMetaType::QDateTime) { myTime->year = date.year(); myTime->month = date.month(); myTime->day = date.day(); @@ -971,30 +971,30 @@ bool QMYSQLResult::exec() currBind->length = 0; currBind->is_unsigned = 0; - switch (val.type()) { - case QVariant::ByteArray: + switch (val.userType()) { + case QMetaType::QByteArray: currBind->buffer_type = MYSQL_TYPE_BLOB; currBind->buffer = const_cast(val.toByteArray().constData()); currBind->buffer_length = val.toByteArray().size(); break; - case QVariant::Time: - case QVariant::Date: - case QVariant::DateTime: { - MYSQL_TIME *myTime = toMySqlDate(val.toDate(), val.toTime(), val.type()); + case QMetaType::QTime: + case QMetaType::QDate: + case QMetaType::QDateTime: { + MYSQL_TIME *myTime = toMySqlDate(val.toDate(), val.toTime(), val.userType()); timeVector.append(myTime); currBind->buffer = myTime; - switch(val.type()) { - case QVariant::Time: + switch (val.userType()) { + case QMetaType::QTime: currBind->buffer_type = MYSQL_TYPE_TIME; myTime->time_type = MYSQL_TIMESTAMP_TIME; break; - case QVariant::Date: + case QMetaType::QDate: currBind->buffer_type = MYSQL_TYPE_DATE; myTime->time_type = MYSQL_TIMESTAMP_DATE; break; - case QVariant::DateTime: + case QMetaType::QDateTime: currBind->buffer_type = MYSQL_TYPE_DATETIME; myTime->time_type = MYSQL_TIMESTAMP_DATETIME; break; @@ -1004,32 +1004,32 @@ bool QMYSQLResult::exec() currBind->buffer_length = sizeof(MYSQL_TIME); currBind->length = 0; break; } - case QVariant::UInt: - case QVariant::Int: + case QMetaType::UInt: + case QMetaType::Int: currBind->buffer_type = MYSQL_TYPE_LONG; currBind->buffer = data; currBind->buffer_length = sizeof(int); - currBind->is_unsigned = (val.type() != QVariant::Int); + currBind->is_unsigned = (val.userType() != QMetaType::Int); break; - case QVariant::Bool: + case QMetaType::Bool: currBind->buffer_type = MYSQL_TYPE_TINY; currBind->buffer = data; currBind->buffer_length = sizeof(bool); currBind->is_unsigned = false; break; - case QVariant::Double: + case QMetaType::Double: currBind->buffer_type = MYSQL_TYPE_DOUBLE; currBind->buffer = data; currBind->buffer_length = sizeof(double); break; - case QVariant::LongLong: - case QVariant::ULongLong: + case QMetaType::LongLong: + case QMetaType::ULongLong: currBind->buffer_type = MYSQL_TYPE_LONGLONG; currBind->buffer = data; currBind->buffer_length = sizeof(qint64); - currBind->is_unsigned = (val.type() == QVariant::ULongLong); + currBind->is_unsigned = (val.userType() == QMetaType::ULongLong); break; - case QVariant::String: + case QMetaType::QString: default: { QByteArray ba = fromUnicode(d->drv_d_func()->tc, val.toString()); stringVector.append(ba); @@ -1548,16 +1548,16 @@ QString QMYSQLDriver::formatValue(const QSqlField &field, bool trimStrings) cons if (field.isNull()) { r = QStringLiteral("NULL"); } else { - switch(field.type()) { - case QVariant::Double: + switch (+field.type()) { + case QMetaType::Double: r = QString::number(field.value().toDouble(), 'g', field.precision()); break; - case QVariant::String: + case QMetaType::QString: // Escape '\' characters r = QSqlDriver::formatValue(field, trimStrings); r.replace(QLatin1String("\\"), QLatin1String("\\\\")); break; - case QVariant::ByteArray: + case QMetaType::QByteArray: if (isOpen()) { const QByteArray ba = field.value().toByteArray(); // buffer has to be at least length*2+1 bytes diff --git a/src/plugins/sqldrivers/odbc/qsql_odbc.cpp b/src/plugins/sqldrivers/odbc/qsql_odbc.cpp index 7709b13cd1..33bad23e3b 100644 --- a/src/plugins/sqldrivers/odbc/qsql_odbc.cpp +++ b/src/plugins/sqldrivers/odbc/qsql_odbc.cpp @@ -1422,7 +1422,7 @@ bool QODBCResult::exec() SQLLEN *ind = &indicators[i]; if (val.isNull()) *ind = SQL_NULL_DATA; - switch (val.type()) { + switch (val.userType()) { case QVariant::Date: { QByteArray &ba = tmpStorage[i]; ba.resize(sizeof(DATE_STRUCT)); @@ -1694,7 +1694,7 @@ bool QODBCResult::exec() return true; for (i = 0; i < values.count(); ++i) { - switch (values.at(i).type()) { + switch (values.at(i).userType()) { case QVariant::Date: { DATE_STRUCT ds = *((DATE_STRUCT *)const_cast(tmpStorage.at(i).constData())); values[i] = QVariant(QDate(ds.year, ds.month, ds.day)); @@ -1735,7 +1735,7 @@ bool QODBCResult::exec() break; } } if (indicators[i] == SQL_NULL_DATA) - values[i] = QVariant(values[i].type()); + values[i] = QVariant(QVariant::Type(values[i].userType())); } return true; } diff --git a/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp b/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp index 65d3f0a580..551d762434 100644 --- a/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp +++ b/src/plugins/sqldrivers/sqlite/qsql_sqlite.cpp @@ -505,7 +505,7 @@ bool QSQLiteResult::exec() if (value.isNull()) { res = sqlite3_bind_null(d->stmt, i + 1); } else { - switch (value.type()) { + switch (value.userType()) { case QVariant::ByteArray: { const QByteArray *ba = static_cast(value.constData()); res = sqlite3_bind_blob(d->stmt, i + 1, ba->constData(), diff --git a/src/sql/kernel/qsqldriver.cpp b/src/sql/kernel/qsqldriver.cpp index fcd3c70a04..d1c9057aac 100644 --- a/src/sql/kernel/qsqldriver.cpp +++ b/src/sql/kernel/qsqldriver.cpp @@ -612,30 +612,30 @@ QString QSqlDriver::formatValue(const QSqlField &field, bool trimStrings) const if (field.isNull()) r = nullTxt; else { - switch (field.type()) { - case QVariant::Int: - case QVariant::UInt: - if (field.value().type() == QVariant::Bool) + switch (+field.type()) { + case QMetaType::Int: + case QMetaType::UInt: + if (field.value().userType() == QMetaType::Bool) r = field.value().toBool() ? QLatin1String("1") : QLatin1String("0"); else r = field.value().toString(); break; #if QT_CONFIG(datestring) - case QVariant::Date: + case QMetaType::QDate: if (field.value().toDate().isValid()) r = QLatin1Char('\'') + field.value().toDate().toString(Qt::ISODate) + QLatin1Char('\''); else r = nullTxt; break; - case QVariant::Time: + case QMetaType::QTime: if (field.value().toTime().isValid()) r = QLatin1Char('\'') + field.value().toTime().toString(Qt::ISODate) + QLatin1Char('\''); else r = nullTxt; break; - case QVariant::DateTime: + case QMetaType::QDateTime: if (field.value().toDateTime().isValid()) r = QLatin1Char('\'') + field.value().toDateTime().toString(Qt::ISODate) + QLatin1Char('\''); @@ -643,8 +643,8 @@ QString QSqlDriver::formatValue(const QSqlField &field, bool trimStrings) const r = nullTxt; break; #endif - case QVariant::String: - case QVariant::Char: + case QMetaType::QString: + case QMetaType::QChar: { QString result = field.value().toString(); if (trimStrings) { @@ -658,10 +658,10 @@ QString QSqlDriver::formatValue(const QSqlField &field, bool trimStrings) const r = QLatin1Char('\'') + result + QLatin1Char('\''); break; } - case QVariant::Bool: + case QMetaType::Bool: r = QString::number(field.value().toBool()); break; - case QVariant::ByteArray : { + case QMetaType::QByteArray : { if (hasFeature(BLOB)) { QByteArray ba = field.value().toByteArray(); QString res; diff --git a/src/sql/kernel/qsqlfield.cpp b/src/sql/kernel/qsqlfield.cpp index 5a6d173b3b..86a22bae10 100644 --- a/src/sql/kernel/qsqlfield.cpp +++ b/src/sql/kernel/qsqlfield.cpp @@ -48,7 +48,7 @@ class QSqlFieldPrivate public: QSqlFieldPrivate(const QString &name, QVariant::Type type, const QString &tableName) : - ref(1), nm(name), table(tableName), def(QVariant()), type(type), + ref(1), nm(name), table(tableName), def(QVariant()), type(QMetaType::Type(type)), req(QSqlField::Unknown), len(-1), prec(-1), tp(-1), ro(false), gen(true), autoval(false) {} @@ -86,7 +86,7 @@ public: QString nm; QString table; QVariant def; - QVariant::Type type; + QMetaType::Type type; QSqlField::RequiredStatus req; int len; int prec; @@ -399,7 +399,7 @@ QString QSqlField::name() const */ QVariant::Type QSqlField::type() const { - return d->type; + return QVariant::Type(d->type); } /*! @@ -411,12 +411,11 @@ QVariant::Type QSqlField::type() const void QSqlField::setType(QVariant::Type type) { detach(); - d->type = type; + d->type = QMetaType::Type(type); if (!val.isValid()) val = QVariant(type); } - /*! Returns \c true if the field's value is read-only; otherwise returns false. @@ -526,7 +525,7 @@ bool QSqlField::isGenerated() const */ bool QSqlField::isValid() const { - return d->type != QVariant::Invalid; + return d->type != QMetaType::UnknownType; } #ifndef QT_NO_DEBUG_STREAM diff --git a/src/sql/kernel/qsqlfield.h b/src/sql/kernel/qsqlfield.h index 8650ba8715..892420d26e 100644 --- a/src/sql/kernel/qsqlfield.h +++ b/src/sql/kernel/qsqlfield.h @@ -55,7 +55,7 @@ public: enum RequiredStatus { Unknown = -1, Optional = 0, Required = 1 }; explicit QSqlField(const QString& fieldName = QString(), - QVariant::Type type = QVariant::Invalid); + QVariant::Type type = {}); QSqlField(const QString &fieldName, QVariant::Type type, const QString &tableName); diff --git a/src/sql/kernel/qsqlresult.cpp b/src/sql/kernel/qsqlresult.cpp index cc91c6d0ed..a41b3d8424 100644 --- a/src/sql/kernel/qsqlresult.cpp +++ b/src/sql/kernel/qsqlresult.cpp @@ -645,7 +645,7 @@ bool QSqlResult::exec() for (i = d->holders.count() - 1; i >= 0; --i) { holder = d->holders.at(i).holderName; val = d->values.value(d->indexes.value(holder).value(0,-1)); - QSqlField f(QLatin1String(""), val.type()); + QSqlField f(QLatin1String(""), QVariant::Type(val.userType())); f.setValue(val); query = query.replace(d->holders.at(i).holderPos, holder.length(), driver()->formatValue(f)); @@ -659,7 +659,7 @@ bool QSqlResult::exec() if (i == -1) continue; QVariant var = d->values.value(idx); - QSqlField f(QLatin1String(""), var.type()); + QSqlField f(QLatin1String(""), QVariant::Type(var.userType())); if (var.isNull()) f.clear(); else diff --git a/src/testlib/qtest.h b/src/testlib/qtest.h index 3b1ffb389e..0298ff96e3 100644 --- a/src/testlib/qtest.h +++ b/src/testlib/qtest.h @@ -218,7 +218,7 @@ template<> inline char *toString(const QVariant &v) vstring.append(type); if (!v.isNull()) { vstring.append(','); - if (v.canConvert(QVariant::String)) { + if (v.canConvert(QMetaType::QString)) { vstring.append(v.toString().toLocal8Bit()); } else { diff --git a/src/testlib/qtestlog.cpp b/src/testlib/qtestlog.cpp index f3ebf343c5..2776740784 100644 --- a/src/testlib/qtestlog.cpp +++ b/src/testlib/qtestlog.cpp @@ -152,7 +152,7 @@ namespace QTest { inline bool matches(QtMsgType tp, const QString &message) const { return tp == type - && (pattern.type() == QVariant::String ? + && (pattern.userType() == QMetaType::QString ? stringsMatch(pattern.toString(), message) : #if QT_CONFIG(regularexpression) pattern.toRegularExpression().match(message).hasMatch()); @@ -292,7 +292,7 @@ void QTestLog::printUnhandledIgnoreMessages() QString message; QTest::IgnoreResultList *list = QTest::ignoreResultList; while (list) { - if (list->pattern.type() == QVariant::String) { + if (list->pattern.userType() == QMetaType::QString) { message = QStringLiteral("Did not receive message: \"") + list->pattern.toString() + QLatin1Char('"'); } else { #if QT_CONFIG(regularexpression) diff --git a/src/tools/qdbuscpp2xml/qdbuscpp2xml.cpp b/src/tools/qdbuscpp2xml/qdbuscpp2xml.cpp index 81ebafad79..768594efb4 100644 --- a/src/tools/qdbuscpp2xml/qdbuscpp2xml.cpp +++ b/src/tools/qdbuscpp2xml/qdbuscpp2xml.cpp @@ -115,7 +115,7 @@ static QString addFunction(const FunctionDef &mm, bool isSignal = false) { .arg(typeNameToXml(typeName)); // do we need to describe this argument? - if (QDBusMetaType::signatureToType(typeName) == QVariant::Invalid) + if (QDBusMetaType::signatureToType(typeName) == QMetaType::UnknownType) xml += QString::fromLatin1(" \n") .arg(typeNameToXml(mm.normalizedType.constData())); } else { @@ -159,7 +159,7 @@ static QString addFunction(const FunctionDef &mm, bool isSignal = false) { isOutput ? QLatin1String("out") : QLatin1String("in")); // do we need to describe this argument? - if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { + if (QDBusMetaType::signatureToType(signature) == QMetaType::UnknownType) { const char *typeName = QMetaType::typeName(types.at(j)); xml += QString::fromLatin1(" \n") .arg(isOutput ? QLatin1String("Out") : QLatin1String("In")) @@ -225,7 +225,7 @@ static QString generateInterfaceXml(const ClassDef *mo) QLatin1String(signature), QLatin1String(accessvalues[access])); - if (QDBusMetaType::signatureToType(signature) == QVariant::Invalid) { + if (QDBusMetaType::signatureToType(signature) == QMetaType::UnknownType) { retval += QString::fromLatin1(">\n \n \n") .arg(typeNameToXml(mp.type.constData())); } else { diff --git a/src/tools/qdbusxml2cpp/qdbusxml2cpp.cpp b/src/tools/qdbusxml2cpp/qdbusxml2cpp.cpp index 9cf753a3f1..9825596f3d 100644 --- a/src/tools/qdbusxml2cpp/qdbusxml2cpp.cpp +++ b/src/tools/qdbusxml2cpp/qdbusxml2cpp.cpp @@ -211,7 +211,7 @@ static QString classNameForInterface(const QString &interface, ClassType classTy static QByteArray qtTypeName(const QString &signature, const QDBusIntrospection::Annotations &annotations, int paramId = -1, const char *direction = "Out", bool isSignal = false) { int type = QDBusMetaType::signatureToType(signature.toLatin1()); - if (type == QVariant::Invalid) { + if (type == QMetaType::UnknownType) { QString annotationName = QString::fromLatin1("org.qtproject.QtDBus.QtTypeName"); if (paramId >= 0) annotationName += QString::fromLatin1(".%1%2").arg(QLatin1String(direction)).arg(paramId); diff --git a/src/widgets/dialogs/qsidebar.cpp b/src/widgets/dialogs/qsidebar.cpp index dfb707eda0..4272b612ec 100644 --- a/src/widgets/dialogs/qsidebar.cpp +++ b/src/widgets/dialogs/qsidebar.cpp @@ -163,7 +163,7 @@ bool QUrlModel::dropMimeData(const QMimeData *data, Qt::DropAction action, */ bool QUrlModel::setData(const QModelIndex &index, const QVariant &value, int role) { - if (value.type() == QVariant::Url) { + if (value.userType() == QMetaType::QUrl) { QUrl url = value.toUrl(); QModelIndex dirIndex = fileSystemModel->index(url.toLocalFile()); //On windows the popup display the "C:\", convert to nativeSeparators diff --git a/src/widgets/graphicsview/qgraphicsitem.cpp b/src/widgets/graphicsview/qgraphicsitem.cpp index 6f1eb4b346..a2120e53fe 100644 --- a/src/widgets/graphicsview/qgraphicsitem.cpp +++ b/src/widgets/graphicsview/qgraphicsitem.cpp @@ -10511,13 +10511,13 @@ QVariant QGraphicsTextItem::inputMethodQuery(Qt::InputMethodQuery query) const v = int(inputMethodHints()); else if (dd->control) v = dd->control->inputMethodQuery(query, QVariant()); - if (v.type() == QVariant::RectF) + if (v.userType() == QMetaType::QRectF) v = v.toRectF().translated(-dd->controlOffset()); - else if (v.type() == QVariant::PointF) + else if (v.userType() == QMetaType::QPointF) v = v.toPointF() - dd->controlOffset(); - else if (v.type() == QVariant::Rect) + else if (v.userType() == QMetaType::QRect) v = v.toRect().translated(-dd->controlOffset().toPoint()); - else if (v.type() == QVariant::Point) + else if (v.userType() == QMetaType::QPoint) v = v.toPoint() - dd->controlOffset().toPoint(); return v; } diff --git a/src/widgets/graphicsview/qgraphicsproxywidget.cpp b/src/widgets/graphicsview/qgraphicsproxywidget.cpp index 4d4958c674..eb8acf1f27 100644 --- a/src/widgets/graphicsview/qgraphicsproxywidget.cpp +++ b/src/widgets/graphicsview/qgraphicsproxywidget.cpp @@ -1441,17 +1441,17 @@ QVariant QGraphicsProxyWidget::inputMethodQuery(Qt::InputMethodQuery query) cons focusWidget = d->widget; QVariant v = focusWidget->inputMethodQuery(query); QPointF focusWidgetPos = subWidgetRect(focusWidget).topLeft(); - switch (v.type()) { - case QVariant::RectF: + switch (v.userType()) { + case QMetaType::QRectF: v = v.toRectF().translated(focusWidgetPos); break; - case QVariant::PointF: + case QMetaType::QPointF: v = v.toPointF() + focusWidgetPos; break; - case QVariant::Rect: + case QMetaType::QRect: v = v.toRect().translated(focusWidgetPos.toPoint()); break; - case QVariant::Point: + case QMetaType::QPoint: v = v.toPoint() + focusWidgetPos.toPoint(); break; default: diff --git a/src/widgets/graphicsview/qgraphicsscene.cpp b/src/widgets/graphicsview/qgraphicsscene.cpp index 1c6e68def1..1cb24f74b6 100644 --- a/src/widgets/graphicsview/qgraphicsscene.cpp +++ b/src/widgets/graphicsview/qgraphicsscene.cpp @@ -3190,13 +3190,13 @@ QVariant QGraphicsScene::inputMethodQuery(Qt::InputMethodQuery query) const return QVariant(); const QTransform matrix = d->focusItem->sceneTransform(); QVariant value = d->focusItem->inputMethodQuery(query); - if (value.type() == QVariant::RectF) + if (value.userType() == QMetaType::QRectF) value = matrix.mapRect(value.toRectF()); - else if (value.type() == QVariant::PointF) + else if (value.userType() == QMetaType::QPointF) value = matrix.map(value.toPointF()); - else if (value.type() == QVariant::Rect) + else if (value.userType() == QMetaType::QRect) value = matrix.mapRect(value.toRect()); - else if (value.type() == QVariant::Point) + else if (value.userType() == QMetaType::QPoint) value = matrix.map(value.toPoint()); return value; } diff --git a/src/widgets/graphicsview/qgraphicsview.cpp b/src/widgets/graphicsview/qgraphicsview.cpp index 7589a1ebbd..e1a829f779 100644 --- a/src/widgets/graphicsview/qgraphicsview.cpp +++ b/src/widgets/graphicsview/qgraphicsview.cpp @@ -2589,13 +2589,13 @@ QVariant QGraphicsView::inputMethodQuery(Qt::InputMethodQuery query) const return QVariant(); QVariant value = d->scene->inputMethodQuery(query); - if (value.type() == QVariant::RectF) + if (value.userType() == QMetaType::QRectF) value = d->mapRectFromScene(value.toRectF()); - else if (value.type() == QVariant::PointF) + else if (value.userType() == QMetaType::QPointF) value = mapFromScene(value.toPointF()); - else if (value.type() == QVariant::Rect) + else if (value.userType() == QMetaType::QRect) value = d->mapRectFromScene(value.toRect()).toRect(); - else if (value.type() == QVariant::Point) + else if (value.userType() == QMetaType::QPoint) value = mapFromScene(value.toPoint()); return value; } diff --git a/src/widgets/itemviews/qabstractitemdelegate.cpp b/src/widgets/itemviews/qabstractitemdelegate.cpp index bb47881c03..c5b22b5667 100644 --- a/src/widgets/itemviews/qabstractitemdelegate.cpp +++ b/src/widgets/itemviews/qabstractitemdelegate.cpp @@ -585,27 +585,27 @@ QString QAbstractItemDelegatePrivate::textForRole(Qt::ItemDataRole role, const Q case QMetaType::Float: text = locale.toString(value.toFloat()); break; - case QVariant::Double: + case QMetaType::Double: text = locale.toString(value.toDouble(), 'g', precision); break; - case QVariant::Int: - case QVariant::LongLong: + case QMetaType::Int: + case QMetaType::LongLong: text = locale.toString(value.toLongLong()); break; - case QVariant::UInt: - case QVariant::ULongLong: + case QMetaType::UInt: + case QMetaType::ULongLong: text = locale.toString(value.toULongLong()); break; - case QVariant::Date: + case QMetaType::QDate: text = locale.toString(value.toDate(), formatType); break; - case QVariant::Time: + case QMetaType::QTime: text = locale.toString(value.toTime(), formatType); break; - case QVariant::DateTime: + case QMetaType::QDateTime: text = locale.toString(value.toDateTime(), formatType); break; - case QVariant::Type(QMetaType::QJsonValue): { + case QMetaType::QJsonValue: { const QJsonValue val = value.toJsonValue(); if (val.isBool()) { text = QVariant(val.toBool()).toString(); diff --git a/src/widgets/itemviews/qabstractitemview.cpp b/src/widgets/itemviews/qabstractitemview.cpp index 0e54cf235f..2524d4acfa 100644 --- a/src/widgets/itemviews/qabstractitemview.cpp +++ b/src/widgets/itemviews/qabstractitemview.cpp @@ -2339,7 +2339,7 @@ void QAbstractItemView::keyPressEvent(QKeyEvent *event) QVariant variant; if (d->model) variant = d->model->data(currentIndex(), Qt::DisplayRole); - if (variant.type() == QVariant::String) + if (variant.userType() == QMetaType::QString) QGuiApplication::clipboard()->setText(variant.toString()); event->accept(); } diff --git a/src/widgets/itemviews/qheaderview.cpp b/src/widgets/itemviews/qheaderview.cpp index 790f305463..84e2fd72a9 100644 --- a/src/widgets/itemviews/qheaderview.cpp +++ b/src/widgets/itemviews/qheaderview.cpp @@ -3660,7 +3660,7 @@ void QHeaderViewPrivate::flipSortIndicator(int section) sortOrder = (sortIndicatorOrder == Qt::DescendingOrder) ? Qt::AscendingOrder : Qt::DescendingOrder; } else { const QVariant value = model->headerData(section, orientation, Qt::InitialSortOrderRole); - if (value.canConvert(QVariant::Int)) + if (value.canConvert(QMetaType::Int)) sortOrder = static_cast(value.toInt()); else sortOrder = Qt::AscendingOrder; diff --git a/src/widgets/itemviews/qitemdelegate.cpp b/src/widgets/itemviews/qitemdelegate.cpp index daea907963..4420d39b8e 100644 --- a/src/widgets/itemviews/qitemdelegate.cpp +++ b/src/widgets/itemviews/qitemdelegate.cpp @@ -414,7 +414,7 @@ void QItemDelegate::paint(QPainter *painter, if (value.isValid()) { // ### we need the pixmap to call the virtual function pixmap = decoration(opt, value); - if (value.type() == QVariant::Icon) { + if (value.userType() == QMetaType::QIcon) { d->tmp.icon = qvariant_cast(value); d->tmp.mode = d->iconMode(option.state); d->tmp.state = d->iconState(option.state); @@ -969,12 +969,12 @@ void QItemDelegate::doLayout(const QStyleOptionViewItem &option, QPixmap QItemDelegate::decoration(const QStyleOptionViewItem &option, const QVariant &variant) const { Q_D(const QItemDelegate); - switch (variant.type()) { - case QVariant::Icon: { + switch (variant.userType()) { + case QMetaType::QIcon: { QIcon::Mode mode = d->iconMode(option.state); QIcon::State state = d->iconState(option.state); return qvariant_cast(variant).pixmap(option.decorationSize, mode, state); } - case QVariant::Color: { + case QMetaType::QColor: { static QPixmap pixmap(option.decorationSize); pixmap.fill(qvariant_cast(variant)); return pixmap; } @@ -1060,24 +1060,24 @@ QRect QItemDelegate::rect(const QStyleOptionViewItem &option, if (role == Qt::CheckStateRole) return doCheck(option, option.rect, value); if (value.isValid() && !value.isNull()) { - switch (value.type()) { - case QVariant::Invalid: + switch (value.userType()) { + case QMetaType::UnknownType: break; - case QVariant::Pixmap: { + case QMetaType::QPixmap: { const QPixmap &pixmap = qvariant_cast(value); return QRect(QPoint(0, 0), pixmap.size() / pixmap.devicePixelRatio() ); } - case QVariant::Image: { + case QMetaType::QImage: { const QImage &image = qvariant_cast(value); return QRect(QPoint(0, 0), image.size() / image.devicePixelRatio() ); } - case QVariant::Icon: { + case QMetaType::QIcon: { QIcon::Mode mode = d->iconMode(option.state); QIcon::State state = d->iconState(option.state); QIcon icon = qvariant_cast(value); QSize size = icon.actualSize(option.decorationSize, mode, state); return QRect(QPoint(0, 0), size); } - case QVariant::Color: + case QMetaType::QColor: return QRect(QPoint(0, 0), option.decorationSize); - case QVariant::String: + case QMetaType::QString: default: { const QString text = d->valueToText(value, option); value = index.data(Qt::FontRole); diff --git a/src/widgets/itemviews/qitemeditorfactory.cpp b/src/widgets/itemviews/qitemeditorfactory.cpp index f874597d59..fe9b482122 100644 --- a/src/widgets/itemviews/qitemeditorfactory.cpp +++ b/src/widgets/itemviews/qitemeditorfactory.cpp @@ -241,21 +241,21 @@ QWidget *QDefaultItemEditorFactory::createEditor(int userType, QWidget *parent) { switch (userType) { #if QT_CONFIG(combobox) - case QVariant::Bool: { + case QMetaType::Bool: { QBooleanComboBox *cb = new QBooleanComboBox(parent); cb->setFrame(false); cb->setSizePolicy(QSizePolicy::Ignored, cb->sizePolicy().verticalPolicy()); return cb; } #endif #if QT_CONFIG(spinbox) - case QVariant::UInt: { + case QMetaType::UInt: { QSpinBox *sb = new QUIntSpinBox(parent); sb->setFrame(false); sb->setMinimum(0); sb->setMaximum(INT_MAX); sb->setSizePolicy(QSizePolicy::Ignored, sb->sizePolicy().verticalPolicy()); return sb; } - case QVariant::Int: { + case QMetaType::Int: { QSpinBox *sb = new QSpinBox(parent); sb->setFrame(false); sb->setMinimum(INT_MIN); @@ -264,25 +264,25 @@ QWidget *QDefaultItemEditorFactory::createEditor(int userType, QWidget *parent) return sb; } #endif #if QT_CONFIG(datetimeedit) - case QVariant::Date: { + case QMetaType::QDate: { QDateTimeEdit *ed = new QDateEdit(parent); ed->setFrame(false); return ed; } - case QVariant::Time: { + case QMetaType::QTime: { QDateTimeEdit *ed = new QTimeEdit(parent); ed->setFrame(false); return ed; } - case QVariant::DateTime: { + case QMetaType::QDateTime: { QDateTimeEdit *ed = new QDateTimeEdit(parent); ed->setFrame(false); return ed; } #endif #if QT_CONFIG(label) - case QVariant::Pixmap: + case QMetaType::QPixmap: return new QLabel(parent); #endif #if QT_CONFIG(spinbox) - case QVariant::Double: { + case QMetaType::Double: { QDoubleSpinBox *sb = new QDoubleSpinBox(parent); sb->setFrame(false); sb->setMinimum(-DBL_MAX); @@ -291,7 +291,7 @@ QWidget *QDefaultItemEditorFactory::createEditor(int userType, QWidget *parent) return sb; } #endif #if QT_CONFIG(lineedit) - case QVariant::String: + case QMetaType::QString: default: { // the default editor is a lineedit QExpandingLineEdit *le = new QExpandingLineEdit(parent); @@ -311,24 +311,24 @@ QByteArray QDefaultItemEditorFactory::valuePropertyName(int userType) const { switch (userType) { #if QT_CONFIG(combobox) - case QVariant::Bool: + case QMetaType::Bool: return "currentIndex"; #endif #if QT_CONFIG(spinbox) - case QVariant::UInt: - case QVariant::Int: - case QVariant::Double: + case QMetaType::UInt: + case QMetaType::Int: + case QMetaType::Double: return "value"; #endif #if QT_CONFIG(datetimeedit) - case QVariant::Date: + case QMetaType::QDate: return "date"; - case QVariant::Time: + case QMetaType::QTime: return "time"; - case QVariant::DateTime: + case QMetaType::QDateTime: return "dateTime"; #endif - case QVariant::String: + case QMetaType::QString: default: // the default editor is a lineedit return "text"; diff --git a/src/widgets/itemviews/qstyleditemdelegate.cpp b/src/widgets/itemviews/qstyleditemdelegate.cpp index f42af2ea00..c685cc7f05 100644 --- a/src/widgets/itemviews/qstyleditemdelegate.cpp +++ b/src/widgets/itemviews/qstyleditemdelegate.cpp @@ -302,8 +302,8 @@ void QStyledItemDelegate::initStyleOption(QStyleOptionViewItem *option, value = index.data(Qt::DecorationRole); if (value.isValid() && !value.isNull()) { option->features |= QStyleOptionViewItem::HasDecoration; - switch (value.type()) { - case QVariant::Icon: { + switch (value.userType()) { + case QMetaType::QIcon: { option->icon = qvariant_cast(value); QIcon::Mode mode; if (!(option->state & QStyle::State_Enabled)) @@ -319,19 +319,19 @@ void QStyledItemDelegate::initStyleOption(QStyleOptionViewItem *option, qMin(option->decorationSize.height(), actualSize.height())); break; } - case QVariant::Color: { + case QMetaType::QColor: { QPixmap pixmap(option->decorationSize); pixmap.fill(qvariant_cast(value)); option->icon = QIcon(pixmap); break; } - case QVariant::Image: { + case QMetaType::QImage: { QImage image = qvariant_cast(value); option->icon = QIcon(QPixmap::fromImage(image)); option->decorationSize = image.size() / image.devicePixelRatio(); break; } - case QVariant::Pixmap: { + case QMetaType::QPixmap: { QPixmap pixmap = qvariant_cast(value); option->icon = QIcon(pixmap); option->decorationSize = pixmap.size() / pixmap.devicePixelRatio(); diff --git a/src/widgets/kernel/qsizepolicy.cpp b/src/widgets/kernel/qsizepolicy.cpp index 54bf8fe0dc..c4372a9fbc 100644 --- a/src/widgets/kernel/qsizepolicy.cpp +++ b/src/widgets/kernel/qsizepolicy.cpp @@ -439,7 +439,7 @@ void QSizePolicy::setControlType(ControlType type) noexcept */ QSizePolicy::operator QVariant() const { - return QVariant(QVariant::SizePolicy, this); + return QVariant(QMetaType::QSizePolicy, this); } #ifndef QT_NO_DATASTREAM diff --git a/src/widgets/kernel/qwidgetsvariant.cpp b/src/widgets/kernel/qwidgetsvariant.cpp index 41600d2143..edb166e8d5 100644 --- a/src/widgets/kernel/qwidgetsvariant.cpp +++ b/src/widgets/kernel/qwidgetsvariant.cpp @@ -51,12 +51,12 @@ namespace { static void construct(QVariant::Private *x, const void *copy) { switch (x->type) { - case QVariant::SizePolicy: + case QMetaType::QSizePolicy: v_construct(x, copy); break; default: qWarning("Trying to construct an instance of an invalid type, type id: %i", x->type); - x->type = QVariant::Invalid; + x->type = QMetaType::UnknownType; return; } x->is_null = !copy; @@ -65,7 +65,7 @@ static void construct(QVariant::Private *x, const void *copy) static void clear(QVariant::Private *d) { switch (d->type) { - case QVariant::SizePolicy: + case QMetaType::QSizePolicy: v_clear(d); break; default: @@ -73,7 +73,7 @@ static void clear(QVariant::Private *d) return; } - d->type = QVariant::Invalid; + d->type = QMetaType::UnknownType; d->is_null = true; d->is_shared = false; } @@ -88,7 +88,7 @@ static bool compare(const QVariant::Private *a, const QVariant::Private *b) { Q_ASSERT(a->type == b->type); switch(a->type) { - case QVariant::SizePolicy: + case QMetaType::QSizePolicy: return *v_cast(a) == *v_cast(b); default: Q_ASSERT(false); @@ -111,7 +111,7 @@ static void streamDebug(QDebug dbg, const QVariant &v) { QVariant::Private *d = const_cast(&v.data_ptr()); switch (d->type) { - case QVariant::SizePolicy: + case QMetaType::QSizePolicy: dbg.nospace() << *v_cast(d); break; default: diff --git a/src/widgets/styles/qstylesheetstyle.cpp b/src/widgets/styles/qstylesheetstyle.cpp index 2eccb24431..1e032b237a 100644 --- a/src/widgets/styles/qstylesheetstyle.cpp +++ b/src/widgets/styles/qstylesheetstyle.cpp @@ -1547,11 +1547,10 @@ public: } } } - QString valueStr; - if(value.type() == QVariant::StringList || value.type() == QVariant::List) - valueStr = value.toStringList().join(QLatin1Char(' ')); - else - valueStr = value.toString(); + QString valueStr = (value.userType() == QMetaType::QStringList + || value.userType() == QMetaType::QVariantList) + ? value.toStringList().join(QLatin1Char(' ')) + : value.toString(); cache[name] = valueStr; return valueStr; } @@ -2611,16 +2610,16 @@ void QStyleSheetStyle::setProperties(QWidget *w) QVariant v; const QVariant value = w->property(property.toLatin1()); - switch (value.type()) { - case QVariant::Icon: v = decl.iconValue(); break; - case QVariant::Image: v = QImage(decl.uriValue()); break; - case QVariant::Pixmap: v = QPixmap(decl.uriValue()); break; - case QVariant::Rect: v = decl.rectValue(); break; - case QVariant::Size: v = decl.sizeValue(); break; - case QVariant::Color: v = decl.colorValue(); break; - case QVariant::Brush: v = decl.brushValue(); break; + switch (value.userType()) { + case QMetaType::QIcon: v = decl.iconValue(); break; + case QMetaType::QImage: v = QImage(decl.uriValue()); break; + case QMetaType::QPixmap: v = QPixmap(decl.uriValue()); break; + case QMetaType::QRect: v = decl.rectValue(); break; + case QMetaType::QSize: v = decl.sizeValue(); break; + case QMetaType::QColor: v = decl.colorValue(); break; + case QMetaType::QBrush: v = decl.brushValue(); break; #ifndef QT_NO_SHORTCUT - case QVariant::KeySequence: v = QKeySequence(decl.d->values.at(0).variant.toString()); break; + case QMetaType::QKeySequence: v = QKeySequence(decl.d->values.at(0).variant.toString()); break; #endif default: v = decl.d->values.at(0).variant; break; } @@ -4648,7 +4647,7 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op } if (baseStyle()->property("_q_styleSheetRealCloseButton").toBool()) - baseStyle()->setProperty("_q_styleSheetRealCloseButton", QVariant(QVariant::Invalid)); + baseStyle()->setProperty("_q_styleSheetRealCloseButton", QVariant()); } QPixmap QStyleSheetStyle::generatedIconPixmap(QIcon::Mode iconMode, const QPixmap& pixmap, @@ -6128,7 +6127,7 @@ void QStyleSheetStyle::saveWidgetFont(QWidget* w, const QFont& font) const void QStyleSheetStyle::clearWidgetFont(QWidget* w) const { - w->setProperty("_q_styleSheetWidgetFont", QVariant(QVariant::Invalid)); + w->setProperty("_q_styleSheetWidgetFont", QVariant()); } // Polish palette that should be used for a particular widget, with particular states diff --git a/src/widgets/widgets/qabstractspinbox.cpp b/src/widgets/widgets/qabstractspinbox.cpp index 6a0d2f5019..04176ab5e2 100644 --- a/src/widgets/widgets/qabstractspinbox.cpp +++ b/src/widgets/widgets/qabstractspinbox.cpp @@ -570,7 +570,7 @@ void QAbstractSpinBox::clear() QAbstractSpinBox::StepEnabled QAbstractSpinBox::stepEnabled() const { Q_D(const QAbstractSpinBox); - if (d->readOnly || d->type == QVariant::Invalid) + if (d->readOnly || d->type == QMetaType::UnknownType) return StepNone; if (d->wrapping) return StepEnabled(StepUpEnabled | StepDownEnabled); @@ -723,7 +723,7 @@ void QAbstractSpinBox::setLineEdit(QLineEdit *lineEdit) d->edit->setFocusProxy(this); d->edit->setAcceptDrops(false); - if (d->type != QVariant::Invalid) { + if (d->type != QMetaType::UnknownType) { connect(d->edit, SIGNAL(textChanged(QString)), this, SLOT(_q_editorTextChanged(QString))); connect(d->edit, SIGNAL(cursorPositionChanged(int,int)), @@ -1421,7 +1421,7 @@ void QAbstractSpinBox::mouseReleaseEvent(QMouseEvent *event) */ QAbstractSpinBoxPrivate::QAbstractSpinBoxPrivate() - : edit(nullptr), type(QVariant::Invalid), spinClickTimerId(-1), + : edit(nullptr), type(QMetaType::UnknownType), spinClickTimerId(-1), spinClickTimerInterval(100), spinClickThresholdTimerId(-1), spinClickThresholdTimerInterval(-1), effectiveSpinRepeatRate(1), buttonState(None), cachedText(QLatin1String("\x01")), cachedState(QValidator::Invalid), pendingEmit(false), readOnly(false), wrapping(false), @@ -1805,7 +1805,7 @@ void QAbstractSpinBoxPrivate::setValue(const QVariant &val, EmitPolicy ep, void QAbstractSpinBoxPrivate::updateEdit() { Q_Q(QAbstractSpinBox); - if (type == QVariant::Invalid) + if (type == QMetaType::UnknownType) return; const QString newText = specialValue() ? specialValueText : prefix + textFromValue(value) + suffix; if (newText == edit->displayText() || cleared) @@ -1865,8 +1865,8 @@ QVariant QAbstractSpinBoxPrivate::getZeroVariant() const { QVariant ret; switch (type) { - case QVariant::Int: ret = QVariant((int)0); break; - case QVariant::Double: ret = QVariant((double)0.0); break; + case QMetaType::Int: ret = QVariant(0); break; + case QMetaType::Double: ret = QVariant(0.0); break; default: break; } return ret; @@ -1913,7 +1913,7 @@ QVariant QAbstractSpinBoxPrivate::valueFromText(const QString &) const void QAbstractSpinBoxPrivate::interpret(EmitPolicy ep) { Q_Q(QAbstractSpinBox); - if (type == QVariant::Invalid || cleared) + if (type == QMetaType::UnknownType || cleared) return; QVariant v = getZeroVariant(); @@ -2013,11 +2013,11 @@ void QSpinBoxValidator::fixup(QString &input) const QVariant operator+(const QVariant &arg1, const QVariant &arg2) { QVariant ret; - if (Q_UNLIKELY(arg1.type() != arg2.type())) + if (Q_UNLIKELY(arg1.userType() != arg2.userType())) qWarning("QAbstractSpinBox: Internal error: Different types (%s vs %s) (%s:%d)", arg1.typeName(), arg2.typeName(), __FILE__, __LINE__); - switch (arg1.type()) { - case QVariant::Int: { + switch (arg1.userType()) { + case QMetaType::Int: { const int int1 = arg1.toInt(); const int int2 = arg2.toInt(); if (int1 > 0 && (int2 >= INT_MAX - int1)) { @@ -2031,9 +2031,9 @@ QVariant operator+(const QVariant &arg1, const QVariant &arg2) } break; } - case QVariant::Double: ret = QVariant(arg1.toDouble() + arg2.toDouble()); break; + case QMetaType::Double: ret = QVariant(arg1.toDouble() + arg2.toDouble()); break; #if QT_CONFIG(datetimeparser) - case QVariant::DateTime: { + case QMetaType::QDateTime: { QDateTime a2 = arg2.toDateTime(); QDateTime a1 = arg1.toDateTime().addDays(QDATETIMEEDIT_DATE_MIN.daysTo(a2.date())); a1.setTime(a1.time().addMSecs(a2.time().msecsSinceStartOfDay())); @@ -2055,13 +2055,13 @@ QVariant operator+(const QVariant &arg1, const QVariant &arg2) QVariant operator-(const QVariant &arg1, const QVariant &arg2) { QVariant ret; - if (Q_UNLIKELY(arg1.type() != arg2.type())) + if (Q_UNLIKELY(arg1.userType() != arg2.userType())) qWarning("QAbstractSpinBox: Internal error: Different types (%s vs %s) (%s:%d)", arg1.typeName(), arg2.typeName(), __FILE__, __LINE__); - switch (arg1.type()) { - case QVariant::Int: ret = QVariant(arg1.toInt() - arg2.toInt()); break; - case QVariant::Double: ret = QVariant(arg1.toDouble() - arg2.toDouble()); break; - case QVariant::DateTime: { + switch (arg1.userType()) { + case QMetaType::Int: ret = QVariant(arg1.toInt() - arg2.toInt()); break; + case QMetaType::Double: ret = QVariant(arg1.toDouble() - arg2.toDouble()); break; + case QMetaType::QDateTime: { QDateTime a1 = arg1.toDateTime(); QDateTime a2 = arg2.toDateTime(); int days = a2.daysTo(a1); @@ -2090,13 +2090,13 @@ QVariant operator*(const QVariant &arg1, double multiplier) { QVariant ret; - switch (arg1.type()) { - case QVariant::Int: + switch (arg1.userType()) { + case QMetaType::Int: ret = static_cast(qBound(INT_MIN, arg1.toInt() * multiplier, INT_MAX)); break; - case QVariant::Double: ret = QVariant(arg1.toDouble() * multiplier); break; + case QMetaType::Double: ret = QVariant(arg1.toDouble() * multiplier); break; #if QT_CONFIG(datetimeparser) - case QVariant::DateTime: { + case QMetaType::QDateTime: { double days = QDATETIMEEDIT_DATE_MIN.daysTo(arg1.toDateTime().date()) * multiplier; const qint64 daysInt = qint64(days); days -= daysInt; @@ -2119,17 +2119,17 @@ double operator/(const QVariant &arg1, const QVariant &arg2) double a1 = 0; double a2 = 0; - switch (arg1.type()) { - case QVariant::Int: + switch (arg1.userType()) { + case QMetaType::Int: a1 = (double)arg1.toInt(); a2 = (double)arg2.toInt(); break; - case QVariant::Double: + case QMetaType::Double: a1 = arg1.toDouble(); a2 = arg2.toDouble(); break; #if QT_CONFIG(datetimeparser) - case QVariant::DateTime: + case QMetaType::QDateTime: a1 = QDATETIMEEDIT_DATE_MIN.daysTo(arg1.toDate()); a2 = QDATETIMEEDIT_DATE_MIN.daysTo(arg2.toDate()); a1 += arg1.toDateTime().time().msecsSinceStartOfDay() / (36e5 * 24); @@ -2144,9 +2144,9 @@ double operator/(const QVariant &arg1, const QVariant &arg2) int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant &arg2) { - switch (arg2.type()) { - case QVariant::Date: - Q_ASSERT_X(arg1.type() == QVariant::Date, "QAbstractSpinBoxPrivate::variantCompare", + switch (arg2.userType()) { + case QMetaType::QDate: + Q_ASSERT_X(arg1.userType() == QMetaType::QDate, "QAbstractSpinBoxPrivate::variantCompare", qPrintable(QString::fromLatin1("Internal error 1 (%1)"). arg(QString::fromLatin1(arg1.typeName())))); if (arg1.toDate() == arg2.toDate()) { @@ -2156,8 +2156,8 @@ int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant } else { return 1; } - case QVariant::Time: - Q_ASSERT_X(arg1.type() == QVariant::Time, "QAbstractSpinBoxPrivate::variantCompare", + case QMetaType::QTime: + Q_ASSERT_X(arg1.userType() == QMetaType::QTime, "QAbstractSpinBoxPrivate::variantCompare", qPrintable(QString::fromLatin1("Internal error 2 (%1)"). arg(QString::fromLatin1(arg1.typeName())))); if (arg1.toTime() == arg2.toTime()) { @@ -2169,7 +2169,7 @@ int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant } - case QVariant::DateTime: + case QMetaType::QDateTime: if (arg1.toDateTime() == arg2.toDateTime()) { return 0; } else if (arg1.toDateTime() < arg2.toDateTime()) { @@ -2177,7 +2177,7 @@ int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant } else { return 1; } - case QVariant::Int: + case QMetaType::Int: if (arg1.toInt() == arg2.toInt()) { return 0; } else if (arg1.toInt() < arg2.toInt()) { @@ -2185,7 +2185,7 @@ int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant } else { return 1; } - case QVariant::Double: + case QMetaType::Double: if (arg1.toDouble() == arg2.toDouble()) { return 0; } else if (arg1.toDouble() < arg2.toDouble()) { @@ -2193,8 +2193,8 @@ int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant } else { return 1; } - case QVariant::Invalid: - if (arg2.type() == QVariant::Invalid) + case QMetaType::UnknownType: + if (arg2.userType() == QMetaType::UnknownType) return 0; Q_FALLTHROUGH(); default: diff --git a/src/widgets/widgets/qabstractspinbox_p.h b/src/widgets/widgets/qabstractspinbox_p.h index ad169fde19..63b19c7317 100644 --- a/src/widgets/widgets/qabstractspinbox_p.h +++ b/src/widgets/widgets/qabstractspinbox_p.h @@ -127,7 +127,7 @@ public: QLineEdit *edit; QString prefix, suffix, specialValueText; QVariant value, minimum, maximum, singleStep; - QVariant::Type type; + QMetaType::Type type; int spinClickTimerId, spinClickTimerInterval, spinClickThresholdTimerId, spinClickThresholdTimerInterval; int effectiveSpinRepeatRate; uint buttonState; diff --git a/src/widgets/widgets/qcombobox.cpp b/src/widgets/widgets/qcombobox.cpp index d786c7ff83..9826cabe50 100644 --- a/src/widgets/widgets/qcombobox.cpp +++ b/src/widgets/widgets/qcombobox.cpp @@ -144,11 +144,11 @@ QStyleOptionMenuItem QComboMenuDelegate::getStyleOption(const QStyleOptionViewIt menuOption.menuItemType = QStyleOptionMenuItem::Normal; QVariant variant = index.model()->data(index, Qt::DecorationRole); - switch (variant.type()) { - case QVariant::Icon: + switch (variant.userType()) { + case QMetaType::QIcon: menuOption.icon = qvariant_cast(variant); break; - case QVariant::Color: { + case QMetaType::QColor: { static QPixmap pixmap(option.decorationSize); pixmap.fill(qvariant_cast(variant)); menuOption.icon = pixmap; @@ -1888,7 +1888,7 @@ void QComboBoxPrivate::updateDelegate(bool force) QIcon QComboBoxPrivate::itemIcon(const QModelIndex &index) const { QVariant decoration = model->data(index, Qt::DecorationRole); - if (decoration.type() == QVariant::Pixmap) + if (decoration.userType() == QMetaType::QPixmap) return QIcon(qvariant_cast(decoration)); else return qvariant_cast(decoration); diff --git a/src/widgets/widgets/qdatetimeedit.cpp b/src/widgets/widgets/qdatetimeedit.cpp index 5f415aca42..63d5ae268e 100644 --- a/src/widgets/widgets/qdatetimeedit.cpp +++ b/src/widgets/widgets/qdatetimeedit.cpp @@ -195,11 +195,19 @@ QDateTimeEdit::QDateTimeEdit(const QTime &time, QWidget *parent) d->init(time.isValid() ? time : QDATETIMEEDIT_TIME_MIN); } +#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) /*! \internal */ - QDateTimeEdit::QDateTimeEdit(const QVariant &var, QVariant::Type parserType, QWidget *parent) + : QDateTimeEdit(var, QMetaType::Type(parserType), parent) +{ } +/*! + \internal +*/ +#endif + +QDateTimeEdit::QDateTimeEdit(const QVariant &var, QMetaType::Type parserType, QWidget *parent) : QAbstractSpinBox(*new QDateTimeEditPrivate, parent) { Q_D(QDateTimeEdit); @@ -1564,7 +1572,7 @@ void QDateTimeEdit::mousePressEvent(QMouseEvent *event) QTimeEdit::QTimeEdit(QWidget *parent) - : QDateTimeEdit(QDATETIMEEDIT_TIME_MIN, QVariant::Time, parent) + : QDateTimeEdit(QDATETIMEEDIT_TIME_MIN, QMetaType::QTime, parent) { connect(this, &QTimeEdit::timeChanged, this, &QTimeEdit::userTimeChanged); } @@ -1575,7 +1583,7 @@ QTimeEdit::QTimeEdit(QWidget *parent) */ QTimeEdit::QTimeEdit(const QTime &time, QWidget *parent) - : QDateTimeEdit(time, QVariant::Time, parent) + : QDateTimeEdit(time, QMetaType::QTime, parent) { connect(this, &QTimeEdit::timeChanged, this, &QTimeEdit::userTimeChanged); } @@ -1634,7 +1642,7 @@ QTimeEdit::~QTimeEdit() */ QDateEdit::QDateEdit(QWidget *parent) - : QDateTimeEdit(QDATETIMEEDIT_DATE_INITIAL, QVariant::Date, parent) + : QDateTimeEdit(QDATETIMEEDIT_DATE_INITIAL, QMetaType::QDate, parent) { connect(this, &QDateEdit::dateChanged, this, &QDateEdit::userDateChanged); } @@ -1645,7 +1653,7 @@ QDateEdit::QDateEdit(QWidget *parent) */ QDateEdit::QDateEdit(const QDate &date, QWidget *parent) - : QDateTimeEdit(date, QVariant::Date, parent) + : QDateTimeEdit(date, QMetaType::QDate, parent) { connect(this, &QDateEdit::dateChanged, this, &QDateEdit::userDateChanged); } @@ -1682,13 +1690,13 @@ QDateEdit::~QDateEdit() QDateTimeEditPrivate::QDateTimeEditPrivate() - : QDateTimeParser(QVariant::DateTime, QDateTimeParser::DateTimeEdit, QCalendar()) + : QDateTimeParser(QMetaType::QDateTime, QDateTimeParser::DateTimeEdit, QCalendar()) { hasHadFocus = false; formatExplicitlySet = false; cacheGuard = false; fixday = true; - type = QVariant::DateTime; + type = QMetaType::QDateTime; sections = { }; cachedDay = -1; currentSectionIndex = FirstSectionIndex; @@ -2430,22 +2438,22 @@ void QDateTimeEdit::initStyleOption(QStyleOptionSpinBox *option) const void QDateTimeEditPrivate::init(const QVariant &var) { Q_Q(QDateTimeEdit); - switch (var.type()) { - case QVariant::Date: + switch (var.userType()) { + case QMetaType::QDate: value = var.toDate().startOfDay(); updateTimeSpec(); q->setDisplayFormat(defaultDateFormat); if (sectionNodes.isEmpty()) // ### safeguard for broken locale q->setDisplayFormat(QLatin1String("dd/MM/yyyy")); break; - case QVariant::DateTime: + case QMetaType::QDateTime: value = var; updateTimeSpec(); q->setDisplayFormat(defaultDateTimeFormat); if (sectionNodes.isEmpty()) // ### safeguard for broken locale q->setDisplayFormat(QLatin1String("dd/MM/yyyy hh:mm:ss")); break; - case QVariant::Time: + case QMetaType::QTime: value = QDateTime(QDATETIMEEDIT_DATE_INITIAL, var.toTime()); updateTimeSpec(); q->setDisplayFormat(defaultTimeFormat); @@ -2524,7 +2532,7 @@ void QDateTimeEditPrivate::updateEditFieldGeometry() QVariant QDateTimeEditPrivate::getZeroVariant() const { - Q_ASSERT(type == QVariant::DateTime); + Q_ASSERT(type == QMetaType::QDateTime); return QDateTime(QDATETIMEEDIT_DATE_INITIAL, QTime(), spec); } diff --git a/src/widgets/widgets/qdatetimeedit.h b/src/widgets/widgets/qdatetimeedit.h index 03994675ae..8905ad4a9c 100644 --- a/src/widgets/widgets/qdatetimeedit.h +++ b/src/widgets/widgets/qdatetimeedit.h @@ -195,7 +195,10 @@ protected: void paintEvent(QPaintEvent *event) override; void initStyleOption(QStyleOptionSpinBox *option) const; +#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) QDateTimeEdit(const QVariant &val, QVariant::Type parserType, QWidget *parent = nullptr); +#endif + QDateTimeEdit(const QVariant &val, QMetaType::Type parserType, QWidget *parent = nullptr); private: Q_DECLARE_PRIVATE(QDateTimeEdit) Q_DISABLE_COPY(QDateTimeEdit) diff --git a/src/widgets/widgets/qplaintextedit.cpp b/src/widgets/widgets/qplaintextedit.cpp index d54c0d0b20..87e8af1382 100644 --- a/src/widgets/widgets/qplaintextedit.cpp +++ b/src/widgets/widgets/qplaintextedit.cpp @@ -2250,17 +2250,17 @@ QVariant QPlainTextEdit::inputMethodQuery(Qt::InputMethodQuery query, QVariant a } const QPointF offset = contentOffset(); - switch (argument.type()) { - case QVariant::RectF: + switch (argument.userType()) { + case QMetaType::QRectF: argument = argument.toRectF().translated(-offset); break; - case QVariant::PointF: + case QMetaType::QPointF: argument = argument.toPointF() - offset; break; - case QVariant::Rect: + case QMetaType::QRect: argument = argument.toRect().translated(-offset.toPoint()); break; - case QVariant::Point: + case QMetaType::QPoint: argument = argument.toPoint() - offset; break; default: @@ -2268,14 +2268,14 @@ QVariant QPlainTextEdit::inputMethodQuery(Qt::InputMethodQuery query, QVariant a } const QVariant v = d->control->inputMethodQuery(query, argument); - switch (v.type()) { - case QVariant::RectF: + switch (v.userType()) { + case QMetaType::QRectF: return v.toRectF().translated(offset); - case QVariant::PointF: + case QMetaType::QPointF: return v.toPointF() + offset; - case QVariant::Rect: + case QMetaType::QRect: return v.toRect().translated(offset.toPoint()); - case QVariant::Point: + case QMetaType::QPoint: return v.toPoint() + offset.toPoint(); default: break; diff --git a/src/widgets/widgets/qspinbox.cpp b/src/widgets/widgets/qspinbox.cpp index 61ea81c892..08428f673e 100644 --- a/src/widgets/widgets/qspinbox.cpp +++ b/src/widgets/widgets/qspinbox.cpp @@ -1081,7 +1081,7 @@ QSpinBoxPrivate::QSpinBoxPrivate() value = minimum; displayIntegerBase = 10; singleStep = QVariant((int)1); - type = QVariant::Int; + type = QMetaType::Int; } /*! @@ -1238,7 +1238,7 @@ QDoubleSpinBoxPrivate::QDoubleSpinBoxPrivate() value = minimum; singleStep = QVariant(1.0); decimals = 2; - type = QVariant::Double; + type = QMetaType::Double; } /*! diff --git a/src/widgets/widgets/qtextbrowser.cpp b/src/widgets/widgets/qtextbrowser.cpp index d0ccd435b3..0ba74a20e0 100644 --- a/src/widgets/widgets/qtextbrowser.cpp +++ b/src/widgets/widgets/qtextbrowser.cpp @@ -310,9 +310,9 @@ void QTextBrowserPrivate::setSource(const QUrl &url, QTextDocument::ResourceType if (url.isValid() && (newUrlWithoutFragment != currentUrlWithoutFragment || forceLoadOnSourceChange)) { QVariant data = q->loadResource(type, resolveUrl(url)); - if (data.type() == QVariant::String) { + if (data.userType() == QMetaType::QString) { txt = data.toString(); - } else if (data.type() == QVariant::ByteArray) { + } else if (data.userType() == QMetaType::QByteArray) { if (type == QTextDocument::HtmlResource) { #if QT_CONFIG(textcodec) QByteArray ba = data.toByteArray(); diff --git a/src/widgets/widgets/qtextedit.cpp b/src/widgets/widgets/qtextedit.cpp index 10de7d0b9e..913ca6ec16 100644 --- a/src/widgets/widgets/qtextedit.cpp +++ b/src/widgets/widgets/qtextedit.cpp @@ -1502,7 +1502,7 @@ void QTextEdit::resizeEvent(QResizeEvent *e) QVariant alignmentProperty = doc->documentLayout()->property("contentHasAlignment"); if (!doc->pageSize().isNull() - && alignmentProperty.type() == QVariant::Bool + && alignmentProperty.userType() == QMetaType::Bool && !alignmentProperty.toBool()) { d->_q_adjustScrollbars(); @@ -1547,7 +1547,7 @@ void QTextEditPrivate::relayoutDocument() width = lineWrapColumnOrWidth; else if (lineWrap == QTextEdit::NoWrap) { QVariant alignmentProperty = doc->documentLayout()->property("contentHasAlignment"); - if (alignmentProperty.type() == QVariant::Bool && !alignmentProperty.toBool()) { + if (alignmentProperty.userType() == QMetaType::Bool && !alignmentProperty.toBool()) { width = 0; } @@ -1835,17 +1835,17 @@ QVariant QTextEdit::inputMethodQuery(Qt::InputMethodQuery query, QVariant argume } const QPointF offset(-d->horizontalOffset(), -d->verticalOffset()); - switch (argument.type()) { - case QVariant::RectF: + switch (argument.userType()) { + case QMetaType::QRectF: argument = argument.toRectF().translated(-offset); break; - case QVariant::PointF: + case QMetaType::QPointF: argument = argument.toPointF() - offset; break; - case QVariant::Rect: + case QMetaType::QRect: argument = argument.toRect().translated(-offset.toPoint()); break; - case QVariant::Point: + case QMetaType::QPoint: argument = argument.toPoint() - offset; break; default: @@ -1853,14 +1853,14 @@ QVariant QTextEdit::inputMethodQuery(Qt::InputMethodQuery query, QVariant argume } const QVariant v = d->control->inputMethodQuery(query, argument); - switch (v.type()) { - case QVariant::RectF: + switch (v.userType()) { + case QMetaType::QRectF: return v.toRectF().translated(offset); - case QVariant::PointF: + case QMetaType::QPointF: return v.toPointF() + offset; - case QVariant::Rect: + case QMetaType::QRect: return v.toRect().translated(offset.toPoint()); - case QVariant::Point: + case QMetaType::QPoint: return v.toPoint() + offset.toPoint(); default: break; -- cgit v1.2.3