{libqmenumodel/src,tests/client}: Fix warnings with Qt6

4 files changed, 178 insertions, 25 deletions

diff --git a/libqmenumodel/src/converter.cpp b/libqmenumodel/src/converter.cpp
index 98757da..35b1507 100644
--- a/libqmenumodel/src/converter.cpp
+++ b/libqmenumodel/src/converter.cpp
@@ -166,7 +166,13 @@ GVariant* Converter::toGVariant(const QVariant &value)
     if (value.isNull() || !value.isValid())
         return result;
 
-    switch((QMetaType::Type)value.type()) {
+    switch(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        value.typeId()
+#else
+        (QMetaType::Type)value.type()
+#endif
+    ) {
     case QMetaType::Bool:
         result = g_variant_new_boolean(value.toBool());
         break;
@@ -255,7 +261,13 @@ GVariant* Converter::toGVariant(const QVariant &value)
         break;
     }
     default:
-        qWarning() << "QVariant type not supported:" << value.type();
+        qWarning() << "QVariant type not supported:" <<
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            value.metaType()
+#else
+            value.type()
+#endif
+            ;
     }
 
     return result;
@@ -313,11 +325,23 @@ GVariant* Converter::toGVariantWithSchema(const QVariant &value, const char* sch
     } else if (g_variant_type_equal(schema_type, G_VARIANT_TYPE_VARIANT)) {
         result = g_variant_new_variant(Converter::toGVariant(value));
     } else if (g_variant_type_equal(schema_type, G_VARIANT_TYPE_VARDICT)) {
-        if (value.canConvert(QVariant::Map)) {
+        if (value.canConvert(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            QMetaType (QVariant::Map)
+#else
+            QVariant::Map
+#endif
+        )) {
             result = Converter::toGVariant(value.toMap());
         }
     } else if (g_variant_type_is_array(schema_type)) {
-        if (value.canConvert(QVariant::List)) {
+        if (value.canConvert(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            QMetaType (QVariant::List)
+#else
+            QVariant::List
+#endif
+        )) {
             const GVariantType* entryType = g_variant_type_element(schema_type);
             const gchar* entryTypeString = g_variant_type_peek_string(entryType);
 
@@ -341,7 +365,13 @@ GVariant* Converter::toGVariantWithSchema(const QVariant &value, const char* sch
             g_variant_builder_unref(b);
         }
     } else if (g_variant_type_is_tuple(schema_type)) {
-        if (value.canConvert(QVariant::List)) {
+        if (value.canConvert(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            QMetaType (QVariant::List)
+#else
+            QVariant::List
+#endif
+        )) {
             const GVariantType* entryType = g_variant_type_first(schema_type);
 
             GVariantBuilder *b = g_variant_builder_new(G_VARIANT_TYPE_TUPLE);
diff --git a/libqmenumodel/src/qstateaction.cpp b/libqmenumodel/src/qstateaction.cpp
index e9736e8..c538ba4 100644
--- a/libqmenumodel/src/qstateaction.cpp
+++ b/libqmenumodel/src/qstateaction.cpp
@@ -95,7 +95,13 @@ bool QStateAction::isValid() const
 void QStateAction::updateState(const QVariant &state)
 {
     QVariant v = state;
-    if (v.convert(m_state.type()))
+    if (v.convert(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+      m_state.metaType()
+#else
+      m_state.type()
+#endif
+    ))
       m_group->updateActionState(m_name, v);
 }
 
@@ -146,7 +152,13 @@ void QStateAction::setValid(bool valid)
 void QStateAction::setState(const QVariant &state)
 {
     QVariant v = state;
-    if (!m_state.isValid() || (v.convert(m_state.type()) && v != m_state)) {
+    if (!m_state.isValid() || (v.convert(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+        m_state.metaType()
+#else
+        m_state.type()
+#endif
+      ) && v != m_state)) {
         m_state = v;
         Q_EMIT stateChanged(m_state);
     }
diff --git a/tests/client/convertertest.cpp b/tests/client/convertertest.cpp
index 095a022..72f3c1d 100644
--- a/tests/client/convertertest.cpp
+++ b/tests/client/convertertest.cpp
@@ -72,14 +72,26 @@ private:
         g_variant_unref(gv);
         return result;
     }
-    bool compare(GVariant *gv, const QVariant::Type type)
+    bool compare(GVariant *gv, const QMetaType::Type type)
     {
         g_variant_ref_sink(gv);
         const QVariant& qv = Converter::toQVariant(gv);
-        bool result = (qv.type() == type);
+        bool result = (
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            qv.typeId()
+#else
+            (QMetaType::Type)qv.type()
+#endif
+            == type
+        );
         if (!result) {
             qWarning() << "types are different: GVariant:" << g_variant_type_peek_string(g_variant_get_type(gv))
-                       << "Result:" << qv.type()
+                       << "Result:" <<
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+                           qv.typeId()
+#else
+                           qv.type()
+#endif
                        << "Expected:"<< type;
         }
         g_variant_unref(gv);
@@ -300,7 +312,7 @@ private Q_SLOTS:
         QFETCH(QGVariant, value);
         QFETCH(unsigned, expectedType);
 
-        QVERIFY(compare(value, (QVariant::Type) expectedType));
+        QVERIFY(compare(value, (QMetaType::Type) expectedType));
     }
 
     void testConvertToQVariantAndBack_data()
@@ -318,7 +330,14 @@ private Q_SLOTS:
         GVariant *gv = Converter::toGVariant(qv);
         gboolean equals = g_variant_equal(value, gv);
 
-        if (!equals && qv.type() == QVariant::List) {
+        if (!equals && (
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            qv.typeId()
+#else
+            qv.type()
+#endif
+            == QVariant::List
+        )) {
             QVERIFY(g_variant_type_is_array(g_variant_get_type(value)));
             QVERIFY(g_variant_type_is_tuple(g_variant_get_type(gv)));
 
@@ -373,7 +392,15 @@ private Q_SLOTS:
         QFETCH(QString, value);
         QFETCH(unsigned, expectedType);
 
-        QCOMPARE(Converter::toQVariantFromVariantString(value).type(), (QVariant::Type) expectedType);
+        QCOMPARE(
+            Converter::toQVariantFromVariantString(value)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+                .typeId()
+#else
+                .type()
+#endif
+            , (QMetaType::Type) expectedType
+        );
     }
 
 };
diff --git a/tests/client/modeltest.cpp b/tests/client/modeltest.cpp
index e6ae82d..59fe6c1 100644
--- a/tests/client/modeltest.cpp
+++ b/tests/client/modeltest.cpp
@@ -106,13 +106,27 @@ private Q_SLOTS:
         // Label (String)
         QVariant label = m_model.data(m_model.index(0, 0), QMenuModel::Label);
         QVERIFY(label.isValid());
-        QCOMPARE(label.type(), QVariant::String);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            label.typeId()
+#else
+            label.type()
+#endif
+            , QVariant::String
+        );
         QCOMPARE(label.toString(), QString("Menu0"));
 
         // Action (String)
         QVariant action = m_model.data(m_model.index(1, 0), QMenuModel::Action);
         QVERIFY(action.isValid());
-        QCOMPARE(action.type(), QVariant::String);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            action.typeId()
+#else
+            action.type()
+#endif
+            , QVariant::String
+        );
         QCOMPARE(action.toString(), QString("Menu1Act"));
 
         // Wait for menu load (submenus are loaded async)
@@ -144,7 +158,14 @@ private Q_SLOTS:
 
         // Boolean
         QVariant v = extra["boolean"];
-        QCOMPARE(v.type(), QVariant::Bool);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::Bool
+        );
         QCOMPARE(v.toBool(), true);
 
         // Byte
@@ -164,32 +185,74 @@ private Q_SLOTS:
 
         // Int32
         v = extra["int32"];
-        QCOMPARE(v.type(), QVariant::Int);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::Int
+        );
         QCOMPARE(v.toInt(), -42);
 
         // UInt32
         v = extra["uint32"];
-        QCOMPARE(v.type(), QVariant::UInt);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::UInt
+        );
         QCOMPARE(v.toUInt(), (uint) 42);
 
         // Int64
         v = extra["int64"];
-        QCOMPARE(v.type(), QVariant::LongLong);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::LongLong
+        );
         QCOMPARE(v.value<long>(), (long) -42);
 
         // UInt64
         v = extra["uint64"];
-        QCOMPARE(v.type(), QVariant::ULongLong);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::ULongLong
+        );
         QCOMPARE(v.value<ulong>(), (ulong) 42);
 
         // Double
         v = extra["double"];
-        QCOMPARE(v.type(), QVariant::Double);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::Double
+        );
         QCOMPARE(v.toDouble(), 42.42);
 
         // String
         v = extra["string"];
-        QCOMPARE(v.type(), QVariant::String);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::String
+        );
         QCOMPARE(v.toString(), QString("42"));
 
         // Map
@@ -199,19 +262,40 @@ private Q_SLOTS:
         map.insert("string", "42");
         map.insert("double", 42.42);
 
-        QCOMPARE(v.type(), QVariant::Map);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::Map
+        );
         QCOMPARE(v.toMap(), map);
 
         // Utf8
         v = extra["utf8"];
-        QCOMPARE(v.type(), QVariant::String);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::String
+        );
         QCOMPARE(v.toString(), QString("dança"));
 
         // Tuple
         v = extra["tuple"];
         QVariantList lst;
         lst << "1" << 2 << 3.3;
-        QCOMPARE(v.type(), QVariant::List);
+        QCOMPARE(
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+            v.typeId()
+#else
+            v.type()
+#endif
+            , QVariant::List
+        );
         QCOMPARE(v.toList(), lst);
    }