QAxBase Class Reference

The QAxBase class is an abstract class that provides an API to initialize and access a COM object. More...

#include <qaxbase.h>

Inheritance diagram for QAxBase:

Public Types
typedef QMap< QString, QVariant >	PropertyBag
	A QMap<QString,QVariant> that can store properties as name:value pairs. More...

Signals
void	exception (int, const QString &, const QString &, const QString &)
	This signal is emitted when the COM object throws an exception while called using the OLE automation interface IDispatch. More...
void	propertyChanged (const QString &)
	If the COM object supports property notification, this signal gets emitted when the property called name is changed. More...
void	signal (const QString &, int, void *)
	This generic signal gets emitted when the COM object issues the event name. More...

Public Functions
QVariant	asVariant () const
	Returns a QVariant that wraps the COM object. More...
virtual const char *	className () const =0
virtual void	clear ()
	Disconnects and destroys the COM object. More...
QString	control () const
	the name of the COM object wrapped by this QAxBase object. More...
void	disableClassInfo ()
	Disables the class info generation for this ActiveX container. More...
void	disableEventSink ()
	Disables the event sink implementation for this ActiveX container. More...
void	disableMetaObject ()
	Disables the meta object generation for this ActiveX container. More...
QVariant	dynamicCall (const char *name, const QVariant &v1=QVariant(), const QVariant &v2=QVariant(), const QVariant &v3=QVariant(), const QVariant &v4=QVariant(), const QVariant &v5=QVariant(), const QVariant &v6=QVariant(), const QVariant &v7=QVariant(), const QVariant &v8=QVariant())
	Calls the COM object's method function, passing the parameters var1, var1, var2, var3, var4, var5, var6, var7 and 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. More...
QVariant	dynamicCall (const char *name, QList< QVariant > &vars)
	Calls the COM object's method function, passing the parameters in vars, and returns the value returned by the method. More...
QString	generateDocumentation ()
	Returns a rich text string with documentation for the wrapped COM object. More...
bool	isNull () const
	Returns true if there is no COM object loaded by this wrapper; otherwise return false. More...
virtual const QMetaObject *	metaObject () const
	The metaobject is generated on the fly from the information provided by the IDispatch and ITypeInfo interface implementations in the COM object. More...
PropertyBag	propertyBag () const
	Returns a name:value map of all the properties exposed by the COM object. More...
virtual bool	propertyWritable (const char *) const
	Returns true if the property prop is writable; otherwise returns false. More...
	QAxBase (IUnknown *iface=0)
	Creates a QAxBase object that wraps the COM object iface. More...
virtual QObject *	qObject () const =0
virtual int	qt_metacall (QMetaObject::Call, int, void **)
long	queryInterface (const QUuid &, void **) const
	Requests the interface uuid from the COM object and sets the value of iface to the provided interface, or to 0 if the requested interface could not be provided. More...
QAxObject *	querySubObject (const char *name, const QVariant &v1=QVariant(), const QVariant &v2=QVariant(), const QVariant &v3=QVariant(), const QVariant &v4=QVariant(), const QVariant &v5=QVariant(), const QVariant &v6=QVariant(), const QVariant &v7=QVariant(), const QVariant &v8=QVariant())
	Returns a pointer to a QAxObject wrapping the COM object provided by the method or property name, passing passing the parameters var1, var1, var2, var3, var4, var5, var6, var7 and var8. More...
QAxObject *	querySubObject (const char *name, QList< QVariant > &vars)
	The QVariant objects in vars are updated when the method has out-parameters. More...
bool	setControl (const QString &)
void	setPropertyBag (const PropertyBag &)
	Sets the properties of the COM object to the corresponding values in bag. More...
virtual void	setPropertyWritable (const char *, bool)
	Sets the property prop to writable if ok is true, otherwise sets prop to be read-only. More...
QStringList	verbs () const
	Returns the list of verbs that the COM object can execute. More...
virtual	~QAxBase ()
	Shuts down the COM object and destroys the QAxBase object. More...

Protected Functions
void	connectNotify ()
	Connects to all event interfaces of the object. More...
long	indexOfVerb (const QString &verb) const
virtual bool	initialize (IUnknown **ptr)
	This virtual function is called by setControl() and creates the requested COM object. More...
bool	initializeActive (IUnknown **ptr)
	Connects to an active instance running on the current machine, and returns the IUnknown interface to the running object in ptr. More...
void	initializeFrom (QAxBase *that)
	Used by subclasses generated with dumpcpp to implement cast-operators. More...
bool	initializeFromFile (IUnknown **ptr)
	Creates the COM object handling the filename in the control property, and returns the IUnknown interface to the object in ptr. More...
bool	initializeLicensed (IUnknown **ptr)
	Creates an instance of a licensed control, and returns the IUnknown interface to the object in ptr. More...
bool	initializeRemote (IUnknown **ptr)
	Creates the instance on a remote server, and returns the IUnknown interface to the object in ptr. More...
void	internalRelease ()
	Used by subclasses generated with dumpcpp to balance reference count. More...

Private Functions
bool	dynamicCallHelper (const char *name, void *out, QList< QVariant > &var, QByteArray &type)
bool	initializeLicensedHelper (void *factory, const QString &key, IUnknown **ptr)
int	internalInvoke (QMetaObject::Call, int index, void **v)
QAxMetaObject *	internalMetaObject () const
int	internalProperty (QMetaObject::Call, int index, void **v)
virtual const QMetaObject *	parentMetaObject () const =0

Properties
QAxBasePrivate *	d

Static Private Attributes
static QMetaObject	staticMetaObject

Friends
void *	qax_createObjectWrapper (int, IUnknown *)
class	QAxEventSink

Detailed Description

The QAxBase class is an abstract class that provides an API to initialize and access a COM object.

Attention

Module: 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.

connect(buttonBack, SIGNAL(clicked()), webBrowser, SLOT(GoBack()));

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.

activeX->setProperty("text", "some text");
int value = activeX->property("value");

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.

webBrowser->dynamicCall("GoHome()");

Outgoing events supported by the COM object are emitted as standard Qt signals.

connect(webBrowser, SIGNAL(TitleChanged(QString)),
    this, SLOT(setCaption(QString)));

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.

COM type	Qt property	in-parameter	out-parameter
VARIANT_BOOL	bool	bool	bool&
BSTR	QString	const QString&	QString&
char, short, int, long	int	int	int&
uchar, ushort, uint, ulong	uint	uint	uint&
float, double	double	double	double&
DATE	QDateTime	const QDateTime&	QDateTime&
CY	qlonglong	qlonglong	qlonglong&
OLE_COLOR	QColor	const QColor&	QColor&
SAFEARRAY(VARIANT)	QList<QVariant>	const QList<QVariant>&	QList<QVariant>&
SAFEARRAY(int), SAFEARRAY(double), SAFEARRAY(Date)	QList<QVariant>	const QList<QVariant>&	QList<QVariant>&
SAFEARRAY(BYTE)	QByteArray	const QByteArray&	QByteArray&
SAFEARRAY(BSTR)	QStringList	const QStringList&	QStringList&
VARIANT	type-dependent	const QVariant&	QVariant&
IFontDisp*	QFont	const QFont&	QFont&
IPictureDisp*	QPixmap	const QPixmap&	QPixmap&
IDispatch*	QAxObject*	QAxBase::asVariant()	QAxObject* (return value)
IUnknown*	QAxObject*	QAxBase::asVariant()	QAxObject* (return value)
SCODE, DECIMAL	unsupported	unsupported	unsupported
VARIANT* (Since Qt 4.5)	unsupported	QVariant&	QVariant&

Supported are also enumerations, and typedefs to supported types.

To call the methods of a COM interface described by the following IDL

dispinterface IControl
{
properties:
    [id(1)] BSTR text;
    [id(2)] IFontDisp *font;

methods:
    [id(6)] void showColumn([in] int i);
    [id(3)] bool addColumn([in] BSTR t);
    [id(4)] int fillList([in, out] SAFEARRAY(VARIANT) *list);
    [id(5)] IDispatch *item([in] int i);
};

use the QAxBase API like this:

QAxObject object("<CLSID>");

QString text = object.property("text").toString();
object.setProperty("font", QFont("Times New Roman", 12));

connect(this, SIGNAL(clicked(int)), &object, SLOT(showColumn(int)));
bool ok = object.dynamicCall("addColumn(const QString&)", "Column 1").toBool();

QList<QVariant> varlist;
QList<QVariant> parameters;
parameters << QVariant(varlist);
int n = object.dynamicCall("fillList(QList<QVariant>&)", parameters).toInt();

QAxObject *item = object.querySubItem("item(int)", 5);

Note that the QList the object should fill has to be provided as an element in the parameter list of QVariant.

If you need to access properties or pass parameters of unsupported datatypes you must access the COM object directly through its IDispatch implementation or other interfaces. Those interfaces can be retrieved through queryInterface().

IUnknown *iface = 0;
activeX->queryInterface(IID_IUnknown, (void**)&iface);
if (iface) {
    // use the interface
    iface->Release();
}

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.

See also

QAxObject, QAxWidget, QAxScript, {ActiveQt Framework}

Definition at line 66 of file qaxbase.h.

Typedefs

PropertyBag

QAxBase::PropertyBag

A QMap<QString,QVariant> that can store properties as name:value pairs.

Definition at line 71 of file qaxbase.h.

Constructors and Destructors

QAxBase()

QAxBase::QAxBase

(

IUnknown *

iface = 0

)

Creates a QAxBase object that wraps the COM object iface.

If iface is 0 (the default), use setControl() to instantiate a COM object.

Definition at line 850 of file qaxbase.cpp.

{
    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
}

~QAxBase()

QAxBase::~QAxBase ( )

virtual

Shuts down the COM object and destroys the QAxBase object.

See also

clear()

Definition at line 868 of file qaxbase.cpp.

{
#if defined(Q_OS_WINCE)
    CoUninitialize();
#endif

    clear();

    delete d;
    d = 0;
}

Functions

asVariant()

QVariant QAxBase::asVariant

(

)

const

Returns a QVariant that wraps the COM object.

The variant can then be used as a parameter in e.g. dynamicCall().

Definition at line 4421 of file qaxbase.cpp.

{
    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())
            qvar.setValue(d->dispatch());
        else if (d->ptr)
            qvar.setValue(d->ptr);
    } else {
        cn = cn.mid(cn.lastIndexOf(':') + 1);
        QObject *object = qObject();
        if (QMetaType::type(cn))
            qvar = QVariant(qRegisterMetaType<QObject*>(cn + '*'), &object);
//            qvar.setValue(qObject(), cn + '*');
    }

    return qvar;
}

className()

const char * QAxBase::className ( ) const

pure virtual

Warning

This function is not part of the public interface.

Implemented in QAxWidget, and QAxObject.

Referenced by MetaObjectGenerator::metaObject().

clear()

void QAxBase::clear ( )

virtual

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.

Reimplemented in QAxWidget.

Definition at line 1095 of file qaxbase.cpp.

Referenced by QAxWidget::clear(), and QAxObject::~QAxObject().

{
    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;
}

connectNotify()

void QAxBase::connectNotify ( )

protected

Connects to all event interfaces of the object.

Warning

This function is not part of the public interface.

Called by the subclasses' connectNotify() reimplementations, so at this point the connection as actually been created already.

Definition at line 3282 of file qaxbase.cpp.

Referenced by QAxObject::connectNotify(), QAxWidget::connectNotify(), QAxObject::qObject(), and QAxWidget::qObject().

{
    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);
}

control()

QString QAxBase::control

(

)

const

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.

ctrl->setControl("{8E27C92B-1264-101C-8A2F-040224009C02}");

The second fastest way is to use the registered control's class name (with or without version number), e.g.

ctrl->setControl("MSCal.Calendar");

The slowest, but easiest way to use is to use the control's full name, e.g.

ctrl->setControl("Calendar Control 9.0");

It is also possible to initialize the object from a file, e.g.

ctrl->setControl("c:/files/file.doc");

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:

• To initialize the control on a different machine use the following pattern:

  <domain/username>:<password>@server/{8E27C92B-1264-101C-8A2F-040224009C02}

• To initialize a licensed control use the following pattern:

  {8E27C92B-1264-101C-8A2F-040224009C02}:<LicenseKey>

• To connect to an already running object use the following pattern:

  {8E27C92B-1264-101C-8A2F-040224009C02}&

The first two patterns can be combined, e.g. to initialize a licensed control on a remote machine:

ctrl->setControl("DOMAIN/user:password@server/{8E27C92B-1264-101C-8A2F-040224009C02}:LicenseKey");

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.

Definition at line 1029 of file qaxbase.cpp.

Referenced by QAxWidget::clear(), operator<<(), operator>>(), qax_generateDocumentation(), qax_noSuchFunction(), and MetaObjectGenerator::readClassInfo().

{
    return d->ctrl;
}

disableClassInfo()

void QAxBase::disableClassInfo

(

)

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

Definition at line 1083 of file qaxbase.cpp.

Referenced by QAxScriptEngine::QAxScriptEngine().

{
    d->useClassInfo = false;
}

disableEventSink()

void QAxBase::disableEventSink

(

)

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.

Definition at line 1047 of file qaxbase.cpp.

Referenced by QAxScriptEngine::QAxScriptEngine().

{
    d->useEventSink = false;
}

disableMetaObject()

void QAxBase::disableMetaObject

(

)

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 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.

Definition at line 1068 of file qaxbase.cpp.

{
    d->useMetaObject    = false;
    d->useEventSink = false;
    d->useClassInfo = false;
}

dynamicCall() [1/2]

QVariant QAxBase::dynamicCall	(	const char *	function,
		const QVariant &	var1 = QVariant(),
		const QVariant &	var2 = QVariant(),
		const QVariant &	var3 = QVariant(),
		const QVariant &	var4 = QVariant(),
		const QVariant &	var5 = QVariant(),
		const QVariant &	var6 = QVariant(),
		const QVariant &	var7 = QVariant(),
		const QVariant &	var8 = QVariant()
	)

Calls the COM object's method function, passing the parameters var1, var1, var2, var3, var4, var5, var6, var7 and 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 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.

activeX->dynamicCall("Navigate(const QString&)", "www.qt-project.org");

Alternatively a function can be called passing the parameters embedded in the string, e.g. above function can also be invoked using

activeX->dynamicCall("Navigate(\"www.qt-project.org\")");

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 function is a property the string has to be the name of the property. The property setter is called when var1 is a valid QVariant, otherwise the getter is called.

activeX->dynamicCall("Value", 5);
QString text = activeX->dynamicCall("Text").toString();

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 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.

IWebBrowser2 *webBrowser = 0;
activeX->queryInterface(IID_IWebBrowser2, (void **)&webBrowser);
if (webBrowser) {
    webBrowser->Navigate2(pvarURL);
    webBrowser->Release();
}

This is also more efficient.

Definition at line 4046 of file qaxbase.cpp.

Referenced by QAxScript::call().

{
    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);
}

dynamicCall() [2/2]

QVariant QAxBase::dynamicCall	(	const char *	function,
		QList< QVariant > &	vars
	)

Calls the COM object's method function, passing the parameters in vars, and returns the value returned by the method.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

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 vars are updated when the method has out-parameters.

Definition at line 4091 of file qaxbase.cpp.

{
    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;
}

dynamicCallHelper()

bool QAxBase::dynamicCallHelper ( const char *  name, void *  inout, QList< QVariant > &  vars, QByteArray &  type  )

private

Warning

This function is not part of the public interface.

name is already normalized?

Definition at line 3784 of file qaxbase.cpp.

{
    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);
}

exception

void QAxBase::exception ( int  code, const QString &  source, const QString &  desc, const QString &  help  )

signal

This signal is emitted when the COM object throws an exception while called using the OLE automation interface IDispatch.

code, source, desc and help provide information about the exception as provided by the COM server and can be used to provide useful feedback to the end user. help includes the help file, and the help context ID in brackets, e.g. "filename [id]".

generateDocumentation()

QString QAxBase::generateDocumentation ( )

inline

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.

Definition at line 183 of file qaxbase.h.

{
    return qax_generateDocumentation(this);
}

indexOfVerb()

long QAxBase::indexOfVerb ( const QString &  verb ) const

protected

Warning

This function is not part of the public interface.

Definition at line 1172 of file qaxbase.cpp.

Referenced by QAxObject::doVerb(), and QAxWidget::doVerb().

{
    return d->verbs.value(verb);
}

initialize()

bool QAxBase::initialize ( IUnknown **  ptr )

protectedvirtual

This virtual function is called by setControl() and creates the requested COM object.

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 control property documentation for details about supported patterns.

The interface returned in 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.

Reimplemented in QAxScriptEngine, and QAxWidget.

Definition at line 1199 of file qaxbase.cpp.

Referenced by QAxWidget::initialize().

{
    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;
}

initializeActive()

bool QAxBase::initializeActive ( IUnknown **  ptr )

protected

Connects to an active instance running on the current machine, and returns the IUnknown interface to the running object in ptr.

This function returns true if successful, otherwise returns false.

This function is called by initialize() if the control string contains the substring "}&".

See also

initialize()

Definition at line 1321 of file qaxbase.cpp.

{
#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
}

initializeFrom()

void QAxBase::initializeFrom ( QAxBase *  that )

protected

Used by subclasses generated with dumpcpp to implement cast-operators.

Warning

This function is not part of the public interface.

Definition at line 902 of file qaxbase.cpp.

{
    if (d->ptr)
        return;

    d->ptr = that->d->ptr;
    if (d->ptr) {
        d->ptr->AddRef();
        d->initialized = true;
    }
}

initializeFromFile()

bool QAxBase::initializeFromFile ( IUnknown **  ptr )

protected

Creates the COM object handling the filename in the control property, and returns the IUnknown interface to the object in 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.

See also

initialize()

Definition at line 1352 of file qaxbase.cpp.

{
#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
}

initializeLicensed()

bool QAxBase::initializeLicensed ( IUnknown **  ptr )

protected

Creates an instance of a licensed control, and returns the IUnknown interface to the object in 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.

See also

initialize()

Definition at line 1240 of file qaxbase.cpp.

{
    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;
}

initializeLicensedHelper()

bool QAxBase::initializeLicensedHelper ( void *  factory, const QString &  key, IUnknown **  ptr  )

private

Definition at line 1261 of file qaxbase.cpp.

{
    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;
}

initializeRemote()

bool QAxBase::initializeRemote ( IUnknown **  ptr )

protected

Creates the instance on a remote server, and returns the IUnknown interface to the object in 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.

See also

initialize()

Definition at line 1390 of file qaxbase.cpp.

{
    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;
}

internalInvoke()

int QAxBase::internalInvoke ( QMetaObject::Call  call, int  index, void **  v  )

private

Definition at line 3593 of file qaxbase.cpp.

{
    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*")
                qvar.setValue(*(IDispatch**)v[p+1]);
            else if (type == "IUnknown*")
                qvar.setValue(*(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;
}

internalMetaObject()

QAxMetaObject * QAxBase::internalMetaObject ( ) const

private

Definition at line 915 of file qaxbase.cpp.

{
    return d->metaObject();
}

internalProperty()

int QAxBase::internalProperty ( QMetaObject::Call  call, int  index, void **  v  )

private

Warning

This function is not part of the public interface.

Definition at line 3476 of file qaxbase.cpp.

{
    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]);
//                    qvar.setValue(*(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;
}

internalRelease()

void QAxBase::internalRelease ( )

protected

Used by subclasses generated with dumpcpp to balance reference count.

Warning

This function is not part of the public interface.

Definition at line 888 of file qaxbase.cpp.

{
    if (d->ptr)
        d->ptr->Release();
}

isNull()

bool QAxBase::isNull

(

)

const

Returns true if there is no COM object loaded by this wrapper; otherwise return false.

See also

control

Definition at line 4412 of file qaxbase.cpp.

Referenced by QAxWidget::changeEvent(), QAxWidget::clear(), and qax_generateDocumentation().

{
    return !d->ptr;
}

metaObject()

const QMetaObject * QAxBase::metaObject ( ) const

virtual

The metaobject is generated on the fly from the information provided by the IDispatch and ITypeInfo interface implementations in the COM object.

Warning

This function is not part of the public interface.

Reimplemented in QAxWidget, and QAxObject.

Definition at line 3245 of file qaxbase.cpp.

Referenced by checkHRESULT(), QAxObject::metaObject(), QAxWidget::metaObject(), qax_generateDocumentation(), and qax_noSuchFunction().

{
    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);
}

parentMetaObject()

virtual const QMetaObject* QAxBase::parentMetaObject ( ) const

privatepure virtual

Implemented in QAxWidget, and QAxObject.

propertyBag()

QAxBase::PropertyBag QAxBase::propertyBag

(

)

const

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.

Definition at line 4303 of file qaxbase.cpp.

Referenced by operator<<().

{
    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;
}

propertyChanged

void QAxBase::propertyChanged ( const QString &  name )

signal

If the COM object supports property notification, this signal gets emitted when the property called name is changed.

propertyWritable()

bool QAxBase::propertyWritable ( const char *  prop ) const

virtual

Returns true if the property 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.

See also

setPropertyWritable(), propertyChanged()

Definition at line 4385 of file qaxbase.cpp.

{
    return d->propWritable.value(prop, true);
}

qObject()

QObject * QAxBase::qObject ( ) const

pure virtual

Warning

This function is not part of the public interface.

Implemented in QAxWidget, and QAxObject.

Referenced by checkHRESULT(), operator>>(), and qax_generateDocumentation().

qt_metacall()

int QAxBase::qt_metacall ( QMetaObject::Call  call, int  id, void **  v  )

virtual

Warning

This function is not part of the public interface.

Reimplemented in QAxWidget, and QAxObject.

Definition at line 3705 of file qaxbase.cpp.

Referenced by checkHRESULT(), QAxObject::qt_metacall(), and QAxWidget::qt_metacall().

{
    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;
}

queryInterface()

long QAxBase::queryInterface	(	const QUuid &	uuid,
		void **	iface
	)		const

Requests the interface uuid from the COM object and sets the value of 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.

See also

control

Definition at line 1479 of file qaxbase.cpp.

Referenced by QAxClientSite::activateObject(), QAxObject::doVerb(), QAxScriptSite::GetItemInfo(), QAxScriptEngine::hasIntrospection(), QAxHostWidget::paintEvent(), qax_generateDocumentation(), and QVariantToVARIANT().

{
    *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;
}

querySubObject() [1/2]

QAxObject * QAxBase::querySubObject	(	const char *	name,
		const QVariant &	var1 = QVariant(),
		const QVariant &	var2 = QVariant(),
		const QVariant &	var3 = QVariant(),
		const QVariant &	var4 = QVariant(),
		const QVariant &	var5 = QVariant(),
		const QVariant &	var6 = QVariant(),
		const QVariant &	var7 = QVariant(),
		const QVariant &	var8 = QVariant()
	)

Returns a pointer to a QAxObject wrapping the COM object provided by the method or property name, passing passing the parameters var1, var1, var2, var3, var4, var5, var6, var7 and var8.

If name is provided by a method the string must include the full function prototype.

If name is a property the string must be the name of the property, and var1, ... 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.

QAxWidget outlook("Outlook.Application");
QAxObject *session = outlook.querySubObject("Session");
if (session) {
    QAxObject *defFolder = session->querySubObject(
                "GetDefaultFolder(OlDefaultFolders)",
                "olFolderContacts");
    //...
}

Definition at line 4130 of file qaxbase.cpp.

{
    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);
}

querySubObject() [2/2]

QAxObject * QAxBase::querySubObject	(	const char *	name,
		QList< QVariant > &	vars
	)

The QVariant objects in vars are updated when the method has out-parameters.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 4169 of file qaxbase.cpp.

{
    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;
}

setControl()

bool QAxBase::setControl

(

const QString &

c

)

Definition at line 975 of file qaxbase.cpp.

Referenced by operator>>(), QAxObject::QAxObject(), and QAxWidget::QAxWidget().

{
    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;
}

setPropertyBag()

void QAxBase::setPropertyBag

(

const PropertyBag &

bag

)

Sets the properties of the COM object to the corresponding values in 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.

See also

propertyBag()

Definition at line 4347 of file qaxbase.cpp.

Referenced by operator>>().

{
    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);
        }
    }
}

setPropertyWritable()

void QAxBase::setPropertyWritable ( const char *  prop, bool  ok  )

virtual

Sets the property prop to writable if ok is true, otherwise sets 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.

See also

propertyWritable(), propertyChanged()

Definition at line 4401 of file qaxbase.cpp.

{
    d->propWritable[prop] = ok;
}

signal

void QAxBase::signal ( const QString &  name, int  argc, void *  argv  )

signal

This generic signal gets emitted when the COM object issues the event name.

argc is the number of parameters provided by the event (DISPPARAMS.cArgs), and 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.

void Receiver::slot(const QString &name, int argc, void *argv)
{
    VARIANTARG *params = (VARIANTARG*)argv;
    if (name.startsWith("BeforeNavigate2(")) {
    IDispatch *pDisp = params[argc-1].pdispVal;
    VARIANTARG URL = *params[argc-2].pvarVal;
    VARIANTARG Flags = *params[argc-3].pvarVal;
    VARIANTARG TargetFrameName = *params[argc-4].pvarVal;
    VARIANTARG PostData = *params[argc-5].pvarVal;
    VARIANTARG Headers = *params[argc-6].pvarVal;
    bool *Cancel = params[argc-7].pboolVal;
    }
}

Use this signal if the event has parameters of unsupported data types. Otherwise, connect directly to the signal name.

Referenced by QAxObject::qObject(), and QAxWidget::qObject().

verbs()

QStringList QAxBase::verbs

(

)

const

Returns the list of verbs that the COM object can execute.

Since

4.1

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.

Definition at line 1137 of file qaxbase.cpp.

Referenced by QAxObject::doVerb(), and QAxWidget::doVerb().

{
    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();
}

Friends and Related Functions

qax_createObjectWrapper

void* qax_createObjectWrapper ( int  , IUnknown *    )

friend

Definition at line 4448 of file qaxbase.cpp.

{
    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;
}

QAxEventSink

friend class QAxEventSink

friend

Definition at line 147 of file qaxbase.h.

Properties

d

QAxBasePrivate* QAxBase::d

private

Definition at line 150 of file qaxbase.h.

Referenced by initializeFrom().

staticMetaObject

QMetaObject QAxBase::staticMetaObject

staticprivate

Definition at line 158 of file qaxbase.h.

---

The documentation for this class was generated from the following files:

• /src/activeqt/container/qaxbase.h
• /src/activeqt/container/qaxbase.cpp