qaxtypes.cpp - mozsearch

++ // Copyright (C) 2015 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

++ // Qt-Security score:significant reason:default

++

++

++ #include <ocidl.h>

++ #include <olectl.h>

++

++ #include "qaxtypes_p.h"

++ #include "../control/iaxserverbase_p.h"

++ #include <QtAxBase/private/qaxutils_p.h>

++ #include <QtAxBase/private/qaxtypefunctions_p.h>

++

++ #include <qcursor.h>

++ #include <qpixmap.h>

++ #include <qpainter.h>

++ #include <private/qpixmap_win_p.h>

++ #include <qobject.h>

++ #include <qdebug.h>

++ #ifdef QAX_SERVER

++ #   include <qaxfactory.h>

++ #   include <private/qsystemlibrary_p.h>

++ #else

++ #   include <quuid.h>

++ #   include <qaxobject.h>

++ #endif

++

++ #include <QtCore/private/qcomptr_p.h>

++

++ QT_BEGIN_NAMESPACE

++

++ #ifdef QAX_SERVER

++ #   define QVariantToVARIANT QVariantToVARIANT_server

++ #   define VARIANTToQVariant VARIANTToQVariant_server

++ extern ComPtr<ITypeLib> qAxTypeLibrary;

++

++ CLSID CLSID_QRect = { 0x34030f30, 0xe359, 0x4fe6, {0xab, 0x82, 0x39, 0x76, 0x6f, 0x5d, 0x91, 0xee } };

++ CLSID CLSID_QSize = { 0xcb5f84b3, 0x29e5, 0x491d, {0xba, 0x18, 0x54, 0x72, 0x48, 0x8e, 0xef, 0xba } };

++ CLSID CLSID_QPoint = { 0x3be838a3, 0x3fac, 0xbfc4, {0x4c, 0x6c, 0x37, 0xc4, 0x4d, 0x03, 0x02, 0x52 } };

++ #else

++ #   define QVariantToVARIANT QVariantToVARIANT_container

++ #   define VARIANTToQVariant VARIANTToQVariant_container

++ extern void *qax_createObjectWrapper(int metaType, IUnknown *iface);

++ #endif

++

++ static IFontDisp *QFontToIFont(const QFont &font)

++ {

++     FONTDESC fdesc;

++     memset(&fdesc, 0, sizeof(fdesc));

++     fdesc.cbSizeofstruct = sizeof(FONTDESC);

++     fdesc.cySize.Lo = font.pointSize() * 10000;

++     fdesc.fItalic = font.italic();

++     fdesc.fStrikethrough = font.strikeOut();

++     fdesc.fUnderline = font.underline();

++     fdesc.lpstrName = QStringToBSTR(font.family());

++     fdesc.sWeight = font.weight() * 10;

++

++     ComPtr<IFontDisp> f;

++     HRESULT res = OleCreateFontIndirect(&fdesc, IID_IFontDisp, &f);

++     if (res != S_OK) {

++         f.Reset();

++ #if defined(QT_CHECK_STATE)

++         qWarning("QFontToIFont: Failed to create IFont");

++ #endif

++     }

++     return f.Detach();

++ }

++

++ static QFont IFontToQFont(IFont *f)

++ {

++     BSTR name;

++     BOOL bold;

++     SHORT charset;

++     BOOL italic;

++     CY size;

++     BOOL strike;

++     BOOL underline;

++     SHORT weight;

++     f->get_Name(&name);

++     f->get_Bold(&bold);

++     f->get_Charset(&charset);

++     f->get_Italic(&italic);

++     f->get_Size(&size);

++     f->get_Strikethrough(&strike);

++     f->get_Underline(&underline);

++     f->get_Weight(&weight);

++     QFont font(QString::fromWCharArray(name), size.Lo/9750, weight / 97, italic);

++     font.setBold(bold);

++     font.setStrikeOut(strike);

++     font.setUnderline(underline);

++     SysFreeString(name);

++

++     return font;

++ }

++

++ static IPictureDisp *QPixmapToIPicture(const QPixmap &pixmap)

++ {

++     ComPtr<IPictureDisp> pic;

++

++     PICTDESC desc;

++     desc.cbSizeofstruct = sizeof(PICTDESC);

++     desc.picType = PICTYPE_BITMAP;

++

++     desc.bmp.hbitmap = nullptr;

++     desc.bmp.hpal = nullptr;

++

++     if (!pixmap.isNull()) {

++         desc.bmp.hbitmap = qt_pixmapToWinHBITMAP(pixmap);

++         Q_ASSERT(desc.bmp.hbitmap);

++     }

++

++     HRESULT res = OleCreatePictureIndirect(&desc, IID_IPictureDisp, true, &pic);

++     if (res != S_OK) {

++         pic.Reset();

++ #if defined(QT_CHECK_STATE)

++         qWarning("QPixmapToIPicture: Failed to create IPicture");

++ #endif

++     }

++     return pic.Detach();

++ }

++

++ static QPixmap IPictureToQPixmap(IPicture *ipic)

++ {

++     SHORT type;

++     ipic->get_Type(&type);

++     if (type != PICTYPE_BITMAP)

++         return QPixmap();

++

++     HBITMAP hbm = nullptr;

++     ipic->get_Handle(reinterpret_cast<OLE_HANDLE*>(&hbm));

++     if (!hbm)

++         return QPixmap();

++

++     return qt_pixmapFromWinHBITMAP(hbm);

++ }

++

++ static QDateTime DATEToQDateTime(DATE ole)

++ {

++     SYSTEMTIME stime;

++     if (ole >= 949998 || !VariantTimeToSystemTime(ole, &stime))

++         return QDateTime();

++

++     QDate date(stime.wYear, stime.wMonth, stime.wDay);

++     QTime time(stime.wHour, stime.wMinute, stime.wSecond, stime.wMilliseconds);

++     return QDateTime(date, time);

++ }

++

++ static DATE QDateTimeToDATE(const QDateTime &dt)

++ {

++     if (!dt.isValid() || dt.isNull())

++         return 949998;

++

++     SYSTEMTIME stime;

++     memset(&stime, 0, sizeof(stime));

++     QDate date = dt.date();

++     QTime time = dt.time();

++     if (date.isValid() && !date.isNull()) {

++         stime.wDay = date.day();

++         stime.wMonth = date.month();

++         stime.wYear = date.year();

++     }

++     if (time.isValid() && !time.isNull()) {

++         stime.wMilliseconds = time.msec();

++         stime.wSecond = time.second();

++         stime.wMinute = time.minute();

++         stime.wHour = time.hour();

++     }

++

++     double vtime;

++     SystemTimeToVariantTime(&stime, &vtime);

++

++     return vtime;

++ }

++

++ static QByteArray msgOutParameterNotSupported(const QByteArray &type)

++ {

++     return QByteArrayLiteral("QVariantToVARIANT: out-parameter not supported for \"")

++         + type + QByteArrayLiteral("\".");

++ }

++

++ /*

++     Converts \a var to \a arg, and tries to coerce \a arg to \a type.

++

++     Used by

++

++     QAxServerBase:

++         - QAxServerBase::qt_metacall

++         - IDispatch::Invoke(PROPERTYGET, METHOD)

++         - IPersistPropertyBag::Save

++

++     QAxBase:

++         - IDispatch::Invoke (QAxEventSink)

++         - QAxBase::internalProperty(WriteProperty)

++         - QAxBase::internalInvoke()

++         - QAxBase::dynamicCallHelper()

++         - IPropertyBag::Read (QtPropertyBag)

++

++     Also called recoursively for lists.

++ */

++

++ // Convenience macro for function QVariantToVARIANT()

++ // storing a POD QVariant value in the VARIANT arg.

++ #define QVARIANT_TO_VARIANT_POD(type, value, out, varType, varMember, varPointerMember) \

++     if (out && arg.vt == ((varType) | VT_BYREF)) { \

++         *arg.varPointerMember = value; /* pre-allocated out-parameter */ \

++     } else { \

++         if (out) { \

++             arg.vt = (varType) | VT_BYREF; \

++             arg.varPointerMember = new type(value); \

++         } else { \

++             arg.vt = (varType); \

++             arg.varMember = value; \

++         } \

++     }

++

++ static qsizetype columnCount2D(const QVariantList &list)

++ {

++     if (!list.isEmpty()) {

++         const auto &firstElement = list.at(0);

++         const auto type = firstElement.typeId();

++         if (type != QMetaType::QString && type != QMetaType::QByteArray

++             && firstElement.canConvert<QVariantList>()) {

++             return firstElement.toList().size();

++         }

++     }

++     return 0;

++ }

++

++ bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName, bool out)

++ {

++     QVariant qvar = var;

++     // "type" is the expected type, so coerce if necessary

++     const int proptype = typeName.isEmpty()

++         ? QMetaType::UnknownType

++         : QMetaType::fromName(typeName).id();

++     if (proptype != QMetaType::UnknownType

++         && proptype != QMetaType::User

++         && proptype != QMetaType::QVariant

++         && proptype != qvar.metaType().id()) {

++         const QMetaType metaType(proptype);

++         if (qvar.canConvert(metaType))

++             qvar.convert(metaType);

++         else

++             qvar = QVariant(metaType);

++     }

++

++     if (out && arg.vt == (VT_VARIANT|VT_BYREF) && arg.pvarVal) {

++         return QVariantToVARIANT(var, *arg.pvarVal, typeName, false);

++     }

++

++     if (out && proptype == QMetaType::QVariant) {

++         VARIANT *pVariant = new VARIANT;

++         QVariantToVARIANT(var, *pVariant, QByteArray(), false);

++         arg.vt = VT_VARIANT|VT_BYREF;

++         arg.pvarVal = pVariant;

++         return true;

++     }

++

++     switch (qvar.metaType().id()) {

++     case QMetaType::QString:

++         if (out && arg.vt == (VT_BSTR|VT_BYREF)) {

++             if (*arg.pbstrVal)

++                 SysFreeString(*arg.pbstrVal);

++             *arg.pbstrVal = QStringToBSTR(qvar.toString());

++             arg.vt = VT_BSTR|VT_BYREF;

++         } else {

++             arg.vt = VT_BSTR;

++             arg.bstrVal = QStringToBSTR(qvar.toString());

++             if (out) {

++                 arg.pbstrVal = new BSTR(arg.bstrVal);

++                 arg.vt |= VT_BYREF;

++             }

++         }

++         break;

++

++     case QMetaType::Char:

++         QVARIANT_TO_VARIANT_POD(char, char(qvar.toInt()), out, VT_I1, cVal, pcVal)

++         break;

++

++     case QMetaType::UChar:

++         QVARIANT_TO_VARIANT_POD(BYTE, uchar(qvar.toUInt()), out, VT_UI1, bVal, pbVal)

++         break;

++

++     case QMetaType::Short:

++         QVARIANT_TO_VARIANT_POD(short, qvariant_cast<short>(qvar), out, VT_I2, iVal, piVal)

++         break;

++

++     case QMetaType::UShort:

++         QVARIANT_TO_VARIANT_POD(ushort, qvariant_cast<ushort>(qvar), out, VT_UI2, uiVal, puiVal)

++         break;

++

++     case QMetaType::Int:

++         QVARIANT_TO_VARIANT_POD(long, qvar.toInt(), out, VT_I4, lVal, plVal)

++         break;

++

++     case QMetaType::UInt:

++         QVARIANT_TO_VARIANT_POD(uint, qvar.toUInt(), out, VT_UI4, uintVal, puintVal)

++         break;

++

++     case QMetaType::LongLong:

++         if (out && arg.vt == (VT_CY|VT_BYREF)) { // VT_CY: Currency

++             arg.pcyVal->int64 = qvar.toLongLong();

++         } else {

++             QVARIANT_TO_VARIANT_POD(LONGLONG, qvar.toLongLong(), out, VT_I8, llVal, pllVal)

++         }

++         break;

++

++     case QMetaType::ULongLong:

++         if (out && arg.vt == (VT_CY|VT_BYREF)) { // VT_CY: Currency

++             arg.pcyVal->int64 = qvar.toULongLong();

++         } else {

++             QVARIANT_TO_VARIANT_POD(ULONGLONG, qvar.toULongLong(), out, VT_UI8, ullVal, pullVal)

++         }

++         break;

++

++     case QMetaType::Bool:

++         QVARIANT_TO_VARIANT_POD(short, short(qvar.toBool() ? VARIANT_TRUE : VARIANT_FALSE),

++                                 out, VT_BOOL, boolVal, pboolVal)

++         break;

++

++     case QMetaType::Float:

++         QVARIANT_TO_VARIANT_POD(float, float(qvar.toDouble()), out, VT_R4, fltVal, pfltVal)

++         break;

++

++     case QMetaType::Double:

++         QVARIANT_TO_VARIANT_POD(double, qvar.toDouble(), out, VT_R8, dblVal, pdblVal)

++         break;

++

++     case QMetaType::QColor:

++         QVARIANT_TO_VARIANT_POD(long, QColorToOLEColor(qvariant_cast<QColor>(qvar)),

++                                 out, VT_COLOR, lVal, plVal)

++         break;

++

++     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 QMetaType::QFont:

++         if (out && arg.vt == (VT_DISPATCH|VT_BYREF)) {

++             if (*arg.ppdispVal)

++                 (*arg.ppdispVal)->Release();

++             *arg.ppdispVal = QFontToIFont(qvariant_cast<QFont>(qvar));

++         } else {

++             arg.vt = VT_DISPATCH;

++             arg.pdispVal = QFontToIFont(qvariant_cast<QFont>(qvar));

++             if (out) {

++                 arg.ppdispVal = new IDispatch*(arg.pdispVal);

++                 arg.vt |= VT_BYREF;

++             }

++         }

++         break;

++

++     case QMetaType::QPixmap:

++         if (out && arg.vt == (VT_DISPATCH|VT_BYREF)) {

++             if (*arg.ppdispVal)

++                 (*arg.ppdispVal)->Release();

++             *arg.ppdispVal = QPixmapToIPicture(qvariant_cast<QPixmap>(qvar));

++         } else {

++             arg.vt = VT_DISPATCH;

++             arg.pdispVal = QPixmapToIPicture(qvariant_cast<QPixmap>(qvar));

++             if (out) {

++                 arg.ppdispVal = new IDispatch*(arg.pdispVal);

++                 arg.vt |= VT_BYREF;

++             }

++         }

++         break;

++

++     case QMetaType::QCursor:

++         {

++ #ifndef QT_NO_CURSOR

++             int shape = qvariant_cast<QCursor>(qvar).shape();

++             if (out && (arg.vt & VT_BYREF)) {

++                 switch(arg.vt & ~VT_BYREF) {

++                 case VT_I4:

++                     *arg.plVal = shape;

++                     break;

++                 case VT_I2:

++                     *arg.piVal = shape;

++                     break;

++                 case VT_UI4:

++                     *arg.pulVal = shape;

++                     break;

++                 case VT_UI2:

++                     *arg.puiVal = shape;

++                     break;

++                 case VT_INT:

++                     *arg.pintVal = shape;

++                     break;

++                 case VT_UINT:

++                     *arg.puintVal = shape;

++                     break;

++                 }

++             } else {

++                 arg.vt = VT_I4;

++                 arg.lVal = shape;

++                 if (out) {

++                     arg.plVal = new long(arg.lVal);

++                     arg.vt |= VT_BYREF;

++                 }

++             }

++ #endif

++         }

++         break;

++

++     case QMetaType::QVariantList:

++         {

++             const auto list = qvar.toList();

++             const qsizetype count = list.size();

++             VARTYPE vt = VT_VARIANT;

++             int listType = QMetaType::QVariant;

++             if (!typeName.isEmpty() && typeName.startsWith("QList<")) {

++                 const QByteArray listTypeName = typeName.mid(6, typeName.length() - 7); // QList<int> -> int

++                 listType = QMetaType::fromName(listTypeName).id();

++             }

++

++             VARIANT variant;

++             void *pElement = &variant;

++             switch(listType) {

++             case QMetaType::Int:

++                 vt = VT_I4;

++                 pElement = &variant.lVal;

++                 break;

++             case QMetaType::Double:

++                 vt = VT_R8;

++                 pElement = &variant.dblVal;

++                 break;

++             case QMetaType::QDateTime:

++                 vt = VT_DATE;

++                 pElement = &variant.date;

++                 break;

++             case QMetaType::Bool:

++                 vt = VT_BOOL;

++                 pElement = &variant.boolVal;

++                 break;

++             case QMetaType::LongLong:

++                 vt = VT_I8;

++                 pElement = &variant.llVal;

++                 break;

++             default:

++                 break;

++             }

++             SAFEARRAY *array = nullptr;

++             // If the first element in the array is a list the whole list is

++             // treated as a 2D array. The column count is taken from the 1st element.

++             if (qsizetype maxColumns = columnCount2D(list)) {

++                 SAFEARRAYBOUND rgsabound[2] = { {0, 0}, {0, 0} };

++                 rgsabound[0].cElements = count;

++                 rgsabound[1].cElements = maxColumns;

++                 array = SafeArrayCreate(VT_VARIANT, 2, rgsabound);

++                 LONG rgIndices[2];

++                 for (LONG i = 0; i < count; ++i) {

++                     rgIndices[0] = i;

++                     QVariantList columns = list.at(i).toList();

++                     qsizetype columnCount = qMin(maxColumns, columns.size());

++                     for (LONG j = 0;  j < columnCount; ++j) {

++                         const QVariant &elem = columns.at(j);

++                         VariantInit(&variant);

++                         QVariantToVARIANT(elem, variant, elem.typeName());

++                         rgIndices[1] = j;

++                         SafeArrayPutElement(array, rgIndices, pElement);

++                         clearVARIANT(&variant);

++                     }

++                 }

++             } else {

++                 array = SafeArrayCreateVector(vt, 0, count);

++                 for (LONG index = 0; index < count; ++index) {

++                     QVariant elem = list.at(index);

++                     if (listType != QMetaType::QVariant)

++                         elem.convert(QMetaType(listType));

++                     VariantInit(&variant);

++                     QVariantToVARIANT(elem, variant, elem.typeName());

++                     SafeArrayPutElement(array, &index, pElement);

++                     clearVARIANT(&variant);

++                 }

++             }

++             if (out && arg.vt == (VT_ARRAY|vt|VT_BYREF)) {

++                 if (*arg.pparray)

++                     SafeArrayDestroy(*arg.pparray);

++                 *arg.pparray = array;

++             } else {

++                 arg.vt = VT_ARRAY|vt;

++                 arg.parray = array;

++                 if (out) {

++                     arg.pparray = new SAFEARRAY*(arg.parray);

++                     arg.vt |= VT_BYREF;

++                 }

++             }

++         }

++         break;

++

++     case QMetaType::QStringList:

++         {

++             const QStringList list = qvar.toStringList();

++             const qsizetype count = list.size();

++             SAFEARRAY *array = SafeArrayCreateVector(VT_BSTR, 0, count);

++             for (LONG index = 0; index < count; ++index) {

++                 QString elem = list.at(index);

++                 BSTR bstr = QStringToBSTR(elem);

++                 SafeArrayPutElement(array, &index, bstr);

++                 SysFreeString(bstr);

++             }

++

++             if (out && arg.vt == (VT_ARRAY|VT_BSTR|VT_BYREF)) {

++                 if (*arg.pparray)

++                     SafeArrayDestroy(*arg.pparray);

++                 *arg.pparray = array;

++             } else {

++                 arg.vt = VT_ARRAY|VT_BSTR;

++                 arg.parray = array;

++                 if (out) {

++                     arg.pparray = new SAFEARRAY*(arg.parray);

++                     arg.vt |= VT_BYREF;

++                 }

++             }

++         }

++         break;

++

++     case QMetaType::QByteArray:

++         {

++             const QByteArray bytes = qvar.toByteArray();

++             const uint count = static_cast<uint>(bytes.size());

++             SAFEARRAY *array = SafeArrayCreateVector(VT_UI1, 0, count);

++             if (count) {

++                 const char *data = bytes.constData();

++                 char *dest;

++                 SafeArrayAccessData(array, reinterpret_cast<void**>(&dest));

++                 memcpy(dest, data, count);

++                 SafeArrayUnaccessData(array);

++             }

++

++             if (out && arg.vt == (VT_ARRAY|VT_UI1|VT_BYREF)) {

++                 if (*arg.pparray)

++                     SafeArrayDestroy(*arg.pparray);

++                 *arg.pparray = array;

++             } else {

++                 arg.vt = VT_ARRAY|VT_UI1;

++                 arg.parray = array;

++                 if (out) {

++                     arg.pparray = new SAFEARRAY*(arg.parray);

++                     arg.vt |= VT_BYREF;

++                 }

++             }

++         }

++         break;

++

++ #ifdef QAX_SERVER

++     case QMetaType::QRect:

++     case QMetaType::QSize:

++     case QMetaType::QPoint:

++         {

++             typedef HRESULT(WINAPI* PGetRecordInfoFromTypeInfo)(ITypeInfo *, IRecordInfo **);

++             static PGetRecordInfoFromTypeInfo pGetRecordInfoFromTypeInfo = 0;

++             static bool resolved = false;

++             if (!resolved) {

++                 resolved = true;

++                 pGetRecordInfoFromTypeInfo = (PGetRecordInfoFromTypeInfo)QSystemLibrary::resolve(QLatin1String("oleaut32"),

++                                               "GetRecordInfoFromTypeInfo");

++             }

++             if (!pGetRecordInfoFromTypeInfo)

++                 break;

++

++             ComPtr<ITypeInfo> typeInfo;

++             IRecordInfo *recordInfo = 0;

++             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;

++             pGetRecordInfoFromTypeInfo(typeInfo.Get(), &recordInfo);

++             if (!recordInfo)

++                 break;

++

++             void *record = 0;

++             switch (qvar.metaType().id()) {

++             case QMetaType::QRect:

++                 {

++                     QRect qrect(qvar.toRect());

++                     recordInfo->RecordCreateCopy(&qrect, &record);

++                 }

++                 break;

++             case QMetaType::QSize:

++                 {

++                     QSize qsize(qvar.toSize());

++                     recordInfo->RecordCreateCopy(&qsize, &record);

++                 }

++                 break;

++             case QMetaType::QPoint:

++                 {

++                     QPoint qpoint(qvar.toPoint());

++                     recordInfo->RecordCreateCopy(&qpoint, &record);

++                 }

++                 break;

++             default:

++                 break;

++             }

++

++             if (out) {

++                 qWarning().noquote() << msgOutParameterNotSupported("records");

++                 arg.vt = VT_EMPTY;

++                 arg.byref = nullptr;

++                 return false;

++             }

++             arg.vt = VT_RECORD;

++             arg.pRecInfo = recordInfo,

++             arg.pvRecord = record;

++         }

++         break;

++ #endif // QAX_SERVER

++

++     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().flags().testFlag(QMetaType::IsEnumeration)) {

++             // A COM enum has no dedicated QMetaType::Type id of its own, so it

++             // ends up here with an id() >= QMetaType::User. It must not be

++             // mistaken for a QAxObject-wrapping container below: pack the

++             // underlying integer value instead.

++             QVARIANT_TO_VARIANT_POD(long, qvar.toInt(), out, VT_I4, lVal, plVal)

++             break;

++         }

++         if (qvar.metaType().id() >= QMetaType::User) {

++             QByteArray subType = qvar.typeName();

++ #ifdef QAX_SERVER

++             if (subType.endsWith('*'))

++                 subType.truncate(subType.length() - 1);

++ #endif

++             if (!qstrcmp(qvar.typeName(), "IDispatch*")) {

++                 if (out) {

++                     qWarning().noquote() << msgOutParameterNotSupported(qvar.typeName());

++                     arg.vt = VT_EMPTY;

++                     arg.byref = nullptr;

++                     return false;

++                 }

++                 arg.vt = VT_DISPATCH;

++                 arg.pdispVal = *static_cast<IDispatch**>(qvar.data());

++                 if (arg.pdispVal)

++                     arg.pdispVal->AddRef();

++             } else if (!qstrcmp(qvar.typeName(), "IDispatch**")) {

++                 arg.vt = VT_DISPATCH;

++                 arg.ppdispVal = *static_cast<IDispatch***>(qvar.data());

++                 if (out)

++                     arg.vt |= VT_BYREF;

++             } else if (!qstrcmp(qvar.typeName(), "IUnknown*")) {

++                 if (out) {

++                     qWarning().noquote() << msgOutParameterNotSupported(qvar.typeName());

++                     arg.vt = VT_EMPTY;

++                     arg.byref = nullptr;

++                     return false;

++                 }

++                 arg.vt = VT_UNKNOWN;

++                 arg.punkVal = *static_cast<IUnknown**>(qvar.data());

++                 if (arg.punkVal)

++                     arg.punkVal->AddRef();

++ #ifdef QAX_SERVER

++             } else if (qAxFactory()->metaObject(QString::fromLatin1(subType.constData()))) {

++                 if (out) {

++                     qWarning().noquote() << msgOutParameterNotSupported("subtype");

++                     arg.vt = VT_EMPTY;

++                     arg.byref = nullptr;

++                     return false;

++                 }

++                 arg.vt = VT_DISPATCH;

++                 void *user = *(void**)qvar.constData();

++ //                qVariantGet(qvar, user, qvar.typeName());

++                 if (!user) {

++                     arg.pdispVal = 0;

++                 } else {

++                     qAxFactory()->createObjectWrapper(static_cast<QObject*>(user), &arg.pdispVal);

++                 }

++ #else

++             } else if (QMetaType::fromName(subType).id() != QMetaType::UnknownType) {

++                 if (out) {

++                     qWarning().noquote() << msgOutParameterNotSupported("subtype");

++                     arg.vt = VT_EMPTY;

++                     arg.byref = nullptr;

++                     return false;

++                 }

++                 QAxObject *object = *static_cast<QAxObject**>(qvar.data());

++ //                qVariantGet(qvar, object, subType);

++                 arg.vt = VT_DISPATCH;

++                 object->queryInterface(IID_IDispatch, reinterpret_cast<void**>(&arg.pdispVal));

++ #endif

++             } else {

++                 return false;

++             }

++         } else { // >= User

++             return false;

++         }

++         break;

++     }

++

++     Q_ASSERT(!out || (arg.vt & VT_BYREF));

++     return true;

++ }

++

++ #ifdef QAX_SERVER

++ static QVariant axServer(IUnknown *unknown, const QByteArray &typeName)

++ {

++     ComPtr<IAxServerBase> iface;

++     if (unknown && typeName != "IDispatch*" && typeName != "IUnknown*")

++         unknown->QueryInterface(IID_IAxServerBase, &iface);

++     if (iface == nullptr)

++         return {};

++

++     auto *qObj = iface->GetQObject();

++     QByteArray pointerType = qObj ? QByteArray(qObj->metaObject()->className()) + '*' : typeName;

++     QMetaType pointerMetaType = QMetaType::fromName(pointerType);

++     if (pointerMetaType.id() == QMetaType::UnknownType)

++         pointerMetaType = QMetaType(qRegisterMetaType<QObject *>(pointerType));

++     return QVariant(pointerMetaType, &qObj);

++ }

++ #endif // QAX_SERVER

++

++ #undef QVARIANT_TO_VARIANT_POD

++

++ /*

++     Returns \a arg as a QVariant of type \a typeName or \a type.

++

++     NOTE: If a \a typeName is specified, value type is assumed. to

++     get/create a pointer type, provide the type id in the \a type argument.

++

++     Used by

++

++     QAxServerBase:

++         - QAxServerBase::qt_metacall(update out parameters/return value)

++         - IDispatch::Invoke(METHOD, PROPERTYPUT)

++         - IPersistPropertyBag::Load

++

++     QAxBase:

++         - IDispatch::Invoke (QAxEventSink)

++         - QAxBase::internalProperty(ReadProperty)

++         - QAxBase::internalInvoke(update out parameters/return value)

++         - QAxBase::dynamicCallHelper(update out parameters)

++         - QAxBase::dynamicCall(return value)

++         - IPropertyBag::Write (QtPropertyBag)

++ */

++ 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:

++         var = QString::fromWCharArray(arg.bstrVal);

++         break;

++     case VT_BSTR|VT_BYREF:

++         var = QString::fromWCharArray(*arg.pbstrVal);

++         break;

++     case VT_BOOL:

++         var = QVariant((bool)arg.boolVal);

++         break;

++     case VT_BOOL|VT_BYREF:

++         var = QVariant((bool)*arg.pboolVal);

++         break;

++     case VT_I1:

++         var = arg.cVal;

++         if (typeName == "char")

++             type = QMetaType::Int;

++         break;

++     case VT_I1|VT_BYREF:

++         var = *arg.pcVal;

++         if (typeName == "char")

++             type = QMetaType::Int;

++         break;

++     case VT_I2:

++         var = arg.iVal;

++         if (typeName == "short")

++             type = QMetaType::Int;

++         break;

++     case VT_I2|VT_BYREF:

++         var = *arg.piVal;

++         if (typeName == "short")

++             type = QMetaType::Int;

++         break;

++     case VT_I4:

++         if (type == QMetaType::QColor || nameTypeId == QMetaType::QColor)

++             var = QVariant::fromValue(OLEColorToQColor(arg.lVal));

++ #ifndef QT_NO_CURSOR

++         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 == QMetaType::QColor || nameTypeId == QMetaType::QColor)

++             var = QVariant::fromValue(OLEColorToQColor((int)*arg.plVal));

++ #ifndef QT_NO_CURSOR

++         else if (type == QMetaType::QCursor || nameTypeId == QMetaType::QCursor)

++             var = QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(*arg.plVal)));

++ #endif

++         else

++             var = (int)*arg.plVal;

++         break;

++     case VT_INT:

++         var = arg.intVal;

++         break;

++     case VT_INT|VT_BYREF:

++         var = *arg.pintVal;

++         break;

++     case VT_UI1:

++         var = arg.bVal;

++         break;

++     case VT_UI1|VT_BYREF:

++         var = *arg.pbVal;

++         break;

++     case VT_UI2:

++         var = arg.uiVal;

++         break;

++     case VT_UI2|VT_BYREF:

++         var = *arg.puiVal;

++         break;

++     case VT_UI4:

++         if (type == QMetaType::QColor || nameTypeId == QMetaType::QColor)

++             var = QVariant::fromValue(OLEColorToQColor(arg.ulVal));

++ #ifndef QT_NO_CURSOR

++         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 == QMetaType::QColor || nameTypeId == QMetaType::QColor)

++             var = QVariant::fromValue(OLEColorToQColor((uint)*arg.pulVal));

++ #ifndef QT_NO_CURSOR

++         else if (type == QMetaType::QCursor || nameTypeId == QMetaType::QCursor)

++             var = QVariant::fromValue(QCursor(static_cast<Qt::CursorShape>(*arg.pulVal)));

++ #endif

++         else

++             var = (int)*arg.pulVal;

++         break;

++     case VT_UINT:

++         var = arg.uintVal;

++         break;

++     case VT_UINT|VT_BYREF:

++         var = *arg.puintVal;

++         break;

++     case VT_CY:

++         var = arg.cyVal.int64;

++         break;

++     case VT_CY|VT_BYREF:

++         var = arg.pcyVal->int64;

++         break;

++     case VT_I8:

++         var = arg.llVal;

++         break;

++     case VT_I8|VT_BYREF:

++         var = *arg.pllVal;

++         break;

++     case VT_UI8:

++         var = arg.ullVal;

++         break;

++     case VT_UI8|VT_BYREF:

++         var = *arg.pullVal;

++         break;

++     case VT_R4:

++         var = arg.fltVal;

++         break;

++     case VT_R4|VT_BYREF:

++         var = *arg.pfltVal;

++         break;

++     case VT_R8:

++         var = arg.dblVal;

++         break;

++     case VT_R8|VT_BYREF:

++         var = *arg.pdblVal;

++         break;

++     case VT_DATE:

++         var = DATEToQDateTime(arg.date);

++         if (type == QMetaType::QDate || nameTypeId == QMetaType::QDate) {

++             var.convert(QMetaType(QMetaType::QDate));

++         } 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 == QMetaType::QDate || nameTypeId == QMetaType::QDate) {

++             var.convert(QMetaType(QMetaType::QDate));

++         } else if (type == QMetaType::QTime || nameTypeId == QMetaType::QTime) {

++             var.convert(QMetaType(QMetaType::QTime));

++         }

++         break;

++     case VT_VARIANT:

++     case VT_VARIANT|VT_BYREF:

++         if (arg.pvarVal)

++             var = VARIANTToQVariant(*arg.pvarVal, typeName);

++         break;

++

++     case VT_DISPATCH:

++     case VT_DISPATCH|VT_BYREF:

++         {

++             // pdispVal and ppdispVal are a union

++             IDispatch *disp = nullptr;

++             if (arg.vt & VT_BYREF)

++                 disp = *arg.ppdispVal;

++             else

++                 disp = arg.pdispVal;

++             if (type == QMetaType::QFont || nameTypeId == QMetaType::QFont) {

++                 ComPtr<IFont> ifont;

++                 if (disp)

++                     disp->QueryInterface(IID_IFont, &ifont);

++                 if (ifont) {

++                     var = QVariant::fromValue(IFontToQFont(ifont.Get()));

++                 } else {

++                     var = QVariant::fromValue(QFont());

++                 }

++             } else if (type == QMetaType::QPixmap || nameTypeId == QMetaType::QPixmap) {

++                 ComPtr<IPicture> ipic;

++                 if (disp)

++                     disp->QueryInterface(IID_IPicture, &ipic);

++                 if (ipic) {

++                     var = QVariant::fromValue(IPictureToQPixmap(ipic.Get()));

++                 } else {

++                     var = QVariant::fromValue(QPixmap());

++                 }

++             } else {

++ #ifdef QAX_SERVER

++                 if (auto axs = axServer(disp, typeName); axs.isValid()) {

++                     var = axs;

++                 } else

++ #endif

++                 {

++                     if (!typeName.isEmpty()) {

++                         if (arg.vt & VT_BYREF) {

++                             // When the dispinterface is a return value, just assign it to a QVariant

++                             static const int dispatchId = qRegisterMetaType<IDispatch**>("IDispatch**");

++                             var = QVariant(QMetaType(dispatchId), &arg.ppdispVal);

++                         } else {

++ #ifndef QAX_SERVER

++                             if (typeName == "QVariant") {

++                                 // If a QVariant is requested, wrap the dispinterface in a QAxObject

++                                 QAxObject *object = new QAxObject(disp);

++                                 var = QVariant::fromValue<QAxObject*>(object);

++                             } else if (typeName != "IDispatch*" &&  QMetaType::fromName(typeName).id() != QMetaType::UnknownType) {

++                                 // Conversion from IDispatch* to a wrapper type is requested. Here, the requested

++                                 // wrapper type is constructed around the dispinterface, and then returned as

++                                 // a QVariant containing a pointer to the wrapper type.

++

++                                 // Calculate the value type from a potential pointer type

++                                 QByteArray valueTypeStr = QByteArray(typeName);

++                                 int pIndex = typeName.lastIndexOf('*');

++                                 if (pIndex != -1)

++                                     valueTypeStr = typeName.left(pIndex);

++

++                                 const QMetaType metaValueType = QMetaType::fromName(valueTypeStr);

++                                 Q_ASSERT(metaValueType.id() != QMetaType::UnknownType);

++

++                                 auto object = static_cast<QAxObject*>(qax_createObjectWrapper(metaValueType.id(), disp));

++

++                                 // Return object as the original type

++                                 const QMetaType returnType = QMetaType::fromName(typeName);

++                                 Q_ASSERT(metaValueType.id() != QMetaType::UnknownType);

++

++                                 var = QVariant(returnType, &object);

++

++                                 // The result must be a pointer to an instance derived from QObject

++                                 Q_ASSERT((var.metaType().flags() & QMetaType::PointerToQObject) != 0);

++                             } else {

++ #endif

++                                 // An IDispatch pointer is requested, no conversion required, just return as QVariant

++                                 // containing the pointer.

++                                 static const int dispatchId = qRegisterMetaType<IDispatch*>(typeName.constData());

++                                 var = QVariant(QMetaType(dispatchId), &disp);

++ #ifndef QAX_SERVER

++                             }

++ #endif

++                         }

++                     }

++                 }

++             }

++         }

++         break;

++     case VT_UNKNOWN:

++     case VT_UNKNOWN|VT_BYREF:

++         {

++             IUnknown *unkn = nullptr;

++             if (arg.vt & VT_BYREF)

++                 unkn = *arg.ppunkVal;

++             else

++                 unkn = arg.punkVal;

++             var.setValue(unkn);

++ #ifdef QAX_SERVER

++             if (auto axs = axServer(unkn, typeName); axs.isValid())

++                 var = axs;

++ #endif

++         }

++         break;

++     case VT_ARRAY|VT_VARIANT:

++     case VT_ARRAY|VT_VARIANT|VT_BYREF:

++         {

++             SAFEARRAY *array = nullptr;

++             if ( arg.vt & VT_BYREF )

++                 array = *arg.pparray;

++             else

++                 array = arg.parray;

++

++             UINT cDims = array ? SafeArrayGetDim(array) : 0;

++             switch(cDims) {

++             case 1:

++                 {

++                     QVariantList list;

++

++                     long lBound, uBound;

++                     SafeArrayGetLBound( array, 1, &lBound );

++                     SafeArrayGetUBound( array, 1, &uBound );

++

++                     for ( long i = lBound; i <= uBound; ++i ) {

++                         VARIANT var;

++                         VariantInit( &var );

++                         SafeArrayGetElement( array, &i, &var );

++

++                         QVariant qvar = VARIANTToQVariant( var, nullptr );

++                         clearVARIANT( &var );

++                         list << qvar;

++                     }

++

++                     var = list;

++                 }

++                 break;

++

++             case 2:

++                 {

++                     QVariantList listList; //  a list of lists

++                     long dimIndices[2];

++

++                     long xlBound, xuBound, ylBound, yuBound;

++                     SafeArrayGetLBound(array, 1, &xlBound);

++                     SafeArrayGetUBound(array, 1, &xuBound);

++                     SafeArrayGetLBound(array, 2, &ylBound);

++                     SafeArrayGetUBound(array, 2, &yuBound);

++

++                     for (long x = xlBound; x <= xuBound; ++x) {

++                         QVariantList list;

++

++                         dimIndices[0] = x;

++                         for (long y = ylBound; y <= yuBound; ++y) {

++                             VARIANT var;

++                             VariantInit(&var);

++                             dimIndices[1] = y;

++                             SafeArrayGetElement(array, dimIndices, &var);

++

++                             QVariant qvar = VARIANTToQVariant(var, nullptr);

++                             clearVARIANT(&var);

++                             list << qvar;

++                         }

++

++                         listList << QVariant(list);

++                     }

++                     var = listList;

++                 }

++                 break;

++             default:

++                 var = QVariantList();

++                 break;

++             }

++         }

++         break;

++

++     case VT_ARRAY|VT_BSTR:

++     case VT_ARRAY|VT_BSTR|VT_BYREF:

++         {

++             SAFEARRAY *array = nullptr;

++             if (arg.vt & VT_BYREF)

++                 array = *arg.pparray;

++             else

++                 array = arg.parray;

++

++             QStringList strings;

++             if (!array || array->cDims != 1) {

++                 var = strings;

++                 break;

++             }

++

++             long lBound, uBound;

++             SafeArrayGetLBound(array, 1, &lBound);

++             SafeArrayGetUBound(array, 1, &uBound);

++

++             for (long i = lBound; i <= uBound; ++i) {

++                 BSTR bstr;

++                 SafeArrayGetElement(array, &i, &bstr);

++                 strings << QString::fromWCharArray(bstr);

++                 SysFreeString(bstr);

++             }

++

++             var = strings;

++         }

++         break;

++

++     case VT_ARRAY|VT_UI1:

++     case VT_ARRAY|VT_UI1|VT_BYREF:

++         {

++             SAFEARRAY *array = nullptr;

++             if (arg.vt & VT_BYREF)

++                 array = *arg.pparray;

++             else

++                 array = arg.parray;

++

++             QByteArray bytes;

++             if (!array || array->cDims != 1) {

++                 var = bytes;

++                 break;

++             }

++

++             long lBound, uBound;

++             SafeArrayGetLBound(array, 1, &lBound);

++             SafeArrayGetUBound(array, 1, &uBound);

++

++             if (uBound != -1) { // non-empty array

++                 bytes.resize(uBound - lBound + 1);

++                 char *data = bytes.data();

++                 char *src;

++                 SafeArrayAccessData(array, reinterpret_cast<void**>(&src));

++                 memcpy(data, src, bytes.size());

++                 SafeArrayUnaccessData(array);

++             }

++

++             var = bytes;

++         }

++         break;

++

++ #if defined(QAX_SERVER)

++     case VT_RECORD:

++     case VT_RECORD|VT_BYREF:

++         if (arg.pvRecord && arg.pRecInfo) {

++             IRecordInfo *recordInfo = arg.pRecInfo;

++             void *record = arg.pvRecord;

++             GUID guid;

++             recordInfo->GetGuid(&guid);

++

++             if (guid == CLSID_QRect) {

++                 QRect qrect;

++                 recordInfo->RecordCopy(record, &qrect);

++                 var = qrect;

++             } else if (guid == CLSID_QSize) {

++                 QSize qsize;

++                 recordInfo->RecordCopy(record, &qsize);

++                 var = qsize;

++             } else if (guid == CLSID_QPoint) {

++                 QPoint qpoint;

++                 recordInfo->RecordCopy(record, &qpoint);

++                 var = qpoint;

++             }

++         }

++         break;

++ #endif // QAX_SERVER

++     default:

++         // support for any SAFEARRAY(Type) where Type can be converted to a QVariant

++         // -> QVariantList

++         if (arg.vt & VT_ARRAY) {

++             SAFEARRAY *array = nullptr;

++             if (arg.vt & VT_BYREF)

++                 array = *arg.pparray;

++             else

++                 array = arg.parray;

++

++             QVariantList list;

++             if (!array || array->cDims != 1) {

++                 var = list;

++                 break;

++             }

++

++             // find out where to store the element

++             VARTYPE vt;

++             VARIANT variant;

++             SafeArrayGetVartype(array, &vt);

++

++             void *pElement = nullptr;

++             switch(vt) {

++             case VT_BSTR: Q_ASSERT(false); break; // already covered

++             case VT_BOOL: pElement = &variant.boolVal; break;

++             case VT_I1: pElement = &variant.cVal; break;

++             case VT_I2: pElement = &variant.iVal; break;

++             case VT_I4: pElement = &variant.lVal; break;

++             case VT_I8: pElement = &variant.llVal; break;

++             case VT_UI8: pElement = &variant.ullVal; break;

++             case VT_INT: pElement = &variant.intVal; break;

++             case VT_UI1: Q_ASSERT(false); break; // already covered

++             case VT_UI2: pElement = &variant.uiVal; break;

++             case VT_UI4: pElement = &variant.ulVal; break;

++             case VT_UINT: pElement = &variant.uintVal; break;

++             case VT_CY: pElement = &variant.cyVal; break;

++             case VT_R4: pElement = &variant.fltVal; break;

++             case VT_R8: pElement = &variant.dblVal; break;

++             case VT_DATE: pElement = &variant.date; break;

++             case VT_VARIANT: Q_ASSERT(false); break; // already covered

++             default:

++                 break;

++             }

++             if (!pElement) {

++                 var = list;

++                 break;

++             }

++

++             long lBound, uBound;

++             SafeArrayGetLBound( array, 1, &lBound );

++             SafeArrayGetUBound( array, 1, &uBound );

++

++             for ( long i = lBound; i <= uBound; ++i ) {

++                 variant.vt = vt;

++                 SafeArrayGetElement(array, &i, pElement);

++                 QVariant qvar = VARIANTToQVariant(variant, nullptr);

++                 clearVARIANT(&variant);

++                 list << qvar;

++             }

++

++             var = list;

++         }

++         break;

++     }

++

++     const int proptype = type != QMetaType::UnknownType || typeName.isEmpty() || typeName == "QVariant"

++         ? type : nameTypeId;

++

++     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.metaType().id() == QMetaType::QVariantList) {

++             bool allStrings = true;

++             QStringList strings;

++             const QVariantList list(var.toList());

++             for (const QVariant &variant : list) {

++                 if (variant.canConvert<QString>())

++                     strings << variant.toString();

++                 else

++                     allStrings = false;

++             }

++             if (allStrings)

++                 var = strings;

++         } else {

++             var = QVariant();

++         }

++     }

++     return var;

++ }

++

++ QT_END_NAMESPACE

Revision control