diff options
Diffstat (limited to 'src/activeqt/shared')
| -rw-r--r-- | src/activeqt/shared/qaxtypes.cpp | 1486 | ||||
| -rw-r--r-- | src/activeqt/shared/qaxtypes.h | 97 |
2 files changed, 1583 insertions, 0 deletions
diff --git a/src/activeqt/shared/qaxtypes.cpp b/src/activeqt/shared/qaxtypes.cpp new file mode 100644 index 0000000..ace81e7 --- /dev/null +++ b/src/activeqt/shared/qaxtypes.cpp @@ -0,0 +1,1486 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the ActiveQt framework of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef UNICODE +#define UNICODE +#endif + + +#include <ocidl.h> +#include <olectl.h> + +#include "qaxtypes.h" + +#ifndef QT_NO_WIN_ACTIVEQT + +#include <qcolormap.h> +#include <qcursor.h> +#include <qpixmap.h> +#include <qpainter.h> +#include <qobject.h> +#ifdef QAX_SERVER +# include <qaxfactory.h> +# include <qlibrary.h> +#else +# include <quuid.h> +# include <qaxobject.h> +#endif + +QT_BEGIN_NAMESPACE + +#ifdef QAX_SERVER +extern 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 } }; + +GUID IID_IAxServerBase = { 0xbd2ec165, 0xdfc9, 0x4319, { 0x8b, 0x9b, 0x60, 0xa5, 0x74, 0x78, 0xe9, 0xe3} }; +#else +extern void *qax_createObjectWrapper(int metaType, IUnknown *iface); +#endif + +static IFontDisp *QFontToIFont(const QFont &font) +{ +#if defined(Q_OS_WINCE) + Q_UNUSED(font); + return 0; +#else + 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; + + IFontDisp *f; + HRESULT res = OleCreateFontIndirect(&fdesc, IID_IFontDisp, (void**)&f); + if (res != S_OK) { + if (f) f->Release(); + f = 0; +#if defined(QT_CHECK_STATE) + qWarning("QFontToIFont: Failed to create IFont"); +#endif + } + return f; +#endif +} + +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::fromUtf16((const ushort *)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) +{ +#if defined(Q_OS_WINCE) + Q_UNUSED(pixmap); + return 0; +#else + IPictureDisp *pic = 0; + + PICTDESC desc; + desc.cbSizeofstruct = sizeof(PICTDESC); + desc.picType = PICTYPE_BITMAP; + + desc.bmp.hbitmap = 0; + desc.bmp.hpal = QColormap::hPal(); + + if (!pixmap.isNull()) { + desc.bmp.hbitmap = pixmap.toWinHBITMAP(); + Q_ASSERT(desc.bmp.hbitmap); + } + + HRESULT res = OleCreatePictureIndirect(&desc, IID_IPictureDisp, true, (void**)&pic); + if (res != S_OK) { + if (pic) pic->Release(); + pic = 0; +#if defined(QT_CHECK_STATE) + qWarning("QPixmapToIPicture: Failed to create IPicture"); +#endif + } + return pic; +#endif +} + +static QPixmap IPictureToQPixmap(IPicture *ipic) +{ + SHORT type; + ipic->get_Type(&type); + if (type != PICTYPE_BITMAP) + return QPixmap(); + + HBITMAP hbm = 0; + ipic->get_Handle((OLE_HANDLE*)&hbm); + if (!hbm) + return QPixmap(); + + return QPixmap::fromWinHBITMAP(hbm); +} + +static QDateTime DATEToQDateTime(DATE ole) +{ + SYSTEMTIME stime; + if (ole >= 949998 || VariantTimeToSystemTime(ole, &stime) == false) + 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; +} + +QColor OLEColorToQColor(uint col) +{ +#if defined(Q_OS_WINCE) + return QColor(GetBValue(col),GetGValue(col),GetRValue(col)); +#else + COLORREF cref; + OleTranslateColor(col, QColormap::hPal(), &cref); + return QColor(GetRValue(cref),GetGValue(cref),GetBValue(cref)); +#endif +} + +/* + 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. +*/ +bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName, bool out) +{ + QVariant qvar = var; + // "type" is the expected type, so coerce if necessary + QVariant::Type proptype = typeName.isEmpty() ? QVariant::Invalid : QVariant::nameToType(typeName); + if (proptype == QVariant::UserType && !typeName.isEmpty()) { + if (typeName == "short" || typeName == "char") + proptype = QVariant::Int; + else if (typeName == "float") + proptype = QVariant::Double; + } + if (proptype != QVariant::Invalid && proptype != QVariant::UserType && proptype != qvar.type()) { + if (qvar.canConvert(proptype)) + qvar.convert(proptype); + else + qvar = QVariant(proptype); + } + + if (out && arg.vt == (VT_VARIANT|VT_BYREF) && arg.pvarVal) { + return QVariantToVARIANT(var, *arg.pvarVal, typeName, false); + } + + if (out && proptype == QVariant::Invalid && typeName == "QVariant") { + VARIANT *pVariant = new VARIANT; + QVariantToVARIANT(var, *pVariant, QByteArray(), false); + arg.vt = VT_VARIANT|VT_BYREF; + arg.pvarVal = pVariant; + return true; + } + + switch ((int)qvar.type()) { + case QVariant::String: + 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 QVariant::Int: + if (out && arg.vt == (VT_I4|VT_BYREF)) { + *arg.plVal = qvar.toInt(); + } else { + arg.vt = VT_I4; + arg.lVal = qvar.toInt(); + if (out) { + if (typeName == "short") { + arg.vt = VT_I2; + arg.piVal = new short(arg.lVal); + } else if (typeName == "char") { + arg.vt = VT_I1; + arg.pcVal= new char(arg.lVal); + } else { + arg.plVal = new long(arg.lVal); + } + arg.vt |= VT_BYREF; + } + } + break; + + case QVariant::UInt: + if (out && (arg.vt == (VT_UINT|VT_BYREF) || arg.vt == (VT_I4|VT_BYREF))) { + *arg.puintVal = qvar.toUInt(); + } else { + arg.vt = VT_UINT; + arg.uintVal = qvar.toUInt(); + if (out) { + arg.puintVal = new uint(arg.uintVal); + arg.vt |= VT_BYREF; + } + } + break; + + case QVariant::LongLong: + if (out && arg.vt == (VT_CY|VT_BYREF)) { + arg.pcyVal->int64 = qvar.toLongLong(); +#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400 + } else if (out && arg.vt == (VT_I8|VT_BYREF)) { + *arg.pllVal = qvar.toLongLong(); + } else { + arg.vt = VT_I8; + arg.llVal = qvar.toLongLong(); + if (out) { + arg.pllVal = new LONGLONG(arg.llVal); + arg.vt |= VT_BYREF; + } + } +#else + } else { + arg.vt = VT_CY; + arg.cyVal.int64 = qvar.toLongLong(); + if (out) { + arg.pcyVal = new CY(arg.cyVal); + arg.vt |= VT_BYREF; + } + } +#endif + break; + + case QVariant::ULongLong: + if (out && arg.vt == (VT_CY|VT_BYREF)) { + arg.pcyVal->int64 = qvar.toULongLong(); +#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400 + } else if (out && arg.vt == (VT_UI8|VT_BYREF)) { + *arg.pullVal = qvar.toULongLong(); + } else { + arg.vt = VT_UI8; + arg.ullVal = qvar.toULongLong(); + if (out) { + arg.pullVal = new ULONGLONG(arg.ullVal); + arg.vt |= VT_BYREF; + } + } +#else + } else { + arg.vt = VT_CY; + arg.cyVal.int64 = qvar.toULongLong(); + if (out) { + arg.pcyVal = new CY(arg.cyVal); + arg.vt |= VT_BYREF; + } + } + +#endif + + break; + + case QVariant::Bool: + if (out && arg.vt == (VT_BOOL|VT_BYREF)) { + *arg.pboolVal = qvar.toBool() ? VARIANT_TRUE : VARIANT_FALSE; + } else { + arg.vt = VT_BOOL; + arg.boolVal = qvar.toBool() ? VARIANT_TRUE : VARIANT_FALSE; + if (out) { + arg.pboolVal = new short(arg.boolVal); + arg.vt |= VT_BYREF; + } + } + break; + case QVariant::Double: + if (out && arg.vt == (VT_R8|VT_BYREF)) { + *arg.pdblVal = qvar.toDouble(); + } else { + arg.vt = VT_R8; + arg.dblVal = qvar.toDouble(); + if (out) { + if (typeName == "float") { + arg.vt = VT_R4; + arg.pfltVal = new float(arg.dblVal); + } else { + arg.pdblVal = new double(arg.dblVal); + } + arg.vt |= VT_BYREF; + } + } + break; + case QVariant::Color: + if (out && arg.vt == (VT_COLOR|VT_BYREF)) { + + *arg.plVal = QColorToOLEColor(qvariant_cast<QColor>(qvar)); + } else { + arg.vt = VT_COLOR; + arg.lVal = QColorToOLEColor(qvariant_cast<QColor>(qvar)); + if (out) { + arg.plVal = new long(arg.lVal); + arg.vt |= VT_BYREF; + } + } + break; + + case QVariant::Date: + case QVariant::Time: + case QVariant::DateTime: + if (out && arg.vt == (VT_DATE|VT_BYREF)) { + *arg.pdate = QDateTimeToDATE(qvar.toDateTime()); + } else { + arg.vt = VT_DATE; + arg.date = QDateTimeToDATE(qvar.toDateTime()); + if (out) { + arg.pdate = new DATE(arg.date); + arg.vt |= VT_BYREF; + } + } + break; + case QVariant::Font: + 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 QVariant::Pixmap: + 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 QVariant::Cursor: + { +#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 QVariant::List: + { + const QList<QVariant> list = qvar.toList(); + const int count = list.count(); + VARTYPE vt = VT_VARIANT; + QVariant::Type listType = QVariant::LastType; // == QVariant + if (!typeName.isEmpty() && typeName.startsWith("QList<")) { + const QByteArray listTypeName = typeName.mid(6, typeName.length() - 7); // QList<int> -> int + listType = QVariant::nameToType(listTypeName); + } + + VARIANT variant; + void *pElement = &variant; + switch(listType) { + case QVariant::Int: + vt = VT_I4; + pElement = &variant.lVal; + break; + case QVariant::Double: + vt = VT_R8; + pElement = &variant.dblVal; + break; + case QVariant::DateTime: + vt = VT_DATE; + pElement = &variant.date; + break; + case QVariant::Bool: + vt = VT_BOOL; + pElement = &variant.boolVal; + break; + case QVariant::LongLong: +#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400 + vt = VT_I8; + pElement = &variant.llVal; +#else + vt = VT_CY; + pElement = &variant.cyVal; +#endif + break; + default: + break; + } + SAFEARRAY *array = 0; + bool is2D = false; + // If the first element in the array is a list the whole list is + // treated as a 2D array. The colum count is taken from the 1st element. + if (count) { + QVariantList col = list.at(0).toList(); + int maxColumns = col.count(); + if (maxColumns) { + is2D = true; + SAFEARRAYBOUND rgsabound[2] = {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(); + int columnCount = qMin(maxColumns, columns.count()); + for (LONG j = 0; j < columnCount; ++j) { + QVariant elem = columns.at(j); + VariantInit(&variant); + QVariantToVARIANT(elem, variant, elem.typeName()); + rgIndices[1] = j; + SafeArrayPutElement(array, rgIndices, pElement); + clearVARIANT(&variant); + } + } + + } + } + if (!is2D) { + array = SafeArrayCreateVector(vt, 0, count); + for (LONG index = 0; index < count; ++index) { + QVariant elem = list.at(index); + if (listType != QVariant::LastType) + elem.convert(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 QVariant::StringList: + { + const QStringList list = qvar.toStringList(); + const int count = list.count(); + 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 QVariant::ByteArray: + { + const QByteArray bytes = qvar.toByteArray(); + const uint count = bytes.count(); + SAFEARRAY *array = SafeArrayCreateVector(VT_UI1, 0, count); + if (count) { + const char *data = bytes.constData(); + char *dest; + SafeArrayAccessData(array, (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 QVariant::Rect: + case QVariant::Size: + case QVariant::Point: + { + typedef HRESULT(WINAPI* PGetRecordInfoFromTypeInfo)(ITypeInfo *, IRecordInfo **); + static PGetRecordInfoFromTypeInfo pGetRecordInfoFromTypeInfo = 0; + static bool resolved = false; + if (!resolved) { + resolved = true; + pGetRecordInfoFromTypeInfo = (PGetRecordInfoFromTypeInfo)QLibrary::resolve(QLatin1String("oleaut32"), + "GetRecordInfoFromTypeInfo"); + } + if (!pGetRecordInfoFromTypeInfo) + break; + + ITypeInfo *typeInfo = 0; + IRecordInfo *recordInfo = 0; + CLSID clsid = qvar.type() == QVariant::Rect ? CLSID_QRect + :qvar.type() == QVariant::Size ? CLSID_QSize + :CLSID_QPoint; + qAxTypeLibrary->GetTypeInfoOfGuid(clsid, &typeInfo); + if (!typeInfo) + break; + pGetRecordInfoFromTypeInfo(typeInfo, &recordInfo); + typeInfo->Release(); + if (!recordInfo) + break; + + void *record = 0; + switch (qvar.type()) { + case QVariant::Rect: + { + QRect qrect(qvar.toRect()); + recordInfo->RecordCreateCopy(&qrect, &record); + } + break; + case QVariant::Size: + { + QSize qsize(qvar.toSize()); + recordInfo->RecordCreateCopy(&qsize, &record); + } + break; + case QVariant::Point: + { + QPoint qpoint(qvar.toPoint()); + recordInfo->RecordCreateCopy(&qpoint, &record); + } + break; + } + + arg.vt = VT_RECORD; + arg.pRecInfo = recordInfo, + arg.pvRecord = record; + if (out) { + qWarning("QVariantToVARIANT: out-parameter not supported for records"); + return false; + } + } + break; +#endif // QAX_SERVER + case QVariant::UserType: + { + QByteArray subType = qvar.typeName(); +#ifdef QAX_SERVER + if (subType.endsWith('*')) + subType.truncate(subType.length() - 1); +#endif + if (!qstrcmp(qvar.typeName(), "IDispatch*")) { + arg.vt = VT_DISPATCH; + arg.pdispVal = *(IDispatch**)qvar.data(); + if (arg.pdispVal) + arg.pdispVal->AddRef(); + if (out) { + qWarning("QVariantToVARIANT: out-parameter not supported for IDispatch"); + return false; + } + } else if (!qstrcmp(qvar.typeName(), "IDispatch**")) { + arg.vt = VT_DISPATCH; + arg.ppdispVal = *(IDispatch***)qvar.data(); + if (out) + arg.vt |= VT_BYREF; + } else if (!qstrcmp(qvar.typeName(), "IUnknown*")) { + arg.vt = VT_UNKNOWN; + arg.punkVal = *(IUnknown**)qvar.data(); + if (arg.punkVal) + arg.punkVal->AddRef(); + if (out) { + qWarning("QVariantToVARIANT: out-parameter not supported for IUnknown"); + return false; + } +#ifdef QAX_SERVER + } else if (qAxFactory()->metaObject(QString::fromLatin1(subType.constData()))) { + 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); + } + if (out) { + qWarning("QVariantToVARIANT: out-parameter not supported for subtype"); + return false; + } +#else + } else if (QMetaType::type(subType)) { + QAxObject *object = *(QAxObject**)qvar.constData(); +// qVariantGet(qvar, object, subType); + arg.vt = VT_DISPATCH; + object->queryInterface(IID_IDispatch, (void**)&arg.pdispVal); + if (out) { + qWarning("QVariantToVARIANT: out-parameter not supported for subtype"); + return false; + } +#endif + } else { + 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)); + return true; +} + +/*! + Copies the data in \a var into \a data. + + Used by + + QAxServerBase: + - QAxServerBase::qt_metacall (update out parameters/return value) + + QAxBase: + - internalProperty(ReadProperty) + - internalInvoke(update out parameters/return value) + +*/ +bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, uint type) +{ + if (!data) + return true; + + if (type == QVariant::LastType || (type == 0 && typeName == "QVariant")) { + *(QVariant*)data = var; + return true; + } + + switch (var.type()) { + case QVariant::Invalid: + break; + case QVariant::String: + *(QString*)data = var.toString(); + break; + case QVariant::Int: + *(int*)data = var.toInt(); + break; + case QVariant::UInt: + *(uint*)data = var.toUInt(); + break; + case QVariant::Bool: + *(bool*)data = var.toBool(); + break; + case QVariant::Double: + *(double*)data = var.toDouble(); + break; + case QVariant::Color: + *(QColor*)data = qvariant_cast<QColor>(var); + break; + case QVariant::Date: + *(QDate*)data = var.toDate(); + break; + case QVariant::Time: + *(QTime*)data = var.toTime(); + break; + case QVariant::DateTime: + *(QDateTime*)data = var.toDateTime(); + break; + case QVariant::Font: + *(QFont*)data = qvariant_cast<QFont>(var); + break; + case QVariant::Pixmap: + *(QPixmap*)data = qvariant_cast<QPixmap>(var); + break; +#ifndef QT_NO_CURSOR + case QVariant::Cursor: + *(QCursor*)data = qvariant_cast<QCursor>(var); + break; +#endif + case QVariant::List: + *(QList<QVariant>*)data = var.toList(); + break; + case QVariant::StringList: + *(QStringList*)data = var.toStringList(); + break; + case QVariant::ByteArray: + *(QByteArray*)data = var.toByteArray(); + break; + case QVariant::LongLong: + *(qint64*)data = var.toLongLong(); + break; + case QVariant::ULongLong: + *(quint64*)data = var.toULongLong(); + break; + case QVariant::Rect: + *(QRect*)data = var.toRect(); + break; + case QVariant::Size: + *(QSize*)data = var.toSize(); + break; + case QVariant::Point: + *(QPoint*)data = var.toPoint(); + break; + case QVariant::UserType: + *(void**)data = *(void**)var.constData(); +// qVariantGet(var, *(void**)data, typeName); + break; + default: + qWarning("QVariantToVoidStar: Unhandled QVariant type"); + return false; + } + + return true; +} + +/*! + Returns \a arg as a QVariant of type \a type. + + 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, uint type) +{ + QVariant var; + switch(arg.vt) { + case VT_BSTR: + var = QString::fromUtf16((const ushort *)arg.bstrVal); + break; + case VT_BSTR|VT_BYREF: + var = QString::fromUtf16((const ushort *)*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 = QVariant::Int; + break; + case VT_I1|VT_BYREF: + var = *arg.pcVal; + if (typeName == "char") + type = QVariant::Int; + break; + case VT_I2: + var = arg.iVal; + if (typeName == "short") + type = QVariant::Int; + break; + case VT_I2|VT_BYREF: + var = *arg.piVal; + if (typeName == "short") + type = QVariant::Int; + break; + case VT_I4: + if (type == QVariant::Color || (!type && typeName == "QColor")) + var = qVariantFromValue(OLEColorToQColor(arg.lVal)); +#ifndef QT_NO_CURSOR + else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*"))) + var = qVariantFromValue(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")) + var = qVariantFromValue(OLEColorToQColor((int)*arg.plVal)); +#ifndef QT_NO_CURSOR + else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*"))) + var = qVariantFromValue(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 == QVariant::Color || (!type && typeName == "QColor")) + var = qVariantFromValue(OLEColorToQColor(arg.ulVal)); +#ifndef QT_NO_CURSOR + else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*"))) + var = qVariantFromValue(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")) + var = qVariantFromValue(OLEColorToQColor((uint)*arg.pulVal)); +#ifndef QT_NO_CURSOR + else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*"))) + var = qVariantFromValue(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; +#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400 + 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; +#endif + 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 == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) { + var.convert(QVariant::Date); + } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) { + var.convert(QVariant::Time); + } + break; + case VT_DATE|VT_BYREF: + var = DATEToQDateTime(*arg.pdate); + if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) { + var.convert(QVariant::Date); + } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) { + var.convert(QVariant::Time); + } + 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 = 0; + if (arg.vt & VT_BYREF) + disp = *arg.ppdispVal; + else + disp = arg.pdispVal; + if (type == QVariant::Font || (!type && (typeName == "QFont" || typeName == "QFont*"))) { + IFont *ifont = 0; + if (disp) + disp->QueryInterface(IID_IFont, (void**)&ifont); + if (ifont) { + var = qVariantFromValue(IFontToQFont(ifont)); + ifont->Release(); + } else { + var = qVariantFromValue(QFont()); + } + } else if (type == QVariant::Pixmap || (!type && (typeName == "QPixmap" || typeName == "QPixmap*"))) { + IPicture *ipic = 0; + if (disp) + disp->QueryInterface(IID_IPicture, (void**)&ipic); + if (ipic) { + var = qVariantFromValue(IPictureToQPixmap(ipic)); + ipic->Release(); + } else { + var = qVariantFromValue(QPixmap()); + } + } else { +#ifdef QAX_SERVER + IAxServerBase *iface = 0; + if (disp && typeName != "IDispatch*") + disp->QueryInterface(IID_IAxServerBase, (void**)&iface); + if (iface) { + QObject *qObj = iface->qObject(); + iface->Release(); + var = QVariant(qRegisterMetaType<QObject*>(qObj ? QByteArray(qObj->metaObject()->className()) + "*" : typeName), &qObj); + } else +#endif + { + if (!typeName.isEmpty()) { + if (arg.vt & VT_BYREF) { + var = QVariant(qRegisterMetaType<IDispatch**>("IDispatch**"), &arg.ppdispVal); + } else { +#ifndef QAX_SERVER + if (typeName == "QVariant") { + QAxObject *object = new QAxObject(disp); + var = qVariantFromValue<QAxObject*>(object); + } else if (typeName != "IDispatch*" && QMetaType::type(typeName)) { + QByteArray typeNameStr = QByteArray(typeName); + int pIndex = typeName.lastIndexOf('*'); + if (pIndex != -1) + typeNameStr = typeName.left(pIndex); + int metaType = QMetaType::type(typeNameStr); + Q_ASSERT(metaType != 0); + QAxObject *object = (QAxObject*)qax_createObjectWrapper(metaType, disp); + var = QVariant(QMetaType::type(typeName), &object); + } else +#endif + var = QVariant(qRegisterMetaType<IDispatch*>(typeName), &disp); + } + } + } + } + } + break; + case VT_UNKNOWN: + case VT_UNKNOWN|VT_BYREF: + { + IUnknown *unkn = 0; + if (arg.vt & VT_BYREF) + unkn = *arg.ppunkVal; + else + unkn = arg.punkVal; + qVariantSetValue(var, unkn); + } + break; + case VT_ARRAY|VT_VARIANT: + case VT_ARRAY|VT_VARIANT|VT_BYREF: + { + SAFEARRAY *array = 0; + 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, 0 ); + 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, 0); + 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 = 0; + 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::fromUtf16((const ushort *)bstr); + SysFreeString(bstr); + } + + var = strings; + } + break; + + case VT_ARRAY|VT_UI1: + case VT_ARRAY|VT_UI1|VT_BYREF: + { + SAFEARRAY *array = 0; + 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, (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: +#if !defined(Q_OS_WINCE) + // support for any SAFEARRAY(Type) where Type can be converted to a QVariant + // -> QVariantList + if (arg.vt & VT_ARRAY) { + SAFEARRAY *array = 0; + 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 = 0; + 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; +#if defined(_MSC_VER) && _MSC_VER >= 1400 + case VT_I8: pElement = &variant.llVal; break; + case VT_UI8: pElement = &variant.ullVal; break; +#endif + 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, 0); + clearVARIANT(&variant); + list << qvar; + } + + var = list; + } +#endif + break; + } + + QVariant::Type proptype = (QVariant::Type)type; + if (proptype == QVariant::Invalid && !typeName.isEmpty()) + proptype = QVariant::nameToType(typeName); + if (proptype != QVariant::LastType && proptype != QVariant::Invalid && var.type() != proptype) { + if (var.canConvert(proptype)) { + QVariant oldvar = var; + if (oldvar.convert(proptype)) + var = oldvar; + } else if (proptype == QVariant::StringList && var.type() == QVariant::List) { + bool allStrings = true; + QStringList strings; + const QList<QVariant> list(var.toList()); + for (QList<QVariant>::ConstIterator it(list.begin()); it != list.end(); ++it) { + QVariant variant = *it; + if (variant.canConvert(QVariant::String)) + strings << variant.toString(); + else + allStrings = false; + } + if (allStrings) + var = strings; + } else { + var = QVariant(); + } + } + return var; +} + +void clearVARIANT(VARIANT *var) +{ + if (var->vt & VT_BYREF) { + switch(var->vt) { + case VT_BSTR|VT_BYREF: + SysFreeString(*var->pbstrVal); + delete var->pbstrVal; + break; + case VT_BOOL|VT_BYREF: + delete var->pboolVal; + break; + case VT_I1|VT_BYREF: + delete var->pcVal; + break; + case VT_I2|VT_BYREF: + delete var->piVal; + break; + case VT_I4|VT_BYREF: + delete var->plVal; + break; + case VT_INT|VT_BYREF: + delete var->pintVal; + break; + case VT_UI1|VT_BYREF: + delete var->pbVal; + break; + case VT_UI2|VT_BYREF: + delete var->puiVal; + break; + case VT_UI4|VT_BYREF: + delete var->pulVal; + break; + case VT_UINT|VT_BYREF: + delete var->puintVal; + break; +#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400 + case VT_I8|VT_BYREF: + delete var->pllVal; + break; + case VT_UI8|VT_BYREF: + delete var->pullVal; + break; +#endif + case VT_CY|VT_BYREF: + delete var->pcyVal; + break; + case VT_R4|VT_BYREF: + delete var->pfltVal; + break; + case VT_R8|VT_BYREF: + delete var->pdblVal; + break; + case VT_DATE|VT_BYREF: + delete var->pdate; + break; + case VT_DISPATCH|VT_BYREF: + (*var->ppdispVal)->Release(); + delete var->ppdispVal; + break; + case VT_ARRAY|VT_VARIANT|VT_BYREF: + case VT_ARRAY|VT_UI1|VT_BYREF: + case VT_ARRAY|VT_BSTR|VT_BYREF: + SafeArrayDestroy(*var->pparray); + delete var->pparray; + break; + case VT_VARIANT|VT_BYREF: + delete var->pvarVal; + break; + } + VariantInit(var); + } else { + VariantClear(var); + } +} + +QT_END_NAMESPACE +#endif // QT_NO_WIN_ACTIVEQT diff --git a/src/activeqt/shared/qaxtypes.h b/src/activeqt/shared/qaxtypes.h new file mode 100644 index 0000000..a29030f --- /dev/null +++ b/src/activeqt/shared/qaxtypes.h @@ -0,0 +1,97 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (qt-info@nokia.com) +** +** This file is part of the ActiveQt framework of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QAXTYPES_H +#define QAXTYPES_H + +#if !defined(_WINDOWS_) && !defined(_WINDOWS_H) && !defined(__WINDOWS__) +#error Must include windows.h first! +#endif + +#include <QtGui/qcolor.h> +#include <QtGui/qfont.h> +#include <QtCore/qdatetime.h> +#include <QtCore/qvariant.h> + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(ActiveQt) + +#ifndef QT_NO_WIN_ACTIVEQT + +extern GUID IID_IAxServerBase; +struct IAxServerBase : public IUnknown +{ + virtual IUnknown *clientSite() const = 0; + virtual void emitPropertyChanged(const char*) = 0; + virtual bool emitRequestPropertyChange(const char*) = 0; + virtual QObject *qObject() const = 0; + virtual void reportError(int code, const QString &src, const QString &desc, const QString &context) = 0; +}; + +#define HIMETRIC_PER_INCH 2540 +#define MAP_PIX_TO_LOGHIM(x,ppli) ((HIMETRIC_PER_INCH*(x) + ((ppli)>>1)) / (ppli)) +#define MAP_LOGHIM_TO_PIX(x,ppli) (((ppli)*(x) + HIMETRIC_PER_INCH/2) / HIMETRIC_PER_INCH) +#define QAX_NUM_PARAMS 8 + +static inline BSTR QStringToBSTR(const QString &str) +{ + return SysAllocStringLen((OLECHAR*)str.unicode(), str.length()); +} + +static inline uint QColorToOLEColor(const QColor &col) +{ + return qRgba(col.blue(), col.green(), col.red(), 0x00); +} + +extern QColor OLEColorToQColor(uint col); + +extern bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName = 0, bool out = false); +extern QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint type = 0); +extern bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, uint type = 0); +extern void clearVARIANT(VARIANT *var); + +QT_END_NAMESPACE +#endif // QT_NO_WIN_ACTIVEQT + +QT_END_HEADER + +#endif // QAXTYPES_H |