qaxbase.cpp File Reference

#include "qaxobject.h"
#include <qfile.h>
#include <qwidget.h>
#include <quuid.h>
#include <qhash.h>
#include <qset.h>
#include <qpair.h>
#include <qmetaobject.h>
#include <qsettings.h>
#include <qmutex.h>
#include <qt_windows.h>
#include <ocidl.h>
#include <ctype.h>
#include "../shared/qaxtypes.h"

Go to the source code of this file.

Classes
class	MetaObjectGenerator
struct	MetaObjectGenerator::Method
struct	MetaObjectGenerator::Property
class	QAxBasePrivate
class	QAxEventSink
struct	QAxMetaObject
class	QtPropertyBag

Macros
#define	QT_CHECK_STATE
#define	VT_UNHANDLED(x)   case VT_##x: qWarning("QAxBase: Unhandled type %s", #x); str = #x; break;

Functions
static bool	checkHRESULT (HRESULT hres, EXCEPINFO *exc, QAxBase *that, const QString &name, uint argerr)
void *	qax_createObjectWrapper (int metaType, IUnknown *iface)
static void	qax_noSuchFunction (int disptype, const QByteArray &name, const QByteArray &function, const QAxBase *that)
QMetaObject *	qax_readClassInfo (ITypeLib *typeLib, ITypeInfo *classInfo, const QMetaObject *parentObject)
QMetaObject *	qax_readEnumInfo (ITypeLib *typeLib, const QMetaObject *parentObject)
QMetaObject *	qax_readInterfaceInfo (ITypeLib *typeLib, ITypeInfo *typeInfo, const QMetaObject *parentObject)

Variables
static QMutex	cache_mutex
static QHash< QUuid, QMap< QByteArray, QList< QPair< QByteArray, int > > > >	enum_cache
static QHash< QString, QAxMetaObject * >	mo_cache
static int	mo_cache_ref = 0
bool	qax_dispatchEqualsIDispatch = true
QList< QByteArray >	qax_qualified_usertypes
static QMetaObject	qaxobject_staticMetaObject
static QMetaObject	qaxwidget_staticMetaObject
static const uint	qt_meta_data_QAxBase []
static const char	qt_meta_stringdata_QAxBase []
static const char *const	type_conversion [][2]

Macro Definition Documentation

QT_CHECK_STATE

#define QT_CHECK_STATE

Definition at line 43 of file qaxbase.cpp.

VT_UNHANDLED

#define VT_UNHANDLED

(

x

)

case VT_##x: qWarning("QAxBase: Unhandled type %s", #x); str = #x; break;

Definition at line 1975 of file qaxbase.cpp.

Referenced by MetaObjectGenerator::guessTypes().

Function Documentation

checkHRESULT()

static bool checkHRESULT ( HRESULT  hres, EXCEPINFO *  exc, QAxBase *  that, const QString &  name, uint  argerr  )

static

Definition at line 3396 of file qaxbase.cpp.

Referenced by QAxBase::dynamicCallHelper(), QAxBase::internalInvoke(), and QAxBase::internalProperty().

{
    switch(hres) {
    case S_OK:
        return true;
    case DISP_E_BADPARAMCOUNT:
        qWarning("QAxBase: Error calling IDispatch member %s: Bad parameter count", name.toLatin1().data());
        return false;
    case DISP_E_BADVARTYPE:
        qWarning("QAxBase: Error calling IDispatch member %s: Bad variant type", name.toLatin1().data());
        return false;
    case DISP_E_EXCEPTION:
        {
            bool printWarning = true;
            unsigned short code = -1;
            QString source, desc, help;
            const QMetaObject *mo = that->metaObject();
            int exceptionSignal = mo->indexOfSignal("exception(int,QString,QString,QString)");
            if (exceptionSignal >= 0) {
                if (exc->pfnDeferredFillIn)
                    exc->pfnDeferredFillIn(exc);

                code = exc->wCode ? exc->wCode : exc->scode;
                source = QString::fromWCharArray(exc->bstrSource);
                desc = QString::fromWCharArray(exc->bstrDescription);
                help = QString::fromWCharArray(exc->bstrHelpFile);
                uint helpContext = exc->dwHelpContext;

                if (helpContext && !help.isEmpty())
                    help += QString::fromLatin1(" [%1]").arg(helpContext);

                if (QAxEventSink::signalHasReceivers(that->qObject(), "exception(int,QString,QString,QString)")) {
                    void *argv[] = {0, &code, &source, &desc, &help};
                    that->qt_metacall(QMetaObject::InvokeMetaMethod, exceptionSignal, argv);
                    printWarning = false;
                }
            }
            if (printWarning) {
                qWarning("QAxBase: Error calling IDispatch member %s: Exception thrown by server", name.toLatin1().data());
                qWarning("             Code       : %d", code);
                qWarning("             Source     : %s", source.toLatin1().data());
                qWarning("             Description: %s", desc.toLatin1().data());
                qWarning("             Help       : %s", help.toLatin1().data());
                qWarning("         Connect to the exception(int,QString,QString,QString) signal to catch this exception");
            }
        }
        return false;
    case DISP_E_MEMBERNOTFOUND:
        qWarning("QAxBase: Error calling IDispatch member %s: Member not found", name.toLatin1().data());
        return false;
    case DISP_E_NONAMEDARGS:
        qWarning("QAxBase: Error calling IDispatch member %s: No named arguments", name.toLatin1().data());
        return false;
    case DISP_E_OVERFLOW:
        qWarning("QAxBase: Error calling IDispatch member %s: Overflow", name.toLatin1().data());
        return false;
    case DISP_E_PARAMNOTFOUND:
        qWarning("QAxBase: Error calling IDispatch member %s: Parameter %d not found", name.toLatin1().data(), argerr);
        return false;
    case DISP_E_TYPEMISMATCH:
        qWarning("QAxBase: Error calling IDispatch member %s: Type mismatch in parameter %d", name.toLatin1().data(), argerr);
        return false;
    case DISP_E_UNKNOWNINTERFACE:
        qWarning("QAxBase: Error calling IDispatch member %s: Unknown interface", name.toLatin1().data());
        return false;
    case DISP_E_UNKNOWNLCID:
        qWarning("QAxBase: Error calling IDispatch member %s: Unknown locale ID", name.toLatin1().data());
        return false;
    case DISP_E_PARAMNOTOPTIONAL:
        qWarning("QAxBase: Error calling IDispatch member %s: Non-optional parameter missing", name.toLatin1().data());
        return false;
    default:
        qWarning("QAxBase: Error calling IDispatch member %s: Unknown error", name.toLatin1().data());
        return false;
    }
}

qax_createObjectWrapper()

void* qax_createObjectWrapper	(	int	metaType,
		IUnknown *	iface
	)

Definition at line 4448 of file qaxbase.cpp.

Referenced by VARIANTToQVariant().

{
    if (!iface)
        return 0;

    QAxObject *object = (QAxObject*)QMetaType::construct(metaType, 0);
    QAxBasePrivate *d = object->d;

    d->ptr = iface;
    d->initialized = true;

    // no release, since no addref

    return object;
}

qax_noSuchFunction()

static void qax_noSuchFunction ( int  disptype, const QByteArray &  name, const QByteArray &  function, const QAxBase *  that  )

static

Definition at line 3748 of file qaxbase.cpp.

Referenced by QAxBase::dynamicCallHelper().

{
    const QMetaObject *metaObject = that->metaObject();
    const char *coclass = metaObject->classInfo(metaObject->indexOfClassInfo("CoClass")).value();

    if (disptype == DISPATCH_METHOD) {
        qWarning("QAxBase::dynamicCallHelper: %s: No such method in %s [%s]", name.data(), that->control().toLatin1().data(), coclass ? coclass: "unknown");
        qWarning("\tCandidates are:");
        for (int i = 0; i < metaObject->methodCount(); ++i) {
            const QMetaMethod slot(metaObject->method(i));
            if (slot.methodType() != QMetaMethod::Slot)
                continue;
            QByteArray signature = slot.signature();
            if (signature.toLower().startsWith(function.toLower()))
                qWarning("\t\t%s", signature.data());
        }
    } else {
        qWarning("QAxBase::dynamicCallHelper: %s: No such property in %s [%s]", name.data(), that->control().toLatin1().data(), coclass ? coclass: "unknown");
        if (!function.isEmpty()) {
            qWarning("\tCandidates are:");
            char f0 = function.toLower().at(0);
            for (int i = metaObject->propertyOffset(); i < metaObject->propertyCount(); ++i) {
                QByteArray signature(metaObject->property(i).name());
                if (!signature.isEmpty() && signature.toLower().at(0) == f0)
                    qWarning("\t\t%s", signature.data());
            }
        }
    }
}

qax_readClassInfo()

QMetaObject* qax_readClassInfo	(	ITypeLib *	typeLib,
		ITypeInfo *	classInfo,
		const QMetaObject *	parentObject
	)

Definition at line 1772 of file qaxbase.cpp.

{
    MetaObjectGenerator generator(typeLib, 0);
    generator.addSignal("exception(int,QString,QString,QString)", "code,source,disc,help");
    generator.addSignal("propertyChanged(QString)", "name");

    QString className;
    BSTR bstr;
    if (S_OK != classInfo->GetDocumentation(-1, &bstr, 0, 0, 0))
        return 0;

    className = QString::fromWCharArray(bstr);
    SysFreeString(bstr);

    generator.readEnumInfo();

    TYPEATTR *typeattr;
    classInfo->GetTypeAttr(&typeattr);
    if (typeattr) {
        int nInterfaces = typeattr->cImplTypes;
        classInfo->ReleaseTypeAttr(typeattr);

        for (int index = 0; index < nInterfaces; ++index) {
            HREFTYPE refType;
            if (S_OK != classInfo->GetRefTypeOfImplType(index, &refType))
                continue;

            int flags = 0;
            classInfo->GetImplTypeFlags(index, &flags);
            if (flags & IMPLTYPEFLAG_FRESTRICTED)
                continue;

            ITypeInfo *interfaceInfo = 0;
            classInfo->GetRefTypeInfo(refType, &interfaceInfo);
            if (!interfaceInfo)
                continue;

            interfaceInfo->GetDocumentation(-1, &bstr, 0, 0, 0);
            QString interfaceName = QString::fromWCharArray(bstr);
            SysFreeString(bstr);
            QByteArray key;

            TYPEATTR *typeattr = 0;
            interfaceInfo->GetTypeAttr(&typeattr);

            if (flags & IMPLTYPEFLAG_FSOURCE) {
                if (typeattr && !(typeattr->wTypeFlags & TYPEFLAG_FHIDDEN))
                    key = "Event Interface " + QByteArray::number(index);
                generator.readEventInterface(interfaceInfo, 0);
            } else {
                if (typeattr && !(typeattr->wTypeFlags & TYPEFLAG_FHIDDEN))
                    key = "Interface " + QByteArray::number(index);
                generator.readFuncsInfo(interfaceInfo, 0);
                generator.readVarsInfo(interfaceInfo, 0);
            }
            if (!key.isEmpty())
                generator.addClassInfo(key.data(), interfaceName.toLatin1());

            if (typeattr)
                interfaceInfo->ReleaseTypeAttr(typeattr);
            interfaceInfo->Release();
        }
    }

    return generator.metaObject(parentObject, className.toLatin1());
}

qax_readEnumInfo()

QMetaObject* qax_readEnumInfo	(	ITypeLib *	typeLib,
		const QMetaObject *	parentObject
	)

Definition at line 1745 of file qaxbase.cpp.

{
    MetaObjectGenerator generator(typeLib, 0);

    generator.readEnumInfo();
    return generator.metaObject(parentObject, "EnumInfo");
}

qax_readInterfaceInfo()

QMetaObject* qax_readInterfaceInfo	(	ITypeLib *	typeLib,
		ITypeInfo *	typeInfo,
		const QMetaObject *	parentObject
	)

Definition at line 1753 of file qaxbase.cpp.

{
    MetaObjectGenerator generator(typeLib, typeInfo);

    QString className;
    BSTR bstr;
    if (S_OK != typeInfo->GetDocumentation(-1, &bstr, 0, 0, 0))
        return 0;

    className = QString::fromWCharArray(bstr);
    SysFreeString(bstr);

    generator.readEnumInfo();
    generator.readFuncsInfo(typeInfo, 0);
    generator.readVarsInfo(typeInfo, 0);

    return generator.metaObject(parentObject, className.toLatin1());
}

Variable Documentation

cache_mutex

QMutex cache_mutex

static

Definition at line 186 of file qaxbase.cpp.

enum_cache

QHash<QUuid, QMap<QByteArray, QList<QPair<QByteArray, int> > > > enum_cache

static

Definition at line 184 of file qaxbase.cpp.

mo_cache

QHash<QString, QAxMetaObject*> mo_cache

static

Definition at line 183 of file qaxbase.cpp.

mo_cache_ref

int mo_cache_ref = 0

static

Definition at line 185 of file qaxbase.cpp.

Referenced by QAxBasePrivate::QAxBasePrivate(), and QAxBasePrivate::~QAxBasePrivate().

qax_dispatchEqualsIDispatch

bool qax_dispatchEqualsIDispatch = true

Definition at line 1886 of file qaxbase.cpp.

Referenced by MetaObjectGenerator::readClassInfo(), and MetaObjectGenerator::usertypeToString().

qax_qualified_usertypes

QList<QByteArray> qax_qualified_usertypes

Definition at line 1887 of file qaxbase.cpp.

qaxobject_staticMetaObject

QMetaObject qaxobject_staticMetaObject

static

Initial value:

= {
    { &QObject::staticMetaObject, qt_meta_stringdata_QAxBase,
        qt_meta_data_QAxBase, 0 }
}

Definition at line 3226 of file qaxbase.cpp.

Referenced by QAxBase::metaObject().

qaxwidget_staticMetaObject

QMetaObject qaxwidget_staticMetaObject

static

Initial value:

= {
    { &QWidget::staticMetaObject, qt_meta_stringdata_QAxBase,
        qt_meta_data_QAxBase, 0 }
}

Definition at line 3230 of file qaxbase.cpp.

Referenced by QAxBase::metaObject().

qt_meta_data_QAxBase

const uint qt_meta_data_QAxBase[]

static

Initial value:

= {

 
       1,       
       0,       
       0,    0, 
       3,   10, 
       1,   25, 
       0,    0, 

 
      24,    9,    8,    8, 0x05,
      55,   50,    8,    8, 0x05,
     102,   80,    8,    8, 0x05,

 
     149,  141, 0x0a095103,

       0        
}

Definition at line 3199 of file qaxbase.cpp.

qt_meta_stringdata_QAxBase

const char qt_meta_stringdata_QAxBase[]

static

Initial value:

= {
    "QAxBase\0\0name,argc,argv\0signal(QString,int,void*)\0name\0"
    "propertyChanged(QString)\0code,source,desc,help\0"
    "exception(int,QString,QString,QString)\0QString\0control\0"
}

Definition at line 3220 of file qaxbase.cpp.

type_conversion

const char* const type_conversion[][2]

static

Initial value:

=
{
    { "float", "double"},
    { "short", "int"},
    { "char", "int"},
    { "QList<int>", "QVariantList" },
    { "QList<uint>", "QVariantList" },
    { "QList<double>", "QVariantList" },
    { "QList<bool>", "QVariantList" },
    { "QList<QDateTime>", "QVariantList" },
    { "QList<qlonglong>", "QVariantList" },
    { 0, 0 }
}

Definition at line 189 of file qaxbase.cpp.

Referenced by QAxEventSink::addSignal(), MetaObjectGenerator::replacePrototype(), and MetaObjectGenerator::replaceType().