QAxBase Class

Detailed Description

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.

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

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.