Fix warnings about deprecated QVariant::Type

Change-Id: I377e524edaf686d1a77e24f3dcb8f94476004b43
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

6 files changed, 143 insertions, 120 deletions

diff --git a/src/activeqt/axbase/qaxtypefunctions.cpp b/src/activeqt/axbase/qaxtypefunctions.cpp
index c1b76f5..baeaef7 100644
--- a/src/activeqt/axbase/qaxtypefunctions.cpp
+++ b/src/activeqt/axbase/qaxtypefunctions.cpp
@@ -76,88 +76,88 @@ QColor OLEColorToQColor(uint col)
         - internalInvoke(update out parameters/return value)
 
 */
-bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, uint type)
+bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, int type)
 {
     if (!data)
         return true;
 
-    if (type == QMetaType::QVariant || type == uint(QVariant::LastType) || (type == 0 && typeName == "QVariant")) {
+    if (type == QMetaType::QVariant || (type == QMetaType::UnknownType && typeName == "QVariant")) {
         *reinterpret_cast<QVariant *>(data) = var;
         return true;
     }
 
-    switch (var.type()) {
-    case QVariant::Invalid:
+    switch (var.metaType().id()) {
+    case QMetaType::UnknownType:
         break;
-    case QVariant::String:
+    case QMetaType::QString:
         *reinterpret_cast<QString *>(data) = var.toString();
         break;
-    case QVariant::Int:
+    case QMetaType::Int:
         *reinterpret_cast<int *>(data) = var.toInt();
         break;
-    case QVariant::UInt:
+    case QMetaType::UInt:
         *reinterpret_cast<uint *>(data) = var.toUInt();
         break;
-    case QVariant::Bool:
+    case QMetaType::Bool:
         *reinterpret_cast<bool *>(data) = var.toBool();
         break;
-    case QVariant::Double:
+    case QMetaType::Double:
         *reinterpret_cast<double *>(data) = var.toDouble();
         break;
-    case QVariant::Color:
+    case QMetaType::QColor:
         *reinterpret_cast<QColor *>(data) = qvariant_cast<QColor>(var);
         break;
-    case QVariant::Date:
+    case QMetaType::QDate:
         *reinterpret_cast<QDate *>(data) = var.toDate();
         break;
-    case QVariant::Time:
+    case QMetaType::QTime:
         *reinterpret_cast<QTime *>(data) = var.toTime();
         break;
-    case QVariant::DateTime:
+    case QMetaType::QDateTime:
         *reinterpret_cast<QDateTime *>(data) = var.toDateTime();
         break;
-    case QVariant::Font:
+    case QMetaType::QFont:
         *reinterpret_cast<QFont *>(data) = qvariant_cast<QFont>(var);
         break;
-    case QVariant::Pixmap:
+    case QMetaType::QPixmap:
         *reinterpret_cast<QPixmap *>(data) = qvariant_cast<QPixmap>(var);
         break;
 #ifndef QT_NO_CURSOR
-    case QVariant::Cursor:
+    case QMetaType::QCursor:
         *reinterpret_cast<QCursor *>(data) = qvariant_cast<QCursor>(var);
         break;
 #endif
-    case QVariant::List:
+    case QMetaType::QVariantList:
         *reinterpret_cast<QVariantList *>(data) = var.toList();
         break;
-    case QVariant::StringList:
+    case QMetaType::QStringList:
         *reinterpret_cast<QStringList *>(data) = var.toStringList();
         break;
-    case QVariant::ByteArray:
+    case QMetaType::QByteArray:
         *reinterpret_cast<QByteArray *>(data) = var.toByteArray();
         break;
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
         *reinterpret_cast<qint64 *>(data) = var.toLongLong();
         break;
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
         *reinterpret_cast<quint64 *>(data) = var.toULongLong();
         break;
-    case QVariant::Rect:
+    case QMetaType::QRect:
         *reinterpret_cast<QRect *>(data) = var.toRect();
         break;
-    case QVariant::Size:
+    case QMetaType::QSize:
         *reinterpret_cast<QSize *>(data) = var.toSize();
         break;
-    case QVariant::Point:
+    case QMetaType::QPoint:
         *reinterpret_cast<QPoint *>(data) = var.toPoint();
         break;
-    case QVariant::UserType:
-        *reinterpret_cast<void **>(data) =
-            *reinterpret_cast<void **>(const_cast<void *>(var.constData()));
-//        qVariantGet(var, *(void**)data, typeName);
-        break;
     default:
-        qWarning("QVariantToVoidStar: Unhandled QVariant type");
+        if (var.metaType().id() >= QMetaType::User) {
+            *reinterpret_cast<void **>(data) =
+                *reinterpret_cast<void **>(const_cast<void *>(var.constData()));
+        } else {
+            qWarning("QVariantToVoidStar: Unhandled QVariant type");
+        }
         return false;
     }
 
diff --git a/src/activeqt/axbase/qaxtypefunctions_p.h b/src/activeqt/axbase/qaxtypefunctions_p.h
index 7ce9067..2d7f613 100644
--- a/src/activeqt/axbase/qaxtypefunctions_p.h
+++ b/src/activeqt/axbase/qaxtypefunctions_p.h
@@ -99,7 +99,8 @@ static inline uint QColorToOLEColor(const QColor &col)
 }
 
 extern QColor OLEColorToQColor(uint col);
-extern bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, uint type = 0);
+extern bool QVariantToVoidStar(const QVariant &var, void *data,
+                               const QByteArray &typeName, int type = 0);
 extern void clearVARIANT(VARIANT *var);
 
 #define QAX_INPROC_SERVER  (0x51540001)
diff --git a/src/activeqt/container/qaxbase.cpp b/src/activeqt/container/qaxbase.cpp
index 526980c..8c70fe1 100644
--- a/src/activeqt/container/qaxbase.cpp
+++ b/src/activeqt/container/qaxbase.cpp
@@ -445,7 +445,7 @@ public:
                 varp[p + 1] = VARIANTToQVariant(pDispParams->rgvarg[pcount - p - 1], ptype);
                 argv_pointer[p + 1] = nullptr;
                 if (varp[p + 1].isValid()) {
-                    if (varp[p + 1].type() == QVariant::UserType) {
+                    if (varp[p + 1].metaType().id() >= QMetaType::User) {
                         argv[p + 1] = varp[p + 1].data();
                     } else if (ptype == "QVariant") {
                         argv[p + 1] = varp + p + 1;
@@ -529,7 +529,7 @@ public:
 
             const QMetaProperty metaProp = meta->property(meta->indexOfProperty(propname));
             void *argv[] = {nullptr, var.data()};
-            if (metaProp.type() == QVariant::Type(QMetaType::QVariant) || metaProp.type() == QVariant::LastType)
+            if (metaProp.metaType().id() == QMetaType::QVariant)
                 argv[1] = &var;
 
             // emit the "changed" signal
@@ -3301,11 +3301,12 @@ int QAxBase::internalProperty(QMetaObject::Call call, int index, void **v)
             hres = Invoke(disp, dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &params, &arg, &excepinfo, nullptr);
 
             // map result VARIANTARG to void*
-            uint type = QVariant::Int;
+            int type = QMetaType::Int;
             if (!prop.isEnumType())
-                type = prop.type();
+                type = prop.metaType().id();
             QVariantToVoidStar(VARIANTToQVariant(arg, proptype, type), *v, proptype, type);
-            if ((arg.vt != VT_DISPATCH && arg.vt != VT_UNKNOWN) || type == QVariant::Pixmap || type == QVariant::Font)
+            if ((arg.vt != VT_DISPATCH && arg.vt != VT_UNKNOWN)
+                || type == QMetaType::QPixmap || type == QMetaType::QFont)
                 clearVARIANT(&arg);
         }
         break;
@@ -3721,7 +3722,9 @@ bool QAxBase::dynamicCallHelper(const char *name, void *inout, QList<QVariant> &
             else
                 paramType = moExtra.paramType(normFunction, i, &out);
 
-            if ((!parse && d->useMetaObject && var.type() == QVariant::String) || var.type() == QVariant::ByteArray) {
+            const int vType = var.metaType().id();
+            if ((!parse && d->useMetaObject && vType == QMetaType::QString)
+                || vType == QMetaType::QByteArray) {
                 int enumIndex =mo->indexOfEnumerator(paramType);
                 if (enumIndex != -1) {
                     QMetaEnum metaEnum =mo->enumerator(enumIndex);
@@ -3903,8 +3906,11 @@ QVariant QAxBase::dynamicCall(const char *function, QList<QVariant> &vars, unsig
         return QVariant();
 
     QVariant qvar = VARIANTToQVariant(res, rettype);
-    if ((res.vt != VT_DISPATCH && res.vt != VT_UNKNOWN) || qvar.type() == QVariant::Pixmap || qvar.type() == QVariant::Font)
+    const int vType = qvar.metaType().id();
+    if ((res.vt != VT_DISPATCH && res.vt != VT_UNKNOWN)
+        || vType == QMetaType::QPixmap || vType == QMetaType::QFont) {
         clearVARIANT(&res);
+    }
 
     return qvar;
 }
diff --git a/src/activeqt/control/qaxserverbase.cpp b/src/activeqt/control/qaxserverbase.cpp
index bf146c2..efdefd3 100644
--- a/src/activeqt/control/qaxserverbase.cpp
+++ b/src/activeqt/control/qaxserverbase.cpp
@@ -2491,7 +2491,7 @@ HRESULT WINAPI QAxServerBase::Invoke(DISPID dispidMember, REFIID riid,
                 varp[p + 1] = VARIANTToQVariant(pDispParams->rgvarg[pcount - p - 1], ptype);
                 argv_pointer[p + 1] = nullptr;
                 if (varp[p + 1].isValid()) {
-                    if (varp[p + 1].type() == QVariant::UserType) {
+                    if (varp[p + 1].metaType().id() >= QMetaType::User) {
                         argv[p + 1] = varp[p + 1].data();
                     } else if (ptype == "QVariant") {
                         argv[p + 1] = varp + p + 1;
@@ -2522,7 +2522,7 @@ HRESULT WINAPI QAxServerBase::Invoke(DISPID dispidMember, REFIID riid,
                     else if (vt == QMetaType::UnknownType && mo->indexOfEnumerator(slot.typeName()) != -1)
                         vt = QMetaType::Int;
                     varp[0] = QVariant(QMetaType(vt));
-                    if (varp[0].type() == QVariant::Invalid)
+                    if (varp[0].metaType().id() == QMetaType::UnknownType)
                         argv[0] = nullptr;
                     else
                         argv[0] = const_cast<void*>(varp[0].constData());
@@ -2589,7 +2589,8 @@ HRESULT WINAPI QAxServerBase::Invoke(DISPID dispidMember, REFIID riid,
                 *pDispParams->rgdispidNamedArgs != DISPID_PROPERTYPUT)
                 return DISP_E_BADPARAMCOUNT;
 
-            QVariant var = VARIANTToQVariant(*pDispParams->rgvarg, property.typeName(), property.type());
+            QVariant var = VARIANTToQVariant(*pDispParams->rgvarg,
+                                             property.typeName(), property.metaType().id());
             if (!var.isValid()) {
                 if (puArgErr)
                     *puArgErr = 0;
@@ -2974,8 +2975,11 @@ HRESULT WINAPI QAxServerBase::Load(IPropertyBag *bag, IErrorLog * /*log*/)
         var.vt = VT_EMPTY;
         HRESULT res = bag->Read(bstr, &var, nullptr);
         if (property.isWritable() && var.vt != VT_EMPTY) {
-            if (res != S_OK || !qt.object->setProperty(pname, VARIANTToQVariant(var, property.typeName(), property.type())))
+            if (res != S_OK
+                || !qt.object->setProperty(pname, VARIANTToQVariant(var, property.typeName(),
+                                                                    property.metaType().id()))) {
                 error = true;
+            }
         }
         SysFreeString(bstr);
     }
@@ -3338,7 +3342,7 @@ HRESULT WINAPI QAxServerBase::OnAmbientPropertyChange(DISPID dispID)
         if (var.vt != VT_DISPATCH || !isWidget)
             break;
         {
-            QVariant qvar = VARIANTToQVariant(var, "QFont", QVariant::Font);
+            QVariant qvar = VARIANTToQVariant(var, "QFont", QMetaType::QFont);
             QFont qfont = qvariant_cast<QFont>(qvar);
             qt.widget->setFont(qfont);
         }
diff --git a/src/activeqt/shared/qaxtypes.cpp b/src/activeqt/shared/qaxtypes.cpp
index 03efbba..d243f3d 100644
--- a/src/activeqt/shared/qaxtypes.cpp
+++ b/src/activeqt/shared/qaxtypes.cpp
@@ -273,7 +273,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
     if (proptype != QMetaType::UnknownType
         && proptype != QMetaType::User
         && proptype != QMetaType::QVariant
-        && proptype != qvar.type()) {
+        && proptype != qvar.metaType().id()) {
         const QMetaType metaType(proptype);
         if (qvar.canConvert(metaType))
             qvar.convert(metaType);
@@ -293,8 +293,8 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         return true;
     }
 
-    switch ((int)qvar.type()) {
-    case QVariant::String:
+    switch (qvar.metaType().id()) {
+    case QMetaType::QString:
         if (out && arg.vt == (VT_BSTR|VT_BYREF)) {
             if (*arg.pbstrVal)
                 SysFreeString(*arg.pbstrVal);
@@ -326,15 +326,15 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         QVARIANT_TO_VARIANT_POD(ushort, qvariant_cast<ushort>(qvar), out, VT_UI2, uiVal, puiVal)
         break;
 
-    case QVariant::Int:
+    case QMetaType::Int:
         QVARIANT_TO_VARIANT_POD(long, qvar.toInt(), out, VT_I4, lVal, plVal)
         break;
 
-    case QVariant::UInt:
+    case QMetaType::UInt:
         QVARIANT_TO_VARIANT_POD(uint, qvar.toUInt(), out, VT_UI4, uintVal, puintVal)
         break;
 
-    case QVariant::LongLong:
+    case QMetaType::LongLong:
         if (out && arg.vt == (VT_CY|VT_BYREF)) { // VT_CY: Currency
             arg.pcyVal->int64 = qvar.toLongLong();
         } else {
@@ -342,7 +342,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::ULongLong:
+    case QMetaType::ULongLong:
         if (out && arg.vt == (VT_CY|VT_BYREF)) { // VT_CY: Currency
             arg.pcyVal->int64 = qvar.toULongLong();
         } else {
@@ -350,7 +350,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::Bool:
+    case QMetaType::Bool:
         QVARIANT_TO_VARIANT_POD(short, short(qvar.toBool() ? VARIANT_TRUE : VARIANT_FALSE),
                                 out, VT_BOOL, boolVal, pboolVal)
         break;
@@ -363,19 +363,19 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         QVARIANT_TO_VARIANT_POD(double, qvar.toDouble(), out, VT_R8, dblVal, pdblVal)
         break;
 
-    case QVariant::Color:
+    case QMetaType::QColor:
         QVARIANT_TO_VARIANT_POD(long, QColorToOLEColor(qvariant_cast<QColor>(qvar)),
                                 out, VT_COLOR, lVal, plVal)
         break;
 
-    case QVariant::Date:
-    case QVariant::Time:
-    case QVariant::DateTime: // DATE = double
+    case QMetaType::QDate:
+    case QMetaType::QTime:
+    case QMetaType::QDateTime: // DATE = double
         QVARIANT_TO_VARIANT_POD(DATE, QDateTimeToDATE(qvar.toDateTime()),
                                 out, VT_DATE, date, pdate)
         break;
 
-    case QVariant::Font:
+    case QMetaType::QFont:
         if (out && arg.vt == (VT_DISPATCH|VT_BYREF)) {
             if (*arg.ppdispVal)
                 (*arg.ppdispVal)->Release();
@@ -390,7 +390,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::Pixmap:
+    case QMetaType::QPixmap:
         if (out && arg.vt == (VT_DISPATCH|VT_BYREF)) {
             if (*arg.ppdispVal)
                 (*arg.ppdispVal)->Release();
@@ -405,7 +405,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::Cursor:
+    case QMetaType::QCursor:
         {
 #ifndef QT_NO_CURSOR
             int shape = qvariant_cast<QCursor>(qvar).shape();
@@ -442,7 +442,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::List:
+    case QMetaType::QVariantList:
         {
             const auto list = qvar.toList();
             const int count = list.count();
@@ -456,23 +456,23 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
             VARIANT variant;
             void *pElement = &variant;
             switch(listType) {
-            case QVariant::Int:
+            case QMetaType::Int:
                 vt = VT_I4;
                 pElement = &variant.lVal;
                 break;
-            case QVariant::Double:
+            case QMetaType::Double:
                 vt = VT_R8;
                 pElement = &variant.dblVal;
                 break;
-            case QVariant::DateTime:
+            case QMetaType::QDateTime:
                 vt = VT_DATE;
                 pElement = &variant.date;
                 break;
-            case QVariant::Bool:
+            case QMetaType::Bool:
                 vt = VT_BOOL;
                 pElement = &variant.boolVal;
                 break;
-            case QVariant::LongLong:
+            case QMetaType::LongLong:
                 vt = VT_I8;
                 pElement = &variant.llVal;
                 break;
@@ -536,7 +536,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::StringList:
+    case QMetaType::QStringList:
         {
             const QStringList list = qvar.toStringList();
             const int count = list.count();
@@ -563,7 +563,7 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 
-    case QVariant::ByteArray:
+    case QMetaType::QByteArray:
         {
             const QByteArray bytes = qvar.toByteArray();
             const uint count = bytes.count();
@@ -592,9 +592,9 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         break;
 
 #ifdef QAX_SERVER
-    case QVariant::Rect:
-    case QVariant::Size:
-    case QVariant::Point:
+    case QMetaType::QRect:
+    case QMetaType::QSize:
+    case QMetaType::QPoint:
         {
             typedef HRESULT(WINAPI* PGetRecordInfoFromTypeInfo)(ITypeInfo *, IRecordInfo **);
             static PGetRecordInfoFromTypeInfo pGetRecordInfoFromTypeInfo = 0;
@@ -609,9 +609,10 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
 
             ITypeInfo *typeInfo = 0;
             IRecordInfo *recordInfo = 0;
-            CLSID clsid = qvar.type() == QVariant::Rect ? CLSID_QRect
-                :qvar.type() == QVariant::Size ? CLSID_QSize
-                :CLSID_QPoint;
+            const int vType = qvar.metaType().id();
+            CLSID clsid = vType == QMetaType::QRect
+                ? CLSID_QRect
+                : vType == QMetaType::QSize ? CLSID_QSize : CLSID_QPoint;
             qAxTypeLibrary->GetTypeInfoOfGuid(clsid, &typeInfo);
             if (!typeInfo)
                 break;
@@ -621,20 +622,20 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
                 break;
 
             void *record = 0;
-            switch (qvar.type()) {
-            case QVariant::Rect:
+            switch (qvar.metaType().id()) {
+            case QMetaType::QRect:
                 {
                     QRect qrect(qvar.toRect());
                     recordInfo->RecordCreateCopy(&qrect, &record);
                 }
                 break;
-            case QVariant::Size:
+            case QMetaType::QSize:
                 {
                     QSize qsize(qvar.toSize());
                     recordInfo->RecordCreateCopy(&qsize, &record);
                 }
                 break;
-            case QVariant::Point:
+            case QMetaType::QPoint:
                 {
                     QPoint qpoint(qvar.toPoint());
                     recordInfo->RecordCreateCopy(&qpoint, &record);
@@ -656,8 +657,22 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         }
         break;
 #endif // QAX_SERVER
-    case QVariant::UserType:
-        {
+
+    case QMetaType::UnknownType: // default-parameters not set
+        if (out && arg.vt == (VT_ERROR|VT_BYREF)) {
+            *arg.plVal = DISP_E_PARAMNOTFOUND;
+        } else {
+            arg.vt = VT_ERROR;
+            arg.lVal = DISP_E_PARAMNOTFOUND;
+            if (out) {
+                arg.plVal = new long(arg.lVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+
+    default:
+        if (qvar.metaType().id() >= QMetaType::User) {
             QByteArray subType = qvar.typeName();
 #ifdef QAX_SERVER
             if (subType.endsWith('*'))
@@ -722,23 +737,10 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
             } else {
                 return false;
             }
+        } else { // >= User
+            return false;
         }
         break;
-    case QVariant::Invalid: // default-parameters not set
-        if (out && arg.vt == (VT_ERROR|VT_BYREF)) {
-            *arg.plVal = DISP_E_PARAMNOTFOUND;
-        } else {
-            arg.vt = VT_ERROR;
-            arg.lVal = DISP_E_PARAMNOTFOUND;
-            if (out) {
-                arg.plVal = new long(arg.lVal);
-                arg.vt |= VT_BYREF;
-            }
-        }
-        break;
-
-    default:
-        return false;
     }
 
     Q_ASSERT(!out || (arg.vt & VT_BYREF));
@@ -765,8 +767,16 @@ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &type
         - QAxBase::dynamicCall(return value)
         - IPropertyBag::Write (QtPropertyBag)
 */
-QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint type)
+QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, int type)
 {
+    int nameTypeId = QMetaType::UnknownType;
+    if (type == QMetaType::UnknownType && !typeName.isEmpty()) {
+        auto name = typeName.endsWith('*')
+            ? QByteArrayView{typeName.constData(), typeName.size() - 1}
+            : QByteArrayView{typeName};
+        nameTypeId = QMetaType::fromName(name).id();
+    }
+
     QVariant var;
     switch(arg.vt) {
     case VT_BSTR:
@@ -784,38 +794,38 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
     case VT_I1:
         var = arg.cVal;
         if (typeName == "char")
-            type = QVariant::Int;
+            type = QMetaType::Int;
         break;
     case VT_I1|VT_BYREF:
         var = *arg.pcVal;
         if (typeName == "char")
-            type = QVariant::Int;
+            type = QMetaType::Int;
         break;
     case VT_I2:
         var = arg.iVal;
         if (typeName == "short")
-            type = QVariant::Int;
+            type = QMetaType::Int;
         break;
     case VT_I2|VT_BYREF:
         var = *arg.piVal;
         if (typeName == "short")
-            type = QVariant::Int;
+            type = QMetaType::Int;
         break;
     case VT_I4:
-        if (type == QVariant::Color || (!type && typeName == "QColor"))
+        if (type == QMetaType::QColor || nameTypeId == QMetaType::QColor)
             var = QVariant::fromValue(OLEColorToQColor(arg.lVal));
 #ifndef QT_NO_CURSOR
-        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+        else if (type == QMetaType::QCursor || nameTypeId == QMetaType::QCursor)
             var = QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(arg.lVal)));
 #endif
         else
             var = (int)arg.lVal;
         break;
     case VT_I4|VT_BYREF:
-        if (type == QVariant::Color || (!type && typeName == "QColor"))
+        if (type == QMetaType::QColor || nameTypeId == QMetaType::QColor)
             var = QVariant::fromValue(OLEColorToQColor((int)*arg.plVal));
 #ifndef QT_NO_CURSOR
-        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+        else if (type == QMetaType::QCursor || nameTypeId == QMetaType::QCursor)
             var = QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(*arg.plVal)));
 #endif
         else
@@ -840,20 +850,20 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
         var = *arg.puiVal;
         break;
     case VT_UI4:
-        if (type == QVariant::Color || (!type && typeName == "QColor"))
+        if (type == QMetaType::QColor || nameTypeId == QMetaType::QColor)
             var = QVariant::fromValue(OLEColorToQColor(arg.ulVal));
 #ifndef QT_NO_CURSOR
-        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+        else if (type == QMetaType::QCursor || nameTypeId == QMetaType::QCursor)
             var = QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(arg.ulVal)));
 #endif
         else
             var = (int)arg.ulVal;
         break;
     case VT_UI4|VT_BYREF:
-        if (type == QVariant::Color || (!type && typeName == "QColor"))
+        if (type == QMetaType::QColor || nameTypeId == QMetaType::QColor)
             var = QVariant::fromValue(OLEColorToQColor((uint)*arg.pulVal));
 #ifndef QT_NO_CURSOR
-        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+        else if (type == QMetaType::QCursor || nameTypeId == QMetaType::QCursor)
             var = QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(*arg.pulVal)));
 #endif
         else
@@ -897,17 +907,17 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
         break;
     case VT_DATE:
         var = DATEToQDateTime(arg.date);
-        if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) {
+        if (type == QMetaType::QDate || nameTypeId == QMetaType::QDate) {
             var.convert(QMetaType(QMetaType::QDate));
-        } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) {
+        } else if (type == QMetaType::QTime || nameTypeId == QMetaType::QTime) {
             var.convert(QMetaType(QMetaType::QTime));
         }
         break;
     case VT_DATE|VT_BYREF:
         var = DATEToQDateTime(*arg.pdate);
-        if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) {
+        if (type == QMetaType::QDate || nameTypeId == QMetaType::QDate) {
             var.convert(QMetaType(QMetaType::QDate));
-        } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) {
+        } else if (type == QMetaType::QTime || nameTypeId == QMetaType::QTime) {
             var.convert(QMetaType(QMetaType::QTime));
         }
         break;
@@ -926,7 +936,7 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
                 disp = *arg.ppdispVal;
             else
                 disp = arg.pdispVal;
-            if (type == QVariant::Font || (!type && (typeName == "QFont" || typeName == "QFont*"))) {
+            if (type == QMetaType::QFont || nameTypeId == QMetaType::QFont) {
                 IFont *ifont = nullptr;
                 if (disp)
                     disp->QueryInterface(IID_IFont, reinterpret_cast<void**>(&ifont));
@@ -936,7 +946,7 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
                 } else {
                     var = QVariant::fromValue(QFont());
                 }
-            } else if (type == QVariant::Pixmap || (!type && (typeName == "QPixmap" || typeName == "QPixmap*"))) {
+            } else if (type == QMetaType::QPixmap || nameTypeId == QMetaType::QPixmap) {
                 IPicture *ipic = nullptr;
                 if (disp)
                     disp->QueryInterface(IID_IPicture, reinterpret_cast<void**>(&ipic));
@@ -1228,22 +1238,22 @@ QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint
     }
 
     const int proptype = type != QMetaType::UnknownType || typeName.isEmpty() || typeName == "QVariant"
-        ? int(type)
-        : QMetaType::fromName(typeName).id();
+        ? type : nameTypeId;
 
-    if (proptype != QMetaType::QVariant && proptype != QVariant::LastType
-        && QMetaType::UnknownType && var.type() != proptype) {
+    if (proptype != QMetaType::QVariant && proptype != QMetaType::UnknownType
+        && var.metaType().id() != proptype) {
         QMetaType propertyMetaType(proptype);
         if (var.canConvert(propertyMetaType)) {
             QVariant oldvar = var;
             if (oldvar.convert(propertyMetaType))
                 var = oldvar;
-        } else if (proptype == QMetaType::QStringList && var.type() == QVariant::List) {
+        } else if (proptype == QMetaType::QStringList
+                   && var.metaType().id() == QMetaType::QVariantList) {
             bool allStrings = true;
             QStringList strings;
             const QVariantList list(var.toList());
             for (const QVariant &variant : list) {
-                if (variant.canConvert(QMetaType(QMetaType::QString)))
+                if (variant.canConvert<QString>())
                     strings << variant.toString();
                 else
                     allStrings = false;
diff --git a/src/activeqt/shared/qaxtypes_p.h b/src/activeqt/shared/qaxtypes_p.h
index 2ce8a3f..0515087 100644
--- a/src/activeqt/shared/qaxtypes_p.h
+++ b/src/activeqt/shared/qaxtypes_p.h
@@ -78,14 +78,16 @@ QT_BEGIN_NAMESPACE
 #endif
 
 extern bool QVariantToVARIANTFunc(const QVariant &var, VARIANT &arg, const QByteArray &typeName = QByteArray(), bool out = false);
-extern QVariant VARIANTToQVariantFunc(const VARIANT &arg, const QByteArray &typeName, uint type = 0);
+extern QVariant VARIANTToQVariantFunc(const VARIANT &arg, const QByteArray &typeName,
+                                      int type = 0);
 
 inline bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName = QByteArray(), bool out = false)
 {
     return QVariantToVARIANTFunc(var, arg, typeName, out);
 }
 
-inline QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint type = 0)
+inline QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName,
+                                  int type = 0)
 {
     return VARIANTToQVariantFunc(arg, typeName, type);
 }