QAxServer Module

Serving Controls

To make a COM server available to the COM system it must be registered in the system registry using five unique identifiers. These identifiers are provided by tools like guidgen or uuidgen. The registration information allows COM to localize the binary providing a requested ActiveX control, marshall remote procedure calls to the control and read type information about the methods and properties exposed by the control.

To create the COM object when the client asks for it the server must export an implementation of a QAxFactory. The easist way to do this is to use a set of macros:

    QAXFACTORY_BEGIN("{ad90301a-849e-4e8b-9a91-0a6dc5f6461f}",
                     "{a8f21901-7ff7-4f6a-b939-789620c03d83}")
        QAXCLASS(MyWidget)
        QAXCLASS(MyWidget2)
        QAXTYPE(MySubType)
    QAXFACTORY_END()

This will export MyWidget and MyWidget2 as COM objects that can be created by COM clients, and will register MySubType as a type that can be used in properties and parameters of MyWidget and MyWidget2.

The QAxFactory class documentation explains how to use this macro, and how to implement and use custom factories.

For out-of-process executable servers you can implement a main() function to instantiate a QApplication object and enter the event loop just like any normal Qt application. By default the application will start as a standard Qt application, but if you pass -activex on the command line it will start as an ActiveX server. Use QAxFactory::isServer() to create and run a standard application interface, or to prevent a stand-alone execution:

    #include <QApplication>
    #include <QAxFactory>

    int main(int argc, char *argv[])
    {
        QApplication app(argc, argv);
        if (!QAxFactory::isServer()) {
            // create and show main window
        }
        return app.exec();
    }

This is however not necessary as ActiveQt provides a default implementation of a main function. The default implemenation calls QAxFactory::startServer(), creates a QApplication instance and calls exec().

To build the ActiveX server executable run qmake to generate the makefile, and use your compiler's make tool as for any other Qt application. The make process will also register the controls in the system registry by calling the resulting executable with the -regserver command line option.

If the ActiveX server is an executable, the following command line options are supported:

In-process servers can be registered using the regsvr32 tool available on all Windows systems.

    MyFactory(const QUuid &, const QUuid &);

    HMODULE dll = LoadLibrary("myserver.dll");
    typedef HRESULT(__stdcall *DllRegisterServerProc)();
    DllRegisterServerProc DllRegisterServer =
        (DllRegisterServerProc)GetProcAddress(dll, "DllRegisterServer");

    HRESULT res = E_FAIL;
    if (DllRegisterServer)
        res = DllRegisterServer();
    if (res != S_OK)
        // error handling

    [version]
        signature="$CHICAGO$"
        AdvancedINF=2.0
     [Add.Code]
        simpleax.exe=simpleax.exe
     [simpleax.exe]
        file-win32-x86=thiscab
        clsid={DF16845C-92CD-4AAB-A982-EB9840E74669}
        RegisterServer=yes

    cabarc N simpleax.cab simpleax.exe simple.inf

    <object ID="MyActiveX1" CLASSID="CLSID:ad90301a-849e-4e8b-9a91-0a6dc5f6461f">
       ...
    <\object>

    <object ID=...>
        <param name="name" value="value">
    <\object>

    class MyActiveX : public QWidget
    {
        Q_OBJECT
        Q_CLASSINFO("Version", "2.0")
        Q_CLASSINFO("ClassID", "{7a4cffd8-cbcd-4ae9-ae7e-343e1e5710df}")
        Q_CLASSINFO("InterfaceID", "{6fb035bf-8019-48d8-be51-ef05427d8994}")
        Q_CLASSINFO("EventsID", "{c42fffdf-6557-47c9-817a-2da2228bc29c}")
        Q_CLASSINFO("Insertable", "yes")
        Q_CLASSINFO("ToSuperClass", "MyActiveX")
        Q_PROPERTY(...)

    public:
        MyActiveX(QWidget *parent = 0);

        ...
    };

    class MyLicensedControl : public QWidget
    {
        Q_OBJECT
        Q_CLASSINFO("LicenseKey", "<key string>")
        ...
    };

    class AxImpl : public QAxAggregated, public ISomeCOMInterface
    {
    public:
        AxImpl() {}

        long queryInterface(const QUuid &iid, void **iface);

        // IUnknown
        QAXAGG_IUNKNOWN

        // ISomeCOMInterface
        ...
    }

    long AxImpl::queryInterface(const QUuid &iid, void **iface)
    {
        *iface = 0;
        if (iid == IID_ISomeCOMInterface)
            *iface = (ISomeCOMInterface *)this;
        else
            return E_NOINTERFACE;

        AddRef();
        return S_OK;
    }

    HRESULT AxImpl::QueryInterface(REFIID iid, void **iface)
    {
        return controllingUnknown()->QueryInterface(iid, iface);
    }

    class MyActiveX : public QWidget, public QAxBindable
    {
        Q_OBJECT

    public:
        MyActiveX(QWidget *parent);

        QAxAggregated *createAggregate()
        {
            return new AxImpl();
        }
    };