Google Git
Sign in
android / platform / external / qt / 9adc00701674d3638e8a2d68e450a6b1a66f0294 / . / Mac-4.7.4 / src / activeqt / container / qaxbase.cpp
blob: a798cd38374ebb2a5b9e033b16d22ca9e6b16792 [file] [log] [blame]
/****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (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$
**
****************************************************************************/
//#define QAX_NO_CLASSINFO
#define QT_CHECK_STATE
#include "qaxobject.h"
#ifndef QT_NO_WIN_ACTIVEQT
#include <qfile.h>
#include <qwidget.h>
#include <quuid.h>
#include <qhash.h>
#include <qset.h>
#include <qpair.h>
#include <qmetaobject.h>
#include <qsettings.h>
#ifndef QT_NO_THREAD
# include <qmutex.h>
#endif
#include <qt_windows.h>
#include <ocidl.h>
#include <ctype.h>
#include "../shared/qaxtypes.h"
QT_BEGIN_NAMESPACE
/*
\internal
\class QAxMetaObject
\brief The QAxMetaObject class stores extended information
*/
struct QAxMetaObject : public QMetaObject
{
QAxMetaObject()
{
d.data = 0;
d.stringdata = 0;
}
~QAxMetaObject()
{
delete [] (int*)d.data;
delete [] (char*)d.stringdata;
}
int numParameter(const QByteArray &prototype);
QByteArray paramType(const QByteArray &signature, int index, bool *out = 0);
QByteArray propertyType(const QByteArray &propertyName);
void parsePrototype(const QByteArray &prototype);
DISPID dispIDofName(const QByteArray &name, IDispatch *disp);
private:
friend class MetaObjectGenerator;
// save information about QAxEventSink connections, and connect when found in cache
QList<QUuid> connectionInterfaces;
// DISPID -> signal name
QMap< QUuid, QMap<DISPID, QByteArray> > sigs;
// DISPID -> property changed signal name
QMap< QUuid, QMap<DISPID, QByteArray> > propsigs;
// DISPID -> property name
QMap< QUuid, QMap<DISPID, QByteArray> > props;
// Prototype -> member info
QHash<QByteArray, QList<QByteArray> > memberInfo;
QMap<QByteArray, QByteArray> realPrototype;
// DISPID cache
QHash<QByteArray, DISPID> dispIDs;
};
void QAxMetaObject::parsePrototype(const QByteArray &prototype)
{
QByteArray realProto = realPrototype.value(prototype, prototype);
QByteArray parameters = realProto.mid(realProto.indexOf('(') + 1);
parameters.truncate(parameters.length() - 1);
if (parameters.isEmpty()) {
memberInfo.insert(prototype, QList<QByteArray>());
} else {
QList<QByteArray> plist = parameters.split(',');
memberInfo.insert(prototype, plist);
}
}
inline QByteArray QAxMetaObject::propertyType(const QByteArray &propertyName)
{
return realPrototype.value(propertyName);
}
int QAxMetaObject::numParameter(const QByteArray &prototype)
{
if (!memberInfo.contains(prototype))
parsePrototype(prototype);
return memberInfo.value(prototype).count();
}
QByteArray QAxMetaObject::paramType(const QByteArray &prototype, int index, bool *out)
{
if (!memberInfo.contains(prototype))
parsePrototype(prototype);
if (out)
*out = false;
QList<QByteArray> plist = memberInfo.value(prototype);
if (index > plist.count() - 1)
return QByteArray();
QByteArray param(plist.at(index));
if (param.isEmpty())
return QByteArray();
bool byRef = param.endsWith('&') || param.endsWith("**");
if (byRef) {
param.truncate(param.length() - 1);
if (out)
*out = true;
}
return param;
}
inline DISPID QAxMetaObject::dispIDofName(const QByteArray &name, IDispatch *disp)
{
DISPID dispid = dispIDs.value(name, DISPID_UNKNOWN);
if (dispid == DISPID_UNKNOWN) {
// get the Dispatch ID from the object
QString unicodeName = QLatin1String(name);
OLECHAR *names = (wchar_t*)unicodeName.utf16();
disp->GetIDsOfNames(IID_NULL, &names, 1, LOCALE_USER_DEFAULT, &dispid);
if (dispid != DISPID_UNKNOWN)
dispIDs.insert(name, dispid);
}
return dispid;
}
static QHash<QString, QAxMetaObject*> mo_cache;
static QHash<QUuid, QMap<QByteArray, QList<QPair<QByteArray, int> > > > enum_cache;
static int mo_cache_ref = 0;
static QMutex cache_mutex;
static const char *const type_conversion[][2] =
{
{ "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 }
};
/*
\internal
\class QAxEventSink
\brief The QAxEventSink class implements the event sink for all
IConnectionPoints implemented in the COM object.
*/
class QAxEventSink : public IDispatch, public IPropertyNotifySink
{
public:
QAxEventSink(QAxBase *com)
: cpoint(0), ciid(IID_NULL), combase(com), ref(1)
{}
virtual ~QAxEventSink()
{
Q_ASSERT(!cpoint);
}
QUuid connectionInterface() const
{
return ciid;
}
QMap<DISPID, QByteArray> signalMap() const
{
return sigs;
}
QMap<DISPID, QByteArray> propertyMap() const
{
return props;
}
QMap<DISPID, QByteArray> propSignalMap() const
{
return propsigs;
}
// add a connection
void advise(IConnectionPoint *cp, IID iid)
{
cpoint = cp;
cpoint->AddRef();
ciid = iid;
cpoint->Advise((IUnknown*)(IDispatch*)this, &cookie);
}
// disconnect from all connection points
void unadvise()
{
combase = 0;
if (cpoint) {
cpoint->Unadvise(cookie);
cpoint->Release();
cpoint = 0;
}
}
void addSignal(DISPID memid, const char *name)
{
QByteArray signalname = name;
int pi = signalname.indexOf('(');
int i = 0;
while (type_conversion[i][0]) {
int ti = pi;
int len = int(strlen(type_conversion[i][0]));
while ((ti = signalname.indexOf(type_conversion[i][0], ti)) != -1)
signalname.replace(ti, len, type_conversion[i][1]);
++i;
}
sigs.insert(memid, signalname);
QMap<DISPID,QByteArray>::ConstIterator it;
DISPID id = -1;
for (it = propsigs.constBegin(); it!= propsigs.constEnd(); ++it) {
if (it.value() == signalname) {
id = it.key();
break;
}
}
if (id != -1)
propsigs.remove(id);
}
void addProperty(DISPID propid, const char *name, const char *signal)
{
props.insert(propid, name);
propsigs.insert(propid, signal);
}
// IUnknown
unsigned long __stdcall AddRef()
{
return ref++;
}
unsigned long __stdcall Release()
{
if (!--ref) {
delete this;
return 0;
}
return ref;
}
HRESULT __stdcall QueryInterface(REFIID riid, void **ppvObject)
{
*ppvObject = 0;
if (riid == IID_IUnknown)
*ppvObject = (IUnknown*)(IDispatch*)this;
else if (riid == IID_IDispatch)
*ppvObject = (IDispatch*)this;
else if (riid == IID_IPropertyNotifySink)
*ppvObject = (IPropertyNotifySink*)this;
else if (ciid == riid)
*ppvObject = (IDispatch*)this;
else
return E_NOINTERFACE;
AddRef();
return S_OK;
}
// IDispatch
HRESULT __stdcall GetTypeInfoCount(unsigned int *) { return E_NOTIMPL; }
HRESULT __stdcall GetTypeInfo(UINT, LCID, ITypeInfo **) { return E_NOTIMPL; }
HRESULT __stdcall GetIDsOfNames(const _GUID &, wchar_t **, unsigned int, unsigned long, long *) { return E_NOTIMPL; }
HRESULT __stdcall Invoke(DISPID dispIdMember,
REFIID riid,
LCID,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT*,
EXCEPINFO*,
UINT*)
{
// verify input
if (riid != IID_NULL)
return DISP_E_UNKNOWNINTERFACE;
if (!(wFlags & DISPATCH_METHOD))
return DISP_E_MEMBERNOTFOUND;
if (!combase)
return E_UNEXPECTED;
QByteArray signame = sigs.value(dispIdMember);
if (signame.isEmpty())
return DISP_E_MEMBERNOTFOUND;
QObject *qobject = combase->qObject();
if (qobject->signalsBlocked())
return S_OK;
QAxMetaObject *axmeta = combase->internalMetaObject();
const QMetaObject *meta = combase->metaObject();
int index = -1;
// emit the generic signal "as is"
if (signalHasReceivers(qobject, "signal(QString,int,void*)")) {
index = meta->indexOfSignal("signal(QString,int,void*)");
Q_ASSERT(index != -1);
QString nameString = QLatin1String(signame);
void *argv[] = {0, &nameString, &pDispParams->cArgs, &pDispParams->rgvarg};
combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);
}
HRESULT hres = S_OK;
// get the signal information from the metaobject
index = -1;
if (signalHasReceivers(qobject, signame)) {
index = meta->indexOfSignal(signame);
Q_ASSERT(index != -1);
const QMetaMethod signal = meta->method(index);
Q_ASSERT(signal.methodType() == QMetaMethod::Signal);
Q_ASSERT(signame == signal.signature());
// verify parameter count
int pcount = axmeta->numParameter(signame);
int argcount = pDispParams->cArgs;
if (pcount > argcount)
return DISP_E_PARAMNOTOPTIONAL;
else if (pcount < argcount)
return DISP_E_BADPARAMCOUNT;
// setup parameters (no return values in signals)
bool ok = true;
void *static_argv[QAX_NUM_PARAMS + 1];
void *static_argv_pointer[QAX_NUM_PARAMS + 1];
QVariant static_varp[QAX_NUM_PARAMS + 1];
void **argv = 0;
void **argv_pointer = 0; // in case we need an additional level of indirection
QVariant *varp = 0;
if (pcount) {
if (pcount <= QAX_NUM_PARAMS) {
argv = static_argv;
argv_pointer = static_argv_pointer;
varp = static_varp;
} else {
argv = new void*[pcount + 1];
argv_pointer = new void*[pcount + 1];
varp = new QVariant[pcount + 1];
}
argv[0] = 0;
argv_pointer[0] = 0;
}
int p;
for (p = 0; p < pcount && ok; ++p) {
// map the VARIANT to the void*
QByteArray ptype = axmeta->paramType(signame, p);
varp[p + 1] = VARIANTToQVariant(pDispParams->rgvarg[pcount - p - 1], ptype);
argv_pointer[p + 1] = 0;
if (varp[p + 1].isValid()) {
if (varp[p + 1].type() == QVariant::UserType) {
argv[p + 1] = varp[p + 1].data();
} else if (ptype == "QVariant") {
argv[p + 1] = varp + p + 1;
} else {
argv[p + 1] = const_cast<void*>(varp[p + 1].constData());
if (ptype.endsWith('*')) {
argv_pointer[p + 1] = argv[p + 1];
argv[p + 1] = argv_pointer + p + 1;
}
}
} else if (ptype == "QVariant") {
argv[p + 1] = varp + p + 1;
} else {
ok = false;
}
}
if (ok) {
// emit the generated signal if everything went well
combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);
// update the VARIANT for references and free memory
for (p = 0; p < pcount; ++p) {
bool out;
QByteArray ptype = axmeta->paramType(signame, p, &out);
if (out) {
if (!QVariantToVARIANT(varp[p + 1], pDispParams->rgvarg[pcount - p - 1], ptype, out))
ok = false;
}
}
}
if (argv != static_argv) {
delete [] argv;
delete [] argv_pointer;
delete [] varp;
}
hres = ok ? S_OK : (ok ? DISP_E_MEMBERNOTFOUND : DISP_E_TYPEMISMATCH);
}
return hres;
}
QByteArray findProperty(DISPID dispID);
// IPropertyNotifySink
HRESULT __stdcall OnChanged(DISPID dispID)
{
// verify input
if (dispID == DISPID_UNKNOWN || !combase)
return S_OK;
const QMetaObject *meta = combase->metaObject();
if (!meta)
return S_OK;
QByteArray propname(findProperty(dispID));
if (propname.isEmpty())
return S_OK;
QObject *qobject = combase->qObject();
if (qobject->signalsBlocked())
return S_OK;
// emit the generic signal
int index = meta->indexOfSignal("propertyChanged(QString)");
if (index != -1) {
QString propnameString = QString::fromLatin1(propname);
void *argv[] = {0, &propnameString};
combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);
}
QByteArray signame = propsigs.value(dispID);
if (signame.isEmpty())
return S_OK;
index = meta->indexOfSignal(signame);
if (index == -1) // bindable but not marked as bindable in typelib
return S_OK;
// get the signal information from the metaobject
if (signalHasReceivers(qobject, signame)) {
index = meta->indexOfSignal(signame);
Q_ASSERT(index != -1);
// setup parameters
QVariant var = qobject->property(propname);
if (!var.isValid())
return S_OK;
const QMetaProperty metaProp = meta->property(meta->indexOfProperty(propname));
void *argv[] = {0, var.data()};
if (metaProp.type() == QVariant::LastType)
argv[1] = &var;
// emit the "changed" signal
combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);
}
return S_OK;
}
HRESULT __stdcall OnRequestEdit(DISPID dispID)
{
if (dispID == DISPID_UNKNOWN || !combase)
return S_OK;
QByteArray propname(findProperty(dispID));
if (propname.isEmpty())
return S_OK;
return combase->propertyWritable(propname) ? S_OK : S_FALSE;
}
static bool signalHasReceivers(QObject *qobject, const char *signalName)
{
Q_ASSERT(qobject);
return ((QAxObject*)qobject)->receivers(QByteArray::number(QSIGNAL_CODE) + signalName);
}
IConnectionPoint *cpoint;
IID ciid;
ULONG cookie;
QMap<DISPID, QByteArray> sigs;
QMap<DISPID, QByteArray> propsigs;
QMap<DISPID, QByteArray> props;
QAxBase *combase;
long ref;
};
/*
\internal
\class QAxBasePrivate
*/
class QAxBasePrivate
{
public:
QAxBasePrivate()
: useEventSink(true), useMetaObject(true), useClassInfo(true),
cachedMetaObject(false), initialized(false), tryCache(false),
ptr(0), disp(0), metaobj(0)
{
// protect initialization
QMutexLocker locker(&cache_mutex);
mo_cache_ref++;
qRegisterMetaType<IUnknown*>("IUnknown*", &ptr);
qRegisterMetaType<IDispatch*>("IDispatch*", &disp);
}
~QAxBasePrivate()
{
Q_ASSERT(!ptr);
Q_ASSERT(!disp);
// protect cleanup
QMutexLocker locker(&cache_mutex);
if (!--mo_cache_ref) {
qDeleteAll(mo_cache);
mo_cache.clear();
}
CoFreeUnusedLibraries();
}
inline IDispatch *dispatch() const
{
if (disp)
return disp;
if (ptr)
ptr->QueryInterface(IID_IDispatch, (void**)&disp);
return disp;
}
QString ctrl;
QHash<QUuid, QAxEventSink*> eventSink;
uint useEventSink :1;
uint useMetaObject :1;
uint useClassInfo :1;
uint cachedMetaObject :1;
uint initialized :1;
uint tryCache :1;
IUnknown *ptr;
mutable IDispatch *disp;
QMap<QByteArray, bool> propWritable;
inline QAxMetaObject *metaObject()
{
if (!metaobj)
metaobj = new QAxMetaObject;
return metaobj;
}
mutable QMap<QString, LONG> verbs;
QAxMetaObject *metaobj;
};
QByteArray QAxEventSink::findProperty(DISPID dispID)
{
// look up in cache, and fall back to
// type info for precompiled metaobjects
QByteArray propname(props.value(dispID));
if (!propname.isEmpty())
return propname;
IDispatch *dispatch = combase->d->dispatch();
ITypeInfo *typeinfo = 0;
if (dispatch)
dispatch->GetTypeInfo(0, LOCALE_USER_DEFAULT, &typeinfo);
if (!typeinfo)
return propname;
BSTR names;
UINT cNames;
typeinfo->GetNames(dispID, &names, 1, &cNames);
if (cNames) {
propname = QString::fromWCharArray(names).toLatin1();
SysFreeString(names);
}
typeinfo->Release();
QByteArray propsignal(propname + "Changed(");
const QMetaObject *mo = combase->metaObject();
int index = mo->indexOfProperty(propname);
const QMetaProperty prop = mo->property(index);
propsignal += prop.typeName();
propsignal += ')';
addProperty(dispID, propname, propsignal);
return propname;
}
/*!
\class QAxBase
\brief The QAxBase class is an abstract class that provides an API
to initialize and access a COM object.
\inmodule QAxContainer
QAxBase is an abstract class that cannot be used directly, and is
instantiated through the subclasses QAxObject and QAxWidget. This
class provides the API to access the COM object directly
through its IUnknown implementation. If the COM object implements
the IDispatch interface, the properties and methods of that object
become available as Qt properties and slots.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 0
Properties exposed by the object's IDispatch implementation can
be read and written through the property system provided by the
Qt Object Model (both subclasses are QObjects, so you can use
QObject::setProperty() and QObject::property()). Properties with
multiple parameters are not supported.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 1
Write-functions for properties and other methods exposed by the
object's IDispatch implementation can be called directly using
dynamicCall(), or indirectly as slots connected to a signal.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 2
Outgoing events supported by the COM object are emitted as
standard Qt signals.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 3
QAxBase transparently converts between COM data types and the
equivalent Qt data types. Some COM types have no equivalent Qt data structure.
Supported COM datatypes are listed in the first column of following table.
The second column is the Qt type that can be used with the QObject property
functions. The third column is the Qt type that is used in the prototype of
generated signals and slots for in-parameters, and the last column is the Qt
type that is used in the prototype of signals and slots for out-parameters.
\table
\header
\i COM type
\i Qt property
\i in-parameter
\i out-parameter
\row
\i VARIANT_BOOL
\i bool
\i bool
\i bool&
\row
\i BSTR
\i QString
\i const QString&
\i QString&
\row
\i char, short, int, long
\i int
\i int
\i int&
\row
\i uchar, ushort, uint, ulong
\i uint
\i uint
\i uint&
\row
\i float, double
\i double
\i double
\i double&
\row
\i DATE
\i QDateTime
\i const QDateTime&
\i QDateTime&
\row
\i CY
\i qlonglong
\i qlonglong
\i qlonglong&
\row
\i OLE_COLOR
\i QColor
\i const QColor&
\i QColor&
\row
\i SAFEARRAY(VARIANT)
\i QList\<QVariant\>
\i const QList\<QVariant\>&
\i QList\<QVariant\>&
\row
\i SAFEARRAY(int), SAFEARRAY(double), SAFEARRAY(Date)
\i QList\<QVariant\>
\i const QList\<QVariant\>&
\i QList\<QVariant\>&
\row
\i SAFEARRAY(BYTE)
\i QByteArray
\i const QByteArray&
\i QByteArray&
\row
\i SAFEARRAY(BSTR)
\i QStringList
\i const QStringList&
\i QStringList&
\row
\i VARIANT
\i type-dependent
\i const QVariant&
\i QVariant&
\row
\i IFontDisp*
\i QFont
\i const QFont&
\i QFont&
\row
\i IPictureDisp*
\i QPixmap
\i const QPixmap&
\i QPixmap&
\row
\i IDispatch*
\i QAxObject*
\i \c QAxBase::asVariant()
\i QAxObject* (return value)
\row
\i IUnknown*
\i QAxObject*
\i \c QAxBase::asVariant()
\i QAxObject* (return value)
\row
\i SCODE, DECIMAL
\i \e unsupported
\i \e unsupported
\i \e unsupported
\row
\i VARIANT* (Since Qt 4.5)
\i \e unsupported
\i \e QVariant&
\i \e QVariant&
\endtable
Supported are also enumerations, and typedefs to supported types.
To call the methods of a COM interface described by the following IDL
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 4
use the QAxBase API like this:
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 5
Note that the QList the object should fill has to be provided as an
element in the parameter list of \l{QVariant}s.
If you need to access properties or pass parameters of
unsupported datatypes you must access the COM object directly
through its \c IDispatch implementation or other interfaces.
Those interfaces can be retrieved through queryInterface().
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 6
To get the definition of the COM interfaces you will have to use the header
files provided with the component you want to use. Some compilers can also
import type libraries using the #import compiler directive. See the component
documentation to find out which type libraries you have to import, and how to use
them.
If you need to react to events that pass parameters of unsupported
datatypes you can use the generic signal that delivers the event
data as provided by the COM event.
\sa QAxObject, QAxWidget, QAxScript, {ActiveQt Framework}
*/
/*!
\typedef QAxBase::PropertyBag
A QMap<QString,QVariant> that can store properties as name:value pairs.
*/
/*!
Creates a QAxBase object that wraps the COM object \a iface. If \a
iface is 0 (the default), use setControl() to instantiate a COM
object.
*/
QAxBase::QAxBase(IUnknown *iface)
{
d = new QAxBasePrivate();
d->ptr = iface;
if (d->ptr) {
d->ptr->AddRef();
d->initialized = true;
}
#if defined(Q_OS_WINCE)
CoInitializeEx(0, COINIT_MULTITHREADED);
#endif
}
/*!
Shuts down the COM object and destroys the QAxBase object.
\sa clear()
*/
QAxBase::~QAxBase()
{
#if defined(Q_OS_WINCE)
CoUninitialize();
#endif
clear();
delete d;
d = 0;
}
/*!
\internal
Used by subclasses generated with dumpcpp to balance reference count.
*/
void QAxBase::internalRelease()
{
if (d->ptr)
d->ptr->Release();
}
/*!
\internal
Used by subclasses generated with dumpcpp to implement cast-operators.
*/
void QAxBase::initializeFrom(QAxBase *that)
{
if (d->ptr)
return;
d->ptr = that->d->ptr;
if (d->ptr) {
d->ptr->AddRef();
d->initialized = true;
}
}
QAxMetaObject *QAxBase::internalMetaObject() const
{
return d->metaObject();
}
/*!
\property QAxBase::control
\brief the name of the COM object wrapped by this QAxBase object.
Setting this property initializes the COM object. Any COM object
previously set is shut down.
The most efficient way to set this property is by using the
registered component's UUID, e.g.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 7
The second fastest way is to use the registered control's class
name (with or without version number), e.g.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 8
The slowest, but easiest way to use is to use the control's full
name, e.g.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 9
It is also possible to initialize the object from a file, e.g.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 10
If the component's UUID is used the following patterns can be used
to initialize the control on a remote machine, to initialize a
licensed control or to connect to a running object:
\list
\i To initialize the control on a different machine use the following
pattern:
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 11
\i To initialize a licensed control use the following pattern:
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 12
\i To connect to an already running object use the following pattern:
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 13
\endlist
The first two patterns can be combined, e.g. to initialize a licensed
control on a remote machine:
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 14
The control's read function always returns the control's UUID, if provided including the license
key, and the name of the server, but not including the username, the domain or the password.
*/
bool QAxBase::setControl(const QString &c)
{
if (c.toLower() == d->ctrl.toLower())
return !d->ctrl.isEmpty();
QString search = c;
// don't waste time for DCOM requests
int dcomIDIndex = search.indexOf(QLatin1String("/{"));
if ((dcomIDIndex == -1 || dcomIDIndex != search.length()-39) && !search.endsWith(QLatin1String("}&"))) {
QUuid uuid(search);
if (uuid.isNull()) {
CLSID clsid;
HRESULT res = CLSIDFromProgID((wchar_t*)c.utf16(), &clsid);
if (res == S_OK)
search = QUuid(clsid).toString();
else {
QSettings controls(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes\\"), QSettings::NativeFormat);
search = controls.value(c + QLatin1String("/CLSID/Default")).toString();
if (search.isEmpty()) {
controls.beginGroup(QLatin1String("/CLSID"));
QStringList clsids = controls.childGroups();
for (QStringList::Iterator it = clsids.begin(); it != clsids.end(); ++it) {
QString clsid = *it;
QString name = controls.value(clsid + QLatin1String("/Default")).toString();
if (name == c) {
search = clsid;
break;
}
}
controls.endGroup();
}
}
}
if (search.isEmpty())
search = c;
}
if (search.toLower() == d->ctrl.toLower())
return !d->ctrl.isEmpty();
clear();
d->ctrl = search;
d->tryCache = true;
if (!initialize(&d->ptr))
d->initialized = true;
if (isNull()) {
qWarning("QAxBase::setControl: requested control %s could not be instantiated", c.toLatin1().data());
clear();
return false;
}
return true;
}
QString QAxBase::control() const
{
return d->ctrl;
}
/*!
Disables the event sink implementation for this ActiveX container.
If you don't intend to listen to the ActiveX control's events use
this function to speed up the meta object generation.
Some ActiveX controls might be unstable when connected to an event
sink. To get OLE events you must use standard COM methods to
register your own event sink. Use queryInterface() to get access
to the raw COM object.
Note that this function should be called immediately after
construction of the object.
*/
void QAxBase::disableEventSink()
{
d->useEventSink = false;
}
/*!
Disables the meta object generation for this ActiveX container.
This also disables the event sink and class info generation. If
you don't intend to use the Qt meta object implementation call
this function to speed up instantiation of the control. You will
still be able to call the object through \l dynamicCall(), but
signals, slots and properties will not be available with QObject
APIs.
Some ActiveX controls might be unstable when used with OLE
automation. Use standard COM methods to use those controls through
the COM interfaces provided by queryInterface().
Note that this function must be called immediately after
construction of the object.
*/
void QAxBase::disableMetaObject()
{
d->useMetaObject = false;
d->useEventSink = false;
d->useClassInfo = false;
}
/*!
Disables the class info generation for this ActiveX container. If
you don't require any class information about the ActiveX control
use this function to speed up the meta object generation.
Note that this function must be called immediately after
construction of the object
*/
void QAxBase::disableClassInfo()
{
d->useClassInfo = false;
}
/*!
Disconnects and destroys the COM object.
If you reimplement this function you must also reimplement the
destructor to call clear(), and call this implementation at the
end of your clear() function.
*/
void QAxBase::clear()
{
QHash<QUuid, QAxEventSink*>::Iterator it = d->eventSink.begin();
while (it != d->eventSink.end()) {
QAxEventSink *eventSink = it.value();
++it;
if (eventSink) {
eventSink->unadvise();
eventSink->Release();
}
}
d->eventSink.clear();
if (d->disp) {
d->disp->Release();
d->disp = 0;
}
if (d->ptr) {
d->ptr->Release();
d->ptr = 0;
d->initialized = false;
}
d->ctrl.clear();
if (!d->cachedMetaObject)
delete d->metaobj;
d->metaobj = 0;
}
/*!
\since 4.1
Returns the list of verbs that the COM object can execute. If
the object does not implement IOleObject, or does not support
any verbs, then this function returns an empty stringlist.
Note that the OLE default verbs (OLEIVERB_SHOW etc) are not
included in the list.
*/
QStringList QAxBase::verbs() const
{
if (!d->ptr)
return QStringList();
if (d->verbs.isEmpty()) {
IOleObject *ole = 0;
d->ptr->QueryInterface(IID_IOleObject, (void**)&ole);
if (ole) {
IEnumOLEVERB *enumVerbs = 0;
ole->EnumVerbs(&enumVerbs);
if (enumVerbs) {
enumVerbs->Reset();
ULONG c;
OLEVERB verb;
while (enumVerbs->Next(1, &verb, &c) == S_OK) {
if (!verb.lpszVerbName)
continue;
QString verbName = QString::fromWCharArray(verb.lpszVerbName);
if (!verbName.isEmpty())
d->verbs.insert(verbName, verb.lVerb);
}
enumVerbs->Release();
}
ole->Release();
}
}
return d->verbs.keys();
}
/*!
\internal
*/
long QAxBase::indexOfVerb(const QString &verb) const
{
return d->verbs.value(verb);
}
/*!
This virtual function is called by setControl() and creates the
requested COM object. \a ptr is set to the object's IUnknown
implementation. The function returns true if the object
initialization succeeded; otherwise the function returns false.
The default implementation interprets the string returned by
control(), and calls initializeRemote(), initializeLicensed()
or initializeActive() if the string matches the respective
patterns. If control() is the name of an existing file,
initializeFromFile() is called. If no pattern is matched, or
if remote or licensed initialization fails, CoCreateInstance
is used directly to create the object.
See the \l control property documentation for details about
supported patterns.
The interface returned in \a ptr must be referenced exactly once
when this function returns. The interface provided by e.g.
CoCreateInstance is already referenced, and there is no need to
reference it again.
*/
bool QAxBase::initialize(IUnknown **ptr)
{
if (*ptr || control().isEmpty())
return false;
*ptr = 0;
bool res = false;
const QString ctrl(d->ctrl);
if (ctrl.contains(QLatin1String("/{"))) // DCOM request
res = initializeRemote(ptr);
else if (ctrl.contains(QLatin1String("}:"))) // licensed control
res = initializeLicensed(ptr);
else if (ctrl.contains(QLatin1String("}&"))) // running object
res = initializeActive(ptr);
else if (QFile::exists(ctrl)) // existing file
res = initializeFromFile(ptr);
if (!res) { // standard
HRESULT hres = CoCreateInstance(QUuid(ctrl), 0, CLSCTX_SERVER, IID_IUnknown, (void**)ptr);
res = S_OK == hres;
#ifndef QT_NO_DEBUG
if (!res)
qErrnoWarning(hres, "CoCreateInstance failure");
#endif
}
return *ptr != 0;
}
/*!
Creates an instance of a licensed control, and returns the IUnknown interface
to the object in \a ptr. This functions returns true if successful, otherwise
returns false.
This function is called by initialize() if the control string contains the
substring "}:". The license key needs to follow this substring.
\sa initialize()
*/
bool QAxBase::initializeLicensed(IUnknown** ptr)
{
int at = control().lastIndexOf(QLatin1String("}:"));
QString clsid(control().left(at));
QString key(control().mid(at+2));
IClassFactory *factory = 0;
CoGetClassObject(QUuid(clsid), CLSCTX_SERVER, 0, IID_IClassFactory, (void**)&factory);
if (!factory)
return false;
initializeLicensedHelper(factory, key, ptr);
factory->Release();
return *ptr != 0;
}
/* \internal
Called by initializeLicensed and initializedRemote to create an object
via IClassFactory2.
*/
bool QAxBase::initializeLicensedHelper(void *f, const QString &key, IUnknown **ptr)
{
IClassFactory *factory = (IClassFactory*)f;
IClassFactory2 *factory2 = 0;
factory->QueryInterface(IID_IClassFactory2, (void**)&factory2);
if (factory2) {
BSTR bkey = QStringToBSTR(key);
HRESULT hres = factory2->CreateInstanceLic(0, 0, IID_IUnknown, bkey, (void**)ptr);
SysFreeString(bkey);
#ifdef QT_DEBUG
LICINFO licinfo;
licinfo.cbLicInfo = sizeof(LICINFO);
factory2->GetLicInfo(&licinfo);
if (hres != S_OK) {
SetLastError(hres);
qErrnoWarning("CreateInstanceLic failed");
if (!licinfo.fLicVerified) {
qWarning("Wrong license key specified, and machine is not fully licensed.");
} else if (licinfo.fRuntimeKeyAvail) {
BSTR licenseKey;
factory2->RequestLicKey(0, &licenseKey);
QString qlicenseKey = QString::fromWCharArray(licenseKey);
SysFreeString(licenseKey);
qWarning("Use license key is '%s' to create object on unlicensed machine.",
qlicenseKey.toLatin1().constData());
}
} else if (licinfo.fLicVerified) {
qWarning("Machine is fully licensed for '%s'", control().toLatin1().constData());
if (licinfo.fRuntimeKeyAvail) {
BSTR licenseKey;
factory2->RequestLicKey(0, &licenseKey);
QString qlicenseKey = QString::fromWCharArray(licenseKey);
SysFreeString(licenseKey);
if (qlicenseKey != key)
qWarning("Runtime license key is '%s'", qlicenseKey.toLatin1().constData());
}
}
#else
Q_UNUSED(hres);
#endif
factory2->Release();
} else { // give it a shot without license
factory->CreateInstance(0, IID_IUnknown, (void**)ptr);
}
return *ptr != 0;
}
/*!
Connects to an active instance running on the current machine, and returns the
IUnknown interface to the running object in \a ptr. This function returns true
if successful, otherwise returns false.
This function is called by initialize() if the control string contains the
substring "}&".
\sa initialize()
*/
bool QAxBase::initializeActive(IUnknown** ptr)
{
#if defined(Q_OS_WINCE)
Q_UNUSED(ptr);
return false;
#else
int at = control().lastIndexOf(QLatin1String("}&"));
QString clsid(control().left(at));
GetActiveObject(QUuid(clsid), 0, ptr);
return *ptr != 0;
#endif
}
#ifdef Q_CC_GNU
# ifndef OLEPENDER_NONE
# define OLERENDER_NONE 0
# endif
#endif
/*!
Creates the COM object handling the filename in the control property, and
returns the IUnknown interface to the object in \a ptr. This function returns
true if successful, otherwise returns false.
This function is called by initialize() if the control string is the name of
an existing file.
\sa initialize()
*/
bool QAxBase::initializeFromFile(IUnknown** ptr)
{
#if defined(Q_OS_WINCE)
Q_UNUSED(ptr);
return false;
#else
IStorage *storage = 0;
ILockBytes * bytes = 0;
HRESULT hres = ::CreateILockBytesOnHGlobal(0, TRUE, &bytes);
hres = ::StgCreateDocfileOnILockBytes(bytes, STGM_SHARE_EXCLUSIVE|STGM_CREATE|STGM_READWRITE, 0, &storage);
hres = OleCreateFromFile(CLSID_NULL, reinterpret_cast<const wchar_t*>(control().utf16()), IID_IUnknown, OLERENDER_NONE, 0, 0, storage, (void**)ptr);
storage->Release();
bytes->Release();
return hres == S_OK;
#endif
}
// There seams to be a naming problem in mingw headers
#if defined(Q_CC_GNU) && !defined(COAUTHIDENTITY) && !defined(__MINGW64_VERSION_MAJOR)
#define COAUTHIDENTITY AUTH_IDENTITY
#endif
/*!
Creates the instance on a remote server, and returns the IUnknown interface
to the object in \a ptr. This function returns true if successful, otherwise
returns false.
This function is called by initialize() if the control string contains the
substring "/{". The information about the remote machine needs to be provided
in front of the substring.
\sa initialize()
*/
bool QAxBase::initializeRemote(IUnknown** ptr)
{
int at = control().lastIndexOf(QLatin1String("/{"));
QString server(control().left(at));
QString clsid(control().mid(at+1));
QString user;
QString domain;
QString passwd;
QString key;
at = server.indexOf(QChar::fromLatin1('@'));
if (at != -1) {
user = server.left(at);
server = server.mid(at+1);
at = user.indexOf(QChar::fromLatin1(':'));
if (at != -1) {
passwd = user.mid(at+1);
user = user.left(at);
}
at = user.indexOf(QChar::fromLatin1('/'));
if (at != -1) {
domain = user.left(at);
user = user.mid(at+1);
}
}
at = clsid.lastIndexOf(QLatin1String("}:"));
if (at != -1) {
key = clsid.mid(at+2);
clsid = clsid.left(at);
}
d->ctrl = server + QChar::fromLatin1('/') + clsid;
if (!key.isEmpty())
d->ctrl = d->ctrl + QChar::fromLatin1(':') + key;
COAUTHIDENTITY authIdentity;
authIdentity.UserLength = user.length();
authIdentity.User = authIdentity.UserLength ? (ushort*)user.utf16() : 0;
authIdentity.DomainLength = domain.length();
authIdentity.Domain = authIdentity.DomainLength ? (ushort*)domain.utf16() : 0;
authIdentity.PasswordLength = passwd.length();
authIdentity.Password = authIdentity.PasswordLength ? (ushort*)passwd.utf16() : 0;
authIdentity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
COAUTHINFO authInfo;
authInfo.dwAuthnSvc = RPC_C_AUTHN_WINNT;
authInfo.dwAuthzSvc = RPC_C_AUTHZ_NONE;
authInfo.pwszServerPrincName = 0;
authInfo.dwAuthnLevel = RPC_C_AUTHN_LEVEL_DEFAULT;
authInfo.dwImpersonationLevel = RPC_C_IMP_LEVEL_IMPERSONATE;
authInfo.pAuthIdentityData = &authIdentity;
authInfo.dwCapabilities = 0;
COSERVERINFO serverInfo;
serverInfo.dwReserved1 = 0;
serverInfo.dwReserved2 = 0;
serverInfo.pAuthInfo = &authInfo;
serverInfo.pwszName = (wchar_t*)server.utf16();
IClassFactory *factory = 0;
HRESULT res = CoGetClassObject(QUuid(clsid), CLSCTX_REMOTE_SERVER, &serverInfo, IID_IClassFactory, (void**)&factory);
if (factory) {
if (!key.isEmpty())
initializeLicensedHelper(factory, key, ptr);
else
res = factory->CreateInstance(0, IID_IUnknown, (void**)ptr);
factory->Release();
}
#ifndef QT_NO_DEBUG
if (res != S_OK)
qErrnoWarning(res, "initializeRemote Failed");
#endif
return res == S_OK;
}
/*!
Requests the interface \a uuid from the COM object and sets the
value of \a iface to the provided interface, or to 0 if the
requested interface could not be provided.
Returns the result of the QueryInterface implementation of the COM object.
\sa control
*/
long QAxBase::queryInterface(const QUuid &uuid, void **iface) const
{
*iface = 0;
if (!d->ptr) {
((QAxBase*)this)->initialize(&d->ptr);
d->initialized = true;
}
if (d->ptr && !uuid.isNull())
return d->ptr->QueryInterface(uuid, iface);
return E_NOTIMPL;
}
class MetaObjectGenerator
{
public:
MetaObjectGenerator(QAxBase *ax, QAxBasePrivate *dptr);
MetaObjectGenerator(ITypeLib *typelib, ITypeInfo *typeinfo);
~MetaObjectGenerator();
QMetaObject *metaObject(const QMetaObject *parentObject, const QByteArray &className = QByteArray());
void readClassInfo();
void readEnumInfo();
void readInterfaceInfo();
void readFuncsInfo(ITypeInfo *typeinfo, ushort nFuncs);
void readVarsInfo(ITypeInfo *typeinfo, ushort nVars);
void readEventInfo();
void readEventInterface(ITypeInfo *eventinfo, IConnectionPoint *cpoint);
inline void addClassInfo(const char *key, const char *value)
{
classinfo_list.insert(key, value);
}
private:
void init();
QMetaObject *tryCache();
QByteArray createPrototype(FUNCDESC *funcdesc, ITypeInfo *typeinfo, const QList<QByteArray> &names,
QByteArray &type, QList<QByteArray> &parameters);
QByteArray usertypeToString(const TYPEDESC &tdesc, ITypeInfo *info, const QByteArray &function);
QByteArray guessTypes(const TYPEDESC &tdesc, ITypeInfo *info, const QByteArray &function);
// ### from qmetaobject.cpp
enum ProperyFlags {
Invalid = 0x00000000,
Readable = 0x00000001,
Writable = 0x00000002,
Resettable = 0x00000004,
EnumOrFlag = 0x00000008,
StdCppSet = 0x00000100,
// Override = 0x00000200,
Designable = 0x00001000,
ResolveDesignable = 0x00002000,
Scriptable = 0x00004000,
ResolveScriptable = 0x00008000,
Stored = 0x00010000,
ResolveStored = 0x00020000,
Editable = 0x00040000,
ResolveEditable = 0x00080000,
User = 0x00100000,
ResolveUser = 0x00200000,
// And our own - don't use the upper byte, as it's used for the property type
RequestingEdit = 0x00400000,
Bindable = 0x00800000
};
enum MemberFlags {
AccessPrivate = 0x00,
AccessProtected = 0x01,
AccessPublic = 0x02,
MemberMethod = 0x00,
MemberSignal = 0x04,
MemberSlot = 0x08,
MemberCompatibility = 0x10,
MemberCloned = 0x20,
MemberScriptable = 0x40,
};
inline QList<QByteArray> paramList(const QByteArray &proto)
{
QByteArray prototype(proto);
QByteArray parameters = prototype.mid(prototype.indexOf('(') + 1);
parameters.truncate(parameters.length() - 1);
QList<QByteArray> plist = parameters.split(',');
return plist;
}
inline QByteArray replaceType(const QByteArray &type)
{
int i = 0;
while (type_conversion[i][0]) {
int len = int(strlen(type_conversion[i][0]));
int ti;
if ((ti = type.indexOf(type_conversion[i][0])) != -1) {
QByteArray rtype(type);
rtype.replace(ti, len, type_conversion[i][1]);
return rtype;
}
++i;
}
return type;
}
QByteArray replacePrototype(const QByteArray &prototype)
{
QByteArray proto(prototype);
QList<QByteArray> plist = paramList(prototype);
for (int p = 0; p < plist.count(); ++p) {
QByteArray param(plist.at(p));
if (param != replaceType(param)) {
int type = 0;
while (type_conversion[type][0]) {
int paren = proto.indexOf('(');
while ((paren = proto.indexOf(type_conversion[type][0])) != -1) {
proto.replace(paren, qstrlen(type_conversion[type][0]), type_conversion[type][1]);
}
++type;
}
break;
}
}
return proto;
}
QMap<QByteArray, QByteArray> classinfo_list;
inline bool hasClassInfo(const char *key)
{
return classinfo_list.contains(key);
}
struct Method {
Method() : flags(0)
{}
QByteArray type;
QByteArray parameters;
int flags;
QByteArray realPrototype;
};
QMap<QByteArray, Method> signal_list;
inline void addSignal(const QByteArray &prototype, const QByteArray &parameters)
{
QByteArray proto(replacePrototype(prototype));
Method &signal = signal_list[proto];
signal.type = 0;
signal.parameters = parameters;
signal.flags = QMetaMethod::Public | MemberSignal;
if (proto != prototype)
signal.realPrototype = prototype;
}
void addChangedSignal(const QByteArray &function, const QByteArray &type, int memid);
inline bool hasSignal(const QByteArray &prototype)
{
return signal_list.contains(prototype);
}
QMap<QByteArray, Method> slot_list;
inline void addSlot(const QByteArray &type, const QByteArray &prototype, const QByteArray &parameters, int flags = QMetaMethod::Public)
{
QByteArray proto = replacePrototype(prototype);
Method &slot = slot_list[proto];
slot.type = replaceType(type);
slot.parameters = parameters;
slot.flags = flags | MemberSlot;
if (proto != prototype)
slot.realPrototype = prototype;
}
void addSetterSlot(const QByteArray &property);
inline bool hasSlot(const QByteArray &prototype)
{
return slot_list.contains(prototype);
}
struct Property {
Property() : typeId(0)
{}
QByteArray type;
uint typeId;
QByteArray realType;
};
QMap<QByteArray, Property> property_list;
void addProperty(const QByteArray &type, const QByteArray &name, uint flags)
{
QByteArray propertyType(type);
if (propertyType.endsWith('&'))
propertyType.chop(1);
Property &prop = property_list[name];
if (!propertyType.isEmpty() && propertyType != "HRESULT") {
prop.type = replaceType(propertyType);
if (prop.type != propertyType)
prop.realType = propertyType;
}
if (flags & Writable)
flags |= Stored;
prop.typeId |= flags;
QVariant::Type vartype = QVariant::nameToType(prop.type);
switch(vartype) {
case QVariant::Invalid:
case QVariant::UserType:
if (prop.type == "QVariant") {
prop.typeId |= 0xff << 24;
break;
}
if (QMetaType::type(prop.type) == -1)
qWarning("QAxBase: Unsupported property type: %s", prop.type.data());
break;
default:
prop.typeId |= vartype << 24;
break;
}
}
inline bool hasProperty(const QByteArray &name)
{
return property_list.contains(name);
}
inline QByteArray propertyType(const QByteArray &name)
{
return property_list.value(name).type;
}
QMap<QByteArray, QList<QPair<QByteArray, int> > > enum_list;
inline void addEnumValue(const QByteArray &enumname, const QByteArray &key, int value)
{
enum_list[enumname].append(QPair<QByteArray, int>(key, value));
}
inline bool hasEnum(const QByteArray &enumname)
{
return enum_list.contains(enumname);
}
QAxBase *that;
QAxBasePrivate *d;
IDispatch *disp;
ITypeInfo *dispInfo;
ITypeInfo *classInfo;
ITypeLib *typelib;
QByteArray current_typelib;
QSettings iidnames;
QString cacheKey;
QByteArray debugInfo;
QUuid iid_propNotifySink;
friend QMetaObject *qax_readClassInfo(ITypeLib *typeLib, ITypeInfo *classInfo, const QMetaObject *parentObject);
};
QMetaObject *qax_readEnumInfo(ITypeLib *typeLib, const QMetaObject *parentObject)
{
MetaObjectGenerator generator(typeLib, 0);
generator.readEnumInfo();
return generator.metaObject(parentObject, "EnumInfo");
}
QMetaObject *qax_readInterfaceInfo(ITypeLib *typeLib, ITypeInfo *typeInfo, const QMetaObject *parentObject)
{
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());
}
QMetaObject *qax_readClassInfo(ITypeLib *typeLib, ITypeInfo *classInfo, const QMetaObject *parentObject)
{
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());
}
MetaObjectGenerator::MetaObjectGenerator(QAxBase *ax, QAxBasePrivate *dptr)
: that(ax), d(dptr), disp(0), dispInfo(0), classInfo(0), typelib(0),
iidnames(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes"), QSettings::NativeFormat)
{
init();
}
MetaObjectGenerator::MetaObjectGenerator(ITypeLib *tlib, ITypeInfo *tinfo)
: that(0), d(0), disp(0), dispInfo(tinfo), classInfo(0), typelib(tlib),
iidnames(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes"), QSettings::NativeFormat)
{
init();
if (dispInfo)
dispInfo->AddRef();
if (typelib) {
typelib->AddRef();
BSTR bstr;
typelib->GetDocumentation(-1, &bstr, 0, 0, 0);
current_typelib = QString::fromWCharArray(bstr).toLatin1();
SysFreeString(bstr);
}
readClassInfo();
}
void MetaObjectGenerator::init()
{
if (d)
disp = d->dispatch();
iid_propNotifySink = IID_IPropertyNotifySink;
addSignal("signal(QString,int,void*)", "name,argc,argv");
addSignal("exception(int,QString,QString,QString)", "code,source,disc,help");
addSignal("propertyChanged(QString)", "name");
if (d || dispInfo) {
addProperty("QString", "control", Readable|Writable|Designable|Scriptable|Stored|Editable|StdCppSet);
}
}
MetaObjectGenerator::~MetaObjectGenerator()
{
if (dispInfo) dispInfo->Release();
if (classInfo) classInfo->Release();
if (typelib) typelib->Release();
}
bool qax_dispatchEqualsIDispatch = true;
QList<QByteArray> qax_qualified_usertypes;
QByteArray MetaObjectGenerator::usertypeToString(const TYPEDESC &tdesc, ITypeInfo *info, const QByteArray &function)
{
HREFTYPE usertype = tdesc.hreftype;
if (tdesc.vt != VT_USERDEFINED)
return 0;
QByteArray typeName;
ITypeInfo *usertypeinfo = 0;
info->GetRefTypeInfo(usertype, &usertypeinfo);
if (usertypeinfo) {
ITypeLib *usertypelib = 0;
UINT index;
usertypeinfo->GetContainingTypeLib(&usertypelib, &index);
if (usertypelib) {
// get type library name
BSTR typelibname = 0;
usertypelib->GetDocumentation(-1, &typelibname, 0, 0, 0);
QByteArray typeLibName = QString::fromWCharArray(typelibname).toLatin1();
SysFreeString(typelibname);
// get type name
BSTR usertypename = 0;
usertypelib->GetDocumentation(index, &usertypename, 0, 0, 0);
QByteArray userTypeName = QString::fromWCharArray(usertypename).toLatin1();
SysFreeString(usertypename);
if (hasEnum(userTypeName)) // known enum?
typeName = userTypeName;
else if (userTypeName == "OLE_COLOR" || userTypeName == "VB_OLE_COLOR")
typeName = "QColor";
else if (userTypeName == "IFontDisp" || userTypeName == "IFontDisp*" || userTypeName == "IFont" || userTypeName == "IFont*")
typeName = "QFont";
else if (userTypeName == "Picture" || userTypeName == "Picture*")
typeName = "QPixmap";
if (typeName.isEmpty()) {
TYPEATTR *typeattr = 0;
usertypeinfo->GetTypeAttr(&typeattr);
if (typeattr) {
switch(typeattr->typekind) {
case TKIND_ALIAS:
userTypeName = guessTypes(typeattr->tdescAlias, usertypeinfo, function);
break;
case TKIND_DISPATCH:
case TKIND_COCLASS:
if (qax_dispatchEqualsIDispatch) {
userTypeName = "IDispatch";
} else {
if (typeLibName != current_typelib)
userTypeName = typeLibName + "::" + userTypeName;
if (!qax_qualified_usertypes.contains(userTypeName))
qax_qualified_usertypes << userTypeName;
}
break;
case TKIND_ENUM:
if (typeLibName != current_typelib)
userTypeName = typeLibName + "::" + userTypeName;
if (!qax_qualified_usertypes.contains("enum " + userTypeName))
qax_qualified_usertypes << "enum " + userTypeName;
break;
case TKIND_INTERFACE:
if (typeLibName != current_typelib)
userTypeName = typeLibName + "::" + userTypeName;
if (!qax_qualified_usertypes.contains(userTypeName))
qax_qualified_usertypes << userTypeName;
break;
case TKIND_RECORD:
if (!qax_qualified_usertypes.contains("struct " + userTypeName))
qax_qualified_usertypes << "struct "+ userTypeName;
break;
default:
break;
}
}
usertypeinfo->ReleaseTypeAttr(typeattr);
typeName = userTypeName;
}
usertypelib->Release();
}
usertypeinfo->Release();
}
return typeName;
}
#define VT_UNHANDLED(x) case VT_##x: qWarning("QAxBase: Unhandled type %s", #x); str = #x; break;
QByteArray MetaObjectGenerator::guessTypes(const TYPEDESC &tdesc, ITypeInfo *info, const QByteArray &function)
{
QByteArray str;
switch (tdesc.vt) {
case VT_EMPTY:
case VT_VOID:
break;
case VT_LPWSTR:
str = "wchar_t *";
break;
case VT_BSTR:
str = "QString";
break;
case VT_BOOL:
str = "bool";
break;
case VT_I1:
str = "char";
break;
case VT_I2:
str = "short";
break;
case VT_I4:
case VT_INT:
str = "int";
break;
case VT_I8:
str = "qlonglong";
break;
case VT_UI1:
case VT_UI2:
case VT_UI4:
case VT_UINT:
str = "uint";
break;
case VT_UI8:
str = "qulonglong";
break;
case VT_CY:
str = "qlonglong";
break;
case VT_R4:
str = "float";
break;
case VT_R8:
str = "double";
break;
case VT_DATE:
str = "QDateTime";
break;
case VT_DISPATCH:
str = "IDispatch*";
break;
case VT_VARIANT:
str = "QVariant";
break;
case VT_UNKNOWN:
str = "IUnknown*";
break;
case VT_HRESULT:
str = "HRESULT";
break;
case VT_PTR:
str = guessTypes(*tdesc.lptdesc, info, function);
switch(tdesc.lptdesc->vt) {
case VT_VOID:
str = "void*";
break;
case VT_VARIANT:
case VT_BSTR:
case VT_I1:
case VT_I2:
case VT_I4:
case VT_I8:
case VT_UI1:
case VT_UI2:
case VT_UI4:
case VT_UI8:
case VT_BOOL:
case VT_R4:
case VT_R8:
case VT_INT:
case VT_UINT:
case VT_CY:
str += '&';
break;
case VT_PTR:
if (str == "QFont" || str == "QPixmap") {
str += '&';
break;
} else if (str == "void*") {
str = "void **";
break;
}
// FALLTHROUGH
default:
if (str == "QColor")
str += '&';
else if (str == "QDateTime")
str += '&';
else if (str == "QVariantList")
str += '&';
else if (str == "QByteArray")
str += '&';
else if (str == "QStringList")
str += '&';
else if (!str.isEmpty() && hasEnum(str))
str += '&';
else if (!str.isEmpty() && str != "QFont" && str != "QPixmap" && str != "QVariant")
str += '*';
}
break;
case VT_SAFEARRAY:
switch(tdesc.lpadesc->tdescElem.vt) {
// some shortcuts, and generic support for lists of QVariant-supported types
case VT_UI1:
str = "QByteArray";
break;
case VT_BSTR:
str = "QStringList";
break;
case VT_VARIANT:
str = "QVariantList";
break;
default:
str = guessTypes(tdesc.lpadesc->tdescElem, info, function);
if (!str.isEmpty())
str = "QList<" + str + '>';
break;
}
break;
case VT_CARRAY:
str = guessTypes(tdesc.lpadesc->tdescElem, info, function);
if (!str.isEmpty()) {
for (int index = 0; index < tdesc.lpadesc->cDims; ++index)
str += '[' + QByteArray::number((int)tdesc.lpadesc->rgbounds[index].cElements) + ']';
}
break;
case VT_USERDEFINED:
str = usertypeToString(tdesc, info, function);
break;
VT_UNHANDLED(FILETIME);
VT_UNHANDLED(BLOB);
VT_UNHANDLED(ERROR);
VT_UNHANDLED(DECIMAL);
VT_UNHANDLED(LPSTR);
default:
break;
}
if (tdesc.vt & VT_BYREF)
str += '&';
str.replace("&*", "**");
return str;
}
void MetaObjectGenerator::readClassInfo()
{
// Read class information
IProvideClassInfo *provideClassInfo = 0;
if (d)
d->ptr->QueryInterface(IID_IProvideClassInfo, (void**)&provideClassInfo);
if (provideClassInfo) {
provideClassInfo->GetClassInfo(&classInfo);
TYPEATTR *typeattr = 0;
if (classInfo)
classInfo->GetTypeAttr(&typeattr);
QString coClassID;
if (typeattr) {
QUuid clsid(typeattr->guid);
coClassID = clsid.toString().toUpper();
#ifndef QAX_NO_CLASSINFO
// UUID
if (d->useClassInfo && !hasClassInfo("CoClass")) {
QString coClassIDstr = iidnames.value(QLatin1String("/CLSID/") + coClassID + QLatin1String("/Default"), coClassID).toString();
addClassInfo("CoClass", coClassIDstr.isEmpty() ? coClassID.toLatin1() : coClassIDstr.toLatin1());
QByteArray version = QByteArray::number(typeattr->wMajorVerNum) + '.' + QByteArray::number(typeattr->wMinorVerNum);
if (version != "0.0")
addClassInfo("Version", version);
}
#endif
classInfo->ReleaseTypeAttr(typeattr);
}
provideClassInfo->Release();
provideClassInfo = 0;
if (d->tryCache && !coClassID.isEmpty())
cacheKey = QString::fromLatin1("%1$%2$%3$%4").arg(coClassID)
.arg((int)d->useEventSink).arg((int)d->useClassInfo).arg((int)qax_dispatchEqualsIDispatch);
}
UINT index = 0;
if (disp && !dispInfo)
disp->GetTypeInfo(index, LOCALE_USER_DEFAULT, &dispInfo);
if (dispInfo && !typelib)
dispInfo->GetContainingTypeLib(&typelib, &index);
if (!typelib) {
QSettings controls(QLatin1String("HKEY_LOCAL_MACHINE\\Software"), QSettings::NativeFormat);
QString tlid = controls.value(QLatin1String("/Classes/CLSID/") + that->control() + QLatin1String("/TypeLib/.")).toString();
QString tlfile;
if (!tlid.isEmpty()) {
controls.beginGroup(QLatin1String("/Classes/TypeLib/") + tlid);
QStringList versions = controls.childGroups();
QStringList::Iterator vit = versions.begin();
while (tlfile.isEmpty() && vit != versions.end()) {
QString version = *vit;
++vit;
tlfile = controls.value(QLatin1Char('/') + version + QLatin1String("/0/win32/.")).toString();
}
controls.endGroup();
} else {
tlfile = controls.value(QLatin1String("/Classes/CLSID/") + that->control() + QLatin1String("/InprocServer32/.")).toString();
if (tlfile.isEmpty())
tlfile = controls.value(QLatin1String("/Classes/CLSID/") + that->control() + QLatin1String("/LocalServer32/.")).toString();
}
if (!tlfile.isEmpty()) {
LoadTypeLib((OLECHAR*)tlfile.utf16(), &typelib);
if (!typelib) {
tlfile = tlfile.left(tlfile.lastIndexOf(QLatin1Char('.'))) + QLatin1String(".tlb");
LoadTypeLib((OLECHAR*)tlfile.utf16(), &typelib);
}
if (!typelib) {
tlfile = tlfile.left(tlfile.lastIndexOf(QLatin1Char('.'))) + QLatin1String(".olb");
LoadTypeLib((OLECHAR*)tlfile.utf16(), &typelib);
}
}
}
if (!classInfo && typelib && that)
typelib->GetTypeInfoOfGuid(QUuid(that->control()), &classInfo);
if (classInfo && !dispInfo) {
TYPEATTR *classAttr;
classInfo->GetTypeAttr(&classAttr);
if (classAttr) {
for (int i = 0; i < classAttr->cImplTypes; ++i) {
int typeFlags = 0;
classInfo->GetImplTypeFlags(i, &typeFlags);
if (typeFlags & IMPLTYPEFLAG_FSOURCE)
continue;
HREFTYPE hrefType;
if (S_OK == classInfo->GetRefTypeOfImplType(i, &hrefType))
classInfo->GetRefTypeInfo(hrefType, &dispInfo);
if (dispInfo) {
TYPEATTR *ifaceAttr;
dispInfo->GetTypeAttr(&ifaceAttr);
WORD typekind = ifaceAttr->typekind;
dispInfo->ReleaseTypeAttr(ifaceAttr);
if (typekind & TKIND_DISPATCH) {
break;
} else {
dispInfo->Release();
dispInfo = 0;
}
}
}
classInfo->ReleaseTypeAttr(classAttr);
}
}
if (!d || !dispInfo || !cacheKey.isEmpty() || !d->tryCache)
return;
TYPEATTR *typeattr = 0;
dispInfo->GetTypeAttr(&typeattr);
QString interfaceID;
if (typeattr) {
QUuid iid(typeattr->guid);
interfaceID = iid.toString().toUpper();
dispInfo->ReleaseTypeAttr(typeattr);
// ### event interfaces!!
if (!interfaceID.isEmpty())
cacheKey = QString::fromLatin1("%1$%2$%3$%4").arg(interfaceID)
.arg((int)d->useEventSink).arg((int)d->useClassInfo).arg((int)qax_dispatchEqualsIDispatch);
}
}
void MetaObjectGenerator::readEnumInfo()
{
if (!typelib)
return;
QUuid libUuid;
if (d && d->tryCache) {
TLIBATTR *libAttr = 0;
typelib->GetLibAttr(&libAttr);
if (libAttr) {
libUuid = QUuid(libAttr->guid);
typelib->ReleaseTLibAttr(libAttr);
enum_list = enum_cache.value(libUuid);
if (!enum_list.isEmpty())
return;
}
}
int valueindex = 0;
QSet<QString> clashCheck;
int clashIndex = 0;
int enum_serial = 0;
UINT index = typelib->GetTypeInfoCount();
for (UINT i = 0; i < index; ++i) {
TYPEKIND typekind;
typelib->GetTypeInfoType(i, &typekind);
if (typekind == TKIND_ENUM) {
// Get the type information for the enum
ITypeInfo *enuminfo = 0;
typelib->GetTypeInfo(i, &enuminfo);
if (!enuminfo)
continue;
// Get the name of the enumeration
BSTR enumname;
QByteArray enumName;
if (typelib->GetDocumentation(i, &enumname, 0, 0, 0) == S_OK) {
enumName = QString::fromWCharArray(enumname).toLatin1();
SysFreeString(enumname);
} else {
enumName = "enum" + QByteArray::number(++enum_serial);
}
// Get the attributes of the enum type
TYPEATTR *typeattr = 0;
enuminfo->GetTypeAttr(&typeattr);
if (typeattr) {
// Get all values of the enumeration
for (UINT vd = 0; vd < (UINT)typeattr->cVars; ++vd) {
VARDESC *vardesc = 0;
enuminfo->GetVarDesc(vd, &vardesc);
if (vardesc && vardesc->varkind == VAR_CONST) {
int value = vardesc->lpvarValue->lVal;
int memid = vardesc->memid;
// Get the name of the value
BSTR valuename;
QByteArray valueName;
UINT maxNamesOut;
enuminfo->GetNames(memid, &valuename, 1, &maxNamesOut);
if (maxNamesOut) {
valueName = QString::fromWCharArray(valuename).toLatin1();
SysFreeString(valuename);
} else {
valueName = "value" + QByteArray::number(valueindex++);
}
if (clashCheck.contains(QString::fromLatin1(valueName)))
valueName += QByteArray::number(++clashIndex);
clashCheck.insert(QString::fromLatin1(valueName));
addEnumValue(enumName, valueName, value);
}
enuminfo->ReleaseVarDesc(vardesc);
}
}
enuminfo->ReleaseTypeAttr(typeattr);
enuminfo->Release();
}
}
if (!libUuid.isNull())
enum_cache.insert(libUuid, enum_list);
}
void MetaObjectGenerator::addChangedSignal(const QByteArray &function, const QByteArray &type, int memid)
{
QAxEventSink *eventSink = 0;
if (d) {
eventSink = d->eventSink.value(iid_propNotifySink);
if (!eventSink && d->useEventSink) {
eventSink = new QAxEventSink(that);
d->eventSink.insert(iid_propNotifySink, eventSink);
}
}
// generate changed signal
QByteArray signalName(function);
signalName += "Changed";
QByteArray signalProto = signalName + '(' + replaceType(type) + ')';
if (!hasSignal(signalProto))
addSignal(signalProto, function);
if (eventSink)
eventSink->addProperty(memid, function, signalProto);
}
void MetaObjectGenerator::addSetterSlot(const QByteArray &property)
{
QByteArray set;
QByteArray prototype(property);
if (isupper(prototype.at(0))) {
set = "Set";
} else {
set = "set";
prototype[0] = toupper(prototype[0]);
}
prototype = set + prototype + '(' + propertyType(property) + ')';
if (!hasSlot(prototype))
addSlot(0, prototype, property);
}
QByteArray MetaObjectGenerator::createPrototype(FUNCDESC *funcdesc, ITypeInfo *typeinfo, const QList<QByteArray> &names,
QByteArray &type, QList<QByteArray> &parameters)
{
QByteArray prototype;
QByteArray function(names.at(0));
const QByteArray hresult("HRESULT");
// get function prototype
type = guessTypes(funcdesc->elemdescFunc.tdesc, typeinfo, function);
if ((type.isEmpty() || type == hresult) && funcdesc->invkind == INVOKE_PROPERTYPUT && funcdesc->lprgelemdescParam) {
type = guessTypes(funcdesc->lprgelemdescParam->tdesc, typeinfo, function);
}
prototype = function + '(';
if (funcdesc->invkind == INVOKE_FUNC && type == hresult)
type = 0;
int p;
for (p = 1; p < names.count(); ++p) {
// parameter
QByteArray paramName = names.at(p);
bool optional = p > (funcdesc->cParams - funcdesc->cParamsOpt);
TYPEDESC tdesc = funcdesc->lprgelemdescParam[p-1].tdesc;
PARAMDESC pdesc = funcdesc->lprgelemdescParam[p-1].paramdesc;
QByteArray ptype = guessTypes(tdesc, typeinfo, function);
if (pdesc.wParamFlags & PARAMFLAG_FRETVAL) {
if (ptype.endsWith('&')) {
ptype.truncate(ptype.length() - 1);
} else if (ptype.endsWith("**")) {
ptype.truncate(ptype.length() - 1);
}
type = ptype;
} else {
prototype += ptype;
if (pdesc.wParamFlags & PARAMFLAG_FOUT && !ptype.endsWith('&') && !ptype.endsWith("**"))
prototype += '&';
if (optional || pdesc.wParamFlags & PARAMFLAG_FOPT)
paramName += "=0";
else if (pdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
// ### get the value from pdesc.pparamdescex
paramName += "=0";
}
parameters << paramName;
}
if (p < funcdesc->cParams && !(pdesc.wParamFlags & PARAMFLAG_FRETVAL))
prototype += ',';
}
if (!prototype.isEmpty()) {
if (prototype.endsWith(',')) {
if (funcdesc->invkind == INVOKE_PROPERTYPUT && p == funcdesc->cParams) {
TYPEDESC tdesc = funcdesc->lprgelemdescParam[p-1].tdesc;
QByteArray ptype = guessTypes(tdesc, typeinfo, function);
prototype += ptype;
prototype += ')';
parameters << "rhs";
} else {
prototype[prototype.length()-1] = ')';
}
} else {
prototype += ')';
}
}
return prototype;
}
void MetaObjectGenerator::readFuncsInfo(ITypeInfo *typeinfo, ushort nFuncs)
{
if (!nFuncs) {
TYPEATTR *typeattr = 0;
typeinfo->GetTypeAttr(&typeattr);
if (typeattr) {
nFuncs = typeattr->cFuncs;
typeinfo->ReleaseTypeAttr(typeattr);
}
}
// get information about all functions
for (ushort fd = 0; fd < nFuncs ; ++fd) {
FUNCDESC *funcdesc = 0;
typeinfo->GetFuncDesc(fd, &funcdesc);
if (!funcdesc)
break;
QByteArray function;
QByteArray type;
QByteArray prototype;
QList<QByteArray> parameters;
// parse function description
BSTR bstrNames[256];
UINT maxNames = 255;
UINT maxNamesOut;
typeinfo->GetNames(funcdesc->memid, (BSTR*)&bstrNames, maxNames, &maxNamesOut);
QList<QByteArray> names;
int p;
for (p = 0; p < (int)maxNamesOut; ++p) {
names << QString::fromWCharArray(bstrNames[p]).toLatin1();
SysFreeString(bstrNames[p]);
}
// function name
function = names.at(0);
if ((maxNamesOut == 3 && function == "QueryInterface") ||
(maxNamesOut == 1 && function == "AddRef") ||
(maxNamesOut == 1 && function == "Release") ||
(maxNamesOut == 9 && function == "Invoke") ||
(maxNamesOut == 6 && function == "GetIDsOfNames") ||
(maxNamesOut == 2 && function == "GetTypeInfoCount") ||
(maxNamesOut == 4 && function == "GetTypeInfo")) {
typeinfo->ReleaseFuncDesc(funcdesc);
continue;
}
prototype = createPrototype(/*in*/ funcdesc, typeinfo, names, /*out*/type, parameters);
// get type of function
switch(funcdesc->invkind) {
case INVOKE_PROPERTYGET: // property
case INVOKE_PROPERTYPUT:
if (funcdesc->cParams - funcdesc->cParamsOpt <= 1) {
bool dontBreak = false;
// getter with non-default-parameters -> fall through to function handling
if (funcdesc->invkind == INVOKE_PROPERTYGET && parameters.count() && funcdesc->cParams - funcdesc->cParamsOpt) {
dontBreak = true;
} else {
uint flags = Readable;
if (funcdesc->invkind != INVOKE_PROPERTYGET)
flags |= Writable;
if (!(funcdesc->wFuncFlags & (FUNCFLAG_FNONBROWSABLE | FUNCFLAG_FHIDDEN)))
flags |= Designable;
if (!(funcdesc->wFuncFlags & FUNCFLAG_FRESTRICTED))
flags |= Scriptable;
if (funcdesc->wFuncFlags & FUNCFLAG_FREQUESTEDIT)
flags |= RequestingEdit;
if (hasEnum(type))
flags |= EnumOrFlag;
if (funcdesc->wFuncFlags & FUNCFLAG_FBINDABLE && funcdesc->invkind == INVOKE_PROPERTYGET) {
addChangedSignal(function, type, funcdesc->memid);
flags |= Bindable;
}
// Don't generate code for properties without type
if (type.isEmpty())
break;
addProperty(type, function, flags);
// more parameters -> function handling
if (funcdesc->invkind == INVOKE_PROPERTYGET && funcdesc->cParams)
dontBreak = true;
}
if (!funcdesc->cParams) {
// don't generate slots for incomplete properties
if (type.isEmpty())
break;
// Done for getters
if (funcdesc->invkind == INVOKE_PROPERTYGET)
break;
// generate setter slot
if (funcdesc->invkind == INVOKE_PROPERTYPUT && hasProperty(function)) {
addSetterSlot(function);
break;
}
} else if (funcdesc->invkind == INVOKE_PROPERTYPUT && hasProperty(function)) {
addSetterSlot(function);
// more parameters -> function handling
if (funcdesc->cParams > 1)
dontBreak = true;
}
if (!dontBreak)
break;
}
if (funcdesc->invkind == INVOKE_PROPERTYPUT) {
// remove the typename guessed for property setters
// its done only for setter's with more than one parameter.
if (funcdesc->cParams - funcdesc->cParamsOpt > 1) {
type.clear();
}
QByteArray set;
if (isupper(prototype.at(0))) {
set = "Set";
} else {
set = "set";
prototype[0] = toupper(prototype[0]);
}
prototype = set + prototype;
}
// FALL THROUGH to support multi-variat properties
case INVOKE_FUNC: // method
{
bool cloned = false;
bool defargs;
do {
QByteArray pnames;
for (p = 0; p < parameters.count(); ++p) {
pnames += parameters.at(p);
if (p < parameters.count() - 1)
pnames += ',';
}
defargs = pnames.contains("=0");
int flags = QMetaMethod::Public;
if (cloned)
flags |= QMetaMethod::Cloned << 4;
cloned |= defargs;
addSlot(type, prototype, pnames.replace("=0", ""), flags);
if (defargs) {
parameters.takeLast();
int lastParam = prototype.lastIndexOf(',');
if (lastParam == -1)
lastParam = prototype.indexOf('(') + 1;
prototype.truncate(lastParam);
prototype += ')';
}
} while (defargs);
}
break;
default:
break;
}
#if 0 // documentation in metaobject would be cool?
// get function documentation
BSTR bstrDocu;
info->GetDocumentation(funcdesc->memid, 0, &bstrDocu, 0, 0);
QString strDocu = QString::fromWCharArray(bstrDocu);
SysFreeString(bstrDocu);
if (!!strDocu)
desc += '[' + strDocu + ']';
desc += '\n';
#endif
typeinfo->ReleaseFuncDesc(funcdesc);
}
}
void MetaObjectGenerator::readVarsInfo(ITypeInfo *typeinfo, ushort nVars)
{
if (!nVars) {
TYPEATTR *typeattr = 0;
typeinfo->GetTypeAttr(&typeattr);
if (typeattr) {
nVars = typeattr->cVars;
typeinfo->ReleaseTypeAttr(typeattr);
}
}
// get information about all variables
for (ushort vd = 0; vd < nVars; ++vd) {
VARDESC *vardesc;
typeinfo->GetVarDesc(vd, &vardesc);
if (!vardesc)
break;
// no use if it's not a dispatched variable
if (vardesc->varkind != VAR_DISPATCH) {
typeinfo->ReleaseVarDesc(vardesc);
continue;
}
// get variable name
BSTR bstrName;
UINT maxNames = 1;
UINT maxNamesOut;
typeinfo->GetNames(vardesc->memid, &bstrName, maxNames, &maxNamesOut);
if (maxNamesOut != 1 || !bstrName) {
typeinfo->ReleaseVarDesc(vardesc);
continue;
}
QByteArray variableType;
QByteArray variableName;
uint flags = 0;
variableName = QString::fromWCharArray(bstrName).toLatin1();
SysFreeString(bstrName);
// get variable type
TYPEDESC typedesc = vardesc->elemdescVar.tdesc;
variableType = guessTypes(typedesc, typeinfo, variableName);
// generate meta property
if (!hasProperty(variableName)) {
flags = Readable;
if (!(vardesc->wVarFlags & VARFLAG_FREADONLY))
flags |= Writable;
if (!(vardesc->wVarFlags & (VARFLAG_FNONBROWSABLE | VARFLAG_FHIDDEN)))
flags |= Designable;
if (!(vardesc->wVarFlags & VARFLAG_FRESTRICTED))
flags |= Scriptable;
if (vardesc->wVarFlags & VARFLAG_FREQUESTEDIT)
flags |= RequestingEdit;
if (hasEnum(variableType))
flags |= EnumOrFlag;
if (vardesc->wVarFlags & VARFLAG_FBINDABLE) {
addChangedSignal(variableName, variableType, vardesc->memid);
flags |= Bindable;
}
addProperty(variableType, variableName, flags);
}
// generate a set slot
if (!(vardesc->wVarFlags & VARFLAG_FREADONLY))
addSetterSlot(variableName);
#if 0 // documentation in metaobject would be cool?
// get function documentation
BSTR bstrDocu;
info->GetDocumentation(vardesc->memid, 0, &bstrDocu, 0, 0);
QString strDocu = QString::fromWCharArray(bstrDocu);
SysFreeString(bstrDocu);
if (!!strDocu)
desc += '[' + strDocu + ']';
desc += '\n';
#endif
typeinfo->ReleaseVarDesc(vardesc);
}
}
void MetaObjectGenerator::readInterfaceInfo()
{
ITypeInfo *typeinfo = dispInfo;
if (!typeinfo)
return;
typeinfo->AddRef();
int interface_serial = 0;
while (typeinfo) {
ushort nFuncs = 0;
ushort nVars = 0;
ushort nImpl = 0;
// get information about type
TYPEATTR *typeattr;
typeinfo->GetTypeAttr(&typeattr);
bool interesting = true;
if (typeattr) {
// get number of functions, variables, and implemented interfaces
nFuncs = typeattr->cFuncs;
nVars = typeattr->cVars;
nImpl = typeattr->cImplTypes;
if ((typeattr->typekind == TKIND_DISPATCH || typeattr->typekind == TKIND_INTERFACE) &&
(typeattr->guid != IID_IDispatch && typeattr->guid != IID_IUnknown)) {
#ifndef QAX_NO_CLASSINFO
if (d && d->useClassInfo) {
// UUID
QUuid uuid(typeattr->guid);
QString uuidstr = uuid.toString().toUpper();
uuidstr = iidnames.value(QLatin1String("/Interface/") + uuidstr + QLatin1String("/Default"), uuidstr).toString();
addClassInfo("Interface " + QByteArray::number(++interface_serial), uuidstr.toLatin1());
}
#endif
typeinfo->ReleaseTypeAttr(typeattr);
} else {
interesting = false;
typeinfo->ReleaseTypeAttr(typeattr);
}
}
if (interesting) {
readFuncsInfo(typeinfo, nFuncs);
readVarsInfo(typeinfo, nVars);
}
if (!nImpl) {
typeinfo->Release();
typeinfo = 0;
break;
}
// go up one base class
HREFTYPE pRefType;
typeinfo->GetRefTypeOfImplType(0, &pRefType);
ITypeInfo *baseInfo = 0;
typeinfo->GetRefTypeInfo(pRefType, &baseInfo);
typeinfo->Release();
if (typeinfo == baseInfo) { // IUnknown inherits IUnknown ???
baseInfo->Release();
typeinfo = 0;
break;
}
typeinfo = baseInfo;
}
}
void MetaObjectGenerator::readEventInterface(ITypeInfo *eventinfo, IConnectionPoint *cpoint)
{
TYPEATTR *eventattr;
eventinfo->GetTypeAttr(&eventattr);
if (!eventattr)
return;
if (eventattr->typekind != TKIND_DISPATCH) {
eventinfo->ReleaseTypeAttr(eventattr);
return;
}
QAxEventSink *eventSink = 0;
if (d) {
IID conniid;
cpoint->GetConnectionInterface(&conniid);
eventSink = d->eventSink.value(QUuid(conniid));
if (!eventSink) {
eventSink = new QAxEventSink(that);
d->eventSink.insert(QUuid(conniid), eventSink);
eventSink->advise(cpoint, conniid);
}
}
// get information about all event functions
for (UINT fd = 0; fd < (UINT)eventattr->cFuncs; ++fd) {
FUNCDESC *funcdesc;
eventinfo->GetFuncDesc(fd, &funcdesc);
if (!funcdesc)
break;
if (funcdesc->invkind != INVOKE_FUNC ||
funcdesc->funckind != FUNC_DISPATCH) {
eventinfo->ReleaseTypeAttr(eventattr);
eventinfo->ReleaseFuncDesc(funcdesc);
continue;
}
QByteArray function;
QByteArray prototype;
QList<QByteArray> parameters;
// parse event function description
BSTR bstrNames[256];
UINT maxNames = 255;
UINT maxNamesOut;
eventinfo->GetNames(funcdesc->memid, (BSTR*)&bstrNames, maxNames, &maxNamesOut);
QList<QByteArray> names;
int p;
for (p = 0; p < (int)maxNamesOut; ++p) {
names << QString::fromWCharArray(bstrNames[p]).toLatin1();
SysFreeString(bstrNames[p]);
}
// get event function prototype
function = names.at(0);
QByteArray type; // dummy - we don't care about return values for signals
prototype = createPrototype(/*in*/ funcdesc, eventinfo, names, /*out*/type, parameters);
if (!hasSignal(prototype)) {
QByteArray pnames;
for (p = 0; p < parameters.count(); ++p) {
pnames += parameters.at(p);
if (p < parameters.count() - 1)
pnames += ',';
}
addSignal(prototype, pnames);
}
if (eventSink)
eventSink->addSignal(funcdesc->memid, prototype);
#if 0 // documentation in metaobject would be cool?
// get function documentation
BSTR bstrDocu;
eventinfo->GetDocumentation(funcdesc->memid, 0, &bstrDocu, 0, 0);
QString strDocu = QString::fromWCharArray(bstrDocu);
SysFreeString(bstrDocu);
if (!!strDocu)
desc += '[' + strDocu + ']';
desc += '\n';
#endif
eventinfo->ReleaseFuncDesc(funcdesc);
}
eventinfo->ReleaseTypeAttr(eventattr);
}
void MetaObjectGenerator::readEventInfo()
{
int event_serial = 0;
IConnectionPointContainer *cpoints = 0;
if (d && d->useEventSink)
d->ptr->QueryInterface(IID_IConnectionPointContainer, (void**)&cpoints);
if (cpoints) {
// Get connection point enumerator
IEnumConnectionPoints *epoints = 0;
cpoints->EnumConnectionPoints(&epoints);
if (epoints) {
ULONG c = 1;
IConnectionPoint *cpoint = 0;
epoints->Reset();
QList<QUuid> cpointlist;
do {
if (cpoint) cpoint->Release();
cpoint = 0;
HRESULT hr = epoints->Next(c, &cpoint, &c);
if (!c || hr != S_OK)
break;
IID conniid;
cpoint->GetConnectionInterface(&conniid);
// workaround for typelibrary bug of Word.Application
QUuid connuuid(conniid);
if (cpointlist.contains(connuuid))
break;
#ifndef QAX_NO_CLASSINFO
if (d->useClassInfo) {
QString uuidstr = connuuid.toString().toUpper();
uuidstr = iidnames.value(QLatin1String("/Interface/") + uuidstr + QLatin1String("/Default"), uuidstr).toString();
addClassInfo("Event Interface " + QByteArray::number(++event_serial), uuidstr.toLatin1());
}
#endif
// get information about type
if (conniid == IID_IPropertyNotifySink) {
// test whether property notify sink has been created already, and advise on it
QAxEventSink *eventSink = d->eventSink.value(iid_propNotifySink);
if (eventSink)
eventSink->advise(cpoint, conniid);
continue;
}
ITypeInfo *eventinfo = 0;
if (typelib)
typelib->GetTypeInfoOfGuid(conniid, &eventinfo);
if (eventinfo) {
// avoid recursion (see workaround above)
cpointlist.append(connuuid);
readEventInterface(eventinfo, cpoint);
eventinfo->Release();
}
} while (c);
if (cpoint) cpoint->Release();
epoints->Release();
} else if (classInfo) { // no enumeration - search source interfaces and ask for those
TYPEATTR *typeattr = 0;
classInfo->GetTypeAttr(&typeattr);
if (typeattr) {
for (int i = 0; i < typeattr->cImplTypes; ++i) {
int flags = 0;
classInfo->GetImplTypeFlags(i, &flags);
if (!(flags & IMPLTYPEFLAG_FSOURCE))
continue;
HREFTYPE reference;
if (S_OK != classInfo->GetRefTypeOfImplType(i, &reference))
continue;
ITypeInfo *eventInfo = 0;
classInfo->GetRefTypeInfo(reference, &eventInfo);
if (!eventInfo)
continue;
TYPEATTR *eventattr = 0;
eventInfo->GetTypeAttr(&eventattr);
if (eventattr) {
IConnectionPoint *cpoint = 0;
cpoints->FindConnectionPoint(eventattr->guid, &cpoint);
if (cpoint) {
if (eventattr->guid == IID_IPropertyNotifySink) {
// test whether property notify sink has been created already, and advise on it
QAxEventSink *eventSink = d->eventSink.value(iid_propNotifySink);
if (eventSink)
eventSink->advise(cpoint, eventattr->guid);
continue;
}
readEventInterface(eventInfo, cpoint);
cpoint->Release();
}
eventInfo->ReleaseTypeAttr(eventattr);
}
eventInfo->Release();
}
classInfo->ReleaseTypeAttr(typeattr);
}
}
cpoints->Release();
}
}
QMetaObject *MetaObjectGenerator::tryCache()
{
if (!cacheKey.isEmpty()) {
d->metaobj = mo_cache.value(cacheKey);
if (d->metaobj) {
d->cachedMetaObject = true;
IConnectionPointContainer *cpoints = 0;
d->ptr->QueryInterface(IID_IConnectionPointContainer, (void**)&cpoints);
if (cpoints) {
QList<QUuid>::ConstIterator it = d->metaobj->connectionInterfaces.begin();
while (it != d->metaobj->connectionInterfaces.end()) {
QUuid iid = *it;
++it;
IConnectionPoint *cpoint = 0;
cpoints->FindConnectionPoint(iid, &cpoint);
if (cpoint) {
QAxEventSink *sink = new QAxEventSink(that);
sink->advise(cpoint, iid);
d->eventSink.insert(iid, sink);
sink->sigs = d->metaobj->sigs.value(iid);
sink->props = d->metaobj->props.value(iid);
sink->propsigs = d->metaobj->propsigs.value(iid);
cpoint->Release();
}
}
cpoints->Release();
}
return d->metaobj;
}
}
return 0;
}
QMetaObject *MetaObjectGenerator::metaObject(const QMetaObject *parentObject, const QByteArray &className)
{
if (that) {
readClassInfo();
if (typelib) {
BSTR bstr;
typelib->GetDocumentation(-1, &bstr, 0, 0, 0);
current_typelib = QString::fromWCharArray(bstr).toLatin1();
SysFreeString(bstr);
}
if (d->tryCache && tryCache())
return d->metaobj;
readEnumInfo();
readInterfaceInfo();
readEventInfo();
}
current_typelib = QByteArray();
#ifndef QAX_NO_CLASSINFO
if (!debugInfo.isEmpty() && d->useClassInfo)
addClassInfo("debugInfo", debugInfo);
#endif
QAxMetaObject *metaobj = new QAxMetaObject;
// revision + classname + table + zero terminator
uint int_data_size = 1+1+2+2+2+2+1;
int_data_size += classinfo_list.count() * 2;
int_data_size += signal_list.count() * 5;
int_data_size += slot_list.count() * 5;
int_data_size += property_list.count() * 3;
int_data_size += enum_list.count() * 4;
for (QMap<QByteArray, QList<QPair<QByteArray, int> > >::ConstIterator it = enum_list.begin();
it != enum_list.end(); ++it) {
int_data_size += (*it).count() * 2;
}
uint *int_data = new uint[int_data_size];
int_data[0] = 1; // revision number
int_data[1] = 0; // classname index
int_data[2] = classinfo_list.count(); // num_classinfo
int_data[3] = 10; // idx_classinfo
int_data[4] = signal_list.count() + slot_list.count(); // num_methods
int_data[5] = int_data[3] + int_data[2] * 2; // idx_signals
int_data[6] = property_list.count(); // num_properties
int_data[7] = int_data[5] + int_data[4] * 5; // idx_properties
int_data[8] = enum_list.count(); // num_enums
int_data[9] = int_data[7] + int_data[6] * 3; // idx_enums
int_data[int_data_size - 1] = 0; // eod;
char null('\0');
// data + zero-terminator
QByteArray stringdata = that ? QByteArray(that->className()) : className;
stringdata += null;
stringdata.reserve(8192);
uint offset = int_data[3]; //idx_classinfo
// each class info in form key\0value\0
for (QMap<QByteArray, QByteArray>::ConstIterator it = classinfo_list.begin(); it != classinfo_list.end(); ++it) {
QByteArray key(it.key());
QByteArray value(it.value());
int_data[offset++] = stringdata.length();
stringdata += key;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += value;
stringdata += null;
}
Q_ASSERT(offset == int_data[5]);
// each signal in form prototype\0parameters\0type\0tag\0
for (QMap<QByteArray, Method>::ConstIterator it = signal_list.begin(); it != signal_list.end(); ++it) {
QByteArray prototype(QMetaObject::normalizedSignature(it.key()));
QByteArray type(it.value().type);
QByteArray parameters(it.value().parameters);
if (!it.value().realPrototype.isEmpty())
metaobj->realPrototype.insert(prototype, it.value().realPrototype);
QByteArray tag;
int flags = it.value().flags;
int_data[offset++] = stringdata.length();
stringdata += prototype;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += parameters;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += type;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += tag;
stringdata += null;
int_data[offset++] = flags;
}
// each slot in form prototype\0parameters\0type\0tag\0
for (QMap<QByteArray, Method>::ConstIterator it = slot_list.begin(); it != slot_list.end(); ++it) {
QByteArray prototype(QMetaObject::normalizedSignature(it.key()));
QByteArray type(it.value().type);
QByteArray parameters(it.value().parameters);
if (!it.value().realPrototype.isEmpty())
metaobj->realPrototype.insert(prototype, it.value().realPrototype);
QByteArray tag;
int flags = it.value().flags;
int_data[offset++] = stringdata.length();
stringdata += prototype;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += parameters;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += type;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += tag;
stringdata += null;
int_data[offset++] = flags;
}
Q_ASSERT(offset == int_data[7]);
// each property in form name\0type\0
for (QMap<QByteArray, Property>::ConstIterator it = property_list.begin(); it != property_list.end(); ++it) {
QByteArray name(it.key());
QByteArray type(it.value().type);
QByteArray realType(it.value().realType);
if (!realType.isEmpty() && realType != type)
metaobj->realPrototype.insert(name, realType);
uint flags = it.value().typeId;
int_data[offset++] = stringdata.length();
stringdata += name;
stringdata += null;
int_data[offset++] = stringdata.length();
stringdata += type;
stringdata += null;
int_data[offset++] = flags;
}
Q_ASSERT(offset == int_data[9]);
int value_offset = offset + enum_list.count() * 4;
// each enum in form name\0
for (QMap<QByteArray, QList<QPair<QByteArray, int> > >::ConstIterator it = enum_list.begin(); it != enum_list.end(); ++it) {
QByteArray name(it.key());
int flags = 0x0; // 0x1 for flag?
int count = it.value().count();
int_data[offset++] = stringdata.length();
stringdata += name;
stringdata += null;
int_data[offset++] = flags;
int_data[offset++] = count;
int_data[offset++] = value_offset;
value_offset += count * 2;
}
Q_ASSERT(offset == int_data[9] + enum_list.count() * 4);
// each enum value in form key\0
for (QMap<QByteArray, QList<QPair<QByteArray, int> > >::ConstIterator it = enum_list.begin(); it != enum_list.end(); ++it) {
for (QList<QPair<QByteArray,int> >::ConstIterator it2 = it.value().begin(); it2 != it.value().end(); ++it2) {
QByteArray key((*it2).first);
int value = (*it2).second;
int_data[offset++] = stringdata.length();
stringdata += key;
stringdata += null;
int_data[offset++] = value;
}
}
Q_ASSERT(offset == int_data_size-1);
char *string_data = new char[stringdata.length()];
memset(string_data, 0, sizeof(string_data));
memcpy(string_data, stringdata, stringdata.length());
// put the metaobject together
metaobj->d.data = int_data;
metaobj->d.extradata = 0;
metaobj->d.stringdata = string_data;
metaobj->d.superdata = parentObject;
if (d)
d->metaobj = metaobj;
if (!cacheKey.isEmpty()) {
mo_cache.insert(cacheKey, d->metaobj);
d->cachedMetaObject = true;
for (QHash<QUuid, QAxEventSink*>::Iterator it = d->eventSink.begin(); it != d->eventSink.end(); ++it) {
QAxEventSink *sink = it.value();
if (sink) {
QUuid ciid = sink->connectionInterface();
d->metaobj->connectionInterfaces.append(ciid);
d->metaobj->sigs.insert(ciid, sink->signalMap());
d->metaobj->props.insert(ciid, sink->propertyMap());
d->metaobj->propsigs.insert(ciid, sink->propSignalMap());
}
}
}
return metaobj;
}
static const uint qt_meta_data_QAxBase[] = {
// content:
1, // revision
0, // classname
0, 0, // classinfo
3, 10, // methods
1, 25, // properties
0, 0, // enums/sets
// signals: signature, parameters, type, tag, flags
24, 9, 8, 8, 0x05,
55, 50, 8, 8, 0x05,
102, 80, 8, 8, 0x05,
// properties: name, type, flags
149, 141, 0x0a095103,
0 // eod
};
static const char qt_meta_stringdata_QAxBase[] = {
"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"
};
static QMetaObject qaxobject_staticMetaObject = {
{ &QObject::staticMetaObject, qt_meta_stringdata_QAxBase,
qt_meta_data_QAxBase, 0 }
};
static QMetaObject qaxwidget_staticMetaObject = {
{ &QWidget::staticMetaObject, qt_meta_stringdata_QAxBase,
qt_meta_data_QAxBase, 0 }
};
/*!
\internal
The metaobject is generated on the fly from the information
provided by the IDispatch and ITypeInfo interface implementations
in the COM object.
*/
const QMetaObject *QAxBase::metaObject() const
{
if (d->metaobj)
return d->metaobj;
const QMetaObject* parentObject = parentMetaObject();
if (!d->ptr && !d->initialized) {
((QAxBase*)this)->initialize(&d->ptr);
d->initialized = true;
}
#ifndef QT_NO_THREAD
// only one thread at a time can generate meta objects
QMutexLocker locker(&cache_mutex);
#endif
// return the default meta object if not yet initialized
if (!d->ptr || !d->useMetaObject) {
if (qObject()->isWidgetType())
return &qaxwidget_staticMetaObject;
return &qaxobject_staticMetaObject;
}
MetaObjectGenerator generator((QAxBase*)this, d);
return generator.metaObject(parentObject);
}
/*!
\internal
Connects to all event interfaces of the object.
Called by the subclasses' connectNotify() reimplementations, so
at this point the connection as actually been created already.
*/
void QAxBase::connectNotify()
{
if (d->eventSink.count()) // already listening
return;
IEnumConnectionPoints *epoints = 0;
if (d->ptr && d->useEventSink) {
IConnectionPointContainer *cpoints = 0;
d->ptr->QueryInterface(IID_IConnectionPointContainer, (void**)&cpoints);
if (!cpoints)
return;
cpoints->EnumConnectionPoints(&epoints);
cpoints->Release();
}
if (!epoints)
return;
UINT index;
IDispatch *disp = d->dispatch();
ITypeInfo *typeinfo = 0;
ITypeLib *typelib = 0;
if (disp)
disp->GetTypeInfo(0, LOCALE_USER_DEFAULT, &typeinfo);
if (typeinfo)
typeinfo->GetContainingTypeLib(&typelib, &index);
if (!typelib) {
epoints->Release();
return;
}
MetaObjectGenerator generator(this, d);
bool haveEnumInfo = false;
ULONG c = 1;
IConnectionPoint *cpoint = 0;
epoints->Reset();
do {
if (cpoint) cpoint->Release();
cpoint = 0;
epoints->Next(c, &cpoint, &c);
if (!c || !cpoint)
break;
IID conniid;
cpoint->GetConnectionInterface(&conniid);
// workaround for typelibrary bug of Word.Application
QString connuuid(QUuid(conniid).toString());
if (d->eventSink.contains(connuuid))
break;
// Get ITypeInfo for source-interface, and skip if not supporting IDispatch
ITypeInfo *eventinfo = 0;
typelib->GetTypeInfoOfGuid(conniid, &eventinfo);
if (eventinfo) {
TYPEATTR *eventAttr;
eventinfo->GetTypeAttr(&eventAttr);
if (!eventAttr) {
eventinfo->Release();
break;
}
TYPEKIND eventKind = eventAttr->typekind;
eventinfo->ReleaseTypeAttr(eventAttr);
if (eventKind != TKIND_DISPATCH) {
eventinfo->Release();
break;
}
}
// always into the cache to avoid recoursion
QAxEventSink *eventSink = eventinfo ? new QAxEventSink(this) : 0;
d->eventSink.insert(connuuid, eventSink);
if (!eventinfo)
continue;
// have to get type info to support signals with enum parameters
if (!haveEnumInfo) {
bool wasTryCache = d->tryCache;
d->tryCache = true;
generator.readClassInfo();
generator.readEnumInfo();
d->tryCache = wasTryCache;
haveEnumInfo = true;
}
generator.readEventInterface(eventinfo, cpoint);
eventSink->advise(cpoint, conniid);
eventinfo->Release();
} while (c);
if (cpoint) cpoint->Release();
epoints->Release();
typelib->Release();
// make sure we don't try again
if (!d->eventSink.count())
d->eventSink.insert(QString(), 0);
}
/*!
\fn QString QAxBase::generateDocumentation()
Returns a rich text string with documentation for the
wrapped COM object. Dump the string to an HTML-file,
or use it in e.g. a QTextBrowser widget.
*/
static bool checkHRESULT(HRESULT hres, EXCEPINFO *exc, QAxBase *that, const QString &name, uint argerr)
{
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;
}
}
/*!
\internal
*/
int QAxBase::internalProperty(QMetaObject::Call call, int index, void **v)
{
const QMetaObject *mo = metaObject();
const QMetaProperty prop = mo->property(index + mo->propertyOffset());
QByteArray propname = prop.name();
// hardcoded control property
if (propname == "control") {
switch(call) {
case QMetaObject::ReadProperty:
*(QString*)*v = control();
break;
case QMetaObject::WriteProperty:
setControl(*(QString*)*v);
break;
case QMetaObject::ResetProperty:
clear();
break;
default:
break;
}
return index - mo->propertyCount();
}
// get the IDispatch
if (!d->ptr || !prop.isValid())
return index;
IDispatch *disp = d->dispatch();
if (!disp)
return index;
DISPID dispid = d->metaObject()->dispIDofName(propname, disp);
if (dispid == DISPID_UNKNOWN)
return index;
Q_ASSERT(d->metaobj);
// property found, so everthing that goes wrong now should not bother the caller
index -= mo->propertyCount();
VARIANTARG arg;
VariantInit(&arg);
DISPPARAMS params;
EXCEPINFO excepinfo;
memset(&excepinfo, 0, sizeof(excepinfo));
UINT argerr = 0;
HRESULT hres = E_FAIL;
QByteArray proptype(prop.typeName());
switch (call) {
case QMetaObject::ReadProperty:
{
params.cArgs = 0;
params.cNamedArgs = 0;
params.rgdispidNamedArgs = 0;
params.rgvarg = 0;
hres = disp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &params, &arg, &excepinfo, 0);
// map result VARIANTARG to void*
uint type = QVariant::Int;
if (!prop.isEnumType())
type = prop.type();
QVariantToVoidStar(VARIANTToQVariant(arg, proptype, type), *v, proptype, type);
if ((arg.vt != VT_DISPATCH && arg.vt != VT_UNKNOWN) || type == QVariant::Pixmap || type == QVariant::Font)
clearVARIANT(&arg);
}
break;
case QMetaObject::WriteProperty:
{
QVariant::Type t = (QVariant::Type)prop.type();
DISPID dispidNamed = DISPID_PROPERTYPUT;
params.cArgs = 1;
params.cNamedArgs = 1;
params.rgdispidNamedArgs = &dispidNamed;
params.rgvarg = &arg;
arg.vt = VT_ERROR;
arg.scode = DISP_E_TYPEMISMATCH;
// map void* to VARIANTARG via QVariant
QVariant qvar;
if (prop.isEnumType()) {
qvar = *(int*)v[0];
proptype = 0;
} else {
if (t == QVariant::LastType) {
qvar = *(QVariant*)v[0];
proptype = 0;
} else if (t == QVariant::UserType) {
qvar = QVariant(qRegisterMetaType<void*>(prop.typeName()), (void**)v[0]);
// qVariantSetValue(qvar, *(void**)v[0], prop.typeName());
} else {
proptype = d->metaObject()->propertyType(propname);
qvar = QVariant(t, v[0]);
}
}
QVariantToVARIANT(qvar, arg, proptype);
if (arg.vt == VT_EMPTY || arg.vt == VT_ERROR) {
qWarning("QAxBase::setProperty: Unhandled property type %s", prop.typeName());
break;
}
}
hres = disp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT, &params, 0, &excepinfo, &argerr);
clearVARIANT(&arg);
break;
default:
break;
}
checkHRESULT(hres, &excepinfo, this, QLatin1String(propname), argerr);
return index;
}
int QAxBase::internalInvoke(QMetaObject::Call call, int index, void **v)
{
Q_ASSERT(call == QMetaObject::InvokeMetaMethod);
Q_UNUSED(call);
// get the IDispatch
IDispatch *disp = d->dispatch();
if (!disp)
return index;
const QMetaObject *mo = metaObject();
// get the slot information
const QMetaMethod slot = mo->method(index + mo->methodOffset());
Q_ASSERT(slot.methodType() == QMetaMethod::Slot);
QByteArray signature(slot.signature());
QByteArray slotname(signature);
slotname.truncate(slotname.indexOf('('));
// Get the Dispatch ID of the method to be called
bool isProperty = false;
DISPID dispid = d->metaObject()->dispIDofName(slotname, disp);
Q_ASSERT(d->metaobj);
if (dispid == DISPID_UNKNOWN && slotname.toLower().startsWith("set")) {
// see if we are calling a property set function as a slot
slotname = slotname.right(slotname.length() - 3);
dispid = d->metaobj->dispIDofName(slotname, disp);
isProperty = true;
}
if (dispid == DISPID_UNKNOWN)
return index;
// slot found, so everthing that goes wrong now should not bother the caller
index -= mo->methodCount();
// setup the parameters
DISPPARAMS params;
DISPID dispidNamed = DISPID_PROPERTYPUT;
params.cArgs = d->metaobj->numParameter(signature);
params.cNamedArgs = isProperty ? 1 : 0;
params.rgdispidNamedArgs = isProperty ? &dispidNamed : 0;
params.rgvarg = 0;
VARIANTARG static_rgvarg[QAX_NUM_PARAMS];
if (params.cArgs) {
if (params.cArgs <= QAX_NUM_PARAMS)
params.rgvarg = static_rgvarg;
else
params.rgvarg = new VARIANTARG[params.cArgs];
}
int p;
for (p = 0; p < (int)params.cArgs; ++p) {
bool out;
QByteArray type = d->metaobj->paramType(signature, p, &out);
QVariant::Type vt = QVariant::nameToType(type);
QVariant qvar;
if (vt != QVariant::UserType)
qvar = QVariant(vt, v[p + 1]);
if (!qvar.isValid()) {
if (type == "IDispatch*")
qVariantSetValue(qvar, *(IDispatch**)v[p+1]);
else if (type == "IUnknown*")
qVariantSetValue(qvar, *(IUnknown**)v[p+1]);
else if (type == "QVariant")
qvar = *(QVariant*)v[p + 1];
else if (mo->indexOfEnumerator(type) != -1)
qvar = *(int*)v[p + 1];
else
qvar = QVariant(QMetaType::type(type), v[p + 1]);
}
QVariantToVARIANT(qvar, params.rgvarg[params.cArgs - p - 1], type, out);
}
// call the method
VARIANT ret;
VariantInit(&ret);
UINT argerr = 0;
HRESULT hres = E_FAIL;
EXCEPINFO excepinfo;
memset(&excepinfo, 0, sizeof(excepinfo));
WORD wFlags = isProperty ? DISPATCH_PROPERTYPUT : DISPATCH_METHOD | DISPATCH_PROPERTYGET;
hres = disp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, wFlags, &params, &ret, &excepinfo, &argerr);
// get return value
if (hres == S_OK && ret.vt != VT_EMPTY)
QVariantToVoidStar(VARIANTToQVariant(ret, slot.typeName()), v[0], slot.typeName());
// update out parameters
for (p = 0; p < (int)params.cArgs; ++p) {
bool out;
QByteArray ptype = d->metaobj->paramType(signature, p, &out);
if (out)
QVariantToVoidStar(VARIANTToQVariant(params.rgvarg[params.cArgs - p - 1], ptype), v[p+1], ptype);
}
// clean up
for (p = 0; p < (int)params.cArgs; ++p)
clearVARIANT(params.rgvarg+p);
if (params.rgvarg != static_rgvarg)
delete [] params.rgvarg;
checkHRESULT(hres, &excepinfo, this, QString::fromLatin1(slotname), params.cArgs-argerr-1);
return index;
}
/*!
\internal
*/
int QAxBase::qt_metacall(QMetaObject::Call call, int id, void **v)
{
const QMetaObject *mo = metaObject();
if (isNull() && mo->property(id + mo->propertyOffset()).name() != QByteArray("control")) {
qWarning("QAxBase::qt_metacall: Object is not initialized, or initialization failed");
return id;
}
switch(call) {
case QMetaObject::InvokeMetaMethod:
switch (mo->method(id + mo->methodOffset()).methodType()) {
case QMetaMethod::Signal:
QMetaObject::activate(qObject(), mo, id, v);
id -= mo->methodCount();
break;
case QMetaMethod::Method:
case QMetaMethod::Slot:
id = internalInvoke(call, id, v);
break;
default:
break;
}
break;
case QMetaObject::ReadProperty:
case QMetaObject::WriteProperty:
case QMetaObject::ResetProperty:
id = internalProperty(call, id, v);
break;
case QMetaObject::QueryPropertyScriptable:
case QMetaObject::QueryPropertyDesignable:
case QMetaObject::QueryPropertyStored:
case QMetaObject::QueryPropertyEditable:
case QMetaObject::QueryPropertyUser:
id -= mo->propertyCount();
break;
default:
break;
}
Q_ASSERT(id < 0);
return id;
}
#ifdef QT_CHECK_STATE
static void qax_noSuchFunction(int disptype, const QByteArray &name, const QByteArray &function, const QAxBase *that)
{
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());
}
}
}
}
#endif
/*!
\internal
\a name is already normalized?
*/
bool QAxBase::dynamicCallHelper(const char *name, void *inout, QList<QVariant> &vars, QByteArray &type)
{
if (isNull()) {
qWarning("QAxBase::dynamicCallHelper: Object is not initialized, or initialization failed");
return false;
}
IDispatch *disp = d->dispatch();
if (!disp) {
qWarning("QAxBase::dynamicCallHelper: Object does not support automation");
return false;
}
const QMetaObject *mo = metaObject();
d->metaObject();
Q_ASSERT(d->metaobj);
int varc = vars.count();
QByteArray normFunction = QMetaObject::normalizedSignature(name);
QByteArray function(normFunction);
VARIANT staticarg[QAX_NUM_PARAMS];
VARIANT *arg = 0;
VARIANTARG *res = (VARIANTARG*)inout;
unsigned short disptype;
int id = -1;
bool parse = false;
if (function.contains('(')) {
disptype = DISPATCH_METHOD | DISPATCH_PROPERTYGET;
if (d->useMetaObject)
id = mo->indexOfSlot(function);
if (id >= 0) {
const QMetaMethod slot = mo->method(id);
Q_ASSERT(slot.methodType() == QMetaMethod::Slot);
function = slot.signature();
type = slot.typeName();
}
function.truncate(function.indexOf('('));
parse = !varc && normFunction.length() > function.length() + 2;
if (parse) {
QString args = QLatin1String(normFunction);
args = args.mid(function.length() + 1);
// parse argument string int list of arguments
QString curArg;
const QChar *c = args.unicode();
int index = 0;
bool inString = false;
bool inEscape = false;
while (index < (int)args.length()) {
QChar cc = *c;
++c;
++index;
switch(cc.toLatin1()) {
case 'n':
if (inEscape)
cc = QLatin1Char('\n');
break;
case 'r':
if (inEscape)
cc = QLatin1Char('\r');
break;
case 't':
if (inEscape)
cc = QLatin1Char('\t');
break;
case '\\':
if (!inEscape && inString) {
inEscape = true;
continue;
}
break;
case '"':
if (!inEscape) {
inString = !inString;
curArg += cc;
continue;
}
break;
case ' ':
if (!inString && curArg.isEmpty())
continue;
break;
case ',':
case ')':
if (inString)
break;
curArg = curArg.trimmed();
if (curArg.at(0) == QLatin1Char('\"') && curArg.at(curArg.length()-1) == QLatin1Char('\"')) {
vars << curArg.mid(1, curArg.length() - 2);
} else {
bool isNumber = false;
bool isDouble = false;
int number = curArg.toInt(&isNumber);
double dbl = curArg.toDouble(&isDouble);
if (isNumber) {
vars << number;
} else if (isDouble) {
vars << dbl;
} else {
bool isEnum = false;
for (int enumIndex = 0; enumIndex < mo->enumeratorCount(); ++enumIndex) {
QMetaEnum metaEnum =mo->enumerator(enumIndex);
int value = metaEnum.keyToValue(curArg.toLatin1());
if (value != -1 && !QByteArray(metaEnum.valueToKey(value)).isEmpty()) {
vars << value;
isEnum = true;
break;
}
}
if (!isEnum)
vars << curArg;
}
}
curArg.clear();
continue;
default:
break;
}
inEscape = false;
curArg += cc;
}
varc = vars.count();
}
} else {
if (d->useMetaObject)
id = mo->indexOfProperty(normFunction);
if (id >= 0) {
const QMetaProperty prop =mo->property(id);
type = prop.typeName();
}
if (varc == 1) {
res = 0;
disptype = DISPATCH_PROPERTYPUT;
} else {
disptype = DISPATCH_PROPERTYGET;
}
}
if (varc) {
varc = qMin(varc, d->metaobj->numParameter(normFunction));
arg = varc <= QAX_NUM_PARAMS ? staticarg : new VARIANT[varc];
for (int i = 0; i < varc; ++i) {
QVariant var(vars.at(i));
VariantInit(arg + (varc - i - 1));
bool out = false;
QByteArray paramType;
if (disptype == DISPATCH_PROPERTYPUT)
paramType = type;
else if (parse || disptype == DISPATCH_PROPERTYGET)
paramType = 0;
else
paramType = d->metaobj->paramType(normFunction, i, &out);
if ((!parse && d->useMetaObject && var.type() == QVariant::String) || var.type() == QVariant::ByteArray) {
int enumIndex =mo->indexOfEnumerator(paramType);
if (enumIndex != -1) {
QMetaEnum metaEnum =mo->enumerator(enumIndex);
QVariantToVARIANT(metaEnum.keyToValue(var.toByteArray()), arg[varc - i - 1], "int", out);
}
}
if (arg[varc - i - 1].vt == VT_EMPTY)
QVariantToVARIANT(var, arg[varc - i - 1], paramType, out);
}
}
DISPID dispid = d->metaobj->dispIDofName(function, disp);
if (dispid == DISPID_UNKNOWN && function.toLower().startsWith("set")) {
function = function.mid(3);
dispid = d->metaobj->dispIDofName(function, disp);
disptype = DISPATCH_PROPERTYPUT;
}
if (dispid == DISPID_UNKNOWN) {
#ifdef QT_CHECK_STATE
qax_noSuchFunction(disptype, normFunction, function, this);
#endif
return false;
}
DISPPARAMS params;
DISPID dispidNamed = DISPID_PROPERTYPUT;
params.cArgs = varc;
params.cNamedArgs = (disptype == DISPATCH_PROPERTYPUT) ? 1 : 0;
params.rgdispidNamedArgs = (disptype == DISPATCH_PROPERTYPUT) ? &dispidNamed : 0;
params.rgvarg = arg;
EXCEPINFO excepinfo;
memset(&excepinfo, 0, sizeof(excepinfo));
UINT argerr = 0;
HRESULT hres = disp->Invoke(dispid, IID_NULL, LOCALE_USER_DEFAULT, disptype, &params, res, &excepinfo, &argerr);
if (disptype == (DISPATCH_METHOD|DISPATCH_PROPERTYGET) && hres == S_OK && varc) {
for (int i = 0; i < varc; ++i)
if (arg[varc-i-1].vt & VT_BYREF) // update out-parameters
vars[i] = VARIANTToQVariant(arg[varc-i-1], vars.at(i).typeName());
}
// clean up
for (int i = 0; i < varc; ++i)
clearVARIANT(params.rgvarg+i);
if (arg && arg != staticarg)
delete[] arg;
return checkHRESULT(hres, &excepinfo, this, QLatin1String(function), varc-argerr-1);
}
/*!
Calls the COM object's method \a function, passing the
parameters \a var1, \a var1, \a var2, \a var3, \a var4, \a var5,
\a var6, \a var7 and \a var8, and returns the value returned by
the method, or an invalid QVariant if the method does not return
a value or when the function call failed.
If \a function is a method of the object the string must be provided
as the full prototype, for example as it would be written in a
QObject::connect() call.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 15
Alternatively a function can be called passing the parameters embedded
in the string, e.g. above function can also be invoked using
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 16
All parameters are passed as strings; it depends on the control whether
they are interpreted correctly, and is slower than using the prototype
with correctly typed parameters.
If \a function is a property the string has to be the name of the
property. The property setter is called when \a var1 is a valid QVariant,
otherwise the getter is called.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 17
Note that it is faster to get and set properties using
QObject::property() and QObject::setProperty().
dynamicCall() can also be used to call objects with a
\l{QAxBase::disableMetaObject()}{disabled metaobject} wrapper,
which can improve performance significantely, esp. when calling many
different objects of different types during an automation process.
ActiveQt will then however not validate parameters.
It is only possible to call functions through dynamicCall() that
have parameters or return values of datatypes supported by
QVariant. See the QAxBase class documentation for a list of
supported and unsupported datatypes. If you want to call functions
that have unsupported datatypes in the parameter list, use
queryInterface() to retrieve the appropriate COM interface, and
use the function directly.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 18
This is also more efficient.
*/
QVariant QAxBase::dynamicCall(const char *function,
const QVariant &var1,
const QVariant &var2,
const QVariant &var3,
const QVariant &var4,
const QVariant &var5,
const QVariant &var6,
const QVariant &var7,
const QVariant &var8)
{
QList<QVariant> vars;
QVariant var = var1;
int argc = 1;
while(var.isValid()) {
vars << var;
switch(++argc) {
case 2: var = var2; break;
case 3: var = var3; break;
case 4: var = var4; break;
case 5: var = var5; break;
case 6: var = var6; break;
case 7: var = var7; break;
case 8: var = var8; break;
default:var = QVariant(); break;
}
}
return dynamicCall(function, vars);
}
/*!
\overload
Calls the COM object's method \a function, passing the
parameters in \a vars, and returns the value returned by
the method. If the method does not return a value or when
the function call failed this function returns an invalid
QVariant object.
The QVariant objects in \a vars are updated when the method has
out-parameters.
*/
QVariant QAxBase::dynamicCall(const char *function, QList<QVariant> &vars)
{
VARIANTARG res;
VariantInit(&res);
QByteArray rettype;
if (!dynamicCallHelper(function, &res, vars, rettype))
return QVariant();
QVariant qvar = VARIANTToQVariant(res, rettype);
if ((res.vt != VT_DISPATCH && res.vt != VT_UNKNOWN) || qvar.type() == QVariant::Pixmap || qvar.type() == QVariant::Font)
clearVARIANT(&res);
return qvar;
}
/*!
Returns a pointer to a QAxObject wrapping the COM object provided
by the method or property \a name, passing passing the parameters
\a var1, \a var1, \a var2, \a var3, \a var4, \a var5, \a var6,
\a var7 and \a var8.
If \a name is provided by a method the string must include the
full function prototype.
If \a name is a property the string must be the name of the property,
and \a var1, ... \a var8 are ignored.
The returned QAxObject is a child of this object (which is either of
type QAxObject or QAxWidget), and is deleted when this object is
deleted. It is however safe to delete the returned object yourself,
and you should do so when you iterate over lists of subobjects.
COM enabled applications usually have an object model publishing
certain elements of the application as dispatch interfaces. Use
this method to navigate the hierarchy of the object model, e.g.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 19
*/
QAxObject *QAxBase::querySubObject(const char *name,
const QVariant &var1,
const QVariant &var2,
const QVariant &var3,
const QVariant &var4,
const QVariant &var5,
const QVariant &var6,
const QVariant &var7,
const QVariant &var8)
{
QList<QVariant> vars;
QVariant var = var1;
int argc = 1;
while(var.isValid()) {
vars << var;
switch(++argc) {
case 2: var = var2; break;
case 3: var = var3; break;
case 4: var = var4; break;
case 5: var = var5; break;
case 6: var = var6; break;
case 7: var = var7; break;
case 8: var = var8; break;
default:var = QVariant(); break;
}
}
return querySubObject(name, vars);
}
/*!
\overload
The QVariant objects in \a vars are updated when the method has
out-parameters.
*/
QAxObject *QAxBase::querySubObject(const char *name, QList<QVariant> &vars)
{
QAxObject *object = 0;
VARIANTARG res;
VariantInit(&res);
QByteArray rettype;
if (!dynamicCallHelper(name, &res, vars, rettype))
return 0;
switch (res.vt) {
case VT_DISPATCH:
if (res.pdispVal) {
if (rettype.isEmpty() || rettype == "IDispatch*" || rettype == "QVariant") {
object = new QAxObject(res.pdispVal, qObject());
} else if (QMetaType::type(rettype)) {
QVariant qvar = VARIANTToQVariant(res, rettype, 0);
object = *(QAxObject**)qvar.constData();
// qVariantGet(qvar, object, rettype);
res.pdispVal->AddRef();
}
if (object)
((QAxBase*)object)->d->tryCache = true;
}
break;
case VT_UNKNOWN:
if (res.punkVal) {
if (rettype.isEmpty() || rettype == "IUnknown*") {
object = new QAxObject(res.punkVal, qObject());
} else if (QMetaType::type(rettype)) {
QVariant qvar = VARIANTToQVariant(res, rettype, 0);
object = *(QAxObject**)qvar.constData();
// qVariantGet(qvar, object, rettype);
res.punkVal->AddRef();
}
if (object)
((QAxBase*)object)->d->tryCache = true;
}
break;
case VT_EMPTY:
#ifdef QT_CHECK_STATE
{
const char *coclass = metaObject()->classInfo(metaObject()->indexOfClassInfo("CoClass")).value();
qWarning("QAxBase::querySubObject: %s: Error calling function or property in %s (%s)"
, name, control().toLatin1().data(), coclass ? coclass: "unknown");
}
#endif
break;
default:
#ifdef QT_CHECK_STATE
{
const char *coclass = metaObject()->classInfo(metaObject()->indexOfClassInfo("CoClass")).value();
qWarning("QAxBase::querySubObject: %s: Method or property is not of interface type in %s (%s)"
, name, control().toLatin1().data(), coclass ? coclass: "unknown");
}
#endif
break;
}
clearVARIANT(&res);
return object;
}
class QtPropertyBag : public IPropertyBag
{
public:
QtPropertyBag() :ref(0) {}
virtual ~QtPropertyBag() {}
HRESULT __stdcall QueryInterface(REFIID iid, LPVOID *iface)
{
*iface = 0;
if (iid == IID_IUnknown)
*iface = this;
else if (iid == IID_IPropertyBag)
*iface = this;
else
return E_NOINTERFACE;
AddRef();
return S_OK;
}
unsigned long __stdcall AddRef() { return ++ref; }
unsigned long __stdcall Release()
{
if (!--ref) {
delete this;
return 0;
}
return ref;
}
HRESULT __stdcall Read(LPCOLESTR name, VARIANT *var, IErrorLog *)
{
if (!var)
return E_POINTER;
QString property = QString::fromWCharArray(name);
QVariant qvar = map.value(property);
QVariantToVARIANT(qvar, *var);
return S_OK;
}
HRESULT __stdcall Write(LPCOLESTR name, VARIANT *var)
{
if (!var)
return E_POINTER;
QString property = QString::fromWCharArray(name);
QVariant qvar = VARIANTToQVariant(*var, 0);
map[property] = qvar;
return S_OK;
}
QAxBase::PropertyBag map;
private:
unsigned long ref;
};
/*!
Returns a name:value map of all the properties exposed by the COM
object.
This is more efficient than getting multiple properties
individually if the COM object supports property bags.
\warning It is not guaranteed that the property bag implementation
of the COM object returns all properties, or that the properties
returned are the same as those available through the IDispatch
interface.
*/
QAxBase::PropertyBag QAxBase::propertyBag() const
{
PropertyBag result;
if (!d->ptr && !d->initialized) {
((QAxBase*)this)->initialize(&d->ptr);
d->initialized = true;
}
if (isNull())
return result;
IPersistPropertyBag *persist = 0;
d->ptr->QueryInterface(IID_IPersistPropertyBag, (void**)&persist);
if (persist) {
QtPropertyBag *pbag = new QtPropertyBag();
pbag->AddRef();
persist->Save(pbag, false, true);
result = pbag->map;
pbag->Release();
persist->Release();
return result;
} else {
const QMetaObject *mo = metaObject();
for (int p = mo->propertyOffset(); p < mo->propertyCount(); ++p) {
const QMetaProperty property = mo->property(p);
QVariant var = qObject()->property(property.name());
result.insert(QLatin1String(property.name()), var);
}
}
return result;
}
/*!
Sets the properties of the COM object to the corresponding values
in \a bag.
\warning
You should only set property bags that have been returned by the
propertyBag function, as it cannot be guaranteed that the property
bag implementation of the COM object supports the same properties
that are available through the IDispatch interface.
\sa propertyBag()
*/
void QAxBase::setPropertyBag(const PropertyBag &bag)
{
if (!d->ptr && !d->initialized) {
initialize(&d->ptr);
d->initialized = true;
}
if (isNull())
return;
IPersistPropertyBag *persist = 0;
d->ptr->QueryInterface(IID_IPersistPropertyBag, (void**)&persist);
if (persist) {
QtPropertyBag *pbag = new QtPropertyBag();
pbag->map = bag;
pbag->AddRef();
persist->Load(pbag, 0);
pbag->Release();
persist->Release();
} else {
const QMetaObject *mo = metaObject();
for (int p = mo->propertyOffset(); p < mo->propertyCount(); ++p) {
const QMetaProperty property = mo->property(p);
QVariant var = bag.value(QLatin1String(property.name()));
qObject()->setProperty(property.name(), var);
}
}
}
/*!
Returns true if the property \a prop is writable; otherwise
returns false. By default, all properties are writable.
\warning
Depending on the control implementation this setting might be
ignored for some properties.
\sa setPropertyWritable(), propertyChanged()
*/
bool QAxBase::propertyWritable(const char *prop) const
{
return d->propWritable.value(prop, true);
}
/*!
Sets the property \a prop to writable if \a ok is true, otherwise
sets \a prop to be read-only. By default, all properties are
writable.
\warning
Depending on the control implementation this setting might be
ignored for some properties.
\sa propertyWritable(), propertyChanged()
*/
void QAxBase::setPropertyWritable(const char *prop, bool ok)
{
d->propWritable[prop] = ok;
}
/*!
Returns true if there is no COM object loaded by this wrapper;
otherwise return false.
\sa control
*/
bool QAxBase::isNull() const
{
return !d->ptr;
}
/*!
Returns a QVariant that wraps the COM object. The variant can
then be used as a parameter in e.g. dynamicCall().
*/
QVariant QAxBase::asVariant() const
{
if (!d->ptr && !d->initialized) {
((QAxBase*)this)->initialize(&d->ptr);
d->initialized = true;
}
QVariant qvar;
QByteArray cn(className());
if (cn == "QAxObject" || cn == "QAxWidget" || cn == "QAxBase") {
if (d->dispatch())
qVariantSetValue(qvar, d->dispatch());
else if (d->ptr)
qVariantSetValue(qvar, d->ptr);
} else {
cn = cn.mid(cn.lastIndexOf(':') + 1);
QObject *object = qObject();
if (QMetaType::type(cn))
qvar = QVariant(qRegisterMetaType<QObject*>(cn + '*'), &object);
// qVariantSetValue(qvar, qObject(), cn + '*');
}
return qvar;
}
// internal function that creates a QAxObject from an iface
// used by type-conversion code (types.cpp)
void *qax_createObjectWrapper(int metaType, IUnknown *iface)
{
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;
}
/*!
\fn void QAxBase::signal(const QString &name, int argc, void *argv)
This generic signal gets emitted when the COM object issues the
event \a name. \a argc is the number of parameters provided by the
event (DISPPARAMS.cArgs), and \a argv is the pointer to the
parameter values (DISPPARAMS.rgvarg). Note that the order of parameter
values is turned around, ie. the last element of the array is the first
parameter in the function.
\snippet doc/src/snippets/code/src_activeqt_container_qaxbase.cpp 20
Use this signal if the event has parameters of unsupported data
types. Otherwise, connect directly to the signal \a name.
*/
/*!
\fn void QAxBase::propertyChanged(const QString &name)
If the COM object supports property notification, this signal gets
emitted when the property called \a name is changed.
*/
/*!
\fn void QAxBase::exception(int code, const QString &source, const QString &desc, const QString &help)
This signal is emitted when the COM object throws an exception while called using the OLE automation
interface IDispatch. \a code, \a source, \a desc and \a help provide information about the exception as
provided by the COM server and can be used to provide useful feedback to the end user. \a help includes
the help file, and the help context ID in brackets, e.g. "filename [id]".
*/
/*!
\fn QObject *QAxBase::qObject() const
\internal
*/
/*!
\fn const char *QAxBase::className() const
\internal
*/
QT_END_NAMESPACE
#endif //QT_NO_WIN_ACTIVEQT