Long live Qt 4.5!

31 files changed, 19086 insertions, 0 deletions

diff --git a/src/activeqt/activeqt.pro b/src/activeqt/activeqt.pro
new file mode 100644
index 0000000..0948ea0
--- /dev/null
+++ b/src/activeqt/activeqt.pro
@@ -0,0 +1,5 @@
+TEMPLATE = subdirs
+
+CONFIG	+= ordered
+SUBDIRS	= container
+!wince*: SUBDIRS += control
diff --git a/src/activeqt/container/container.pro b/src/activeqt/container/container.pro
new file mode 100644
index 0000000..ceedacf
--- /dev/null
+++ b/src/activeqt/container/container.pro
@@ -0,0 +1,45 @@
+TEMPLATE = lib
+
+TARGET   = ActiveQt
+CONFIG += qt_install_headers
+SYNCQT.HEADER_FILES = qaxbase.h qaxobject.h qaxscript.h qaxselect.h qaxwidget.h
+SYNCQT.HEADER_CLASSES = ../../../include/ActiveQt/QAxBase ../../../include/ActiveQt/QAxObject ../../../include/ActiveQt/QAxScriptEngine ../../../include/ActiveQt/QAxScript ../../../include/ActiveQt/QAxScriptManager ../../../include/ActiveQt/QAxSelect ../../../include/ActiveQt/QAxWidget
+include(../../qt_install.pri)
+
+TARGET   = QAxContainer
+
+!debug_and_release|build_pass {
+    CONFIG(debug, debug|release) {
+        TARGET = $$member(TARGET, 0)d
+    }
+}
+
+CONFIG  += qt warn_on staticlib
+QTDIR_build:DESTDIR  = $$QT_BUILD_TREE/lib
+
+LIBS    += -lole32 -loleaut32
+!wince*:LIBS    += -luser32 -lgdi32 -ladvapi32
+win32-g++:LIBS += -luuid
+
+contains(QT_EDITION, OpenSource|Console) {
+    message( "You are not licensed to use ActiveQt." )
+} else {
+    HEADERS         = ../control/qaxaggregated.h \
+                      qaxbase.h \
+		      qaxwidget.h \
+		      qaxobject.h \
+		      qaxscript.h \
+                      qaxselect.h \
+		      ../shared/qaxtypes.h
+
+    SOURCES         = qaxbase.cpp \
+		      qaxdump.cpp \
+		      qaxwidget.cpp \
+		      qaxobject.cpp \
+		      qaxscript.cpp \
+		      qaxscriptwrapper.cpp \
+                      qaxselect.cpp \
+		      ../shared/qaxtypes.cpp
+
+    FORMS           = qaxselect.ui
+}
diff --git a/src/activeqt/container/qaxbase.cpp b/src/activeqt/container/qaxbase.cpp
new file mode 100644
index 0000000..1ec704a
--- /dev/null
+++ b/src/activeqt/container/qaxbase.cpp
@@ -0,0 +1,4465 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+#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 = (TCHAR*)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::fromUtf16((const ushort *)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 initilializes 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*)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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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
+#ifdef Q_CC_GNU
+#ifndef COAUTHIDENTITY
+#define COAUTHIDENTITY AUTH_IDENTITY
+#endif
+#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*)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)
+    {
+        Property &prop = property_list[name];
+        if (!type.isEmpty() && type != "HRESULT") {
+            prop.type = replaceType(type);
+            if (prop.type != type)
+                prop.realType = type;
+        }
+        if (flags & Writable)
+            flags |= Stored;
+        prop.typeId |= flags;
+        QVariant::Type vartype = QVariant::nameToType(prop.type);
+        switch(vartype) {
+        case QVariant::Invalid:
+            if (prop.type == "QVariant") {
+                prop.typeId |= 0xff << 24;
+                break;
+            }
+            // fall through
+        case QVariant::UserType:
+            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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)typelibname).toLatin1();
+            SysFreeString(typelibname);
+
+            // get type name
+            BSTR usertypename = 0;
+            usertypelib->GetDocumentation(index, &usertypename, 0, 0, 0);
+            QByteArray userTypeName = QString::fromUtf16((const ushort *)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(QLatin1String("/") + 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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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.right(1) == ",") {
+            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::fromUtf16((const ushort *)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) {
+                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::fromUtf16((const ushort*)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::fromUtf16((const ushort *)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::fromUtf16((const ushort*)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::fromUtf16((const ushort *)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::fromUtf16((const ushort*)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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)exc->bstrSource);
+                desc = QString::fromUtf16((const ushort *)exc->bstrDescription);
+                help = QString::fromUtf16((const ushort *)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;
+        }
+        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;
+    }
+    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::fromUtf16((const ushort *)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::fromUtf16((const ushort *)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
diff --git a/src/activeqt/container/qaxbase.h b/src/activeqt/container/qaxbase.h
new file mode 100644
index 0000000..7e128e5
--- /dev/null
+++ b/src/activeqt/container/qaxbase.h
@@ -0,0 +1,226 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXBASE_H
+#define QAXBASE_H
+
+#include <QtCore/qdatastream.h>
+#include <QtCore/qmap.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qvariant.h>
+
+struct IUnknown;
+struct IDispatch;
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+struct QUuid;
+class QAxEventSink;
+class QAxObject;
+class QAxBasePrivate;
+struct QAxMetaObject;
+
+class QAxBase
+{
+    QDOC_PROPERTY(QString control READ control WRITE setControl)
+
+public:
+    typedef QMap<QString, QVariant> PropertyBag;
+    
+    QAxBase(IUnknown *iface = 0);
+    virtual ~QAxBase();
+    
+    QString control() const;
+    
+    long queryInterface(const QUuid &, void**) const;
+    
+    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());
+    QVariant dynamicCall(const char *name, QList<QVariant> &vars);
+    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());
+    QAxObject* querySubObject(const char *name, QList<QVariant> &vars);
+
+    virtual const QMetaObject *metaObject() const;
+    virtual int qt_metacall(QMetaObject::Call, int, void **);
+
+    virtual QObject *qObject() const = 0;
+    virtual const char *className() const = 0;
+    
+    PropertyBag propertyBag() const;
+    void setPropertyBag(const PropertyBag&);
+    
+    QString generateDocumentation();
+    
+    virtual bool propertyWritable(const char*) const;
+    virtual void setPropertyWritable(const char*, bool);
+    
+    bool isNull() const;
+
+    QStringList verbs() const;
+    
+    QVariant asVariant() const;
+    
+#ifdef qdoc
+Q_SIGNALS:
+    void signal(const QString&,int,void*);
+    void propertyChanged(const QString&);
+    void exception(int,const QString&,const QString&,const QString&);
+#endif
+
+public:
+    virtual void clear();
+    bool setControl(const QString&);
+
+    void disableMetaObject();
+    void disableClassInfo();
+    void disableEventSink();
+
+protected:
+    virtual bool initialize(IUnknown** ptr);
+    bool initializeRemote(IUnknown** ptr);
+    bool initializeLicensed(IUnknown** ptr);
+    bool initializeActive(IUnknown** ptr);
+    bool initializeFromFile(IUnknown** ptr);
+
+    void internalRelease();
+    void initializeFrom(QAxBase *that);
+    void connectNotify();
+    long indexOfVerb(const QString &verb) const;
+
+private:
+    friend class QAxEventSink;
+    friend void *qax_createObjectWrapper(int, IUnknown*);
+    bool initializeLicensedHelper(void *factory, const QString &key, IUnknown **ptr);
+    QAxBasePrivate *d;
+    QAxMetaObject *internalMetaObject() const;
+    
+    virtual const QMetaObject *parentMetaObject() const = 0;
+    int internalProperty(QMetaObject::Call, int index, void **v);
+    int internalInvoke(QMetaObject::Call, int index, void **v);
+    bool dynamicCallHelper(const char *name, void *out, QList<QVariant> &var, QByteArray &type);
+
+    static QMetaObject staticMetaObject;
+};
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QAxBase *qobject_cast_helper<QAxBase*>(const QObject *o, QAxBase *)
+#else
+template <> inline QAxBase *qobject_cast<QAxBase*>(const QObject *o)
+#endif
+{
+    void *result = o ? const_cast<QObject *>(o)->qt_metacast("QAxBase") : 0;
+    return (QAxBase*)(result);
+}
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QAxBase *qobject_cast_helper<QAxBase*>(QObject *o, QAxBase *)
+#else
+template <> inline QAxBase *qobject_cast<QAxBase*>(QObject *o)
+#endif
+{
+    void *result = o ? o->qt_metacast("QAxBase") : 0;
+    return (QAxBase*)(result);
+}
+
+extern QString qax_generateDocumentation(QAxBase *);
+
+inline QString QAxBase::generateDocumentation()
+{
+    return qax_generateDocumentation(this);
+}
+
+#ifndef QT_NO_DATASTREAM
+inline QDataStream &operator >>(QDataStream &s, QAxBase &c)
+{
+    QAxBase::PropertyBag bag;
+    c.qObject()->blockSignals(true);
+    QString control;
+    s >> control;
+    c.setControl(control);
+    s >> bag;
+    c.setPropertyBag(bag);
+    c.qObject()->blockSignals(false);
+    
+    return s;
+}
+
+inline QDataStream &operator <<(QDataStream &s, const QAxBase &c)
+{
+    QAxBase::PropertyBag bag = c.propertyBag();
+    s << c.control();
+    s << bag;
+    
+    return s;
+}
+#endif // QT_NO_DATASTREAM
+
+QT_END_NAMESPACE
+
+#ifndef Q_COM_METATYPE_DECLARED
+#define Q_COM_METATYPE_DECLARED
+
+Q_DECLARE_METATYPE(IUnknown*)
+Q_DECLARE_METATYPE(IDispatch*)
+
+#endif
+
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXBASE_H
diff --git a/src/activeqt/container/qaxdump.cpp b/src/activeqt/container/qaxdump.cpp
new file mode 100644
index 0000000..62ef0a4
--- /dev/null
+++ b/src/activeqt/container/qaxdump.cpp
@@ -0,0 +1,404 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include "qaxbase.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qmetaobject.h>
+#include <quuid.h>
+#include <qt_windows.h>
+#include <qtextstream.h>
+
+#include <ctype.h>
+
+#include "../shared/qaxtypes.h"
+
+QT_BEGIN_NAMESPACE
+
+QString qax_docuFromName(ITypeInfo *typeInfo, const QString &name)
+{
+    QString docu;
+    if (!typeInfo)
+        return docu;
+
+    MEMBERID memId;
+    BSTR names = QStringToBSTR(name);
+    typeInfo->GetIDsOfNames((BSTR*)&names, 1, &memId);
+    SysFreeString(names);
+    if (memId != DISPID_UNKNOWN) {
+        BSTR docStringBstr, helpFileBstr;
+        ulong helpContext;
+        HRESULT hres = typeInfo->GetDocumentation(memId, 0, &docStringBstr, &helpContext, &helpFileBstr);
+        QString docString = QString::fromUtf16((const ushort *)docStringBstr);
+        QString helpFile = QString::fromUtf16((const ushort *)helpFileBstr);
+        SysFreeString(docStringBstr);
+        SysFreeString(helpFileBstr);
+        if (hres == S_OK) {
+            if (!docString.isEmpty())
+                docu += docString + QLatin1String("\n");
+            if (!helpFile.isEmpty())
+                docu += QString::fromLatin1("For more information, see help context %1 in %2.").arg((uint)helpContext).arg(helpFile);
+        }
+    }
+
+    return docu;
+}
+
+static inline QString docuFromName(ITypeInfo *typeInfo, const QString &name)
+{
+    return QLatin1String("<p>") + qax_docuFromName(typeInfo, name) + QLatin1String("\n");
+}
+
+static QByteArray namedPrototype(const QList<QByteArray> &parameterTypes, const QList<QByteArray> &parameterNames, int numDefArgs = 0)
+{
+    QByteArray prototype("(");
+    for (int p = 0; p < parameterTypes.count(); ++p) {
+        QByteArray type(parameterTypes.at(p));
+        prototype += type;
+
+        if (p < parameterNames.count())
+            prototype += " " + parameterNames.at(p);
+         
+        if (numDefArgs >= parameterTypes.count() - p)
+            prototype += " = 0";
+        if (p < parameterTypes.count() - 1)
+            prototype += ", ";
+    }
+    prototype += ")";
+
+    return prototype;
+}
+
+static QByteArray toType(const QByteArray &t)
+{
+    QByteArray type = t;
+    int vartype = QVariant::nameToType(type);
+    if (vartype == QVariant::Invalid)
+        type = "int";
+    
+    if (type.at(0) == 'Q')
+        type = type.mid(1);
+    type[0] = toupper(type.at(0));
+    if (type == "VariantList")
+        type = "List";
+    else if (type == "Map<QVariant,QVariant>")
+        type = "Map";
+    else if (type == "Uint")
+        type = "UInt";
+    
+    return "to" + type + "()";
+}
+
+QString qax_generateDocumentation(QAxBase *that)
+{
+    that->metaObject();
+
+    if (that->isNull())
+	return QString();
+
+    ITypeInfo *typeInfo = 0;
+    IDispatch *dispatch = 0;
+    that->queryInterface(IID_IDispatch, (void**)&dispatch);
+    if (dispatch)
+	dispatch->GetTypeInfo(0, LOCALE_SYSTEM_DEFAULT, &typeInfo);
+
+    QString docu;
+    QTextStream stream(&docu, QIODevice::WriteOnly);
+
+    const QMetaObject *mo = that->metaObject();
+    QString coClass  = QLatin1String(mo->classInfo(mo->indexOfClassInfo("CoClass")).value());
+
+    stream << "<h1 align=center>" << coClass << " Reference</h1>" << endl;
+    stream << "<p>The " << coClass << " COM object is a " << that->qObject()->metaObject()->className();
+    stream << " with the CLSID " <<  that->control() << ".</p>" << endl;
+
+    stream << "<h3>Interfaces</h3>" << endl;
+    stream << "<ul>" << endl;
+    const char *inter = 0;
+    int interCount = 1;
+    while ((inter = mo->classInfo(mo->indexOfClassInfo("Interface " + QByteArray::number(interCount))).value())) {
+	stream << "<li>" << inter << endl;
+	interCount++;
+    }
+    stream << "</ul>" << endl;
+
+    stream << "<h3>Event Interfaces</h3>" << endl;
+    stream << "<ul>" << endl;
+    interCount = 1;  
+    while ((inter = mo->classInfo(mo->indexOfClassInfo("Event Interface " + QByteArray::number(interCount))).value())) {
+	stream << "<li>" << inter << endl;
+	interCount++;
+    }
+    stream << "</ul>" << endl;
+
+    QList<QString> methodDetails, propDetails;
+
+    const int slotCount = mo->methodCount();
+    if (slotCount) {
+	stream << "<h2>Public Slots:</h2>" << endl;
+	stream << "<ul>" << endl;
+
+        int defArgCount = 0;
+	for (int islot = mo->methodOffset(); islot < slotCount; ++islot) {
+	    const QMetaMethod slot = mo->method(islot);
+            if (slot.methodType() != QMetaMethod::Slot)
+                continue;
+
+            if (slot.attributes() & QMetaMethod::Cloned) {
+                ++defArgCount;
+                continue;
+            }
+
+	    QByteArray returntype(slot.typeName());
+            if (returntype.isEmpty())
+                returntype = "void";
+            QByteArray prototype = namedPrototype(slot.parameterTypes(), slot.parameterNames(), defArgCount);
+            QByteArray signature = slot.signature();
+	    QByteArray name = signature.left(signature.indexOf('('));
+	    stream << "<li>" << returntype << " <a href=\"#" << name << "\"><b>" << name << "</b></a>" << prototype << ";</li>" << endl;
+            
+            prototype = namedPrototype(slot.parameterTypes(), slot.parameterNames());
+	    QString detail = QString::fromLatin1("<h3><a name=") + QString::fromLatin1(name.constData()) + QLatin1String("></a>") +
+                             QString::fromLatin1(returntype.constData()) + QLatin1String(" ") +
+                             QString::fromLatin1(name.constData()) + QLatin1String(" ") +
+                             QString::fromLatin1(prototype.constData()) + QLatin1String("<tt> [slot]</tt></h3>\n");
+            prototype = namedPrototype(slot.parameterTypes(), QList<QByteArray>());
+	    detail += docuFromName(typeInfo, QString::fromLatin1(name.constData()));
+	    detail += QLatin1String("<p>Connect a signal to this slot:<pre>\n");
+	    detail += QString::fromLatin1("\tQObject::connect(sender, SIGNAL(someSignal") + QString::fromLatin1(prototype.constData()) +
+                      QLatin1String("), object, SLOT(") + QString::fromLatin1(name.constData()) +
+                      QString::fromLatin1(prototype.constData()) + QLatin1String("));");
+	    detail += QLatin1String("</pre>\n");
+
+            if (1) {
+                detail += QLatin1String("<p>Or call the function directly:<pre>\n");
+
+                bool hasParams = slot.parameterTypes().count() != 0;
+                if (hasParams)
+                    detail += QLatin1String("\tQVariantList params = ...\n");
+                detail += QLatin1String("\t");
+                QByteArray functionToCall = "dynamicCall";
+                if (returntype == "IDispatch*" || returntype == "IUnknown*") {
+                    functionToCall = "querySubObject";
+                    returntype = "QAxObject *";
+                }
+                if (returntype != "void")
+                    detail += QString::fromLatin1(returntype.constData()) + QLatin1String(" result = ");
+                detail += QLatin1String("object->") + QString::fromLatin1(functionToCall.constData()) +
+                          QLatin1String("(\"" + name + prototype + "\"");
+                if (hasParams)
+                    detail += QLatin1String(", params");
+                detail += QLatin1String(")");
+                if (returntype != "void" && returntype != "QAxObject *" && returntype != "QVariant")
+                    detail += QLatin1String(".") + QString::fromLatin1(toType(returntype));
+	        detail += QLatin1String(";</pre>\n");
+	    } else {
+		detail += QLatin1String("<p>This function has parameters of unsupported types and cannot be called directly.");
+	    }
+
+	    methodDetails << detail;
+            defArgCount = 0;
+	}
+
+	stream << "</ul>" << endl;
+    }
+    int signalCount = mo->methodCount();
+    if (signalCount) {
+        ITypeLib *typeLib = 0;
+        if (typeInfo) {
+            UINT index = 0;
+            typeInfo->GetContainingTypeLib(&typeLib, &index);
+            typeInfo->Release();
+        }
+        typeInfo = 0;
+
+	stream << "<h2>Signals:</h2>" << endl;
+	stream << "<ul>" << endl;
+
+	for (int isignal = mo->methodOffset(); isignal < signalCount; ++isignal) {
+	    const QMetaMethod signal(mo->method(isignal));
+            if (signal.methodType() != QMetaMethod::Signal)
+                continue;
+
+            QByteArray prototype = namedPrototype(signal.parameterTypes(), signal.parameterNames());
+	    QByteArray signature = signal.signature();
+	    QByteArray name = signature.left(signature.indexOf('('));
+	    stream << "<li>void <a href=\"#" << name << "\"><b>" << name << "</b></a>" << prototype << ";</li>" << endl;
+
+            QString detail = QLatin1String("<h3><a name=") + QString::fromLatin1(name.constData()) + QLatin1String("></a>void ") +
+                             QString::fromLatin1(name.constData()) + QLatin1String(" ") +
+                             QString::fromLatin1(prototype.constData()) + QLatin1String("<tt> [signal]</tt></h3>\n");
+            if (typeLib) {
+                interCount = 0;
+                do {
+                    if (typeInfo)
+                        typeInfo->Release();
+                    typeInfo = 0;
+                    typeLib->GetTypeInfo(++interCount, &typeInfo);
+                    QString typeLibDocu = docuFromName(typeInfo, QString::fromLatin1(name.constData()));
+                    if (!typeLibDocu.isEmpty()) {
+                        detail += typeLibDocu;
+                        break;
+                    }
+                } while (typeInfo);
+            }
+            prototype = namedPrototype(signal.parameterTypes(), QList<QByteArray>());
+	    detail += QLatin1String("<p>Connect a slot to this signal:<pre>\n");
+	    detail += QLatin1String("\tQObject::connect(object, SIGNAL(") + QString::fromLatin1(name.constData()) +
+                      QString::fromLatin1(prototype.constData()) +
+                      QLatin1String("), receiver, SLOT(someSlot") + QString::fromLatin1(prototype.constData()) + QLatin1String("));");
+	    detail += QLatin1String("</pre>\n");
+
+	    methodDetails << detail;
+            if (typeInfo)
+                typeInfo->Release();
+            typeInfo = 0;
+	}
+	stream << "</ul>" << endl;
+
+        if (typeLib)
+            typeLib->Release();
+    }
+
+    const int propCount = mo->propertyCount();
+    if (propCount) {
+        if (dispatch)
+	    dispatch->GetTypeInfo(0, LOCALE_SYSTEM_DEFAULT, &typeInfo);
+	stream << "<h2>Properties:</h2>" << endl;
+	stream << "<ul>" << endl;
+
+	for (int iprop = 0; iprop < propCount; ++iprop) {
+	    const QMetaProperty prop = mo->property(iprop);
+	    QByteArray name(prop.name());
+	    QByteArray type(prop.typeName());
+
+	    stream << "<li>" << type << " <a href=\"#" << name << "\"><b>" << name << "</b></a>;</li>" << endl;
+	    QString detail = QLatin1String("<h3><a name=") + QString::fromLatin1(name.constData()) + QLatin1String("></a>") +
+                             QString::fromLatin1(type.constData()) +
+		             QLatin1String(" ") + QString::fromLatin1(name.constData()) + QLatin1String("</h3>\n");
+	    detail += docuFromName(typeInfo, QString::fromLatin1(name));
+	    QVariant::Type vartype = QVariant::nameToType(type);
+	    if (!prop.isReadable())
+		continue;
+
+	    if (prop.isEnumType())
+		vartype = QVariant::Int;
+
+            if (vartype != QVariant::Invalid) {
+		detail += QLatin1String("<p>Read this property's value using QObject::property:<pre>\n");
+                if (prop.isEnumType())
+		    detail += QLatin1String("\tint val = ");
+                else
+                    detail += QLatin1String("\t") + QString::fromLatin1(type.constData()) + QLatin1String(" val = ");
+		detail += QLatin1String("object->property(\"") + QString::fromLatin1(name.constData()) +
+                          QLatin1String("\").") + QString::fromLatin1(toType(type).constData()) + QLatin1String(";\n");
+		detail += QLatin1String("</pre>\n");
+	    } else if (type == "IDispatch*" || type == "IUnknown*") {
+		detail += QLatin1String("<p>Get the subobject using querySubObject:<pre>\n");
+		detail += QLatin1String("\tQAxObject *") + QString::fromLatin1(name.constData()) +
+                          QLatin1String(" = object->querySubObject(\"") + QString::fromLatin1(name.constData()) + QLatin1String("\");\n");
+		detail += QLatin1String("</pre>\n");
+	    } else {
+		detail += QLatin1String("<p>This property is of an unsupported type.\n");
+	    }
+	    if (prop.isWritable()) {
+		detail += QLatin1String("Set this property' value using QObject::setProperty:<pre>\n");
+                if (prop.isEnumType()) {
+                    detail += QLatin1String("\tint newValue = ... // string representation of values also supported\n");
+                } else {
+		    detail += QLatin1String("\t") + QString::fromLatin1(type.constData()) + QLatin1String(" newValue = ...\n");
+                }
+		detail += QLatin1String("\tobject->setProperty(\"") + QString::fromLatin1(name) + QLatin1String("\", newValue);\n");
+		detail += QLatin1String("</pre>\n");
+		detail += QLatin1String("Or using the ");
+		QByteArray setterSlot;
+                if (isupper(name.at(0))) {
+		    setterSlot = "Set" + name;
+		} else {
+		    QByteArray nameUp = name;
+		    nameUp[0] = toupper(nameUp.at(0));
+		    setterSlot = "set" + nameUp;
+		}
+		detail += QLatin1String("<a href=\"#") + QString::fromLatin1(setterSlot) + QLatin1String("\">") +
+                          QString::fromLatin1(setterSlot.constData()) + QLatin1String("</a> slot.\n");
+	    }
+	    if (prop.isEnumType()) {
+		detail += QLatin1String("<p>See also <a href=\"#") + QString::fromLatin1(type) +
+                QLatin1String("\">") + QString::fromLatin1(type) + QLatin1String("</a>.\n");
+	    }
+
+	    propDetails << detail;
+	}
+	stream << "</ul>" << endl;
+    }
+
+    const int enumCount = mo->enumeratorCount();
+    if (enumCount) {
+	stream << "<hr><h2>Member Type Documentation</h2>" << endl;
+	for (int i = 0; i < enumCount; ++i) {
+	    const QMetaEnum enumdata = mo->enumerator(i);
+	    stream << "<h3><a name=" << enumdata.name() << "></a>" << enumdata.name() << "</h3>" << endl;
+	    stream << "<ul>" << endl;
+	    for (int e = 0; e < enumdata.keyCount(); ++e) {
+		stream << "<li>" << enumdata.key(e) << "\t=" << enumdata.value(e) << "</li>" << endl;
+	    }
+	    stream << "</ul>" << endl;
+	}
+    }
+    if (methodDetails.count()) {
+	stream << "<hr><h2>Member Function Documentation</h2>" << endl;
+	for (int i = 0; i < methodDetails.count(); ++i)
+	    stream << methodDetails.at(i) << endl;
+    }
+    if (propDetails.count()) {
+	stream << "<hr><h2>Property Documentation</h2>" << endl;
+	for (int i = 0; i < propDetails.count(); ++i)
+	    stream << propDetails.at(i) << endl;
+    }
+
+    if (typeInfo)
+        typeInfo->Release();
+    if (dispatch)
+        dispatch->Release();
+    return docu;
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/container/qaxobject.cpp b/src/activeqt/container/qaxobject.cpp
new file mode 100644
index 0000000..bd71dfa
--- /dev/null
+++ b/src/activeqt/container/qaxobject.cpp
@@ -0,0 +1,213 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+#include "qaxobject.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <quuid.h>
+#include <qmetaobject.h>
+#include <qstringlist.h>
+
+#include <windows.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QAxObject
+    \brief The QAxObject class provides a QObject that wraps a COM object.
+
+    \inmodule QAxContainer
+
+    A QAxObject can be instantiated as an empty object, with the name
+    of the COM object it should wrap, or with a pointer to the
+    IUnknown that represents an existing COM object. If the COM object
+    implements the \c IDispatch interface, the properties, methods and
+    events of that object become available as Qt properties, slots and
+    signals. The base class, QAxBase, provides an API to access the
+    COM object directly through the IUnknown pointer.
+
+    QAxObject is a QObject and can be used as such, e.g. it can be
+    organized in an object hierarchy, receive events and connect to
+    signals and slots.
+
+    QAxObject also inherits most of its ActiveX-related functionality
+    from QAxBase, notably dynamicCall() and querySubObject().
+
+    \warning
+    You can subclass QAxObject, but you cannot use the Q_OBJECT macro
+    in the subclass (the generated moc-file will not compile), so you
+    cannot add further signals, slots or properties. This limitation is 
+    due to the metaobject information generated in runtime. 
+    To work around this problem, aggregate the QAxObject as a member of 
+    the QObject subclass.
+
+    \sa QAxBase, QAxWidget, QAxScript, {ActiveQt Framework}
+*/
+
+/*!
+    Creates an empty COM object and propagates \a parent to the
+    QObject constructor. To initialize the object, call \link
+    QAxBase::setControl() setControl \endlink.
+*/
+QAxObject::QAxObject(QObject *parent)
+: QObject(parent)
+{
+}
+
+/*!
+    Creates a QAxObject that wraps the COM object \a c. \a parent is
+    propagated to the QObject constructor.
+
+    \sa setControl()
+*/
+QAxObject::QAxObject(const QString &c, QObject *parent)
+: QObject(parent)
+{
+    setControl(c);
+}
+
+/*!
+    Creates a QAxObject that wraps the COM object referenced by \a
+    iface. \a parent is propagated to the QObject constructor.
+*/
+QAxObject::QAxObject(IUnknown *iface, QObject *parent)
+: QObject(parent), QAxBase(iface)
+{
+}
+
+/*!
+    Releases the COM object and destroys the QAxObject,
+    cleaning up all allocated resources.
+*/
+QAxObject::~QAxObject()
+{
+    clear();
+}
+
+/*!
+    \reimp
+*/
+const QMetaObject *QAxObject::metaObject() const
+{
+    return QAxBase::metaObject();
+}
+
+/*!
+    \reimp
+*/
+const QMetaObject *QAxObject::parentMetaObject() const
+{
+    return &QObject::staticMetaObject;
+}
+
+/*!
+    \internal
+*/
+void *QAxObject::qt_metacast(const char *cname)
+{
+    if (!qstrcmp(cname, "QAxObject")) return (void*)this;
+    if (!qstrcmp(cname, "QAxBase")) return (QAxBase*)this;
+    return QObject::qt_metacast(cname);
+}
+
+/*!
+    \reimp
+*/
+const char *QAxObject::className() const
+{
+    return "QAxObject";
+}
+
+/*!
+    \reimp
+*/
+int QAxObject::qt_metacall(QMetaObject::Call call, int id, void **v)
+{
+    id = QObject::qt_metacall(call, id, v);
+    if (id < 0)
+        return id;
+    return QAxBase::qt_metacall(call, id, v);
+}
+
+/*!
+    \fn QObject *QAxObject::qObject() const
+    \internal
+*/
+
+/*!
+    \reimp
+*/
+void QAxObject::connectNotify(const char *)
+{
+    QAxBase::connectNotify();
+}
+
+/*!
+    \since 4.1
+
+    Requests the COM object to perform the action \a verb. The
+    possible verbs are returned by verbs().
+
+    The function returns true if the object could perform the action, otherwise returns false.
+*/
+bool QAxObject::doVerb(const QString &verb)
+{
+    if (!verbs().contains(verb))
+        return false;
+    IOleObject *ole = 0;
+    queryInterface(IID_IOleObject, (void**)&ole);
+    if (!ole)
+        return false;
+
+    LONG index = indexOfVerb(verb);
+
+    HRESULT hres = ole->DoVerb(index, 0, 0, 0, 0, 0);
+
+    ole->Release();
+
+    return hres == S_OK;
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/container/qaxobject.h b/src/activeqt/container/qaxobject.h
new file mode 100644
index 0000000..ffa2087
--- /dev/null
+++ b/src/activeqt/container/qaxobject.h
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXOBJECT_H
+#define QAXOBJECT_H
+
+#include <ActiveQt/qaxbase.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+class QAxObject : public QObject, public QAxBase
+{
+    friend class QAxEventSink;
+public:
+    const QMetaObject *metaObject() const;
+    void* qt_metacast(const char*);
+    int qt_metacall(QMetaObject::Call, int, void **);
+    QObject* qObject() const { return (QObject*)this; }
+    const char *className() const;
+    
+    QAxObject(QObject *parent = 0);
+    QAxObject(const QString &c, QObject *parent = 0);
+    QAxObject(IUnknown *iface, QObject *parent = 0);
+    ~QAxObject();
+    
+    bool doVerb(const QString &verb);
+
+protected:
+    void connectNotify(const char *signal);
+
+private:
+    const QMetaObject *parentMetaObject() const;
+    static QMetaObject staticMetaObject;
+};
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QAxObject *qobject_cast_helper<QAxObject*>(const QObject *o, QAxObject *)
+#else
+template <> inline QAxObject *qobject_cast<QAxObject*>(const QObject *o)
+#endif
+{
+    void *result = o ? const_cast<QObject *>(o)->qt_metacast("QAxObject") : 0;
+    return (QAxObject*)(result);
+}
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QAxObject *qobject_cast_helper<QAxObject*>(QObject *o, QAxObject *)
+#else
+template <> inline QAxObject *qobject_cast<QAxObject*>(QObject *o)
+#endif
+{
+    void *result = o ? o->qt_metacast("QAxObject") : 0;
+    return (QAxObject*)(result);
+}
+
+QT_END_NAMESPACE
+Q_DECLARE_METATYPE(QAxObject*)
+
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXOBJECT_H
diff --git a/src/activeqt/container/qaxscript.cpp b/src/activeqt/container/qaxscript.cpp
new file mode 100644
index 0000000..c69fea0
--- /dev/null
+++ b/src/activeqt/container/qaxscript.cpp
@@ -0,0 +1,1293 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+#include "qaxscript.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#if defined(Q_CC_GNU)
+# define QT_NO_QAXSCRIPT
+#elif defined(Q_CC_BOR) && __BORLANDC__ < 0x560
+# define QT_NO_QAXSCRIPT
+#endif
+
+#include <qapplication.h>
+#include <qfile.h>
+#include <qhash.h>
+#include <qmetaobject.h>
+#include <quuid.h>
+#include <qwidget.h>
+
+#include <qt_windows.h>
+#ifndef QT_NO_QAXSCRIPT
+#include <initguid.h>
+#include <activscp.h>
+#endif
+
+#include "../shared/qaxtypes.h"
+
+QT_BEGIN_NAMESPACE
+
+struct QAxEngineDescriptor { QString name, extension, code; };
+static QList<QAxEngineDescriptor> engines;
+
+class QAxScriptManagerPrivate
+{
+public:
+    QHash<QString, QAxScript*> scriptDict;
+    QHash<QString, QAxBase*> objectDict;
+};
+
+/*
+    \class QAxScriptSite
+    \brief The QAxScriptSite class implements a Windows Scripting Host
+    \internal
+
+    The QAxScriptSite is used internally to communicate callbacks from the script
+    engine to the script manager.
+*/
+
+#ifndef QT_NO_QAXSCRIPT
+
+class QAxScriptSite : public IActiveScriptSite, public IActiveScriptSiteWindow
+{
+public:
+    QAxScriptSite(QAxScript *script);
+    
+    ULONG WINAPI AddRef();
+    ULONG WINAPI Release();
+    HRESULT WINAPI QueryInterface(REFIID iid, void **ppvObject);
+    
+    HRESULT WINAPI GetLCID(LCID *plcid);
+    HRESULT WINAPI GetItemInfo(LPCOLESTR pstrName, DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti);
+    HRESULT WINAPI GetDocVersionString(BSTR *pbstrVersion);
+    
+    HRESULT WINAPI OnScriptTerminate(const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo);
+    HRESULT WINAPI OnStateChange(SCRIPTSTATE ssScriptState);
+    HRESULT WINAPI OnScriptError(IActiveScriptError *pscripterror);
+    HRESULT WINAPI OnEnterScript();
+    HRESULT WINAPI OnLeaveScript();
+    
+    HRESULT WINAPI GetWindow(HWND *phwnd);
+    HRESULT WINAPI EnableModeless(BOOL fEnable);
+    
+protected:
+    QWidget *window() const;
+    
+private:
+    QAxScript *script;
+    unsigned long ref;
+};
+
+/*
+    Constructs the site for the \a s.
+*/
+QAxScriptSite::QAxScriptSite(QAxScript *s)
+: script(s), ref(1)
+{
+}
+
+/*
+    Implements IUnknown::AddRef
+*/
+ULONG WINAPI QAxScriptSite::AddRef()
+{
+    return ++ref;
+}
+
+/*
+    Implements IUnknown::Release
+*/
+ULONG WINAPI QAxScriptSite::Release()
+{
+    if (!--ref) {
+        delete this;
+        return 0;
+    }
+    return ref;
+}
+
+/*
+    Implements IUnknown::QueryInterface
+*/
+HRESULT WINAPI QAxScriptSite::QueryInterface(REFIID iid, void **ppvObject)
+{
+    *ppvObject = 0;
+    if (iid == IID_IUnknown)
+        *ppvObject = (IUnknown*)(IActiveScriptSite*)this;
+    else if (iid == IID_IActiveScriptSite)
+        *ppvObject = (IActiveScriptSite*)this;
+    else if (iid == IID_IActiveScriptSiteWindow)
+        *ppvObject = (IActiveScriptSiteWindow*)this;
+    else
+        return E_NOINTERFACE;
+    
+    AddRef();
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSite::GetLCID
+
+    This method is not implemented. Use the system-defined locale.
+*/
+HRESULT WINAPI QAxScriptSite::GetLCID(LCID * /*plcid*/)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Implements IActiveScriptSite::GetItemInfo
+
+    Tries to find the QAxBase for \a pstrName and returns the 
+    relevant interfaces in \a item and \a type as requested through \a mask.
+*/
+HRESULT WINAPI QAxScriptSite::GetItemInfo(LPCOLESTR pstrName, DWORD mask, IUnknown **item, ITypeInfo **type)
+{
+    if (item)
+        *item = 0;
+    else if (mask & SCRIPTINFO_IUNKNOWN)
+        return E_POINTER;
+    
+    if (type)
+        *type = 0;
+    else if (mask & SCRIPTINFO_ITYPEINFO)
+        return E_POINTER;
+    
+    QAxBase *object = script->findObject(QString::fromUtf16((const ushort*)pstrName));
+    if (!object)
+        return TYPE_E_ELEMENTNOTFOUND;
+    
+    if (mask & SCRIPTINFO_IUNKNOWN)
+        object->queryInterface(IID_IUnknown, (void**)item);
+    if (mask & SCRIPTINFO_ITYPEINFO) {
+        IProvideClassInfo *classInfo = 0;
+        object->queryInterface(IID_IProvideClassInfo, (void**)&classInfo);
+        if (classInfo) {
+            classInfo->GetClassInfo(type);
+            classInfo->Release();
+        }
+    }
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSite::GetDocVersionString
+
+    This method is not implemented. The scripting engine should assume 
+    that the script is in sync with the document.
+*/
+HRESULT WINAPI QAxScriptSite::GetDocVersionString(BSTR * /*version*/)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Implements IActiveScriptSite::OnScriptTerminate
+
+    This method is usually not called, but if it is it fires
+    QAxScript::finished().
+*/
+HRESULT WINAPI QAxScriptSite::OnScriptTerminate(const VARIANT *result, const EXCEPINFO *exception)
+{
+    emit script->finished();
+    
+    if (result && result->vt != VT_EMPTY)
+        emit script->finished(VARIANTToQVariant(*result, 0));
+    if (exception)
+        emit script->finished(exception->wCode, 
+        QString::fromUtf16((const ushort*)exception->bstrSource),
+        QString::fromUtf16((const ushort*)exception->bstrDescription),
+        QString::fromUtf16((const ushort*)exception->bstrHelpFile)
+			    );
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSite::OnEnterScript
+
+    Fires QAxScript::entered() to inform the host that the 
+    scripting engine has begun executing the script code.
+*/
+HRESULT WINAPI QAxScriptSite::OnEnterScript()
+{
+    emit script->entered();
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSite::OnLeaveScript
+
+    Fires QAxScript::finished() to inform the host that the 
+    scripting engine has returned from executing the script code.
+*/
+HRESULT WINAPI QAxScriptSite::OnLeaveScript()
+{
+    emit script->finished();
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSite::OnScriptError
+
+    Fires QAxScript::error() to inform the host that an 
+    that an execution error occurred while the engine was running the script.
+*/
+HRESULT WINAPI QAxScriptSite::OnScriptError(IActiveScriptError *error)
+{
+    EXCEPINFO exception;
+    memset(&exception, 0, sizeof(exception));
+    DWORD context;
+    ULONG lineNumber;
+    LONG charPos;
+    BSTR bstrLineText;
+    QString lineText;
+    
+    error->GetExceptionInfo(&exception);
+    error->GetSourcePosition(&context, &lineNumber, &charPos);
+    HRESULT hres = error->GetSourceLineText(&bstrLineText);
+    if (hres == S_OK) {
+        lineText = QString::fromUtf16((const ushort*)bstrLineText);
+        SysFreeString(bstrLineText);
+    }
+    SysFreeString(exception.bstrSource);
+    SysFreeString(exception.bstrDescription);
+    SysFreeString(exception.bstrHelpFile);
+
+    emit script->error(exception.wCode, QString::fromUtf16((const ushort*)exception.bstrDescription), lineNumber, lineText);
+    
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSite::OnStateChange
+
+    Fires QAxScript::stateChanged() to inform the
+    the host that the scripting engine has changed states.
+*/
+HRESULT WINAPI QAxScriptSite::OnStateChange(SCRIPTSTATE ssScriptState)
+{
+    emit script->stateChanged(ssScriptState);
+    return S_OK;
+}
+
+/*
+    \internal
+    Returns the toplevel widget parent of this script, or
+    the application' active window if there is no widget parent.
+*/
+QWidget *QAxScriptSite::window() const
+{
+    QWidget *w = 0;
+    QObject *p = script->parent();
+    while (!w && p) {
+        w = qobject_cast<QWidget*>(p);
+        p = p->parent();
+    }
+    
+    if (w)
+        w = w->window();
+    if (!w && qApp)
+        w = qApp->activeWindow();
+    
+    return w;
+}
+
+/*
+    Implements IActiveScriptSiteWindow::GetWindow
+
+    Retrieves the handle to a window that can act as the owner of a 
+    pop-up window that the scripting engine must display.
+*/
+HRESULT WINAPI QAxScriptSite::GetWindow(HWND *phwnd)
+{
+    if (!phwnd)
+        return E_POINTER;
+    
+    *phwnd = 0;
+    QWidget *w = window();
+    if (!w)
+        return E_FAIL;
+    
+    *phwnd = w->winId();
+    return S_OK;
+}
+
+/*
+    Implements IActiveScriptSiteWindow::EnableModeless
+
+    Causes the host to enable or disable its main window 
+    as well as any modeless dialog boxes.
+*/
+HRESULT WINAPI QAxScriptSite::EnableModeless(BOOL fEnable)
+{
+    QWidget *w = window();
+    if (!w)
+        return E_FAIL;
+    
+    EnableWindow(w->winId(), fEnable);
+    return S_OK;
+}
+
+#endif //QT_NO_QAXSCRIPT
+
+
+/*!
+    \class QAxScriptEngine
+    \brief The QAxScriptEngine class provides a wrapper around a script engine.
+    \inmodule QAxContainer
+
+    Every instance of the QAxScriptEngine class represents an interpreter
+    for script code in a particular scripting language. The class is usually
+    not used directly. The QAxScript and QAxScriptManager classes provide
+    convenient functions to handle and call script code.
+
+    Direct access to the script engine is provided through
+    queryInterface().
+
+    \warning This class is not available with the bcc5.5 and MingW
+    compilers.
+
+    \sa QAxScript, QAxScriptManager, QAxBase, {ActiveQt Framework}
+*/
+
+/*!
+    \enum QAxScriptEngine::State
+
+    The State enumeration defines the different states a script
+    engine can be in.
+
+    \value Uninitialized The script has been created, but not yet initialized
+    \value Initialized The script has been initialized, but is not running
+    \value Started The script can execute code, but does not yet handle events
+    \value Connected The script can execute code and is connected so
+    that it can handle events
+    \value Disconnected The script is loaded, but is not connected to
+    event sources
+    \value Closed The script has been closed.
+*/
+
+/*!
+    Constructs a QAxScriptEngine object interpreting script code in \a language
+    provided by the code in \a script. This is usually done by the QAxScript 
+    class when \link QAxScript::load() loading a script\endlink.
+
+    Instances of QAxScriptEngine should always have both a language and a
+    script.
+*/
+QAxScriptEngine::QAxScriptEngine(const QString &language, QAxScript *script)
+: QAxObject(script), script_code(script), engine(0), script_language(language)
+{
+#ifdef QT_CHECK_STATE
+    if (language.isEmpty())
+        qWarning("QAxScriptEngine: created without language");
+    
+    if (!script_code)
+        qWarning("QAxScriptEngine: created without script");
+#endif
+    setObjectName(QLatin1String("QAxScriptEngine_") + language);
+    disableClassInfo();
+    disableEventSink();
+}
+
+/*!
+    Destroys the QAxScriptEngine object, releasing all allocated
+    resources.
+*/
+QAxScriptEngine::~QAxScriptEngine()
+{
+#ifndef QT_NO_QAXSCRIPT
+    if (engine) {
+        engine->SetScriptState(SCRIPTSTATE_DISCONNECTED);
+        engine->Close();
+        engine->Release();
+    }
+#endif
+}
+
+/*! 
+    \fn QString QAxScriptEngine::scriptLanguage() const
+    Returns the scripting language, for example "VBScript",
+    or "JScript".
+*/
+
+/*!
+    \reimp
+*/
+bool QAxScriptEngine::initialize(IUnknown **ptr)
+{
+    *ptr = 0;
+    
+#ifndef QT_NO_QAXSCRIPT
+    if (!script_code || script_language.isEmpty())
+        return false;
+    
+    CLSID clsid;
+    HRESULT hres = CLSIDFromProgID((WCHAR*)script_language.utf16(), &clsid);
+    if(FAILED(hres))
+        return false;
+    
+    CoCreateInstance(clsid, 0, CLSCTX_INPROC_SERVER, IID_IActiveScript, (void**)&engine);
+    if (!engine)
+        return false;
+    
+    IActiveScriptParse *parser = 0;
+    engine->QueryInterface(IID_IActiveScriptParse, (void**)&parser);
+    if (!parser) {
+        engine->Release();
+        engine = 0;
+        return false;
+    }
+    
+    if (engine->SetScriptSite(script_code->script_site) != S_OK) {
+        engine->Release();
+        engine = 0;
+        return false;
+    }
+    if (parser->InitNew() != S_OK) {
+        parser->Release();
+        engine->Release();
+        engine = 0;
+        return false;
+    }
+    
+    BSTR bstrCode = QStringToBSTR(script_code->scriptCode());
+#ifdef Q_OS_WIN64
+    hres = parser->ParseScriptText(bstrCode, 0, 0, 0, DWORDLONG(this), 0, SCRIPTTEXT_ISVISIBLE, 0, 0);
+#else
+    hres = parser->ParseScriptText(bstrCode, 0, 0, 0, DWORD(this), 0, SCRIPTTEXT_ISVISIBLE, 0, 0);
+#endif
+    SysFreeString(bstrCode);
+    
+    parser->Release();
+    parser = 0;
+    
+    script_code->updateObjects();
+    
+    if (engine->SetScriptState(SCRIPTSTATE_CONNECTED) != S_OK) {
+        engine = 0;
+        return false;
+    }
+    
+    IDispatch *scriptDispatch = 0;
+    engine->GetScriptDispatch(0, &scriptDispatch);
+    if (scriptDispatch) {
+        scriptDispatch->QueryInterface(IID_IUnknown, (void**)ptr);
+        scriptDispatch->Release();
+    }
+#endif
+    
+    return *ptr != 0;
+}
+
+/*!
+    \fn bool QAxScriptEngine::isValid() const
+
+    Returns true if the script engine has been initialized
+    correctly; otherwise returns false.
+*/
+
+/*!
+    Returns true if the script engine supports introspection;
+    otherwise returns false.
+*/
+bool QAxScriptEngine::hasIntrospection() const
+{
+    if (!isValid())
+        return false;
+    
+    IDispatch *scriptDispatch = 0;
+    QAxBase::queryInterface(IID_IDispatch, (void**)&scriptDispatch);
+    if (!scriptDispatch)
+        return false;
+    
+    UINT tic = 0;
+    HRESULT hres = scriptDispatch->GetTypeInfoCount(&tic);
+    scriptDispatch->Release();
+    return hres == S_OK && tic > 0;
+}
+
+/*!
+    Requests the interface \a uuid from the script engine 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.
+*/
+long QAxScriptEngine::queryInterface(const QUuid &uuid, void **iface) const
+{
+    *iface = 0;
+    if (!engine)
+        return E_NOTIMPL;
+    
+#ifndef QT_NO_QAXSCRIPT
+    return engine->QueryInterface(uuid, iface);
+#else
+    return E_NOTIMPL;
+#endif
+}
+
+/*!
+    Returns the state of the script engine.
+*/
+QAxScriptEngine::State QAxScriptEngine::state() const
+{
+    if (!engine)
+        return Uninitialized;
+    
+#ifndef QT_NO_QAXSCRIPT
+    SCRIPTSTATE state;
+    engine->GetScriptState(&state);
+    return (State)state;
+#else
+    return Uninitialized;
+#endif
+}
+
+/*!
+    Sets the state of the script engine to \a st.
+    Calling this function is usually not necessary.
+*/
+void QAxScriptEngine::setState(State st)
+{
+#ifndef QT_NO_QAXSCRIPT
+    if (!engine)
+        return;
+    
+    engine->SetScriptState((SCRIPTSTATE)st);
+#endif
+}
+
+/*!
+    Registers an item with the script engine. Script code can
+    refer to this item using \a name.
+*/
+void QAxScriptEngine::addItem(const QString &name)
+{
+#ifndef QT_NO_QAXSCRIPT
+    if (!engine)
+        return;
+    
+    engine->AddNamedItem((WCHAR*)name.utf16(), SCRIPTITEM_ISSOURCE|SCRIPTITEM_ISVISIBLE);
+#endif
+}
+
+/*!
+    \class QAxScript
+    \brief The QAxScript class provides a wrapper around script code.
+    \inmodule QAxContainer
+
+    Every instance of the QAxScript class represents a piece of
+    scripting code in a particular scripting language. The code is
+    loaded into the script engine using load(). Functions declared
+    in the code can be called using call(). 
+
+    The script provides scriptEngine() provides feedback to the 
+    application through signals. The most important signal is the 
+    error() signal. Direct access to the QAxScriptEngine is provided
+    through the scriptEngine() function.
+
+    \warning This class is not available with the bcc5.5 and MingW
+    compilers.
+
+    \sa QAxScriptEngine, QAxScriptManager, QAxBase, {ActiveQt Framework}
+*/
+
+/*!
+    \enum QAxScript::FunctionFlags
+
+    This FunctionFlags enum describes formatting for function introspection.
+
+    \value FunctionNames Only function names are returned.
+    \value FunctionSignatures Returns the functions with signatures.
+*/
+
+/*!
+    Constructs a QAxScript object called \a name and registers
+    it with the QAxScriptManager \a manager. This is usually done by the
+    QAxScriptManager class when \link QAxScriptManager::load() loading a 
+    script\endlink.
+
+    A script should always have a name. A manager is necessary to allow
+    the script code to reference objects in the application. The \a manager
+    takes ownership of the object.
+*/
+QAxScript::QAxScript(const QString &name, QAxScriptManager *manager)
+: QObject(manager), script_name(name), script_manager(manager),
+script_engine(0)
+{
+    if (manager) {
+        manager->d->scriptDict.insert(name, this);
+        connect(this, SIGNAL(error(int,QString,int,QString)), 
+            manager, SLOT(scriptError(int,QString,int,QString)));
+    }
+    
+#ifndef QT_NO_QAXSCRIPT
+    script_site = new QAxScriptSite(this);
+#else
+    script_site = 0;
+#endif
+}
+
+/*!
+    Destroys the object, releasing all allocated resources.
+*/
+QAxScript::~QAxScript()
+{
+    delete script_engine;
+    script_engine = 0;
+    
+#ifndef QT_NO_QAXSCRIPT
+    script_site->Release();
+#endif
+}
+
+/*!
+    Loads the script source \a code written in language \a language
+    into the script engine. Returns true if \a code was successfully
+    entered into the script engine; otherwise returns false.
+
+    If \a language is empty (the default) it will be determined 
+    heuristically. If \a code contains the string \c {End Sub} it will 
+    be interpreted as VBScript, otherwise as JScript. Additional 
+    scripting languages can be registered using 
+    QAxScript::registerEngine().
+
+    This function can only be called once for each QAxScript object,
+    which is done automatically when using QAxScriptManager::load().
+*/
+bool QAxScript::load(const QString &code, const QString &language)
+{
+    if (script_engine || code.isEmpty())
+        return false;
+    
+    script_code = code;
+    QString lang = language;
+    if (lang.isEmpty()) {
+        if (code.contains(QLatin1String("End Sub"), Qt::CaseInsensitive))
+            lang = QLatin1String("VBScript");
+        
+        QList<QAxEngineDescriptor>::ConstIterator it;
+        for (it = engines.begin(); it != engines.end(); ++it) {
+            QAxEngineDescriptor engine = *it;
+            if (engine.code.isEmpty())
+                continue;
+            
+            if (code.contains(engine.code)) {
+                lang = engine.name;
+                break;
+            }
+        }
+    }
+    if (lang.isEmpty())
+        lang = QLatin1String("JScript");
+    
+    script_engine = new QAxScriptEngine(lang, this);
+    // trigger call to initialize
+    script_engine->metaObject();
+    
+    return script_engine->isValid();
+}
+
+/*!
+    Returns a list of all the functions in this script if the respective
+    script engine supports introspection; otherwise returns an empty list.
+    The functions are either provided with full prototypes or only as 
+    names, depending on the value of \a flags.
+
+    \sa QAxScriptEngine::hasIntrospection()
+*/
+QStringList QAxScript::functions(FunctionFlags flags) const
+{
+    QStringList functions;
+    
+    const QMetaObject *mo = script_engine->metaObject();
+    for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
+       const QMetaMethod slot(mo->method(i));
+       if (slot.methodType() != QMetaMethod::Slot || slot.access() != QMetaMethod::Public)
+            continue;
+        QString slotname = QString::fromLatin1(slot.signature());
+        if (slotname.contains(QLatin1Char('_')))
+            continue;
+        
+        if (flags == FunctionSignatures)
+            functions << slotname;
+        else
+            functions << slotname.left(slotname.indexOf(QLatin1Char('(')));
+    }
+    
+    return functions;
+}
+
+/*!
+    Calls \a function, passing the parameters \a var1, \a var1, 
+    \a var2, \a var3, \a var4, \a var5, \a var6, \a var7 and \a var8
+    as arguments and returns the value returned by the function, or an 
+    invalid QVariant if the function does not return a value or when 
+    the function call failed.
+
+    See QAxScriptManager::call() for more information about how to call
+    script functions.
+*/
+QVariant QAxScript::call(const QString &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)
+{
+    if (!script_engine)
+        return QVariant();
+    
+    return script_engine->dynamicCall(function.toLatin1(), var1, var2, var3, var4, var5, var6, var7, var8);
+}
+
+/*!
+    \overload
+
+    Calls \a function passing \a arguments as parameters, and returns
+    the result. Returns when the script's execution has finished.
+
+    See QAxScriptManager::call() for more information about how to call
+    script functions.
+*/
+QVariant QAxScript::call(const QString &function, QList<QVariant> &arguments)
+{
+    if (!script_engine)
+        return QVariant();
+    
+    return script_engine->dynamicCall(function.toLatin1(), arguments);
+}
+
+/*! \internal
+    Registers all objects in the manager with the script engine.
+*/
+void QAxScript::updateObjects()
+{
+    if (!script_manager)
+        return;
+    
+    script_manager->updateScript(this);
+}
+
+/*! \internal
+    Returns the object \a name registered with the manager.
+*/
+QAxBase *QAxScript::findObject(const QString &name)
+{
+    if (!script_manager)
+        return 0;
+    
+    return script_manager->d->objectDict.value(name);
+}
+
+/*! \fn QString QAxScript::scriptName() const
+    Returns the name of the script.
+*/
+
+/*! \fn QString QAxScript::scriptCode() const
+    Returns the script's code, or the null-string if no
+    code has been loaded yet.
+
+    \sa load()
+*/
+
+/*! \fn QAxScriptEngine* QAxScript::scriptEngine() const
+    Returns a pointer to the script engine.
+
+    You can use the object returned to connect signals to the 
+    script functions, or to access the script engine directly.
+*/
+
+/*! \fn void QAxScript::entered()
+
+    This signal is emitted when a script engine has started executing code.
+*/
+
+/*! \fn void QAxScript::finished()
+
+    This signal is emitted when a script engine has finished executing code.
+*/
+
+/*!
+    \fn void QAxScript::finished(const QVariant &result)
+    \overload
+
+    \a result contains the script's result. This will be an invalid
+    QVariant if the script has no return value.
+*/
+
+/*! \fn void QAxScript::finished(int code, const QString &source,
+                                 const QString &description, const QString &help)
+    \overload
+
+    \a code, \a source, \a description and \a help contain exception information
+    when the script terminated.
+*/
+
+/*! \fn void QAxScript::stateChanged(int state);
+
+    This signal is emitted when a script engine changes state.
+    \a state can be any value in the QAxScriptEngineState enumeration.
+*/
+
+/*!
+    \fn void QAxScript::error(int code, const QString &description,
+    int sourcePosition, const QString &sourceText)
+
+    This signal is emitted when an execution error occurred while
+    running a script.
+
+    \a code, \a description, \a sourcePosition and \a sourceText
+    contain information about the execution error.
+*/
+
+
+
+/*!
+    \class QAxScriptManager
+    \brief The QAxScriptManager class provides a bridge between application objects
+    and script code.
+    \inmodule QAxContainer
+
+    The QAxScriptManager acts as a bridge between the COM objects embedded 
+    in the Qt application through QAxObject or QAxWidget, and the scripting 
+    languages available through the Windows Script technologies, usually JScript 
+    and VBScript.
+
+    Create one QAxScriptManager for each separate document in your
+    application, and add the COM objects the scripts need to access
+    using addObject(). Then load() the script sources and invoke the
+    functions using call().
+
+    \warning This class is not available with the bcc5.5 and MingW
+    compilers.
+
+    \sa QAxScript, QAxScriptEngine, QAxBase, {ActiveQt Framework}
+*/
+
+/*!
+    Creates a QAxScriptManager object. \a parent is passed on to the
+    QObject constructor.
+
+    It is usual to create one QAxScriptManager for each document in an
+    application.
+*/
+QAxScriptManager::QAxScriptManager(QObject *parent)
+: QObject(parent)
+{
+    d = new QAxScriptManagerPrivate;
+}
+
+/*!
+    Destroys the objects, releasing all allocated resources.
+*/
+QAxScriptManager::~QAxScriptManager()
+{
+    delete d;
+}
+
+/*!
+    Returns a list with all the functions that are available.
+    Functions provided by script engines that don't support
+    introspection are not included in the list.
+    The functions are either provided with full prototypes or 
+    only as names, depending on the value of \a flags.
+*/
+QStringList QAxScriptManager::functions(QAxScript::FunctionFlags flags) const
+{
+    QStringList functions;
+    
+    QHash<QString, QAxScript*>::ConstIterator scriptIt;
+    for (scriptIt = d->scriptDict.begin(); scriptIt != d->scriptDict.end(); ++scriptIt) {
+        QAxScript *script = scriptIt.value();
+        functions += script->functions(flags);
+    }
+    
+    return functions;
+}
+
+/*!
+    Returns a list with the names of all the scripts.
+*/
+QStringList QAxScriptManager::scriptNames() const
+{
+    QStringList scripts;
+    
+    QHash<QString, QAxScript*>::ConstIterator scriptIt;
+    for (scriptIt = d->scriptDict.begin(); scriptIt != d->scriptDict.end(); ++scriptIt) {
+        scripts << scriptIt.key();
+    }
+    
+    return scripts;
+}
+
+/*!
+    Returns the script called \a name.
+
+    You can use the returned pointer to call functions directly 
+    through QAxScript::call(), to access the script engine directly, or
+    to delete and thus unload the script.
+*/
+QAxScript *QAxScriptManager::script(const QString &name) const
+{
+    return d->scriptDict.value(name);
+}
+
+/*!
+    Adds \a object to the manager. Scripts handled by this manager
+    can access the object in the code using the object's
+    \l{QObject::objectName}{objectName} property.
+
+    You must add all the necessary objects before loading any scripts.
+*/
+void QAxScriptManager::addObject(QAxBase *object)
+{
+    QObject *obj = object->qObject();
+    QString name = obj->objectName();
+    if (d->objectDict.contains(name))
+        return;
+    
+    d->objectDict.insert(name, object);
+    connect(obj, SIGNAL(destroyed(QObject*)), this, SLOT(objectDestroyed(QObject*)));
+}
+
+/*! \fn void QAxScriptManager::addObject(QObject *object)
+    \overload
+
+    Adds a generic COM wrapper for \a object to the manager. \a object
+    must be exposed as a COM object using the functionality provided
+    by the QAxServer module. Applications
+    using this function you must link against the qaxserver library.
+*/
+
+/*!
+    Loads the script source \a code using the script engine for \a
+    language. The script can later be referred to using its \a name
+    which should not be empty.
+
+    The function returns a pointer to the script for the given
+    \a code if the \a code was loaded successfully; otherwise it
+    returns 0.
+
+    If \a language is empty it will be determined heuristically. If \a
+    code contains the string "End Sub" it will be interpreted as
+    VBScript, otherwise as JScript. Additional script engines can be
+    registered using registerEngine().
+
+    You must add all the objects necessary (using addObject()) \e
+    before loading any scripts. If \a code declares a function that is
+    already available (no matter in which language) the first function
+    is overloaded and can no longer be called via call(); but it will
+    still be available by calling its \link script() script \endlink 
+    directly.
+
+    \sa addObject(), scriptNames(), functions()
+*/
+QAxScript *QAxScriptManager::load(const QString &code, const QString &name, const QString &language)
+{
+    QAxScript *script = new QAxScript(name, this);
+    if (script->load(code, language))
+        return script;
+    
+    delete script;
+    return 0;
+}
+
+/*!
+    \overload
+
+    Loads the source code from the \a file. The script can later be
+    referred to using its \a name which should not be empty.
+
+    The function returns a pointer to the script engine for the code
+    in \a file if \a file was loaded successfully; otherwise it
+    returns 0.
+
+    The script engine used is determined from the file's extension. By
+    default ".js" files are interpreted as JScript files, and ".vbs"
+    and ".dsm" files are interpreted as VBScript. Additional script
+    engines can be registered using registerEngine().
+*/
+QAxScript *QAxScriptManager::load(const QString &file, const QString &name)
+{
+    QFile f(file);
+    if (!f.open(QIODevice::ReadOnly))
+        return 0;
+    QByteArray data = f.readAll();
+    QString contents = QString::fromLocal8Bit(data, data.size());
+    f.close();
+    
+    if (contents.isEmpty())
+        return 0;
+    
+    QString language;
+    if (file.endsWith(QLatin1String(".js"))) {
+        language = QLatin1String("JScript");
+    } else {
+        QList<QAxEngineDescriptor>::ConstIterator it;
+        for (it = engines.begin(); it != engines.end(); ++it) {
+            QAxEngineDescriptor engine = *it;
+            if (engine.extension.isEmpty())
+                continue;
+            
+            if (file.endsWith(engine.extension)) {
+                language = engine.name;
+                break;
+            }
+        }
+    }
+    
+    if (language.isEmpty())
+        language = QLatin1String("VBScript");
+    
+    QAxScript *script = new QAxScript(name, this);
+    if (script->load(contents, language))
+        return script;
+    
+    delete script;
+    return 0;
+}
+
+/*!
+    Calls \a function, passing the parameters \a var1, \a var1, 
+    \a var2, \a var3, \a var4, \a var5, \a var6, \a var7 and \a var8
+    as arguments and returns the value returned by the function, or an 
+    invalid QVariant if the function does not return a value or when 
+    the function call failed. The call returns when the script's
+    execution has finished.
+
+    In most script engines the only supported parameter type is "const
+    QVariant&", for example, to call a JavaScript function
+    \snippet doc/src/snippets/code/src_activeqt_container_qaxscript.cpp 0
+    use
+    \snippet doc/src/snippets/code/src_activeqt_container_qaxscript.cpp 1
+    As with \link QAxBase::dynamicCall() dynamicCall \endlink the 
+    parameters can directly be embedded in the function string.
+    \snippet doc/src/snippets/code/src_activeqt_container_qaxscript.cpp 2
+    However, this is slower.
+
+    Functions provided by script engines that don't support
+    introspection are not available and must be called directly
+    using QAxScript::call() on the respective \link script() 
+    script \endlink object.
+
+    Note that calling this function can be significantely slower than
+    using call() on the respective QAxScript directly.
+*/
+QVariant QAxScriptManager::call(const QString &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)
+{
+    QAxScript *s = script(function);
+    if (!s) {
+#ifdef QT_CHECK_STATE
+        qWarning("QAxScriptManager::call: No script provides function %s, or this function\n"
+            "\tis provided through an engine that does not support introspection", function.latin1());
+#endif
+        return QVariant();
+    }
+    
+    return s->call(function, var1, var2, var3, var4, var5, var6, var7, var8);
+}
+
+/*! \overload
+
+    Calls \a function passing \a arguments as parameters, and returns
+    the result. Returns when the script's execution has finished.
+*/
+QVariant QAxScriptManager::call(const QString &function, QList<QVariant> &arguments)
+{
+    QAxScript *s = script(function);
+    if (!s) {
+#ifdef QT_CHECK_STATE
+        qWarning("QAxScriptManager::call: No script provides function %s, or this function\n"
+            "\tis provided through an engine that does not support introspection", function.latin1());
+#endif
+        return QVariant();
+    }
+    
+    QList<QVariant> args(arguments);
+    return s->call(function, args);
+}
+
+/*!
+    Registers the script engine called \a name and returns true if the
+    engine was found; otherwise does nothing and returns false.
+
+    The script engine will be used when loading files with the given
+    \a extension, or when loading source code that contains the string
+    \a code.
+*/
+bool QAxScriptManager::registerEngine(const QString &name, const QString &extension, const QString &code)
+{
+    if (name.isEmpty())
+        return false;
+    
+    CLSID clsid;
+    HRESULT hres = CLSIDFromProgID((WCHAR*)name.utf16(), &clsid);
+    if (hres != S_OK)
+        return false;
+    
+    QAxEngineDescriptor engine;
+    engine.name = name;
+    engine.extension = extension;
+    engine.code = code;
+    
+    engines.prepend(engine);
+    return true;
+}
+
+/*!
+    Returns a file filter listing all the supported script languages.
+    This filter string is convenient for use with QFileDialog.
+*/
+QString QAxScriptManager::scriptFileFilter()
+{
+    QString allFiles = QLatin1String("Script Files (*.js *.vbs *.dsm");
+    QString specialFiles = QLatin1String(";;VBScript Files (*.vbs *.dsm)"
+        ";;JavaScript Files (*.js)");
+    
+    QList<QAxEngineDescriptor>::ConstIterator it;
+    for (it = engines.begin(); it != engines.end(); ++it) {
+        QAxEngineDescriptor engine = *it;
+        if (engine.extension.isEmpty())
+            continue;
+        
+        allFiles += QLatin1String(" *") + engine.extension;
+        specialFiles += QLatin1String(";;") + engine.name + QLatin1String(" Files (*") + engine.extension + QLatin1String(")");
+    }
+    allFiles += QLatin1String(")");
+    
+    return allFiles + specialFiles + QLatin1String(";;All Files (*.*)");
+}
+
+/*!
+    \fn void QAxScriptManager::error(QAxScript *script, int code, const QString &description,
+    int sourcePosition, const QString &sourceText)
+
+    This signal is emitted when an execution error occurred while
+    running \a script.
+
+    \a code, \a description, \a sourcePosition and \a sourceText
+    contain information about the execution error.
+
+    \warning Do not delete \a script in a slot connected to this signal. Use deleteLater()
+    instead.
+*/
+
+/*!
+    \internal
+
+    Returns a pointer to the first QAxScript that knows 
+    about \a function, or 0 if this function is unknown.
+*/
+QAxScript *QAxScriptManager::scriptForFunction(const QString &function) const
+{
+    // check full prototypes if included
+    if (function.contains(QLatin1Char('('))) {
+        QHash<QString, QAxScript*>::ConstIterator scriptIt;
+        for (scriptIt = d->scriptDict.begin(); scriptIt != d->scriptDict.end(); ++scriptIt) {
+            QAxScript *script = scriptIt.value();
+            
+            if (script->functions(QAxScript::FunctionSignatures).contains(function))
+                return script;
+        }
+    }
+    
+    QString funcName = function;
+    funcName = funcName.left(funcName.indexOf(QLatin1Char('(')));
+    // second try, checking only names, not prototypes
+    QHash<QString, QAxScript*>::ConstIterator scriptIt;
+    for (scriptIt = d->scriptDict.begin(); scriptIt != d->scriptDict.end(); ++scriptIt) {
+        QAxScript *script = scriptIt.value();
+        
+        if (script->functions(QAxScript::FunctionNames).contains(funcName))
+            return script;
+    }
+    
+    return 0;
+}
+
+/*!
+    \internal
+*/
+void QAxScriptManager::updateScript(QAxScript *script)
+{
+    QHash<QString, QAxBase*>::ConstIterator objectIt;
+    for (objectIt = d->objectDict.constBegin(); objectIt != d->objectDict.constEnd(); ++objectIt) {
+        QString name = objectIt.key();
+        
+        QAxScriptEngine *engine = script->scriptEngine();
+        if (engine)
+            engine->addItem(name);
+    }
+}
+
+/*!
+    \internal
+*/
+void QAxScriptManager::objectDestroyed(QObject *o)
+{
+    d->objectDict.take(o->objectName());
+}
+
+/*!
+    \internal
+*/
+void QAxScriptManager::scriptError(int code, const QString &desc, int spos, const QString &stext)
+{
+    QAxScript *source = qobject_cast<QAxScript*>(sender());
+    emit error(source, code, desc, spos, stext);
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/container/qaxscript.h b/src/activeqt/container/qaxscript.h
new file mode 100644
index 0000000..3332715
--- /dev/null
+++ b/src/activeqt/container/qaxscript.h
@@ -0,0 +1,248 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXSCRIPT_H
+#define QAXSCRIPT_H
+
+#include <ActiveQt/qaxobject.h>
+
+struct IActiveScript;
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+class QAxBase;
+class QAxScript;
+class QAxScriptSite;
+class QAxScriptEngine;
+class QAxScriptManager;
+class QAxScriptManagerPrivate;
+
+class QAxScriptEngine : public QAxObject
+{
+public:
+    enum State {
+        Uninitialized = 0,
+        Initialized = 5,
+        Started = 1,
+        Connected = 2,
+        Disconnected = 3,
+        Closed = 4
+    };
+    
+    QAxScriptEngine(const QString &language, QAxScript *script);
+    ~QAxScriptEngine();
+    
+    bool isValid() const;
+    bool hasIntrospection() const;
+    
+    QString scriptLanguage() const;
+    
+    State state() const;
+    void setState(State st);
+    
+    void addItem(const QString &name);
+    
+    long queryInterface(const QUuid &, void**) const;
+    
+protected:
+    bool initialize(IUnknown** ptr);
+    
+private:
+    QAxScript *script_code;
+    IActiveScript *engine;
+    
+    QString script_language;
+};
+
+class QAxScript : public QObject
+{
+    Q_OBJECT
+        
+public:
+    enum FunctionFlags {
+        FunctionNames = 0,
+        FunctionSignatures	
+    };
+    
+    QAxScript(const QString &name, QAxScriptManager *manager);
+    ~QAxScript();
+    
+    bool load(const QString &code, const QString &language = QString());
+    
+    QStringList functions(FunctionFlags = FunctionNames) const;
+    
+    QString scriptCode() const;
+    QString scriptName() const;
+    QAxScriptEngine *scriptEngine() const;
+    
+    QVariant call(const QString &function, 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());
+    QVariant call(const QString &function, QList<QVariant> &arguments);
+    
+Q_SIGNALS:
+    void entered();
+    void finished();
+    void finished(const QVariant &result);
+    void finished(int code, const QString &source,const QString &description, const QString &help);
+    void stateChanged(int state);
+    void error(int code, const QString &description, int sourcePosition, const QString &sourceText);
+    
+private:
+    friend class QAxScriptSite;
+    friend class QAxScriptEngine;
+    
+    void updateObjects();
+    QAxBase *findObject(const QString &name);
+    
+    QString script_name;
+    QString script_code;
+    QAxScriptManager *script_manager;
+    QAxScriptEngine *script_engine;
+    QAxScriptSite *script_site;
+};
+
+class QAxScriptManager : public QObject
+{
+    Q_OBJECT
+        
+public:
+    QAxScriptManager(QObject *parent = 0);
+    ~QAxScriptManager();
+    
+    void addObject(QAxBase *object);
+    void addObject(QObject *object);
+    
+    QStringList functions(QAxScript::FunctionFlags = QAxScript::FunctionNames) const;
+    QStringList scriptNames() const;
+    QAxScript *script(const QString &name) const;
+    
+    QAxScript* load(const QString &code, const QString &name, const QString &language);
+    QAxScript* load(const QString &file, const QString &name);
+    
+    QVariant call(const QString &function, 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());
+    QVariant call(const QString &function, QList<QVariant> &arguments);
+    
+    static bool registerEngine(const QString &name, const QString &extension, const QString &code = QString());
+    static QString scriptFileFilter();
+    
+Q_SIGNALS:
+    void error(QAxScript *script, int code, const QString &description, int sourcePosition, const QString &sourceText);
+    
+private Q_SLOTS:
+    void objectDestroyed(QObject *o);
+    void scriptError(int code, const QString &description, int sourcePosition, const QString &sourceText);
+    
+private:
+    friend class QAxScript;
+    QAxScriptManagerPrivate *d;
+    
+    void updateScript(QAxScript*);
+    QAxScript *scriptForFunction(const QString &function) const;
+};
+
+
+// QAxScript inlines
+
+inline QString QAxScript::scriptCode() const
+{
+    return script_code;
+}
+
+inline QString QAxScript::scriptName() const
+{
+    return script_name;
+}
+
+inline QAxScriptEngine *QAxScript::scriptEngine() const
+{
+    return script_engine;
+}
+
+// QAxScriptEngine inlines
+
+inline bool QAxScriptEngine::isValid() const
+{
+    return engine != 0;
+}
+
+inline QString QAxScriptEngine::scriptLanguage() const
+{
+    return script_language;
+}
+
+// QAxScriptManager inlines
+
+extern QAxBase *qax_create_object_wrapper(QObject*);
+
+inline void QAxScriptManager::addObject(QObject *object)
+{
+    QAxBase *wrapper = qax_create_object_wrapper(object);
+    if (!wrapper) {
+        qWarning("QAxScriptMananger::addObject: Class %s not exposed through the QAxFactory", 
+            object->metaObject()->className());
+        Q_ASSERT(wrapper);
+    }
+    addObject(wrapper);
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXSCRIPT_H
diff --git a/src/activeqt/container/qaxscriptwrapper.cpp b/src/activeqt/container/qaxscriptwrapper.cpp
new file mode 100644
index 0000000..7515975
--- /dev/null
+++ b/src/activeqt/container/qaxscriptwrapper.cpp
@@ -0,0 +1,64 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include "qaxobject.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <ActiveQt/qaxfactory.h>
+
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+QAxBase *qax_create_object_wrapper(QObject *object)
+{
+    IDispatch *dispatch = 0;
+    QAxObject *wrapper = 0;
+    qAxFactory()->createObjectWrapper(object, &dispatch);
+    if (dispatch) {
+        wrapper = new QAxObject(dispatch, object);
+        wrapper->setObjectName(object->objectName());
+        dispatch->Release();
+    }
+    return wrapper;
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/container/qaxselect.cpp b/src/activeqt/container/qaxselect.cpp
new file mode 100644
index 0000000..7a47004
--- /dev/null
+++ b/src/activeqt/container/qaxselect.cpp
@@ -0,0 +1,164 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include "qaxselect.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+class ControlList : public QAbstractListModel
+{
+public:
+    ControlList(QObject *parent=0)
+    : QAbstractListModel(parent) 
+    {
+        HKEY classes_key;
+        QT_WA_INLINE(
+            RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_READ, &classes_key),
+            RegOpenKeyExA(HKEY_CLASSES_ROOT, "CLSID", 0, KEY_READ, &classes_key));
+        if (!classes_key)
+            return;
+
+        DWORD index = 0;
+        LONG result = 0;
+        TCHAR buffer[256];
+        DWORD szBuffer = sizeof(buffer);
+        FILETIME ft;
+        do {
+            result = QT_WA_INLINE(
+                RegEnumKeyExW(classes_key, index, (wchar_t*)&buffer, &szBuffer, 0, 0, 0, &ft),
+                RegEnumKeyExA(classes_key, index, (char*)&buffer, &szBuffer, 0, 0, 0, &ft));
+            szBuffer = sizeof(buffer);
+            if (result == ERROR_SUCCESS) {
+                HKEY sub_key;
+                QString clsid = QT_WA_INLINE(QString::fromUtf16((ushort*)buffer), QString::fromLocal8Bit((char*)buffer));
+                result = QT_WA_INLINE(
+                    RegOpenKeyExW(classes_key, reinterpret_cast<const wchar_t *>(QString(clsid + "\\Control").utf16()), 0, KEY_READ, &sub_key),
+                    RegOpenKeyA(classes_key, QString(clsid + QLatin1String("\\Control")).toLocal8Bit(), &sub_key));
+                if (result == ERROR_SUCCESS) {
+                    RegCloseKey(sub_key);
+                    QT_WA_INLINE(
+                        RegistryQueryValueW(classes_key, buffer, (LPBYTE)buffer, &szBuffer),
+                        RegQueryValueA(classes_key, (char*)buffer, (char*)buffer, (LONG*)&szBuffer));
+                    QString name = QT_WA_INLINE(QString::fromUtf16((ushort*)buffer, szBuffer / sizeof(TCHAR)) , QString::fromLocal8Bit((char*)buffer, szBuffer));
+
+                    controls << name;
+                    clsids.insert(name, clsid);
+                }
+                result = ERROR_SUCCESS;
+            }
+            szBuffer = sizeof(buffer);
+            ++index;
+        } while (result == ERROR_SUCCESS);
+        RegCloseKey(classes_key);
+        controls.sort();
+    }
+
+    LONG RegistryQueryValueW(HKEY hKey, LPCWSTR lpSubKey, LPBYTE lpData, LPDWORD lpcbData)
+    {
+        LONG ret = ERROR_FILE_NOT_FOUND;
+        HKEY hSubKey = NULL;
+        RegOpenKeyExW(hKey, lpSubKey, 0, KEY_READ, &hSubKey);
+        if (hSubKey) {
+            ret = RegQueryValueExW(hSubKey, 0, 0, 0, lpData, lpcbData);
+            RegCloseKey(hSubKey);
+        }
+        return ret;
+    }
+
+    int rowCount(const QModelIndex & = QModelIndex()) const { return controls.count(); }
+    QVariant data(const QModelIndex &index, int role) const;
+    
+private:
+    QStringList controls;
+    QMap<QString, QString> clsids;
+};
+
+QVariant ControlList::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid())
+        return QVariant();
+
+    if (role == Qt::DisplayRole)
+        return controls.at(index.row());
+    if (role == Qt::UserRole)
+        return clsids.value(controls.at(index.row()));
+
+    return QVariant();
+}
+
+QAxSelect::QAxSelect(QWidget *parent, Qt::WindowFlags f)
+: QDialog(parent, f)
+{
+#ifndef QT_NO_CURSOR
+    QApplication::setOverrideCursor(Qt::WaitCursor);
+#endif
+
+    setupUi(this);
+    ActiveXList->setModel(new ControlList(this));
+    connect(ActiveXList->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
+        this, SLOT(on_ActiveXList_clicked(QModelIndex)));
+#ifndef QT_NO_CURSOR
+    QApplication::restoreOverrideCursor();
+#endif
+    ActiveXList->setFocus();
+
+    connect(buttonOk, SIGNAL(clicked()), this, SLOT(accept()));
+    connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
+}
+
+void QAxSelect::on_ActiveXList_clicked(const QModelIndex &index)
+{
+    QVariant clsid = ActiveXList->model()->data(index, Qt::UserRole);
+    ActiveX->setText(clsid.toString());
+}
+
+void QAxSelect::on_ActiveXList_doubleClicked(const QModelIndex &index)
+{
+    QVariant clsid = ActiveXList->model()->data(index, Qt::UserRole);
+    ActiveX->setText(clsid.toString());
+
+    accept();
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/container/qaxselect.h b/src/activeqt/container/qaxselect.h
new file mode 100644
index 0000000..7e41b3f
--- /dev/null
+++ b/src/activeqt/container/qaxselect.h
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXSELECT_H
+#define QAXSELECT_H
+
+#include <QtGui/qdialog.h>
+
+#ifndef QT_NO_WIN_ACTIVEQT
+#include "ui_qaxselect.h"
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+class QAxSelect : public QDialog, private Ui::QAxSelect
+{
+    Q_OBJECT
+public:
+    QAxSelect(QWidget *parent = 0, Qt::WindowFlags f = 0);
+
+    QString clsid() const { return ActiveX->text(); }
+
+private Q_SLOTS:
+    void on_ActiveXList_clicked(const QModelIndex &index);
+    void on_ActiveXList_doubleClicked(const QModelIndex &index);
+};
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXSELECT_H
diff --git a/src/activeqt/container/qaxselect.ui b/src/activeqt/container/qaxselect.ui
new file mode 100644
index 0000000..f9c8d2c
--- /dev/null
+++ b/src/activeqt/container/qaxselect.ui
@@ -0,0 +1,173 @@
+<ui version="4.0" stdsetdef="1" >
+  <class>QAxSelect</class>
+  <comment>*********************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+*********************************************************************</comment>
+  <widget class="QDialog" name="QAxSelect" >
+    <property name="objectName" >
+      <string notr="true" >QAxSelect</string>
+    </property>
+    <property name="geometry" >
+      <rect>
+        <x>0</x>
+        <y>0</y>
+        <width>439</width>
+        <height>326</height>
+      </rect>
+    </property>
+    <property name="windowTitle" >
+      <string>Select ActiveX Control</string>
+    </property>
+    <property name="sizeGripEnabled" >
+      <bool>true</bool>
+    </property>
+    <layout class="QGridLayout" >
+      <property name="objectName" >
+        <string notr="true" >unnamed</string>
+      </property>
+      <property name="margin" >
+        <number>11</number>
+      </property>
+      <property name="spacing" >
+        <number>6</number>
+      </property>
+      <item rowspan="2" row="0" column="1" colspan="1" >
+        <layout class="QVBoxLayout" >
+          <property name="objectName" >
+            <string notr="true" >unnamed</string>
+          </property>
+          <property name="margin" >
+            <number>0</number>
+          </property>
+          <property name="spacing" >
+            <number>6</number>
+          </property>
+          <item>
+            <widget class="QPushButton" name="buttonOk" >
+              <property name="objectName" >
+                <string notr="true" >buttonOk</string>
+              </property>
+              <property name="text" >
+                <string>OK</string>
+              </property>
+              <property name="autoDefault" >
+                <bool>true</bool>
+              </property>
+              <property name="default" >
+                <bool>true</bool>
+              </property>
+            </widget>
+          </item>
+          <item>
+            <widget class="QPushButton" name="buttonCancel" >
+              <property name="objectName" >
+                <string notr="true" >buttonCancel</string>
+              </property>
+              <property name="text" >
+                <string>&amp;Cancel</string>
+              </property>
+              <property name="autoDefault" >
+                <bool>true</bool>
+              </property>
+            </widget>
+          </item>
+          <item>
+            <spacer name="Spacer2" >
+              <property name="sizeHint" >
+                <size>
+                  <width>20</width>
+                  <height>0</height>
+                </size>
+              </property>
+              <property name="sizeType" >
+                <enum>Expanding</enum>
+              </property>
+              <property name="orientation" >
+                <enum>Vertical</enum>
+              </property>
+            </spacer>
+          </item>
+        </layout>
+      </item>
+      <item row="0" column="0" >
+        <widget class="QListView" name="ActiveXList" >
+          <property name="objectName" >
+            <string notr="true" >ActiveXList</string>
+          </property>
+        </widget>
+      </item>
+      <item row="1" column="0" >
+        <layout class="QHBoxLayout" >
+          <property name="objectName" >
+            <string notr="true" >unnamed</string>
+          </property>
+          <property name="margin" >
+            <number>0</number>
+          </property>
+          <property name="spacing" >
+            <number>6</number>
+          </property>
+          <item>
+            <widget class="QLabel" name="TextLabel1" >
+              <property name="objectName" >
+                <string notr="true" >TextLabel1</string>
+              </property>
+              <property name="text" >
+                <string>COM &amp;Object:</string>
+              </property>
+              <property name="buddy" stdset="0" >
+                <cstring>ActiveX</cstring>
+              </property>
+            </widget>
+          </item>
+          <item>
+            <widget class="QLineEdit" name="ActiveX" >
+              <property name="objectName" >
+                <string notr="true" >ActiveX</string>
+              </property>
+            </widget>
+          </item>
+        </layout>
+      </item>
+    </layout>
+  </widget>
+  <layoutdefault spacing="6" margin="11" />
+  <includes>
+    <include location="local" >qaxwidget.h</include>
+  </includes>
+</ui>
diff --git a/src/activeqt/container/qaxwidget.cpp b/src/activeqt/container/qaxwidget.cpp
new file mode 100644
index 0000000..4e8473f
--- /dev/null
+++ b/src/activeqt/container/qaxwidget.cpp
@@ -0,0 +1,2228 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+
+#include "qaxwidget.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <ActiveQt/qaxaggregated.h>
+
+#include <qabstracteventdispatcher.h>
+#include <qapplication.h>
+#include <private/qapplication_p.h>
+#include <qdockwidget.h>
+#include <qevent.h>
+#include <qlayout.h>
+#include <qmainwindow.h>
+#include <qmenu.h>
+#include <qmenubar.h>
+#include <qmetaobject.h>
+#include <qpainter.h>
+#include <qpointer.h>
+#include <qregexp.h>
+#include <quuid.h>
+#include <qwhatsthis.h>
+
+#include <windowsx.h>
+#include <ocidl.h>
+#include <olectl.h>
+#include <docobj.h>
+
+// #define QAX_DEBUG
+
+#ifdef QAX_DEBUG
+#define AX_DEBUG(x) qDebug(#x);
+#else
+#define AX_DEBUG(x);
+#endif
+
+// #define QAX_SUPPORT_WINDOWLESS
+// #define QAX_SUPPORT_BORDERSPACE
+
+// missing interface from win32api
+#if defined(Q_CC_GNU)
+#   if !defined(IOleInPlaceObjectWindowless)
+#       undef INTERFACE
+#       define INTERFACE IOleInPlaceObjectWindowless
+        DECLARE_INTERFACE_(IOleInPlaceObjectWindowless,IOleInPlaceObject)
+        {
+           STDMETHOD(QueryInterface)(THIS_ REFIID,PVOID*) PURE;
+           STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+           STDMETHOD_(ULONG,Release)(THIS) PURE;
+           STDMETHOD(GetWindow)(THIS_ HWND*) PURE;
+           STDMETHOD(ContextSensitiveHelp)(THIS_ BOOL) PURE;
+           STDMETHOD(InPlaceDeactivate)(THIS) PURE;
+           STDMETHOD(UIDeactivate)(THIS) PURE;
+           STDMETHOD(SetObjectRects)(THIS_ LPCRECT,LPCRECT) PURE;
+           STDMETHOD(ReactivateAndUndo)(THIS) PURE;
+           STDMETHOD(OnWindowMessage)(THIS_ UINT, WPARAM, LPARAM, LRESULT*) PURE;
+           STDMETHOD(GetDropTarget)(THIS_ IDropTarget**) PURE;
+        };
+#   endif
+#endif
+
+#include "../shared/qaxtypes.h"
+
+QT_BEGIN_NAMESPACE
+
+/*  \class QAxHostWidget
+    \brief The QAxHostWidget class is the actual container widget.
+
+    \internal
+*/
+class QAxHostWidget : public QWidget
+{
+    friend class QAxClientSite;
+public:
+    Q_OBJECT_CHECK
+    QAxHostWidget(QWidget *parent, QAxClientSite *ax);
+    ~QAxHostWidget();
+
+    QSize sizeHint() const;
+    QSize minimumSizeHint() const;
+
+    int qt_metacall(QMetaObject::Call, int isignal, void **argv);
+    inline QAxClientSite *clientSite() const
+    {
+        return axhost;
+    }
+
+protected:
+    bool winEvent(MSG *msg, long *result);
+    bool event(QEvent *e);
+    bool eventFilter(QObject *o, QEvent *e);
+    void resizeEvent(QResizeEvent *e);
+    void focusInEvent(QFocusEvent *e);
+    void focusOutEvent(QFocusEvent *e);
+    void paintEvent(QPaintEvent *e);
+    void showEvent(QShowEvent *e);
+    QPaintEngine* paintEngine() const
+    {
+        return 0;
+    }
+
+private:
+    void resizeObject();
+
+    int setFocusTimer;
+    bool hasFocus;
+    QAxClientSite *axhost;
+};
+
+/*  \class QAxClientSite
+    \brief The QAxClientSite class implements the client site interfaces.
+
+    \internal
+*/
+class QAxClientSite : public IDispatch,
+                    public IOleClientSite,
+                    public IOleControlSite,
+#ifdef QAX_SUPPORT_WINDOWLESS
+                    public IOleInPlaceSiteWindowless,
+#else
+                    public IOleInPlaceSite,
+#endif
+                    public IOleInPlaceFrame,
+                    public IOleDocumentSite,
+                    public IAdviseSink
+{
+    friend class QAxHostWidget;
+public:
+    QAxClientSite(QAxWidget *c);
+    virtual ~QAxClientSite();
+
+    bool activateObject(bool initialized, const QByteArray &data);
+
+    void releaseAll();
+    void deactivate();
+    inline void reset(QWidget *p)
+    {
+        if (widget == p)
+            widget = 0;
+        else if (host == p)
+            host = 0;
+    }
+
+    inline IOleInPlaceActiveObject *inPlaceObject() const
+    {
+        return m_spInPlaceActiveObject;
+    }
+
+    inline HRESULT doVerb(LONG index)
+    {
+        if (!m_spOleObject)
+            return E_NOTIMPL;
+        if (!host)
+            return OLE_E_NOT_INPLACEACTIVE;
+
+        RECT rcPos = { host->x(), host->y(), host->x()+host->width(), host->y()+host->height() };
+        return m_spOleObject->DoVerb(index, 0, this, 0, host->winId(), &rcPos);
+    }
+
+    // IUnknown
+    unsigned long WINAPI AddRef();
+    unsigned long WINAPI Release();
+    STDMETHOD(QueryInterface)(REFIID iid, void **iface);
+
+    // 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 lcid,
+        WORD wFlags,
+        DISPPARAMS *pDispParams,
+        VARIANT *pVarResult,
+        EXCEPINFO *pExcepInfo,
+        UINT *puArgErr);
+    void emitAmbientPropertyChange(DISPID dispid);
+
+    // IOleClientSite
+    STDMETHOD(SaveObject)();
+    STDMETHOD(GetMoniker)(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk);
+    STDMETHOD(GetContainer)(LPOLECONTAINER FAR* ppContainer);
+    STDMETHOD(ShowObject)();
+    STDMETHOD(OnShowWindow)(BOOL fShow);
+    STDMETHOD(RequestNewObjectLayout)();
+
+    // IOleControlSite
+    STDMETHOD(OnControlInfoChanged)();
+    STDMETHOD(LockInPlaceActive)(BOOL fLock);
+    STDMETHOD(GetExtendedControl)(IDispatch** ppDisp);
+    STDMETHOD(TransformCoords)(POINTL* pPtlHimetric, POINTF* pPtfContainer, DWORD dwFlags);
+    STDMETHOD(TranslateAccelerator)(LPMSG lpMsg, DWORD grfModifiers);
+    STDMETHOD(OnFocus)(BOOL fGotFocus);
+    STDMETHOD(ShowPropertyFrame)();
+
+    // IOleWindow
+    STDMETHOD(GetWindow)(HWND *phwnd);
+    STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);
+
+    // IOleInPlaceSite
+    STDMETHOD(CanInPlaceActivate)();
+    STDMETHOD(OnInPlaceActivate)();
+    STDMETHOD(OnUIActivate)();
+    STDMETHOD(GetWindowContext)(IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo);
+    STDMETHOD(Scroll)(SIZE scrollExtant);
+    STDMETHOD(OnUIDeactivate)(BOOL fUndoable);
+    STDMETHOD(OnInPlaceDeactivate)();
+    STDMETHOD(DiscardUndoState)();
+    STDMETHOD(DeactivateAndUndo)();
+    STDMETHOD(OnPosRectChange)(LPCRECT lprcPosRect);
+
+#ifdef QAX_SUPPORT_WINDOWLESS
+// IOleInPlaceSiteEx ###
+    STDMETHOD(OnInPlaceActivateEx)(BOOL* /*pfNoRedraw*/, DWORD /*dwFlags*/)
+    {
+        return S_OK;
+    }
+    STDMETHOD(OnInPlaceDeactivateEx)(BOOL /*fNoRedraw*/)
+    {
+        return S_OK;
+    }
+    STDMETHOD(RequestUIActivate)()
+    {
+        return S_OK;
+    }
+
+// IOleInPlaceSiteWindowless ###
+    STDMETHOD(CanWindowlessActivate)()
+    {
+        return S_OK;
+    }
+    STDMETHOD(GetCapture)()
+    {
+        return S_FALSE;
+    }
+    STDMETHOD(SetCapture)(BOOL /*fCapture*/)
+    {
+        return S_FALSE;
+    }
+    STDMETHOD(GetFocus)()
+    {
+        return S_FALSE;
+    }
+    STDMETHOD(SetFocus)(BOOL /*fCapture*/)
+    {
+        return S_FALSE;
+    }
+    STDMETHOD(GetDC)(LPCRECT /*pRect*/, DWORD /*grfFlags*/, HDC *phDC)
+    {
+        *phDC = 0;
+        return S_OK;
+    }
+    STDMETHOD(ReleaseDC)(HDC hDC)
+    {
+        ::ReleaseDC(widget->winId(), hDC);
+        return S_OK;
+    }
+    STDMETHOD(InvalidateRect)(LPCRECT pRect, BOOL fErase)
+    {
+        ::InvalidateRect(host->winId(), pRect, fErase);
+        return S_OK;
+    }
+    STDMETHOD(InvalidateRgn)(HRGN hRGN, BOOL fErase)
+    {
+        ::InvalidateRgn(host->winId(), hRGN, fErase);
+        return S_OK;
+    }
+    STDMETHOD(ScrollRect)(int /*dx*/, int /*dy*/, LPCRECT /*pRectScroll*/, LPCRECT /*pRectClip*/)
+    {
+        return S_OK;
+    }
+    STDMETHOD(AdjustRect)(LPRECT /*prc*/)
+    {
+        return S_OK;
+    }
+#ifdef Q_CC_GNU // signature incorrect in win32api
+    STDMETHOD(AdjustRect)(LPCRECT /*prc*/)
+    {
+        RECT rect;
+        return AdjustRect(&rect);
+    }
+#endif
+
+    STDMETHOD(OnDefWindowMessage)(UINT /*msg*/, WPARAM /*wPara*/, LPARAM /*lParam*/, LRESULT* /*plResult*/)
+    {
+        return S_FALSE;
+    }
+#endif
+
+    // IOleInPlaceFrame
+    STDMETHOD(InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths));
+    STDMETHOD(SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject));
+    STDMETHOD(RemoveMenus(HMENU hmenuShared));
+    STDMETHOD(SetStatusText(LPCOLESTR pszStatusText));
+    STDMETHOD(EnableModeless(BOOL fEnable));
+    STDMETHOD(TranslateAccelerator(LPMSG lpMsg, WORD grfModifiers));
+
+    // IOleInPlaceUIWindow
+    STDMETHOD(GetBorder(LPRECT lprectBorder));
+    STDMETHOD(RequestBorderSpace(LPCBORDERWIDTHS pborderwidths));
+    STDMETHOD(SetBorderSpace(LPCBORDERWIDTHS pborderwidths));
+    STDMETHOD(SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName));
+
+    // IOleDocumentSite
+    STDMETHOD(ActivateMe(IOleDocumentView *pViewToActivate));
+
+    // IAdviseSink
+    STDMETHOD_(void, OnDataChange)(FORMATETC* /*pFormatetc*/, STGMEDIUM* /*pStgmed*/)
+    {
+        AX_DEBUG(QAxClientSite::OnDataChange);
+    }
+    STDMETHOD_(void, OnViewChange)(DWORD /*dwAspect*/, LONG /*lindex*/)
+    {
+        AX_DEBUG(QAxClientSite::OnViewChange);
+    }
+    STDMETHOD_(void, OnRename)(IMoniker* /*pmk*/)
+    {
+    }
+    STDMETHOD_(void, OnSave)()
+    {
+    }
+    STDMETHOD_(void, OnClose)()
+    {
+    }
+
+    QSize sizeHint() const { return sizehint; }
+    QSize minimumSizeHint() const;
+    inline void resize(QSize sz) { if (host) host->resize(sz); }
+
+    bool translateKeyEvent(int message, int keycode) const
+    {
+        if (!widget)
+            return false;
+        return widget->translateKeyEvent(message, keycode);
+    }
+
+    int qt_metacall(QMetaObject::Call, int isignal, void **argv);
+    void windowActivationChange();
+
+    bool eventTranslated : 1;
+
+private:
+#if !defined(Q_OS_WINCE)
+    struct OleMenuItem {
+        OleMenuItem(HMENU hm = 0, int ID = 0, QMenu *menu = 0)
+            : hMenu(hm), id(ID), subMenu(menu)
+        {}
+        HMENU hMenu;
+        int id;
+        QMenu *subMenu;
+    };
+    QMenu *generatePopup(HMENU subMenu, QWidget *parent);
+#endif
+
+    IOleObject *m_spOleObject;
+    IOleControl *m_spOleControl;
+    IOleInPlaceObjectWindowless *m_spInPlaceObject;
+    IOleInPlaceActiveObject *m_spInPlaceActiveObject;
+    IOleDocumentView *m_spActiveView;
+
+    QAxAggregated *aggregatedObject;
+
+    bool inPlaceObjectWindowless :1;
+    bool inPlaceModelessEnabled :1;
+    bool canHostDocument : 1;
+
+    DWORD m_dwOleObject;
+#if !defined(Q_OS_WINCE)
+    HWND m_menuOwner;
+#endif
+    CONTROLINFO control_info;
+
+    QSize sizehint;
+    unsigned long ref;
+    QAxWidget *widget;
+    QAxHostWidget *host;
+#if !defined(Q_OS_WINCE)
+    QPointer<QMenuBar> menuBar;
+    QMap<QAction*,OleMenuItem> menuItemMap;
+#endif
+};
+
+static const ushort mouseTbl[] = {
+    WM_MOUSEMOVE,       QEvent::MouseMove,              0,
+    WM_LBUTTONDOWN,     QEvent::MouseButtonPress,       Qt::LeftButton,
+    WM_LBUTTONUP,       QEvent::MouseButtonRelease,     Qt::LeftButton,
+    WM_LBUTTONDBLCLK,   QEvent::MouseButtonDblClick,    Qt::LeftButton,
+    WM_RBUTTONDOWN,     QEvent::MouseButtonPress,       Qt::RightButton,
+    WM_RBUTTONUP,       QEvent::MouseButtonRelease,     Qt::RightButton,
+    WM_RBUTTONDBLCLK,   QEvent::MouseButtonDblClick,    Qt::RightButton,
+    WM_MBUTTONDOWN,     QEvent::MouseButtonPress,       Qt::MidButton,
+    WM_MBUTTONUP,       QEvent::MouseButtonRelease,     Qt::MidButton,
+    WM_MBUTTONDBLCLK,   QEvent::MouseButtonDblClick,    Qt::MidButton,
+    0,                  0,                              0
+};
+
+static Qt::MouseButtons translateMouseButtonState(int s)
+{
+    Qt::MouseButtons bst = 0;
+    if (s & MK_LBUTTON)
+        bst |= Qt::LeftButton;
+    if (s & MK_MBUTTON)
+        bst |= Qt::MidButton;
+    if (s & MK_RBUTTON)
+        bst |= Qt::RightButton;
+
+    return bst;
+}
+
+static Qt::KeyboardModifiers translateModifierState(int s)
+{
+    Qt::KeyboardModifiers bst = 0;
+    if (s & MK_SHIFT)
+        bst |= Qt::ShiftModifier;
+    if (s & MK_CONTROL)
+        bst |= Qt::ControlModifier;
+    if (GetKeyState(VK_MENU) < 0)
+        bst |= Qt::AltModifier;
+
+    return bst;
+}
+
+static QAbstractEventDispatcher::EventFilter previous_filter = 0;
+#if QT_VERSION >= 0x050000
+#error "Fix QAbstractEventDispatcher::setEventFilter"
+#endif
+#if defined(Q_OS_WINCE)
+static int filter_ref = 0;
+#else
+static const char *qaxatom = "QAxContainer4_Atom";
+#endif
+
+// The filter procedure listening to user interaction on the control
+bool axc_FilterProc(void *m)
+{
+    MSG *msg = (MSG*)m;
+    const uint message = msg->message;
+    if ((message >= WM_MOUSEFIRST && message <= WM_MOUSELAST) || (message >= WM_KEYFIRST && message <= WM_KEYLAST)) {
+        HWND hwnd = msg->hwnd;
+        QAxWidget *ax = 0;
+        QAxHostWidget *host = 0;
+        while (!host && hwnd) {
+            host = qobject_cast<QAxHostWidget*>(QWidget::find(hwnd));
+            hwnd = ::GetParent(hwnd);
+        }
+        if (host)
+            ax = qobject_cast<QAxWidget*>(host->parentWidget());
+        if (ax && msg->hwnd != host->winId()) {
+            if (message >= WM_KEYFIRST && message <= WM_KEYLAST) {
+                QAxClientSite *site = host->clientSite();
+                site->eventTranslated = true; // reset in QAxClientSite::TranslateAccelerator
+                HRESULT hres = S_FALSE;
+                if (site && site->inPlaceObject() && site->translateKeyEvent(msg->message, msg->wParam))
+                    hres = site->inPlaceObject()->TranslateAccelerator(msg);
+                // if the object calls our TranslateAccelerator implementation, then continue with normal event processing
+                // otherwise the object has translated the accelerator, and the event should be stopped
+                if (site->eventTranslated && hres == S_OK)
+                    return true;
+            } else {
+                int i;
+                for (i = 0; (UINT)mouseTbl[i] != message && mouseTbl[i]; i += 3)
+                    ;
+
+                if (mouseTbl[i]) {
+                    QEvent::Type type = (QEvent::Type)mouseTbl[++i];
+                    int button = mouseTbl[++i];
+                    if (type != QEvent::MouseMove || ax->hasMouseTracking() || button) {
+                        if (type == QEvent::MouseMove)
+                            button = 0;
+
+                        DWORD ol_pos = GetMessagePos();
+                        QPoint gpos(GET_X_LPARAM(ol_pos), GET_Y_LPARAM(ol_pos));
+                        QPoint pos = ax->mapFromGlobal(gpos);
+
+                        QMouseEvent e(type, pos, gpos, (Qt::MouseButton)button,
+                            translateMouseButtonState(msg->wParam),
+                            translateModifierState(msg->wParam));
+                        QApplication::sendEvent(ax, &e);
+                    }
+                }
+            }
+        }
+    }
+
+    if (previous_filter)
+        return previous_filter(m);
+
+    return false;
+}
+
+QAxClientSite::QAxClientSite(QAxWidget *c)
+: ref(1), widget(c), host(0), eventTranslated(true)
+{
+    aggregatedObject = widget->createAggregate();
+    if (aggregatedObject) {
+        aggregatedObject->controlling_unknown = (IUnknown*)(IDispatch*)this;
+        aggregatedObject->the_object = c;
+    }
+
+    m_spOleObject = 0;
+    m_spOleControl = 0;
+    m_spInPlaceObject = 0;
+    m_spInPlaceActiveObject = 0;
+    m_spActiveView = 0;
+
+    inPlaceObjectWindowless = false;
+    inPlaceModelessEnabled = true;
+    canHostDocument = false;
+
+    m_dwOleObject = 0;
+#if !defined(Q_OS_WINCE)
+    m_menuOwner = 0;
+    menuBar = 0;
+#endif
+    memset(&control_info, 0, sizeof(control_info));
+}
+
+bool QAxClientSite::activateObject(bool initialized, const QByteArray &data)
+{
+    if (!host)
+        host = new QAxHostWidget(widget, this);
+
+    bool showHost = false;
+    HRESULT hr = S_OK;
+    if (!m_spOleObject)
+        widget->queryInterface(IID_IOleObject, (void**)&m_spOleObject);
+    if (m_spOleObject) {
+        DWORD dwMiscStatus = 0;
+        m_spOleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
+
+#if !defined(Q_OS_WINCE)
+        IOleDocument *document = 0;
+        m_spOleObject->QueryInterface(IID_IOleDocument, (void**)&document);
+        if (document) {
+            IPersistStorage *persistStorage = 0;
+            document->QueryInterface(IID_IPersistStorage, (void**)&persistStorage);
+            if (persistStorage) {
+            // try to activate as document server
+                IStorage *storage = 0;
+                ILockBytes * bytes = 0;
+                HRESULT hres = ::CreateILockBytesOnHGlobal(0, TRUE, &bytes);
+                hres = ::StgCreateDocfileOnILockBytes(bytes, STGM_SHARE_EXCLUSIVE|STGM_CREATE|STGM_READWRITE, 0, &storage);
+
+                persistStorage->InitNew(storage);
+                persistStorage->Release();
+                canHostDocument = true;
+                storage->Release();
+                bytes->Release();
+
+                m_spOleObject->SetClientSite(this);
+                OleRun(m_spOleObject);
+            }
+            document->Release();
+        }
+#endif
+
+        if (!canHostDocument) {
+            // activate as control
+            if(dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
+                m_spOleObject->SetClientSite(this);
+
+            if (!initialized) {
+                IPersistStreamInit *spPSI = 0;
+                m_spOleObject->QueryInterface(IID_IPersistStreamInit, (void**)&spPSI);
+                if (spPSI) {
+                    if (data.length()) {
+                        IStream *pStream = 0;
+                        HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, data.length());
+                        if (hGlobal) {
+                            BYTE *pStByte = (BYTE *)GlobalLock(hGlobal);
+                            if (pStByte)
+                                memcpy(pStByte, data.data(), data.length());
+                            GlobalUnlock(hGlobal);
+                            if (SUCCEEDED(CreateStreamOnHGlobal(hGlobal, TRUE, &pStream))) {
+                                spPSI->Load(pStream);
+                                pStream->Release();
+                            }
+                            GlobalFree(hGlobal);
+                        }
+                    } else {
+                        spPSI->InitNew();
+                    }
+                    spPSI->Release();
+                } else if (data.length()) { //try initializing using a IPersistStorage
+                    IPersistStorage *spPS = 0;
+                    m_spOleObject->QueryInterface( IID_IPersistStorage, (void**)&spPS );
+                    if (spPS) {
+                        HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, data.length());
+                        if (hGlobal) {
+#if !defined(Q_OS_WINCE)
+                            BYTE* pbData = (BYTE*)GlobalLock(hGlobal);
+                            if (pbData)
+                                memcpy(pbData, data.data(), data.length());
+                            GlobalUnlock(hGlobal);
+                            // open an IStorage on the data and pass it to Load
+                            LPLOCKBYTES pLockBytes = 0;
+                            if (SUCCEEDED(CreateILockBytesOnHGlobal(hGlobal, TRUE, &pLockBytes))) {
+                                LPSTORAGE pStorage = 0;
+                                if (SUCCEEDED(StgOpenStorageOnILockBytes(pLockBytes, 0,
+                                              STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &pStorage))) {
+                                    spPS->Load(pStorage);
+                                    pStorage->Release();
+                                }
+                                pLockBytes->Release();
+                            }
+                            GlobalFree(hGlobal);
+#endif
+                        }
+                        spPS->Release();
+                    }
+                }
+            }
+
+            if(!(dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
+                m_spOleObject->SetClientSite(this);
+        }
+
+        IViewObject *spViewObject = 0;
+        m_spOleObject->QueryInterface(IID_IViewObject, (void**) &spViewObject);
+
+        m_spOleObject->Advise(this, &m_dwOleObject);
+        IAdviseSink *spAdviseSink = 0;
+        QueryInterface(IID_IAdviseSink, (void**)&spAdviseSink);
+        if (spAdviseSink && spViewObject) {
+            if (spViewObject)
+                spViewObject->SetAdvise(DVASPECT_CONTENT, 0, spAdviseSink);
+            spAdviseSink->Release();
+        }
+        if (spViewObject)
+            spViewObject->Release();
+
+        m_spOleObject->SetHostNames(OLESTR("AXWIN"), 0);
+
+        if (!(dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME)) {
+            SIZEL hmSize;
+            hmSize.cx = MAP_PIX_TO_LOGHIM(250, widget->logicalDpiX());
+            hmSize.cy = MAP_PIX_TO_LOGHIM(250, widget->logicalDpiY());
+
+            m_spOleObject->SetExtent(DVASPECT_CONTENT, &hmSize);
+            m_spOleObject->GetExtent(DVASPECT_CONTENT, &hmSize);
+
+            sizehint.setWidth(MAP_LOGHIM_TO_PIX(hmSize.cx, widget->logicalDpiX()));
+            sizehint.setHeight(MAP_LOGHIM_TO_PIX(hmSize.cy, widget->logicalDpiY()));
+            showHost = true;
+        } else {
+            sizehint = QSize(0, 0);
+            host->hide();
+        }
+        if (!(dwMiscStatus & OLEMISC_NOUIACTIVATE)) {
+            host->setFocusPolicy(Qt::StrongFocus);
+        } else {
+            host->setFocusPolicy(Qt::NoFocus);
+        }
+
+        RECT rcPos = { host->x(), host->y(), host->x()+sizehint.width(), host->y()+sizehint.height() };
+
+        hr = m_spOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, 0, (IOleClientSite*)this, 0, host->winId(), &rcPos);
+
+        if (!m_spOleControl)
+            m_spOleObject->QueryInterface(IID_IOleControl, (void**)&m_spOleControl);
+        if (m_spOleControl) {
+            m_spOleControl->OnAmbientPropertyChange(DISPID_AMBIENT_BACKCOLOR);
+            m_spOleControl->OnAmbientPropertyChange(DISPID_AMBIENT_FORECOLOR);
+            m_spOleControl->OnAmbientPropertyChange(DISPID_AMBIENT_FONT);
+            m_spOleControl->OnAmbientPropertyChange(DISPID_AMBIENT_USERMODE);
+
+            control_info.cb = sizeof(control_info);
+            m_spOleControl->GetControlInfo(&control_info);
+        }
+
+        BSTR userType;
+        HRESULT result = m_spOleObject->GetUserType(USERCLASSTYPE_SHORT, &userType);
+        if (result == S_OK) {
+            widget->setWindowTitle(QString::fromUtf16((const ushort *)userType));
+            CoTaskMemFree(userType);
+        }
+    } else {
+        IObjectWithSite *spSite = 0;
+        widget->queryInterface(IID_IObjectWithSite, (void**)&spSite);
+        if (spSite) {
+            spSite->SetSite((IUnknown*)(IDispatch*)this);
+            spSite->Release();
+        }
+    }
+
+    host->resize(widget->size());
+    if (showHost)
+        host->show();
+
+    if (host->focusPolicy() != Qt::NoFocus) {
+        widget->setFocusProxy(host);
+        widget->setFocusPolicy(host->focusPolicy());
+    }
+
+    return true;
+}
+
+QAxClientSite::~QAxClientSite()
+{
+    if (host) {
+        host->axhost = 0;
+    }
+
+    if (aggregatedObject)
+        aggregatedObject->the_object = 0;
+    delete aggregatedObject;
+    delete host;
+}
+
+void QAxClientSite::releaseAll()
+{
+    if (m_spOleObject) {
+        m_spOleObject->SetClientSite(0);
+        m_spOleObject->Unadvise(m_dwOleObject);
+        m_spOleObject->Release();
+    }
+    m_spOleObject = 0;
+    if (m_spOleControl) m_spOleControl->Release();
+    m_spOleControl = 0;
+    if (m_spInPlaceObject) m_spInPlaceObject->Release();
+    m_spInPlaceObject = 0;
+    if (m_spInPlaceActiveObject) m_spInPlaceActiveObject->Release();
+    m_spInPlaceActiveObject = 0;
+
+    inPlaceObjectWindowless = false;
+}
+
+void QAxClientSite::deactivate()
+{
+    if (m_spInPlaceObject) m_spInPlaceObject->InPlaceDeactivate();
+    // if this assertion fails the control didn't call OnInPlaceDeactivate
+    Q_ASSERT(m_spInPlaceObject == 0);
+}
+
+//**** IUnknown
+unsigned long WINAPI QAxClientSite::AddRef()
+{
+    return ++ref;
+}
+
+unsigned long WINAPI QAxClientSite::Release()
+{
+    if (!--ref) {
+        delete this;
+        return 0;
+    }
+    return ref;
+}
+
+HRESULT WINAPI QAxClientSite::QueryInterface(REFIID iid, void **iface)
+{
+    *iface = 0;
+
+    if (iid == IID_IUnknown) {
+        *iface = (IUnknown*)(IDispatch*)this;
+    } else {
+        HRESULT res = S_OK;
+        if (aggregatedObject)
+            res = aggregatedObject->queryInterface(iid, iface);
+        if (*iface)
+            return res;
+    }
+
+    if (!(*iface)) {
+        if (iid == IID_IDispatch)
+            *iface = (IDispatch*)this;
+        else if (iid == IID_IOleClientSite)
+            *iface = (IOleClientSite*)this;
+        else if (iid == IID_IOleControlSite)
+            *iface = (IOleControlSite*)this;
+        else if (iid == IID_IOleWindow)
+            *iface = (IOleWindow*)(IOleInPlaceSite*)this;
+        else if (iid == IID_IOleInPlaceSite)
+            *iface = (IOleInPlaceSite*)this;
+#ifdef QAX_SUPPORT_WINDOWLESS
+        else if (iid == IID_IOleInPlaceSiteEx)
+            *iface = (IOleInPlaceSiteEx*)this;
+        else if (iid == IID_IOleInPlaceSiteWindowless)
+            *iface = (IOleInPlaceSiteWindowless*)this;
+#endif
+        else if (iid == IID_IOleInPlaceFrame)
+            *iface = (IOleInPlaceFrame*)this;
+        else if (iid == IID_IOleInPlaceUIWindow)
+            *iface = (IOleInPlaceUIWindow*)this;
+        else if (iid == IID_IOleDocumentSite && canHostDocument)
+            *iface = (IOleDocumentSite*)this;
+        else if (iid == IID_IAdviseSink)
+            *iface = (IAdviseSink*)this;
+    }
+    if (!*iface)
+        return E_NOINTERFACE;
+
+    AddRef();
+    return S_OK;
+}
+
+bool qax_runsInDesignMode = false;
+
+//**** IDispatch
+HRESULT WINAPI QAxClientSite::Invoke(DISPID dispIdMember,
+                                     REFIID /*riid*/,
+                                     LCID /*lcid*/,
+                                     WORD /*wFlags*/,
+                                     DISPPARAMS * /*pDispParams*/,
+                                     VARIANT *pVarResult,
+                                     EXCEPINFO * /*pExcepInfo*/,
+                                     UINT * /*puArgErr*/)
+{
+    if (!pVarResult)
+        return E_POINTER;
+    if (!widget || !host)
+        return E_UNEXPECTED;
+
+    switch(dispIdMember) {
+    case DISPID_AMBIENT_USERMODE:
+        pVarResult->vt = VT_BOOL;
+        pVarResult->boolVal = !qax_runsInDesignMode;
+        return S_OK;
+
+    case DISPID_AMBIENT_AUTOCLIP:
+    case DISPID_AMBIENT_SUPPORTSMNEMONICS:
+        pVarResult->vt = VT_BOOL;
+        pVarResult->boolVal = true;
+        return S_OK;
+
+    case DISPID_AMBIENT_SHOWHATCHING:
+    case DISPID_AMBIENT_SHOWGRABHANDLES:
+    case DISPID_AMBIENT_DISPLAYASDEFAULT:
+    case DISPID_AMBIENT_MESSAGEREFLECT:
+        pVarResult->vt = VT_BOOL;
+        pVarResult->boolVal = false;
+        return S_OK;
+
+    case DISPID_AMBIENT_DISPLAYNAME:
+        pVarResult->vt = VT_BSTR;
+        pVarResult->bstrVal = QStringToBSTR(widget->windowTitle());
+        return S_OK;
+
+    case DISPID_AMBIENT_FONT:
+        QVariantToVARIANT(widget->font(), *pVarResult);
+        return S_OK;
+
+    case DISPID_AMBIENT_BACKCOLOR:
+        pVarResult->vt = VT_UI4;
+        pVarResult->lVal = QColorToOLEColor(widget->palette().color(widget->backgroundRole()));
+        return S_OK;
+
+    case DISPID_AMBIENT_FORECOLOR:
+        pVarResult->vt = VT_UI4;
+        pVarResult->lVal = QColorToOLEColor(widget->palette().color(widget->foregroundRole()));
+        return S_OK;
+
+    case DISPID_AMBIENT_UIDEAD:
+        pVarResult->vt = VT_BOOL;
+        pVarResult->boolVal = !widget->isEnabled();
+        return S_OK;
+
+    default:
+        break;
+    }
+
+    return DISP_E_MEMBERNOTFOUND;
+}
+
+void QAxClientSite::emitAmbientPropertyChange(DISPID dispid)
+{
+    if (m_spOleControl)
+        m_spOleControl->OnAmbientPropertyChange(dispid);
+}
+
+//**** IOleClientSite
+HRESULT WINAPI QAxClientSite::SaveObject()
+{
+    return E_NOTIMPL;
+}
+
+HRESULT WINAPI QAxClientSite::GetMoniker(DWORD, DWORD, IMoniker **ppmk)
+{
+    if (!ppmk)
+        return E_POINTER;
+
+    *ppmk = 0;
+    return E_NOTIMPL;
+}
+
+HRESULT WINAPI QAxClientSite::GetContainer(LPOLECONTAINER *ppContainer)
+{
+    if (!ppContainer)
+        return E_POINTER;
+
+    *ppContainer = 0;
+    return E_NOINTERFACE;
+}
+
+HRESULT WINAPI QAxClientSite::ShowObject()
+{
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::OnShowWindow(BOOL /*fShow*/)
+{
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::RequestNewObjectLayout()
+{
+    return E_NOTIMPL;
+}
+
+//**** IOleControlSite
+HRESULT WINAPI QAxClientSite::OnControlInfoChanged()
+{
+    if (m_spOleControl)
+        m_spOleControl->GetControlInfo(&control_info);
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::LockInPlaceActive(BOOL /*fLock*/)
+{
+    AX_DEBUG(QAxClientSite::LockInPlaceActive);
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::GetExtendedControl(IDispatch** ppDisp)
+{
+    if (!ppDisp)
+        return E_POINTER;
+
+    *ppDisp = 0;
+    return E_NOTIMPL;
+}
+
+HRESULT WINAPI QAxClientSite::TransformCoords(POINTL* /*pPtlHimetric*/, POINTF* /*pPtfContainer*/, DWORD /*dwFlags*/)
+{
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::TranslateAccelerator(LPMSG lpMsg, DWORD /*grfModifiers*/)
+{
+    eventTranslated = false;
+    if (lpMsg->message == WM_KEYDOWN && !lpMsg->wParam)
+        return S_OK;
+    QT_WA_INLINE(
+        SendMessage(host->winId(), lpMsg->message, lpMsg->wParam, lpMsg->lParam),
+        SendMessageA(host->winId(), lpMsg->message, lpMsg->wParam, lpMsg->lParam)
+    );
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::OnFocus(BOOL bGotFocus)
+{
+    AX_DEBUG(QAxClientSite::OnFocus);
+    if (host) {
+        host->hasFocus = bGotFocus;
+        qApp->removeEventFilter(host);
+        if (bGotFocus)
+            qApp->installEventFilter(host);
+    }
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::ShowPropertyFrame()
+{
+    return E_NOTIMPL;
+}
+
+//**** IOleWindow
+HRESULT WINAPI QAxClientSite::GetWindow(HWND *phwnd)
+{
+    if (!phwnd)
+        return E_POINTER;
+
+    *phwnd = host->winId();
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::ContextSensitiveHelp(BOOL fEnterMode)
+{
+    if (fEnterMode)
+        QWhatsThis::enterWhatsThisMode();
+    else
+        QWhatsThis::leaveWhatsThisMode();
+
+    return S_OK;
+}
+
+//**** IOleInPlaceSite
+HRESULT WINAPI QAxClientSite::CanInPlaceActivate()
+{
+    AX_DEBUG(QAxClientSite::CanInPlaceActivate);
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::OnInPlaceActivate()
+{
+    AX_DEBUG(QAxClientSite::OnInPlaceActivate);
+#if !defined(Q_OS_WINCE)
+    OleLockRunning(m_spOleObject, true, false);
+#endif
+    if (!m_spInPlaceObject) {
+/* ### disabled for now
+        m_spOleObject->QueryInterface(IID_IOleInPlaceObjectWindowless, (void**) &m_spInPlaceObject);
+*/
+        if (m_spInPlaceObject) {
+            inPlaceObjectWindowless = true;
+        } else {
+            inPlaceObjectWindowless = false;
+            m_spOleObject->QueryInterface(IID_IOleInPlaceObject, (void**) &m_spInPlaceObject);
+        }
+    }
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::OnUIActivate()
+{
+    AX_DEBUG(QAxClientSite::OnUIActivate);
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::GetWindowContext(IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo)
+{
+    if (!ppFrame || !ppDoc || !lprcPosRect || !lprcClipRect || !lpFrameInfo)
+        return E_POINTER;
+
+    QueryInterface(IID_IOleInPlaceFrame, (void**)ppFrame);
+    QueryInterface(IID_IOleInPlaceUIWindow, (void**)ppDoc);
+
+    ::GetClientRect(host->winId(), lprcPosRect);
+    ::GetClientRect(host->winId(), lprcClipRect);
+
+    lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
+    lpFrameInfo->fMDIApp = false;
+    lpFrameInfo->haccel = 0;
+    lpFrameInfo->cAccelEntries = 0;
+    lpFrameInfo->hwndFrame = widget ? widget->window()->winId() : 0;
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::Scroll(SIZE /*scrollExtant*/)
+{
+    return S_FALSE;
+}
+
+HRESULT WINAPI QAxClientSite::OnUIDeactivate(BOOL)
+{
+    AX_DEBUG(QAxClientSite::OnUIDeactivate);
+    if (host && host->hasFocus) {
+        qApp->removeEventFilter(host);
+        host->hasFocus = false;
+    }
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::OnInPlaceDeactivate()
+{
+    AX_DEBUG(QAxClientSite::OnInPlaceDeactivate);
+    if (m_spInPlaceObject)
+        m_spInPlaceObject->Release();
+    m_spInPlaceObject = 0;
+    inPlaceObjectWindowless = false;
+#if !defined(Q_OS_WINCE)
+    OleLockRunning(m_spOleObject, false, false);
+#endif
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::DiscardUndoState()
+{
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::DeactivateAndUndo()
+{
+    if (m_spInPlaceObject)
+        m_spInPlaceObject->UIDeactivate();
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::OnPosRectChange(LPCRECT /*lprcPosRect*/)
+{
+    AX_DEBUG(QAxClientSite::OnPosRectChange);
+    // ###
+    return S_OK;
+}
+
+//**** IOleInPlaceFrame
+#if defined(Q_OS_WINCE)
+HRESULT WINAPI QAxClientSite::InsertMenus(HMENU /*hmenuShared*/, LPOLEMENUGROUPWIDTHS /*lpMenuWidths*/)
+{
+    return E_NOTIMPL;
+#else
+HRESULT WINAPI QAxClientSite::InsertMenus(HMENU /*hmenuShared*/, LPOLEMENUGROUPWIDTHS lpMenuWidths)
+{
+    AX_DEBUG(QAxClientSite::InsertMenus);
+    QMenuBar *mb = menuBar;
+    if (!mb)
+        mb = qFindChild<QMenuBar*>(widget->window());
+    if (!mb)
+        return E_NOTIMPL;
+    menuBar = mb;
+
+    QMenu *fileMenu = 0;
+    QMenu *viewMenu = 0;
+    QMenu *windowMenu = 0;
+    QList<QAction*> actions = menuBar->actions();
+    for (int i = 0; i < actions.count(); ++i) {
+        QAction *action = actions.at(i);
+        QString text = action->text().remove(QLatin1Char('&'));
+        if (text == QLatin1String("File")) {
+            fileMenu = action->menu();
+        } else if (text == QLatin1String("View")) {
+            viewMenu = action->menu();
+        } else if (text == QLatin1String("Window")) {
+            windowMenu = action->menu();
+        }
+    }
+    if (fileMenu)
+        lpMenuWidths->width[0] = fileMenu->actions().count();
+    if (viewMenu)
+        lpMenuWidths->width[2] = viewMenu->actions().count();
+    if (windowMenu)
+        lpMenuWidths->width[4] = windowMenu->actions().count();
+
+    return S_OK;
+#endif
+}
+
+static int menuItemEntry(HMENU menu, int index, MENUITEMINFOA item, QString &text, QPixmap &/*icon*/)
+{
+    if (item.fType == MFT_STRING && item.cch) {
+        char *titlebuf = new char[item.cch+1];
+        item.dwTypeData = titlebuf;
+        item.cch++;
+        ::GetMenuItemInfoA(menu, index, true, &item);
+        text = QString::fromLocal8Bit(titlebuf);
+        delete []titlebuf;
+        return MFT_STRING;
+    }
+#if 0
+    else if (item.fType == MFT_BITMAP) {
+        HBITMAP hbm = (HBITMAP)LOWORD(item.hbmpItem);
+        SIZE bmsize;
+        GetBitmapDimensionEx(hbm, &bmsize);
+        QPixmap pixmap(1,1);
+        QSize sz(MAP_LOGHIM_TO_PIX(bmsize.cx, pixmap.logicalDpiX()),
+            MAP_LOGHIM_TO_PIX(bmsize.cy, pixmap.logicalDpiY()));
+
+        pixmap.resize(bmsize.cx, bmsize.cy);
+        if (!pixmap.isNull()) {
+            HDC hdc = ::CreateCompatibleDC(pixmap.handle());
+            ::SelectObject(hdc, hbm);
+            BOOL res = ::BitBlt(pixmap.handle(), 0, 0, pixmap.width(), pixmap.height(), hdc, 0, 0, SRCCOPY);
+            ::DeleteObject(hdc);
+        }
+
+        icon = pixmap;
+    }
+#endif
+    return -1;
+}
+
+#if !defined(Q_OS_WINCE)
+QMenu *QAxClientSite::generatePopup(HMENU subMenu, QWidget *parent)
+{
+    QMenu *popup = 0;
+    int count = GetMenuItemCount(subMenu);
+    if (count)
+        popup = new QMenu(parent);
+    for (int i = 0; i < count; ++i) {
+        MENUITEMINFOA item;
+        memset(&item, 0, sizeof(MENUITEMINFOA));
+        item.cbSize = sizeof(MENUITEMINFOA);
+        item.fMask = MIIM_ID | MIIM_TYPE | MIIM_SUBMENU;
+        ::GetMenuItemInfoA(subMenu, i, true, &item);
+
+        QAction *action = 0;
+        QMenu *popupMenu = 0;
+        if (item.fType == MFT_SEPARATOR) {
+            action = popup->addSeparator();
+        } else {
+            QString text;
+            QPixmap icon;
+            QKeySequence accel;
+            popupMenu = item.hSubMenu ? generatePopup(item.hSubMenu, popup) : 0;
+            int res = menuItemEntry(subMenu, i, item, text, icon);
+
+            int lastSep = text.lastIndexOf(QRegExp(QLatin1String("[\\s]")));
+            if (lastSep != -1) {
+                QString keyString = text.right(text.length() - lastSep);
+                accel = keyString;
+                if ((int)accel)
+                    text = text.left(lastSep);
+            }
+
+            if (popupMenu)
+                popupMenu->setTitle(text);
+
+            switch (res) {
+            case MFT_STRING:
+                if (popupMenu)
+                    action = popup->addMenu(popupMenu);
+                else
+                    action = popup->addAction(text);
+                break;
+            case MFT_BITMAP:
+                if (popupMenu)
+                    action = popup->addMenu(popupMenu);
+                else
+                    action = popup->addAction(icon, text);
+                break;
+            }
+
+            if (action) {
+                if (int(accel))
+                    action->setShortcut(accel);
+                if (!icon.isNull())
+                    action->setIcon(icon);
+            }
+        }
+
+        if (action) {
+            OleMenuItem oleItem(subMenu, item.wID, popupMenu);
+            menuItemMap.insert(action, oleItem);
+        }
+    }
+    return popup;
+}
+#endif
+
+#if defined(Q_OS_WINCE)
+HRESULT WINAPI QAxClientSite::SetMenu(HMENU /*hmenuShared*/, HOLEMENU /*holemenu*/, HWND /*hwndActiveObject*/)
+{
+    return E_NOTIMPL;
+#else
+HRESULT WINAPI QAxClientSite::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject)
+{
+    AX_DEBUG(QAxClientSite::SetMenu);
+
+    if (hmenuShared) {
+        m_menuOwner = hwndActiveObject;
+        QMenuBar *mb = menuBar;
+        if (!mb)
+            mb = qFindChild<QMenuBar*>(widget->window());
+        if (!mb)
+            return E_NOTIMPL;
+        menuBar = mb;
+
+        int count = GetMenuItemCount(hmenuShared);
+        for (int i = 0; i < count; ++i) {
+            MENUITEMINFOA item;
+            memset(&item, 0, sizeof(MENUITEMINFOA));
+            item.cbSize = sizeof(MENUITEMINFOA);
+            item.fMask = MIIM_ID | MIIM_TYPE | MIIM_SUBMENU;
+            ::GetMenuItemInfoA(hmenuShared, i, true, &item);
+
+            QAction *action = 0;
+            QMenu *popupMenu = 0;
+            if (item.fType == MFT_SEPARATOR) {
+                action = menuBar->addSeparator();
+            } else {
+                QString text;
+                QPixmap icon;
+                popupMenu = item.hSubMenu ? generatePopup(item.hSubMenu, menuBar) : 0;
+                int res = menuItemEntry(hmenuShared, i, item, text, icon);
+
+                if (popupMenu)
+                    popupMenu->setTitle(text);
+
+                switch(res) {
+                case MFT_STRING:
+                    if (popupMenu)
+                        action = menuBar->addMenu(popupMenu);
+                    else
+                        action = menuBar->addAction(text);
+                    break;
+                case MFT_BITMAP:
+                    if (popupMenu)
+                        action = menuBar->addMenu(popupMenu);
+                    else
+                        action = menuBar->addAction(text);
+                    break;
+                default:
+                    break;
+                }
+                if (action && !icon.isNull())
+                    action->setIcon(icon);
+            }
+
+            if (action) {
+                OleMenuItem oleItem(hmenuShared, item.wID, popupMenu);
+                menuItemMap.insert(action, oleItem);
+            }
+        }
+        if (count) {
+            const QMetaObject *mbmo = menuBar->metaObject();
+            int index = mbmo->indexOfSignal("triggered(QAction*)");
+            Q_ASSERT(index != -1);
+            menuBar->disconnect(SIGNAL(triggered(QAction*)), host);
+            QMetaObject::connect(menuBar, index, host, index);
+        }
+    } else if (menuBar) {
+        m_menuOwner = 0;
+        QMap<QAction*, OleMenuItem>::Iterator it;
+        for (it = menuItemMap.begin(); it != menuItemMap.end(); ++it) {
+            QAction *action = it.key();
+            delete action;
+        }
+        menuItemMap.clear();
+    }
+
+    OleSetMenuDescriptor(holemenu, widget ? widget->window()->winId() : 0, m_menuOwner, this, m_spInPlaceActiveObject);
+    return S_OK;
+#endif
+}
+
+#if defined(Q_OS_WINCE)
+int QAxClientSite::qt_metacall(QMetaObject::Call /*call*/, int isignal, void ** /*argv*/)
+{
+    return isignal;
+#else
+int QAxClientSite::qt_metacall(QMetaObject::Call call, int isignal, void **argv)
+{
+    if (!m_spOleObject || call != QMetaObject::InvokeMetaMethod || !menuBar)
+        return isignal;
+
+    if (isignal != menuBar->metaObject()->indexOfSignal("triggered(QAction*)"))
+        return isignal;
+
+    QAction *action = *(QAction**)argv[1];
+    // ###
+
+    OleMenuItem oleItem = menuItemMap.value(action);
+    if (oleItem.hMenu)
+        ::PostMessageA(m_menuOwner, WM_COMMAND, oleItem.id, 0);
+    return -1;
+#endif
+}
+
+
+HRESULT WINAPI QAxClientSite::RemoveMenus(HMENU /*hmenuShared*/)
+{
+#if defined(Q_OS_WINCE)
+    return E_NOTIMPL;
+#else
+    AX_DEBUG(QAxClientSite::RemoveMenus);
+    QMap<QAction*, OleMenuItem>::Iterator it;
+    for (it = menuItemMap.begin(); it != menuItemMap.end(); ++it) {
+        QAction *action = it.key();
+        action->setVisible(false);
+        delete action;
+    }
+    menuItemMap.clear();
+    return S_OK;
+#endif
+}
+
+HRESULT WINAPI QAxClientSite::SetStatusText(LPCOLESTR pszStatusText)
+{
+    QStatusTipEvent tip(QString::fromUtf16((const ushort *)(BSTR)pszStatusText));
+    QApplication::sendEvent(widget, &tip);
+    return S_OK;
+}
+
+extern Q_GUI_EXPORT bool qt_win_ignoreNextMouseReleaseEvent;
+
+HRESULT WINAPI QAxClientSite::EnableModeless(BOOL fEnable)
+{
+    EnableWindow(host->window()->winId(), fEnable);
+
+    if (!fEnable) {
+        if (!QApplicationPrivate::isBlockedByModal(host))
+            QApplicationPrivate::enterModal(host);
+    } else {
+        if (QApplicationPrivate::isBlockedByModal(host))
+            QApplicationPrivate::leaveModal(host);
+    }
+    qt_win_ignoreNextMouseReleaseEvent = false;
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxClientSite::TranslateAccelerator(LPMSG lpMsg, WORD grfModifiers)
+{
+    return TranslateAccelerator(lpMsg, (DWORD)grfModifiers);
+}
+
+//**** IOleInPlaceUIWindow
+HRESULT WINAPI QAxClientSite::GetBorder(LPRECT lprectBorder)
+{
+#ifndef QAX_SUPPORT_BORDERSPACE
+    Q_UNUSED(lprectBorder);
+    return INPLACE_E_NOTOOLSPACE;
+#else
+    AX_DEBUG(QAxClientSite::GetBorder);
+
+    QMainWindow *mw = qobject_cast<QMainWindow*>(widget->window());
+    if (!mw)
+        return INPLACE_E_NOTOOLSPACE;
+
+    RECT border = { 0,0, 300, 200 };
+    *lprectBorder = border;
+    return S_OK;
+#endif
+}
+
+HRESULT WINAPI QAxClientSite::RequestBorderSpace(LPCBORDERWIDTHS /*pborderwidths*/)
+{
+#ifndef QAX_SUPPORT_BORDERSPACE
+    return INPLACE_E_NOTOOLSPACE;
+#else
+    AX_DEBUG(QAxClientSite::RequestBorderSpace);
+
+    QMainWindow *mw = qobject_cast<QMainWindow*>(widget->window());
+    if (!mw)
+        return INPLACE_E_NOTOOLSPACE;
+
+    return S_OK;
+#endif
+}
+
+HRESULT WINAPI QAxClientSite::SetBorderSpace(LPCBORDERWIDTHS pborderwidths)
+{
+#ifndef QAX_SUPPORT_BORDERSPACE
+    Q_UNUSED(pborderwidths);
+    return OLE_E_INVALIDRECT;
+#else
+    AX_DEBUG(QAxClientSite::SetBorderSpace);
+
+    // object has no toolbars and wants container toolbars to remain
+    if (!pborderwidths)
+        return S_OK;
+
+    QMainWindow *mw = qobject_cast<QMainWindow*>(widget->window());
+    if (!mw)
+        return OLE_E_INVALIDRECT;
+
+    bool removeToolBars = !(pborderwidths->left || pborderwidths->top || pborderwidths->right || pborderwidths->bottom);
+
+    // object has toolbars, and wants container to remove toolbars
+    if (removeToolBars) {
+        if (mw) {
+            //### remove our toolbars
+        }
+    }
+
+    if (pborderwidths->left) {
+        QDockWidget *left = new QDockWidget(mw);
+        left->setFixedWidth(pborderwidths->left);
+        mw->addDockWidget(Qt::LeftDockWidgetArea, left);
+        left->show();
+    }
+    if (pborderwidths->top) {
+        QDockWidget *top = new QDockWidget(mw);
+        top->setFixedHeight(pborderwidths->top);
+        mw->addDockWidget(Qt::TopDockWidgetArea, top);
+        top->show();
+    }
+
+    return S_OK;
+#endif
+}
+
+HRESULT WINAPI QAxClientSite::SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName)
+{
+    AX_DEBUG(QAxClientSite::SetActiveObject);
+
+    if (pszObjName && widget)
+        widget->setWindowTitle(QString::fromUtf16((const ushort *)(BSTR)pszObjName));
+
+    if (m_spInPlaceActiveObject) {
+        if (!inPlaceModelessEnabled)
+            m_spInPlaceActiveObject->EnableModeless(true);
+        inPlaceModelessEnabled = true;
+        m_spInPlaceActiveObject->Release();
+    }
+
+    m_spInPlaceActiveObject = pActiveObject;
+    if (m_spInPlaceActiveObject)
+        m_spInPlaceActiveObject->AddRef();
+
+    return S_OK;
+}
+
+//**** IOleDocumentSite
+HRESULT WINAPI QAxClientSite::ActivateMe(IOleDocumentView *pViewToActivate)
+{
+    AX_DEBUG(QAxClientSite::ActivateMe);
+
+    if (m_spActiveView)
+        m_spActiveView->Release();
+    m_spActiveView = 0;
+
+    if (!pViewToActivate) {
+        IOleDocument *document = 0;
+        m_spOleObject->QueryInterface(IID_IOleDocument, (void**)&document);
+        if (!document)
+            return E_FAIL;
+
+        document->CreateView(this, 0, 0, &pViewToActivate);
+
+        document->Release();
+        if (!pViewToActivate)
+            return E_OUTOFMEMORY;
+    } else {
+        pViewToActivate->SetInPlaceSite(this);
+    }
+
+    m_spActiveView = pViewToActivate;
+    m_spActiveView->AddRef();
+
+    m_spActiveView->UIActivate(TRUE);
+
+    RECT rect;
+    GetClientRect(widget->winId(), &rect);
+    m_spActiveView->SetRect(&rect);
+    m_spActiveView->Show(TRUE);
+
+    return S_OK;
+}
+
+QSize QAxClientSite::minimumSizeHint() const
+{
+    if (!m_spOleObject)
+        return QSize();
+
+    SIZE sz = { 0, 0 };
+    m_spOleObject->SetExtent(DVASPECT_CONTENT, &sz);
+    HRESULT res = m_spOleObject->GetExtent(DVASPECT_CONTENT, &sz);
+    if (SUCCEEDED(res)) {
+        return QSize(MAP_LOGHIM_TO_PIX(sz.cx, widget->logicalDpiX()),
+            MAP_LOGHIM_TO_PIX(sz.cy, widget->logicalDpiY()));
+    }
+    return QSize();
+}
+
+void QAxClientSite::windowActivationChange()
+{
+    AX_DEBUG(QAxClientSite::windowActivationChange);
+
+    if (m_spInPlaceActiveObject && widget) {
+        QWidget *modal = QApplication::activeModalWidget();
+        if (modal && inPlaceModelessEnabled) {
+            m_spInPlaceActiveObject->EnableModeless(false);
+            inPlaceModelessEnabled = false;
+        } else if (!inPlaceModelessEnabled) {
+            m_spInPlaceActiveObject->EnableModeless(true);
+            inPlaceModelessEnabled = true;
+        }
+        m_spInPlaceActiveObject->OnFrameWindowActivate(widget->isActiveWindow());
+    }
+}
+
+
+//**** QWidget
+
+QAxHostWidget::QAxHostWidget(QWidget *parent, QAxClientSite *ax)
+: QWidget(parent), setFocusTimer(0), hasFocus(false), axhost(ax)
+{
+    setAttribute(Qt::WA_NoBackground);
+    setAttribute(Qt::WA_NoSystemBackground);
+    setAttribute(Qt::WA_OpaquePaintEvent);
+    setAttribute(Qt::WA_PaintOnScreen);
+
+    setObjectName(parent->objectName() + QLatin1String(" - QAxHostWidget"));
+}
+
+QAxHostWidget::~QAxHostWidget()
+{
+    if (axhost)
+        axhost->reset(this);
+}
+
+int QAxHostWidget::qt_metacall(QMetaObject::Call call, int isignal, void **argv)
+{
+    if (axhost)
+        return axhost->qt_metacall(call, isignal, argv);
+    return -1;
+}
+
+QSize QAxHostWidget::sizeHint() const
+{
+    return axhost ? axhost->sizeHint() : QWidget::sizeHint();
+}
+
+QSize QAxHostWidget::minimumSizeHint() const
+{
+    QSize size;
+    if (axhost)
+        size = axhost->minimumSizeHint();
+    if (size.isValid())
+        return size;
+    return QWidget::minimumSizeHint();
+}
+
+void QAxHostWidget::resizeObject()
+{
+    if (!axhost)
+        return;
+
+    // document server - talk to view?
+    if (axhost->m_spActiveView) {
+        RECT rect;
+        GetClientRect(winId(), &rect);
+        axhost->m_spActiveView->SetRect(&rect);
+
+        return;
+    }
+
+    SIZEL hmSize;
+    hmSize.cx = MAP_PIX_TO_LOGHIM(width(), logicalDpiX());
+    hmSize.cy = MAP_PIX_TO_LOGHIM(height(), logicalDpiY());
+
+    if (axhost->m_spOleObject)
+        axhost->m_spOleObject->SetExtent(DVASPECT_CONTENT, &hmSize);
+    if (axhost->m_spInPlaceObject) {
+        RECT rcPos = { x(), y(), x()+width(), y()+height() };
+        axhost->m_spInPlaceObject->SetObjectRects(&rcPos, &rcPos);
+    }
+}
+
+void QAxHostWidget::resizeEvent(QResizeEvent *)
+{
+    resizeObject();
+}
+
+void QAxHostWidget::showEvent(QShowEvent *)
+{
+    resizeObject();
+}
+
+bool QAxHostWidget::winEvent(MSG *msg, long *result)
+{
+    if (axhost && axhost->inPlaceObjectWindowless) {
+        Q_ASSERT(axhost->m_spInPlaceObject);
+        IOleInPlaceObjectWindowless *windowless = (IOleInPlaceObjectWindowless*)axhost->m_spInPlaceObject;
+        Q_ASSERT(windowless);
+        LRESULT lres;
+        HRESULT hres = windowless->OnWindowMessage(msg->message, msg->wParam, msg->lParam, &lres);
+        if (hres == S_OK)
+            return true;
+    }
+    return QWidget::winEvent(msg, result);
+}
+
+bool QAxHostWidget::event(QEvent *e)
+{
+    switch (e->type()) {
+    case QEvent::Timer:
+        if (axhost && ((QTimerEvent*)e)->timerId() == setFocusTimer) {
+            killTimer(setFocusTimer);
+            setFocusTimer = 0;
+            RECT rcPos = { x(), y(), x()+size().width(), y()+size().height() };
+            axhost->m_spOleObject->DoVerb(OLEIVERB_UIACTIVATE, 0, (IOleClientSite*)axhost, 0, winId(), &rcPos);
+            if (axhost->m_spActiveView)
+                axhost->m_spActiveView->UIActivate(TRUE);
+        }
+        break;
+    case QEvent::WindowBlocked:
+        if (IsWindowEnabled(winId())) {
+            EnableWindow(winId(), false);
+            if (axhost && axhost->m_spInPlaceActiveObject) {
+                axhost->inPlaceModelessEnabled = false;
+                axhost->m_spInPlaceActiveObject->EnableModeless(false);
+            }
+        }
+        break;
+    case QEvent::WindowUnblocked:
+        if (!IsWindowEnabled(winId())) {
+            EnableWindow(winId(), true);
+            if (axhost && axhost->m_spInPlaceActiveObject) {
+                axhost->inPlaceModelessEnabled = true;
+                axhost->m_spInPlaceActiveObject->EnableModeless(true);
+            }
+        }
+        break;
+    default:
+        break;
+    }
+
+    return QWidget::event(e);
+}
+
+bool QAxHostWidget::eventFilter(QObject *o, QEvent *e)
+{
+    // focus goes to Qt while ActiveX still has it - deactivate
+    QWidget *newFocus = qobject_cast<QWidget*>(o);
+    if (e->type() == QEvent::FocusIn && hasFocus
+        && newFocus && newFocus->window() == window()) {
+        if (axhost && axhost->m_spInPlaceActiveObject && axhost->m_spInPlaceObject)
+            axhost->m_spInPlaceObject->UIDeactivate();
+        qApp->removeEventFilter(this);
+    }
+
+    return QWidget::eventFilter(o, e);
+}
+
+void QAxHostWidget::focusInEvent(QFocusEvent *e)
+{
+    QWidget::focusInEvent(e);
+
+    if (!axhost || !axhost->m_spOleObject)
+        return;
+
+    // this is called by QWidget::setFocus which calls ::SetFocus on "this",
+    // so we have to UIActivate the control after all that had happend.
+    AX_DEBUG(Setting focus on in-place object);
+    setFocusTimer = startTimer(0);
+}
+
+void QAxHostWidget::focusOutEvent(QFocusEvent *e)
+{
+    QWidget::focusOutEvent(e);
+    if (setFocusTimer) {
+        killTimer(setFocusTimer);
+        setFocusTimer = 0;
+    }
+    if (e->reason() == Qt::PopupFocusReason || e->reason() == Qt::MenuBarFocusReason)
+        return;
+
+    if (!axhost || !axhost->m_spInPlaceActiveObject || !axhost->m_spInPlaceObject)
+        return;
+
+    AX_DEBUG(Deactivating in-place object);
+    axhost->m_spInPlaceObject->UIDeactivate();
+}
+
+
+void QAxHostWidget::paintEvent(QPaintEvent*)
+{
+    if (!QPainter::redirected(this))
+        return;
+
+    IViewObject *view = 0;
+    if (axhost)
+        axhost->widget->queryInterface(IID_IViewObject, (void**)&view);
+    if (!view)
+        return;
+
+    // somebody tries to grab us!
+    QPixmap pm(size());
+    pm.fill();
+
+    HBITMAP hBmp = pm.toWinHBITMAP();
+    HDC hBmp_hdc = CreateCompatibleDC(qt_win_display_dc());
+    HGDIOBJ old_hBmp = SelectObject(hBmp_hdc, hBmp);
+
+    RECTL bounds;
+    bounds.left = 0;
+    bounds.right = pm.width();
+    bounds.top = 0;
+    bounds.bottom = pm.height();
+
+    view->Draw(DVASPECT_CONTENT, -1, 0, 0, 0, hBmp_hdc, &bounds, 0, 0 /*fptr*/, 0);
+    view->Release();
+
+    QPainter painter(this);
+    painter.drawPixmap(0, 0, QPixmap::fromWinHBITMAP(hBmp));
+
+    SelectObject(hBmp_hdc, old_hBmp);
+    DeleteObject(hBmp);
+    DeleteDC(hBmp_hdc);
+}
+
+/*!
+    \class QAxWidget
+    \brief The QAxWidget class is a QWidget that wraps an ActiveX control.
+
+    \inmodule QAxContainer
+
+    A QAxWidget can be instantiated as an empty object, with the name
+    of the ActiveX control it should wrap, or with an existing
+    interface pointer to the ActiveX control. The ActiveX control's
+    properties, methods and events which only use QAxBase
+    supported data types, become available as Qt properties,
+    slots and signals. The base class QAxBase provides an API to
+    access the ActiveX directly through the \c IUnknown pointer.
+
+    QAxWidget is a QWidget and can mostly be used as such, e.g. it can be
+    organized in a widget hierarchy and layouts or act as an event filter.
+    Standard widget properties, e.g. \link QWidget::enabled
+    enabled \endlink are supported, but it depends on the ActiveX
+    control to implement support for ambient properties like e.g.
+    palette or font. QAxWidget tries to provide the necessary hints.
+
+    However, you cannot reimplement Qt-specific event handlers like
+    mousePressEvent or keyPressEvent and expect them to be called reliably.
+    The embedded control covers the QAxWidget completely, and usually
+    handles the user interface itself. Use control-specific APIs (i.e. listen
+    to the signals of the control), or use standard COM techniques like
+    window procedure subclassing.
+
+    QAxWidget also inherits most of its ActiveX-related functionality
+    from QAxBase, notably dynamicCall() and querySubObject().
+
+    \warning
+    You can subclass QAxWidget, but you cannot use the \c Q_OBJECT macro
+    in the subclass (the generated moc-file will not compile), so you
+    cannot add further signals, slots or properties. This limitation
+    is due to the metaobject information generated in runtime. To work
+    around this problem, aggregate the QAxWidget as a member of the
+    QObject subclass.
+
+    \sa QAxBase, QAxObject, QAxScript, {ActiveQt Framework}
+*/
+
+/*!
+    Creates an empty QAxWidget widget and propagates \a parent
+    and \a f to the QWidget constructor. To initialize a control,
+    call setControl().
+*/
+QAxWidget::QAxWidget(QWidget *parent, Qt::WindowFlags f)
+: QWidget(parent, f), container(0)
+{
+}
+
+/*!
+    Creates an QAxWidget widget and initializes the ActiveX control \a c.
+    \a parent and \a f are propagated to the QWidget contructor.
+
+    \sa setControl()
+*/
+QAxWidget::QAxWidget(const QString &c, QWidget *parent, Qt::WindowFlags f)
+: QWidget(parent, f), container(0)
+{
+    setControl(c);
+}
+
+/*!
+    Creates a QAxWidget that wraps the COM object referenced by \a iface.
+    \a parent and \a f are propagated to the QWidget contructor.
+*/
+QAxWidget::QAxWidget(IUnknown *iface, QWidget *parent, Qt::WindowFlags f)
+: QWidget(parent, f), QAxBase(iface), container(0)
+{
+}
+
+/*!
+    Shuts down the ActiveX control and destroys the QAxWidget widget,
+    cleaning up all allocated resources.
+
+    \sa clear()
+*/
+QAxWidget::~QAxWidget()
+{
+    if (container)
+        container->reset(this);
+    clear();
+}
+
+/*!
+    \since 4.2
+
+    Calls QAxBase::initialize(\a ptr), and embeds the control in this
+    widget by calling createHostWindow(false) if successful.
+
+    To initialize the control before it is activated, reimplement this
+    function and add your initialization code before you call
+    createHostWindow(true).
+*/
+bool QAxWidget::initialize(IUnknown **ptr)
+{
+    if (!QAxBase::initialize(ptr))
+        return false;
+
+    return createHostWindow(false); // assume that control is not initialized
+}
+
+/*!
+    Creates the client site for the ActiveX control, and returns true if
+    the control could be embedded successfully, otherwise returns false.
+    If \a initialized is true the control has already been initialized.
+
+    This function is called by initialize(). If you reimplement initialize
+    to customize the actual control instantiation, call this function in your
+    reimplementation to have the control embedded by the default client side.
+    Creates the client site for the ActiveX control, and returns true if
+    the control could be embedded successfully, otherwise returns false.
+*/
+bool QAxWidget::createHostWindow(bool initialized)
+{
+    return createHostWindow(initialized, QByteArray());
+}
+
+/*!
+    \since 4.4
+
+    Creates the client site for the ActiveX control, and returns true if
+    the control could be embedded successfully, otherwise returns false.
+    If \a initialized is false the control will be initialized using the
+    \a data. The control will be initialized through either IPersistStreamInit
+    or IPersistStorage interface.
+
+    If the control needs to be initialized using custom data, call this function
+    in your reimplementation of initialize(). This function is not called by
+    the  default implementation of initialize().
+*/
+bool QAxWidget::createHostWindow(bool initialized, const QByteArray &data)
+{
+#ifdef QT3_SUPPORT
+    QApplication::sendPostedEvents(0, QEvent::ChildInserted);
+#endif
+
+    container = new QAxClientSite(this);
+    container->activateObject(initialized, data);
+
+#if !defined(Q_OS_WINCE)
+    ATOM filter_ref = FindAtomA(qaxatom);
+#endif
+    if (!filter_ref)
+        previous_filter = QAbstractEventDispatcher::instance()->setEventFilter(axc_FilterProc);
+#if !defined(Q_OS_WINCE)
+    AddAtomA(qaxatom);
+#else
+    ++filter_ref;
+#endif
+
+    if (parentWidget())
+        QApplication::postEvent(parentWidget(), new QEvent(QEvent::LayoutRequest));
+
+    return true;
+}
+
+/*!
+    Reimplement this function when you want to implement additional
+    COM interfaces for the client site of the ActiveX control, or when
+    you want to provide alternative implementations of COM interfaces.
+    Return a new object of a QAxAggregated subclass.
+
+    The default implementation returns the null pointer.
+*/
+QAxAggregated *QAxWidget::createAggregate()
+{
+    return 0;
+}
+
+/*!
+    \reimp
+
+    Shuts down the ActiveX control.
+*/
+void QAxWidget::clear()
+{
+    if (isNull())
+        return;
+    if (!control().isEmpty()) {
+#if !defined(Q_OS_WINCE)
+        ATOM filter_ref = FindAtomA(qaxatom);
+        if (filter_ref)
+            DeleteAtom(filter_ref);
+        filter_ref = FindAtomA(qaxatom);
+        if (!filter_ref) {
+#else
+        if (!filter_ref && !--filter_ref) {
+#endif
+            QAbstractEventDispatcher::instance()->setEventFilter(previous_filter);
+            previous_filter = 0;
+        }
+    }
+
+    if (container)
+        container->deactivate();
+
+    QAxBase::clear();
+    setFocusPolicy(Qt::NoFocus);
+
+    if (container) {
+        container->releaseAll();
+        container->Release();
+    }
+    container = 0;
+}
+
+/*!
+    \since 4.1
+
+    Requests the ActiveX control to perform the action \a verb. The
+    possible verbs are returned by verbs().
+
+    The function returns true if the object could perform the action, otherwise returns false.
+*/
+bool QAxWidget::doVerb(const QString &verb)
+{
+    if (!verbs().contains(verb))
+        return false;
+
+    HRESULT hres = container->doVerb(indexOfVerb(verb));
+
+    return hres == S_OK;
+}
+
+ /*!
+    \fn QObject *QAxWidget::qObject() const
+    \internal
+*/
+
+/*!
+    \reimp
+*/
+const QMetaObject *QAxWidget::metaObject() const
+{
+    return QAxBase::metaObject();
+}
+
+/*!
+    \reimp
+*/
+const QMetaObject *QAxWidget::parentMetaObject() const
+{
+    return &QWidget::staticMetaObject;
+}
+
+/*!
+    \internal
+*/
+void *QAxWidget::qt_metacast(const char *cname)
+{
+    if (!qstrcmp(cname, "QAxWidget")) return (void*)this;
+    if (!qstrcmp(cname, "QAxBase")) return (QAxBase*)this;
+    return QWidget::qt_metacast(cname);
+}
+
+/*!
+    \reimp
+*/
+const char *QAxWidget::className() const
+{
+    return "QAxWidget";
+}
+
+/*!
+    \reimp
+*/
+int QAxWidget::qt_metacall(QMetaObject::Call call, int id, void **v)
+{
+    id = QWidget::qt_metacall(call, id, v);
+    if (id < 0)
+        return id;
+    return QAxBase::qt_metacall(call, id, v);
+}
+
+/*!
+    \reimp
+*/
+QSize QAxWidget::sizeHint() const
+{
+    if (container) {
+        QSize sh = container->sizeHint();
+        if (sh.isValid())
+            return sh;
+    }
+
+    return QWidget::sizeHint();
+}
+
+/*!
+    \reimp
+*/
+QSize QAxWidget::minimumSizeHint() const
+{
+    if (container) {
+        QSize sh = container->minimumSizeHint();
+        if (sh.isValid())
+            return sh;
+    }
+
+    return QWidget::minimumSizeHint();
+}
+
+/*!
+    \reimp
+*/
+void QAxWidget::changeEvent(QEvent *e)
+{
+    if (isNull())
+        return;
+
+    switch (e->type()) {
+    case QEvent::EnabledChange:
+        container->emitAmbientPropertyChange(DISPID_AMBIENT_UIDEAD);
+        break;
+    case QEvent::FontChange:
+        container->emitAmbientPropertyChange(DISPID_AMBIENT_FONT);
+        break;
+    case QEvent::PaletteChange:
+        container->emitAmbientPropertyChange(DISPID_AMBIENT_BACKCOLOR);
+        container->emitAmbientPropertyChange(DISPID_AMBIENT_FORECOLOR);
+        break;
+    case QEvent::ActivationChange:
+        container->windowActivationChange();
+        break;
+    default:
+        break;
+    }
+}
+
+/*!
+    \reimp
+*/
+void QAxWidget::resizeEvent(QResizeEvent *)
+{
+    if (container)
+        container->resize(size());
+}
+
+/*!
+    \reimp
+*/
+void QAxWidget::connectNotify(const char *)
+{
+    QAxBase::connectNotify();
+}
+
+
+/*!
+    Reimplement this function to pass certain key events to the
+    ActiveX control. \a message is the Window message identifier
+    specifying the message type (ie. WM_KEYDOWN), and \a keycode is
+    the virtual keycode (ie. VK_TAB).
+
+    If the function returns true the key event is passed on to the
+    ActiveX control, which then either processes the event or passes
+    the event on to Qt.
+
+    If the function returns false the processing of the key event is
+    ignored by ActiveQt, ie. the ActiveX control might handle it or
+    not.
+
+    The default implementation returns true for the following cases:
+
+    \table
+    \header
+    \i WM_SYSKEYDOWN
+    \i WM_SYSKEYUP
+    \i WM_KEYDOWN
+    \row
+    \i All keycodes
+    \i VK_MENU
+    \i VK_TAB, VK_DELETE and all non-arrow-keys in combination with VK_SHIFT,
+       VK_CONTROL or VK_MENU
+    \endtable
+
+    This table is the result of experimenting with popular ActiveX controls,
+    ie. Internet Explorer and Microsoft Office applications, but for some
+    controls it might require modification.
+*/
+bool QAxWidget::translateKeyEvent(int message, int keycode) const
+{
+    bool translate = false;
+
+    switch (message) {
+    case WM_SYSKEYDOWN:
+        translate = true;
+        break;
+    case WM_KEYDOWN:
+        translate = keycode == VK_TAB
+            || keycode == VK_DELETE;
+        if (!translate) {
+            int state = 0;
+            if (GetKeyState(VK_SHIFT) < 0)
+                state |= 0x01;
+            if (GetKeyState(VK_CONTROL) < 0)
+                state |= 0x02;
+            if (GetKeyState(VK_MENU) < 0)
+                state |= 0x04;
+            if (state) {
+                state = keycode < VK_LEFT || keycode > VK_DOWN;
+            }
+            translate = state;
+        }
+        break;
+    case WM_SYSKEYUP:
+        translate = keycode == VK_MENU;
+        break;
+    }
+
+    return translate;
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/container/qaxwidget.h b/src/activeqt/container/qaxwidget.h
new file mode 100644
index 0000000..e07caad
--- /dev/null
+++ b/src/activeqt/container/qaxwidget.h
@@ -0,0 +1,125 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXWIDGET_H
+#define QAXWIDGET_H
+
+#include <ActiveQt/qaxbase.h>
+#include <QtGui/qwidget.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+class QAxHostWindow;
+class QAxAggregated;
+
+class QAxClientSite;
+
+class QAxWidget : public QWidget, public QAxBase
+{
+public:
+    const QMetaObject *metaObject() const;
+    void* qt_metacast(const char*);
+    int qt_metacall(QMetaObject::Call, int, void **);
+    QObject* qObject() const { return (QWidget*)this; }
+    const char *className() const;
+    
+    QAxWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
+    QAxWidget(const QString &c, QWidget *parent = 0, Qt::WindowFlags f = 0);
+    QAxWidget(IUnknown *iface, QWidget *parent = 0, Qt::WindowFlags f = 0);
+    ~QAxWidget();
+    
+    void clear();
+    bool doVerb(const QString &verb);
+
+    QSize sizeHint() const;
+    QSize minimumSizeHint() const;
+
+    virtual QAxAggregated *createAggregate();
+
+protected:
+    bool initialize(IUnknown**);
+    virtual bool createHostWindow(bool);
+    bool createHostWindow(bool, const QByteArray&);
+    
+    void changeEvent(QEvent *e);
+    void resizeEvent(QResizeEvent *);
+
+    virtual bool translateKeyEvent(int message, int keycode) const;
+
+    void connectNotify(const char *signal);
+private:
+    friend class QAxClientSite;
+    QAxClientSite *container;
+    
+    const QMetaObject *parentMetaObject() const;
+    static QMetaObject staticMetaObject;
+};
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QAxWidget *qobject_cast_helper<QAxWidget*>(const QObject *o, QAxWidget *)
+#else
+template <> inline QAxWidget *qobject_cast<QAxWidget*>(const QObject *o)
+#endif
+{
+    void *result = o ? const_cast<QObject *>(o)->qt_metacast("QAxWidget") : 0;
+    return (QAxWidget*)(result);
+}
+
+#if defined Q_CC_MSVC && _MSC_VER < 1300
+template <> inline QAxWidget *qobject_cast_helper<QAxWidget*>(QObject *o, QAxWidget *)
+#else
+template <> inline QAxWidget *qobject_cast<QAxWidget*>(QObject *o)
+#endif
+{
+    void *result = o ? o->qt_metacast("QAxWidget") : 0;
+    return (QAxWidget*)(result);
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXWIDGET_H
diff --git a/src/activeqt/control/control.pro b/src/activeqt/control/control.pro
new file mode 100644
index 0000000..65b0251
--- /dev/null
+++ b/src/activeqt/control/control.pro
@@ -0,0 +1,43 @@
+TEMPLATE = lib
+
+TARGET   = ActiveQt
+CONFIG += qt_install_headers
+SYNCQT.HEADER_FILES = qaxaggregated.h qaxbindable.h qaxfactory.h
+SYNCQT.HEADER_CLASSES = ../../../include/ActiveQt/QAxAggregated ../../../include/ActiveQt/QAxBindable ../../../include/ActiveQt/QAxFactory ../../../include/ActiveQt/QAxClass 
+include(../../qt_install.pri)
+
+TARGET   = QAxServer
+
+!debug_and_release|build_pass {
+   CONFIG(debug, debug|release) {
+      TARGET = $$member(TARGET, 0)d
+   }
+}
+
+CONFIG  += qt warn_off staticlib
+QTDIR_build:DESTDIR  = $$QT_BUILD_TREE\lib
+
+DEFINES	+= QAX_SERVER
+win32-g++:DEFINES += QT_NEEDS_QMAIN
+win32-borland:DEFINES += QT_NEEDS_QMAIN
+
+LIBS    += -luser32 -lole32 -loleaut32 -lgdi32
+win32-g++:LIBS += -luuid
+
+contains(QT_EDITION, OpenSource|Console) {
+    message( "You are not licensed to use ActiveQt." )
+} else {
+    HEADERS     = qaxaggregated.h \
+                  qaxbindable.h \
+		  qaxfactory.h \
+		  ../shared/qaxtypes.h
+
+    SOURCES     = qaxserver.cpp \
+		  qaxserverbase.cpp \
+		  qaxbindable.cpp \
+		  qaxfactory.cpp \
+		  qaxservermain.cpp \
+		  qaxserverdll.cpp \
+		  qaxmain.cpp \
+		  ../shared/qaxtypes.cpp
+}
diff --git a/src/activeqt/control/qaxaggregated.h b/src/activeqt/control/qaxaggregated.h
new file mode 100644
index 0000000..3e6ce44
--- /dev/null
+++ b/src/activeqt/control/qaxaggregated.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXAGGREGATED_H
+#define QAXAGGREGATED_H
+
+#include <QtCore/qobject.h>
+
+struct IUnknown;
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+struct QUuid;
+
+class QAxAggregated
+{
+    friend class QAxServerBase;
+    friend class QAxClientSite;
+public:
+    virtual long queryInterface(const QUuid &iid, void **iface) = 0;
+
+protected:
+    virtual ~QAxAggregated()
+    {}
+
+    inline IUnknown *controllingUnknown() const
+    { return controlling_unknown; }
+    inline QWidget *widget() const 
+    {
+        return qobject_cast<QWidget*>(the_object);
+    }
+    inline QObject *object() const { return the_object; }
+
+private:
+    IUnknown *controlling_unknown;
+    QObject *the_object;
+};
+
+#define QAXAGG_IUNKNOWN \
+    HRESULT WINAPI QueryInterface(REFIID iid, LPVOID *iface) { \
+    return controllingUnknown()->QueryInterface(iid, iface); } \
+    ULONG WINAPI AddRef() {return controllingUnknown()->AddRef(); } \
+    ULONG WINAPI Release() {return controllingUnknown()->Release(); } \
+
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QAXAGGREGATED_H
diff --git a/src/activeqt/control/qaxbindable.cpp b/src/activeqt/control/qaxbindable.cpp
new file mode 100644
index 0000000..b2e1a49
--- /dev/null
+++ b/src/activeqt/control/qaxbindable.cpp
@@ -0,0 +1,324 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include "qaxbindable.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qmetaobject.h>
+
+#include <qt_windows.h> // for IUnknown
+#include "../shared/qaxtypes.h"
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \class QAxBindable
+    \brief The QAxBindable class provides an interface between a
+    QWidget and an ActiveX client.
+
+    \inmodule QAxServer
+
+    The functions provided by this class allow an ActiveX control to
+    communicate property changes to a client application. Inherit
+    your control class from both QWidget (directly or indirectly) and
+    this class to get access to this class's functions. The
+    \l{moc}{meta-object compiler} requires you to inherit from
+    QWidget first.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxbindable.cpp 0
+
+    When implementing the property write function, use
+    requestPropertyChange() to get permission from the ActiveX client
+    application to change this property. When the property changes,
+    call propertyChanged() to notify the ActiveX client application
+    about the change. If a fatal error occurs in the control, use the
+    static reportError() function to notify the client.
+
+    Use the interface returned by clientSite() to call the ActiveX
+    client. To implement additional COM interfaces in your ActiveX
+    control, reimplement createAggregate() to return a new object of a
+    QAxAggregated subclass.
+
+    The ActiveQt \l{activeqt/opengl}{OpenGL} example shows how to use
+    QAxBindable to implement additional COM interfaces.
+
+    \sa QAxAggregated, QAxFactory, {ActiveQt Framework}
+*/
+
+/*!
+    Constructs an empty QAxBindable object.
+*/
+QAxBindable::QAxBindable()
+:activex(0)
+{
+}
+
+/*!
+    Destroys the QAxBindable object.
+*/
+QAxBindable::~QAxBindable()
+{
+}
+
+/*!
+    Call this function to request permission to change the property
+    \a property from the client that is hosting this ActiveX control.
+    Returns true if the client allows the change; otherwise returns
+    false.
+
+    This function is usually called first in the write function for \a
+    property, and writing is abandoned if the function returns false.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxbindable.cpp 1
+
+    \sa propertyChanged()
+*/
+bool QAxBindable::requestPropertyChange(const char *property)
+{
+    if (!activex)
+        return true;
+
+    return activex->emitRequestPropertyChange(property);
+}
+
+/*!
+    Call this function to notify the client that is hosting this
+    ActiveX control that the property \a property has been changed.
+
+    This function is usually called at the end of the property's write
+    function.
+
+    \sa requestPropertyChange()
+*/
+void QAxBindable::propertyChanged(const char *property)
+{
+    if (!activex)
+        return;
+
+    activex->emitPropertyChanged(property);
+}
+
+/*!
+    Returns a pointer to the client site interface for this ActiveX object,
+    or null if no client site has been set.
+
+    Call \c QueryInterface() on the returned interface to get the
+    interface you want to call.
+*/
+IUnknown *QAxBindable::clientSite() const
+{
+    if (!activex)
+        return 0;
+
+    return activex->clientSite();
+}
+
+/*!
+    Reimplement this function when you want to implement additional
+    COM interfaces in the ActiveX control, or when you want to provide
+    alternative implementations of COM interfaces. Return a new object
+    of a QAxAggregated subclass.
+
+    The default implementation returns the null pointer.
+*/
+QAxAggregated *QAxBindable::createAggregate()
+{
+    return 0;
+}
+
+/*!
+    Reports an error to the client application. \a code is a
+    control-defined error code. \a desc is a human-readable description
+    of the error intended for the application user. \a src is the name
+    of the source for the error, typically the ActiveX server name. \a
+    context can be the location of a help file with more information
+    about the error. If \a context ends with a number in brackets,
+    e.g. [12], this number will be interpreted as the context ID in
+    the help file.
+*/
+void QAxBindable::reportError(int code, const QString &src, const QString &desc, const QString &context)
+{
+    if (!activex)
+        return;
+
+    activex->reportError(code, src, desc, context);
+}
+
+/*!
+    \since 4.1
+
+    If the COM object supports a MIME type then this function is called
+    to initialize the COM object from the data \a source in \a format.
+    You have to open \a source for reading before you can read from it.
+
+    Returns true to indicate success. If the function returns false,
+    then ActiveQt will process the data by setting the properties
+    through the meta object system.
+
+    If you reimplement this function you also have to implement
+    writeData().  The default implementation does nothing and returns
+    false.
+
+    \warning ActiveX controls embedded in HTML can use either the 
+    \c type and \c data attribute of the \c object tag to read data,
+    or use a list of \c param tags to initialize properties. If
+    \c param tags are used, then Internet Explorer will ignore the
+    \c data attribute, and readData will not be called.
+
+    \sa writeData()
+*/
+bool QAxBindable::readData(QIODevice *source, const QString &format)
+{
+    Q_UNUSED(source);
+    Q_UNUSED(format);
+    return false;
+}
+
+/*!
+    \since 4.1
+
+    If the COM object supports a MIME type then this function is called
+    to store the COM object into \a sink.
+    You have to open \a sink for writing before you can write to it.
+
+    Returns true to indicate success. If the function returns false,
+    then ActiveQt will serialize the object by storing the property
+    values.
+
+    If you reimplement this function you also have to implement
+    readData(). The default implementation does nothing and returns
+    false.
+
+    \sa readData()
+*/
+bool QAxBindable::writeData(QIODevice *sink)
+{
+    Q_UNUSED(sink);
+    return false;
+}
+
+/*!
+    \class QAxAggregated
+    \brief The QAxAggregated class is an abstract base class for implementations of
+    additional COM interfaces.
+
+    \inmodule QAxServer
+
+    Create a subclass of QAxAggregated and reimplement
+    queryInterface() to support additional COM interfaces. Use
+    multiple inheritance from those COM interfaces. Implement the
+    IUnknown interface of those COM interfaces by delegating the
+    calls to \c QueryInterface(), \c AddRef() and \c Release() to the
+    interface provided by controllingUnknown().
+
+    Use the widget() method if you need to make calls to the QWidget
+    implementing the ActiveX control. You must not store that pointer
+    in your subclass (unless you use QPointer), as the QWidget can
+    be destroyed by the ActiveQt framework at any time.
+
+    \sa QAxBindable, QAxFactory, {ActiveQt Framework}
+*/
+
+/*!
+    \fn QAxAggregated::~QAxAggregated()
+
+    The destructor is called internally by Qt.
+*/
+
+/*!
+    \fn long QAxAggregated::queryInterface(const QUuid &iid, void **iface)
+
+    Reimplement this pure virtual function to support additional COM
+    interfaces. Set the value of \a iface to point to this object to
+    support the interface \a iid. Note that you must cast the \c
+    this pointer to the appropriate superclass.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxbindable.cpp 2
+
+    Return the standard COM results \c S_OK (interface is supported)
+    or \c E_NOINTERFACE (requested interface is not supported).
+
+    \warning
+    Even though you must implement the \c IUnknown interface if you
+    implement any COM interface you must not support the \c IUnknown
+    interface in your queryInterface() implementation.
+*/
+
+/*!
+    \fn IUnknown *QAxAggregated::controllingUnknown() const
+
+    Returns the \c IUnknown interface of the ActiveX control. Implement
+    the \c IUnknown interface in your QAxAggregated subclass to
+    delegate calls to \c QueryInterface(), \c AddRef(), and \c
+    Release() to the interface provided by this function.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxbindable.cpp 3
+
+    Instead of declaring and implementing these three functions
+    manually, you can use the \c QAXAGG_IUNKNOWN macro in the class
+    declaration of your subclass.
+*/
+
+/*!
+    \fn QObject *QAxAggregated::object() const
+
+    Returns a pointer to the QObject subclass implementing the COM object.
+    This function might return 0.
+
+    \warning
+    You must not store the returned pointer, unless you use a
+    QPointer, since the QObject can be destroyed by ActiveQt at any
+    time.
+*/
+
+/*!
+    \fn QWidget *QAxAggregated::widget() const
+
+    Returns a pointer to the QWidget subclass implementing the ActiveX control.
+    This function might return 0.
+
+    \warning
+    You must not store the returned pointer, unless you use a
+    QPointer, since the QWidget can be destroyed by ActiveQt at any
+    time.
+*/
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/control/qaxbindable.h b/src/activeqt/control/qaxbindable.h
new file mode 100644
index 0000000..d3fd07a
--- /dev/null
+++ b/src/activeqt/control/qaxbindable.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXBINDABLE_H
+#define QAXBINDABLE_H
+
+#include <QtGui/qwidget.h>
+
+struct IUnknown;
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+class QAxAggregated;
+class QIODevice;
+struct IAxServerBase;
+
+class QAxBindable
+{
+    friend class QAxServerBase;
+public:
+    QAxBindable();
+    virtual ~QAxBindable();
+
+    virtual QAxAggregated *createAggregate();
+    void reportError(int code, const QString &src, const QString &desc, const QString &help = QString());
+
+    virtual bool readData(QIODevice *source, const QString &format);
+    virtual bool writeData(QIODevice *sink);
+
+protected:
+    bool requestPropertyChange(const char *property);
+    void propertyChanged(const char *property);
+
+    IUnknown *clientSite() const;
+
+private:
+    IAxServerBase *activex;
+};
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXBINDABLE_H
diff --git a/src/activeqt/control/qaxfactory.cpp b/src/activeqt/control/qaxfactory.cpp
new file mode 100644
index 0000000..ec72c830
--- /dev/null
+++ b/src/activeqt/control/qaxfactory.cpp
@@ -0,0 +1,591 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include "qaxfactory.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qfile.h>
+#include <qfileinfo.h>
+#include <qmetaobject.h>
+#include <qsettings.h>
+#include <qwidget.h>
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+extern char qAxModuleFilename[MAX_PATH];
+
+/*!
+    \class QAxFactory
+    \brief The QAxFactory class defines a factory for the creation of COM components.
+
+    \inmodule QAxServer
+
+    Implement this factory once in your COM server to provide information
+    about the components the server can create. Subclass QAxFactory and implement
+    the pure virtual functions in any implementation file (e.g. main.cpp), and export
+    the factory using the \c QAXFACTORY_EXPORT() macro.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 0
+
+    If you use the \c Q_CLASSINFO() macro to provide the unique
+    identifiers or other attributes for your class you can use the \c
+    QAXFACTORY_BEGIN(), \c QAXCLASS() and \c QAXFACTORY_END() macros to
+    expose one or more classes as COM objects.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 1
+
+
+    If your server supports just a single COM object, you can use
+    a default factory implementation through the \c QAXFACTORY_DEFAULT() macro.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 2
+
+    Only one QAxFactory implementation may be instantiated and
+    exported by an ActiveX server application. This instance is accessible
+    through the global qAxFactory() function.
+
+    A factory can also reimplement the registerClass() and
+    unregisterClass() functions to set additional flags for an ActiveX
+    control in the registry. To limit the number of methods or
+    properties a widget class exposes from its parent classes
+    reimplement exposeToSuperClass().
+
+    \sa QAxAggregated, QAxBindable, {ActiveQt Framework}
+*/
+
+/*!
+    Constructs a QAxFactory object that returns \a libid and \a appid
+    in the implementation of the respective interface functions.
+*/
+
+QAxFactory::QAxFactory(const QUuid &libid, const QUuid &appid)
+: typelib(libid), app(appid)
+{
+}
+
+/*!
+    Destroys the QAxFactory object.
+*/
+QAxFactory::~QAxFactory()
+{
+}
+
+/*!
+    \fn QUuid QAxFactory::typeLibID() const
+
+    Reimplement this function to return the ActiveX server's type
+    library identifier.
+*/
+QUuid QAxFactory::typeLibID() const
+{
+    return typelib;
+}
+
+/*!
+    \fn QUuid QAxFactory::appID() const
+
+    Reimplement this function to return the ActiveX server's
+    application identifier.
+*/
+QUuid QAxFactory::appID() const
+{
+    return app;
+}
+
+/*!
+    \fn QStringList QAxFactory::featureList() const
+
+    Reimplement this function to return a list of the widgets (class
+    names) supported by this factory.
+*/
+
+/*!
+    \fn QObject *QAxFactory::createObject(const QString &key)
+
+    Reimplement this function to return a new object for \a key, or 0 if
+    this factory doesn't support the value of \a key.
+
+    If the object returned is a QWidget it will be exposed as an ActiveX
+    control, otherwise the returned object will be exposed as a simple COM
+    object.
+*/
+
+/*!
+    \fn const QMetaObject *QAxFactory::metaObject(const QString &key) const
+
+    Reimplement this function to return the QMetaObject corresponding to
+    \a key, or 0 if this factory doesn't support the value of \a key.
+*/
+
+/*!
+    \fn bool QAxFactory::createObjectWrapper(QObject *object, IDispatch **wrapper)
+
+    Reimplement this function to provide the COM object for \a object
+    in \a wrapper. Return true if the function was successful; otherwise
+    return false.
+
+    The default implementation creates a generic automation wrapper based
+    on the meta object information of \a object.
+*/
+// implementation in qaxserverbase.cpp
+
+/*!
+    Reimplement this function to return the class identifier for each
+    \a key returned by the featureList() implementation, or an empty
+    QUuid if this factory doesn't support the value of \a key.
+
+    The default implementation interprets \a key as the class name,
+    and returns the value of the Q_CLASSINFO() entry "ClassID".
+*/
+QUuid QAxFactory::classID(const QString &key) const
+{
+    const QMetaObject *mo = metaObject(key);
+    if (!mo)
+        return QUuid();
+    QString id = QString::fromLatin1(mo->classInfo(mo->indexOfClassInfo("ClassID")).value());
+
+    return QUuid(id);
+}
+
+/*!
+    Reimplement this function to return the interface identifier for
+    each \a key returned by the featureList() implementation, or an
+    empty QUuid if this factory doesn't support the value of \a key.
+
+    The default implementation interprets \a key as the class name,
+    and returns the value of the Q_CLASSINFO() entry "InterfaceID".
+*/
+QUuid QAxFactory::interfaceID(const QString &key) const
+{
+    const QMetaObject *mo = metaObject(key);
+    if (!mo)
+        return QUuid();
+    QString id = QString::fromLatin1(mo->classInfo(mo->indexOfClassInfo("InterfaceID")).value());
+
+    return QUuid(id);
+}
+
+/*!
+    Reimplement this function to return the identifier of the event
+    interface for each \a key returned by the featureList()
+    implementation, or an empty QUuid if this factory doesn't support
+    the value of \a key.
+
+    The default implementation interprets \a key as the class name,
+    and returns the value of the Q_CLASSINFO() entry "EventsID".
+*/
+QUuid QAxFactory::eventsID(const QString &key) const
+{
+    const QMetaObject *mo = metaObject(key);
+    if (!mo)
+        return QUuid();
+    QString id = QString::fromLatin1(mo->classInfo(mo->indexOfClassInfo("EventsID")).value());
+
+    return QUuid(id);
+}
+
+/*!
+    Registers additional values for the class \a key in the system
+    registry using the \a settings object. The standard values have
+    already been registered by the framework, but additional values,
+    e.g. implemented categories, can be added in an implementation of
+    this function.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 3
+
+    If you reimplement this function you must also reimplement
+    unregisterClass() to remove the additional registry values.
+
+    \sa QSettings
+*/
+void QAxFactory::registerClass(const QString &key, QSettings *settings) const
+{
+    Q_UNUSED(key);
+    Q_UNUSED(settings)
+}
+
+/*!
+    Unregisters any additional values for the class \a key from the
+    system registry using the \a settings object.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 4
+
+    \sa registerClass(), QSettings
+*/
+void QAxFactory::unregisterClass(const QString &key, QSettings *settings) const
+{
+    Q_UNUSED(key);
+    Q_UNUSED(settings)
+}
+
+/*!
+    Reimplement this function to return true if \a licenseKey is a valid
+    license for the class \a key, or if the current machine is licensed.
+
+    The default implementation returns true if the class \a key is
+    not licensed (ie. no \c Q_CLASSINFO() attribute "LicenseKey"), or
+    if  \a licenseKey matches the value of the "LicenseKey"
+    attribute, or if the machine is licensed through a .LIC file with
+    the same filename as this COM server.
+*/
+bool QAxFactory::validateLicenseKey(const QString &key, const QString &licenseKey) const
+{
+    const QMetaObject *mo = metaObject(key);
+    if (!mo)
+        return true;
+
+    QString classKey = QString::fromLatin1(mo->classInfo(mo->indexOfClassInfo("LicenseKey")).value());
+    if (classKey.isEmpty())
+        return true;
+
+    if (licenseKey.isEmpty()) {
+        QString licFile(QFile::decodeName(qAxModuleFilename));
+        int lastDot = licFile.lastIndexOf(QLatin1Char('.'));
+        licFile = licFile.left(lastDot) + QLatin1String(".lic");
+        if (QFile::exists(licFile))
+            return true;
+        return false;
+    }
+    return licenseKey == classKey;
+}
+
+/*!
+    Reimplement this function to return the name of the super class of
+    \a key up to which methods and properties should be exposed by the
+    ActiveX control.
+
+    The default implementation interprets \a key as the class name,
+    and returns the value of the \c Q_CLASSINFO() entry
+    "ToSuperClass". If no such value is set the null-string is
+    returned, and the functions  and properties of all the super
+    classes including QWidget will be  exposed.
+
+    To only expose the functions and properties of the class itself,
+    reimplement this function to return \a key.
+*/
+QString QAxFactory::exposeToSuperClass(const QString &key) const
+{
+    const QMetaObject *mo = metaObject(key);
+    if (!mo)
+        return QString();
+    return QString::fromLatin1(mo->classInfo(mo->indexOfClassInfo("ToSuperClass")).value());
+}
+
+/*!
+    Reimplement this function to return true if the ActiveX control \a key
+    should be a top level window, e.g. a dialog. The default implementation
+    returns false.
+*/
+bool QAxFactory::stayTopLevel(const QString &key) const
+{
+    return false;
+}
+
+/*!
+    Reimplement this function to return true if the ActiveX control
+    \a key should support the standard ActiveX events
+    \list
+    \i Click
+    \i DblClick
+    \i KeyDown
+    \i KeyPress
+    \i KeyUp
+    \i MouseDown
+    \i MouseUp
+    \i MouseMove
+    \endlist
+
+    The default implementation interprets \a key as the class name,
+    and returns true if the value of the \c Q_CLASSINFO() entry
+    "StockEvents" is "yes". Otherwise this function returns false.
+*/
+bool QAxFactory::hasStockEvents(const QString &key) const
+{
+    const QMetaObject *mo = metaObject(key);
+    if (!mo)
+        return false;
+    return QString::fromLatin1(mo->classInfo(mo->indexOfClassInfo("StockEvents")).value()) == QLatin1String("yes");
+}
+
+
+extern bool qAxIsServer;
+
+/*!
+    Returns true if the application has been started (by COM) as an ActiveX
+    server, otherwise returns false.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 5
+*/
+
+bool QAxFactory::isServer()
+{
+    return qAxIsServer;
+}
+
+extern char qAxModuleFilename[MAX_PATH];
+
+/*!
+    Returns the directory that contains the server binary.
+
+    For out-of-process servers this is the same as
+    QApplication::applicationDirPath(). For in-process servers
+    that function returns the directory that contains the hosting
+    application.
+*/
+QString QAxFactory::serverDirPath()
+{
+    return QFileInfo(QString::fromLocal8Bit(qAxModuleFilename)).absolutePath();
+}
+
+/*!
+    Returns the file path of the server binary.
+
+    For out-of-process servers this is the same as
+    QApplication::applicationFilePath(). For in-process servers
+    that function returns the file path of the hosting application.
+*/
+QString QAxFactory::serverFilePath()
+{
+    return QString::fromLocal8Bit(qAxModuleFilename);
+}
+
+/*!
+    Reimplement this function to return true if the server is
+    running as a persistent service (e.g. an NT service) and should
+    not terminate even when all objects provided have been released.
+
+    The default implementation returns false.
+*/
+bool QAxFactory::isService() const
+{
+    return false;
+}
+
+/*!
+    \enum QAxFactory::ServerType
+
+    This enum specifies the different types of servers that can be
+    started with startServer.
+
+    \value SingleInstance The server process can create only one instance of each
+    exported class. COM starts a new process for each request. This is typically
+    used in servers that export only one creatable class.
+    \value MultipleInstances The server can create multiple instances of
+    each exported class. This is the default. All instances will live in the same
+    thread, and will share static resources.
+*/
+
+/*!
+    \fn bool QAxFactory::startServer(ServerType type);
+
+    Starts the COM server with \a type and returns true if successful,
+    otherwise returns false.
+
+    Calling this function if the server is already running (or for an
+    in-process server) does nothing and returns true.
+
+    The server is started automatically with \a type set to \c MultipleInstances
+    if the server executable has been started with the \c -activex
+    command line parameter. To switch to SingleInstance, call 
+    
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 6
+
+    in your own main() entry point function.
+*/
+
+/*!
+    \fn bool QAxFactory::stopServer();
+
+    Stops the COM server and returns true if successful, otherwise
+    returns false.
+
+    Calling this function if the server is not running (or for an
+    in-process server) does nothing and returns true.
+
+    Stopping the server will not invalidate existing objects, but no
+    new objects can be created from the existing server process. Usually
+    COM will start a new server process if additional objects are requested.
+
+    The server is stopped automatically when the main() function returns.
+*/
+
+class ActiveObject : public QObject
+{
+public:
+    ActiveObject(QObject *parent, QAxFactory *factory);
+    ~ActiveObject();
+
+    IDispatch *wrapper;
+    DWORD cookie;
+};
+
+ActiveObject::ActiveObject(QObject *parent, QAxFactory *factory)
+: QObject(parent), wrapper(0), cookie(0)
+{
+    QLatin1String key(parent->metaObject()->className());
+
+    factory->createObjectWrapper(parent, &wrapper);
+    if (wrapper)
+        RegisterActiveObject(wrapper, QUuid(factory->classID(key)), ACTIVEOBJECT_STRONG, &cookie);
+}
+
+ActiveObject::~ActiveObject()
+{
+    if (cookie)
+        RevokeActiveObject(cookie, 0);
+    if (wrapper)
+        wrapper->Release();
+}
+
+/*!
+    Registers the QObject \a object with COM as a running object, and returns true if
+    the registration succeeded, otherwise returns false. The object is unregistered
+    automatically when it is destroyed.
+
+    This function should only be called if the application has been started by the user
+    (i.e. not by COM to respond to a request), and only for one object, usually the
+    toplevel object of the application's object hierarchy.
+
+    This function does nothing and returns false if the object's class info for
+    "RegisterObject" is not set to "yes", or if the server is an in-process server.
+*/
+bool QAxFactory::registerActiveObject(QObject *object)
+{
+    if (qstricmp(object->metaObject()->classInfo(object->metaObject()->indexOfClassInfo("RegisterObject")).value(), "yes"))
+        return false;
+
+    if (!QString::fromLocal8Bit(qAxModuleFilename).toLower().endsWith(QLatin1String(".exe")))
+	return false;
+
+    ActiveObject *active = new ActiveObject(object, qAxFactory());
+    if (!active->wrapper || !active->cookie) {
+        delete active;
+        return false;
+    }
+    return true;
+}
+
+/*!
+    \macro QAXFACTORY_DEFAULT(Class, ClassID, InterfaceID, EventID, LibID, AppID)
+    \relates QAxFactory
+
+    This macro can be used to export a single QObject subclass \a Class a this
+    COM server through an implicitly declared QAxFactory implementation.
+
+    This macro exports the class \a Class as a COM coclass with the CLSID \a ClassID.
+    The properties and slots will be declared through a COM interface with the IID
+    \a InterfaceID, and signals will be declared through a COM event interface with
+    the IID \a EventID. All declarations will be in a type library with the id \a LibID,
+    and if the server is an executable server then it will have the application id
+    \a AppID.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 7
+
+    \sa QAXFACTORY_EXPORT(), QAXFACTORY_BEGIN()
+*/
+
+/*!
+    \macro QAXFACTORY_EXPORT(Class, LibID, AppID)
+    \relates QAxFactory
+
+    This macro can be used to export a QAxFactory implementation \a Class from
+    a COM server. All declarations will be in a type library with the id \a LibID,
+    and if the server is an executable server then it will have the application id
+    \a AppID.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 8
+
+    \sa QAXFACTORY_BEGIN()
+*/
+
+/*!
+    \macro QAXFACTORY_BEGIN(IDTypeLib, IDApp)
+    \relates QAxFactory
+
+    This macro can be used to export multiple QObject classes through an
+    implicitly declared QAxFactory implementation. All QObject classes have to
+    declare the ClassID, InterfaceID and EventsID (if applicable) through the
+    Q_CLASSINFO() macro. All declarations will be in a type library with the id
+    \a IDTypeLib, and if the server is an executable server then it will have the
+    application id \a IDApp.
+
+    This macro needs to be used together with the QAXCLASS(), QAXTYPE()
+    and QAXFACTORY_END() macros.
+
+    \snippet doc/src/snippets/code/src_activeqt_control_qaxfactory.cpp 9
+*/
+
+/*!
+    \macro QAXCLASS(Class)
+    \relates QAxFactory
+
+    This macro adds a creatable COM class \a Class to the QAxFactory declared
+    with the QAXFACTORY_BEGIN() macro.
+
+    \sa QAXFACTORY_BEGIN(), QAXTYPE(), QAXFACTORY_END(), Q_CLASSINFO()
+*/
+
+/*!
+    \macro QAXTYPE(Class)
+    \relates QAxFactory
+
+    This macro adds a non-creatable COM class \a Class to the QAxFactory
+    declared with the QAXFACTORY_BEGIN(). The class \a Class can be used
+    in APIs of other COM classes exported through QAXTYPE() or QAXCLASS().
+
+    Instances of type \a Class can only be retrieved using APIs of already
+    instantiated objects.
+
+    \sa QAXFACTORY_BEGIN(), QAXCLASS(), QAXFACTORY_END(), Q_CLASSINFO()
+*/
+
+/*!
+    \macro QAXFACTORY_END()
+    \relates QAxFactory
+
+    Completes the QAxFactory declaration started with the QAXFACTORY_BEGIN()
+    macro.
+
+    \sa QAXFACTORY_BEGIN(), QAXCLASS(), QAXTYPE()
+*/
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/control/qaxfactory.h b/src/activeqt/control/qaxfactory.h
new file mode 100644
index 0000000..e5bb9c1
--- /dev/null
+++ b/src/activeqt/control/qaxfactory.h
@@ -0,0 +1,310 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXFACTORY_H
+#define QAXFACTORY_H
+
+#include <QtCore/qhash.h>
+#include <QtCore/quuid.h>
+#include <QtCore/qfactoryinterface.h>
+#include <QtCore/qmetaobject.h>
+#include <QtCore/qstringlist.h>
+
+struct IUnknown;
+struct IDispatch;
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+class QWidget;
+class QSettings;
+
+class QAxFactory : public QObject
+{
+public:
+    QAxFactory(const QUuid &libId, const QUuid &appId);
+    virtual ~QAxFactory();
+    
+    virtual QStringList featureList() const = 0;
+
+    virtual QObject *createObject(const QString &key) = 0;
+    virtual const QMetaObject *metaObject(const QString &key) const = 0;
+    virtual bool createObjectWrapper(QObject *object, IDispatch **wrapper);
+    
+    virtual QUuid classID(const QString &key) const;
+    virtual QUuid interfaceID(const QString &key) const;
+    virtual QUuid eventsID(const QString &key) const;
+    
+    virtual QUuid typeLibID() const;
+    virtual QUuid appID() const;
+    
+    virtual void registerClass(const QString &key, QSettings *) const;
+    virtual void unregisterClass(const QString &key, QSettings *) const;
+    
+    virtual bool validateLicenseKey(const QString &key, const QString &licenseKey) const;
+    
+    virtual QString exposeToSuperClass(const QString &key) const;
+    virtual bool stayTopLevel(const QString &key) const;
+    virtual bool hasStockEvents(const QString &key) const;
+    virtual bool isService() const;
+    
+    enum ServerType {
+        SingleInstance,
+        MultipleInstances
+    };
+    
+    static bool isServer();
+    static QString serverDirPath();
+    static QString serverFilePath();
+    static bool startServer(ServerType type = MultipleInstances);
+    static bool stopServer();
+
+    static bool registerActiveObject(QObject *object);
+    
+private:
+    QUuid typelib;
+    QUuid app;
+};
+
+extern QAxFactory *qAxFactory();
+
+extern bool qax_startServer(QAxFactory::ServerType);
+
+inline bool QAxFactory::startServer(ServerType type)
+{
+    // implementation in qaxservermain.cpp
+    return qax_startServer(type);
+}
+
+extern bool qax_stopServer();
+
+inline bool QAxFactory::stopServer()
+{
+    // implementation in qaxservermain.cpp
+    return qax_stopServer();
+}
+
+#define QAXFACTORY_EXPORT(IMPL, TYPELIB, APPID)	\
+    QT_BEGIN_NAMESPACE \
+    QAxFactory *qax_instantiate()		\
+    {							\
+        IMPL *impl = new IMPL(QUuid(TYPELIB), QUuid(APPID));	\
+        return impl;					\
+    } \
+    QT_END_NAMESPACE
+
+#define QAXFACTORY_DEFAULT(Class, IIDClass, IIDInterface, IIDEvents, IIDTypeLib, IIDApp) \
+    QT_BEGIN_NAMESPACE \
+    class QAxDefaultFactory : public QAxFactory \
+    { \
+    public: \
+        QAxDefaultFactory(const QUuid &app, const QUuid &lib) \
+        : QAxFactory(app, lib), className(QLatin1String(#Class)) {} \
+        QStringList featureList() const \
+        { \
+            QStringList list; \
+            list << className; \
+            return list; \
+        } \
+        const QMetaObject *metaObject(const QString &key) const \
+        { \
+            if (key == className) \
+            return &Class::staticMetaObject; \
+            return 0; \
+        } \
+        QObject *createObject(const QString &key) \
+        { \
+            if (key == className) \
+                return new Class(0); \
+            return 0; \
+        } \
+        QUuid classID(const QString &key) const \
+        { \
+            if (key == className) \
+                return QUuid(IIDClass); \
+            return QUuid(); \
+        } \
+        QUuid interfaceID(const QString &key) const \
+        { \
+            if (key == className) \
+                return QUuid(IIDInterface); \
+            return QUuid(); \
+        } \
+        QUuid eventsID(const QString &key) const \
+        { \
+            if (key == className) \
+                return QUuid(IIDEvents); \
+            return QUuid(); \
+        } \
+    private: \
+        QString className; \
+    }; \
+    QT_END_NAMESPACE \
+    QAXFACTORY_EXPORT(QAxDefaultFactory, IIDTypeLib, IIDApp) \
+
+template<class T>
+class QAxClass : public QAxFactory
+{
+public:
+    QAxClass(const QString &libId, const QString &appId)
+    : QAxFactory(libId, appId)
+    {}
+    
+    const QMetaObject *metaObject(const QString &) const { return &T::staticMetaObject; }
+    QStringList featureList() const { return QStringList(QString(T::staticMetaObject.className())); }
+    QObject *createObject(const QString &key)
+    {
+        const QMetaObject &mo = T::staticMetaObject;
+        if (key != QLatin1String(mo.className()))
+            return 0;
+        if (!qstrcmp(mo.classInfo(mo.indexOfClassInfo("Creatable")).value(), "no"))
+            return 0;
+        return new T(0);
+    }
+};
+
+#define QAXFACTORY_BEGIN(IDTypeLib, IDApp) \
+    QT_BEGIN_NAMESPACE \
+    class QAxFactoryList : public QAxFactory \
+    { \
+        QStringList factoryKeys; \
+        QHash<QString, QAxFactory*> factories; \
+        QHash<QString, bool> creatable; \
+    public: \
+        QAxFactoryList() \
+        : QAxFactory(IDTypeLib, IDApp) \
+        { \
+            QAxFactory *factory = 0; \
+            QStringList keys; \
+            QStringList::Iterator it; \
+
+#define QAXCLASS(Class) \
+            factory = new QAxClass<Class>(typeLibID(), appID()); \
+            qRegisterMetaType<Class*>(#Class"*"); \
+            keys = factory->featureList(); \
+            for (it = keys.begin(); it != keys.end(); ++it) { \
+                factoryKeys += *it; \
+                factories.insert(*it, factory); \
+                creatable.insert(*it, true); \
+            }\
+
+#define QAXTYPE(Class) \
+            factory = new QAxClass<Class>(typeLibID(), appID()); \
+            qRegisterMetaType<Class*>(#Class"*"); \
+            keys = factory->featureList(); \
+            for (it = keys.begin(); it != keys.end(); ++it) { \
+                factoryKeys += *it; \
+                factories.insert(*it, factory); \
+                creatable.insert(*it, false); \
+            }\
+
+#define QAXFACTORY_END() \
+        } \
+        ~QAxFactoryList() { qDeleteAll(factories); } \
+        QStringList featureList() const {  return factoryKeys; } \
+        const QMetaObject *metaObject(const QString&key) const { \
+            QAxFactory *f = factories[key]; \
+            return f ? f->metaObject(key) : 0; \
+        } \
+        QObject *createObject(const QString &key) { \
+            if (!creatable.value(key)) \
+                return 0; \
+            QAxFactory *f = factories[key]; \
+            return f ? f->createObject(key) : 0; \
+        } \
+        QUuid classID(const QString &key) { \
+            QAxFactory *f = factories.value(key); \
+            return f ? f->classID(key) : QUuid(); \
+        } \
+        QUuid interfaceID(const QString &key) { \
+            QAxFactory *f = factories.value(key); \
+            return f ? f->interfaceID(key) : QUuid(); \
+        } \
+        QUuid eventsID(const QString &key) { \
+            QAxFactory *f = factories.value(key); \
+            return f ? f->eventsID(key) : QUuid(); \
+        } \
+        void registerClass(const QString &key, QSettings *s) const { \
+            QAxFactory *f = factories.value(key); \
+            if (f) f->registerClass(key, s); \
+        } \
+        void unregisterClass(const QString &key, QSettings *s) const { \
+            QAxFactory *f = factories.value(key); \
+            if (f) f->unregisterClass(key, s); \
+        } \
+        QString exposeToSuperClass(const QString &key) const { \
+            QAxFactory *f = factories.value(key); \
+            return f ? f->exposeToSuperClass(key) : QString(); \
+        } \
+        bool stayTopLevel(const QString &key) const { \
+            QAxFactory *f = factories.value(key); \
+            return f ? f->stayTopLevel(key) : false; \
+        } \
+        bool hasStockEvents(const QString &key) const { \
+            QAxFactory *f = factories.value(key); \
+            return f ? f->hasStockEvents(key) : false; \
+        } \
+    }; \
+    QAxFactory *qax_instantiate()		\
+    {							\
+        QAxFactoryList *impl = new QAxFactoryList();	\
+        return impl;					\
+    } \
+    QT_END_NAMESPACE
+
+QT_END_NAMESPACE
+
+#ifndef Q_COM_METATYPE_DECLARED
+#define Q_COM_METATYPE_DECLARED
+
+Q_DECLARE_METATYPE(IUnknown*)
+Q_DECLARE_METATYPE(IDispatch*)
+
+#endif
+
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXFACTORY_H
diff --git a/src/activeqt/control/qaxmain.cpp b/src/activeqt/control/qaxmain.cpp
new file mode 100644
index 0000000..27ab052
--- /dev/null
+++ b/src/activeqt/control/qaxmain.cpp
@@ -0,0 +1,54 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include <qapplication.h>
+#include <qaxfactory.h>
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+int main(int argc, char **argv)
+{
+    QT_USE_NAMESPACE
+    QAxFactory::startServer();
+    QApplication app(argc, argv);
+    app.setQuitOnLastWindowClosed(false);
+
+    return app.exec();
+}
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/control/qaxserver.cpp b/src/activeqt/control/qaxserver.cpp
new file mode 100644
index 0000000..d919382
--- /dev/null
+++ b/src/activeqt/control/qaxserver.cpp
@@ -0,0 +1,1251 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include "qaxbindable.h"
+#include "qaxfactory.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qapplication.h>
+#include <qdatetime.h>
+#include <qdir.h>
+#include <qmap.h>
+#include <qmenubar.h>
+#include <qmetaobject.h>
+#include <qsettings.h>
+#include <qvariant.h>
+#include <qtextstream.h>
+
+#include <qt_windows.h>
+#include <olectl.h>
+
+QT_BEGIN_NAMESPACE
+
+#define Q_REQUIRED_RPCNDR_H_VERSION 475
+
+// Some global variables to store module information
+bool qAxIsServer = false;
+HANDLE qAxInstance = 0;
+ITypeLib *qAxTypeLibrary = 0;
+char qAxModuleFilename[MAX_PATH];
+bool qAxOutProcServer = false;
+
+// The QAxFactory instance
+static QAxFactory* qax_factory = 0;
+extern CLSID CLSID_QRect;
+extern CLSID CLSID_QSize;
+extern CLSID CLSID_QPoint;
+extern void qax_shutDown();
+extern bool qax_ownQApp;
+
+
+extern QAxFactory *qax_instantiate();
+
+QAxFactory *qAxFactory()
+{
+    if (!qax_factory) {
+        bool hadQApp = qApp != 0;
+        qax_factory = qax_instantiate();
+        // QAxFactory created a QApplication
+        if (!hadQApp && qApp)
+            qax_ownQApp = true;
+
+        // register all types with metatype system as pointers
+        QStringList keys(qax_factory->featureList());
+        for (int i = 0; i < keys.count(); ++i) {
+            QString key(keys.at(i));
+            qRegisterMetaType((key + QLatin1String("*")).toLatin1(), (void**)0);
+        }
+    }
+    return qax_factory;
+}
+
+// Some local variables to handle module lifetime
+static unsigned long qAxModuleRef = 0;
+static CRITICAL_SECTION qAxModuleSection;
+
+
+/////////////////////////////////////////////////////////////////////////////
+// Server control
+/////////////////////////////////////////////////////////////////////////////
+
+static int initCount = 0;
+
+QString qAxInit()
+{
+    static QString libFile;
+
+    if (initCount++)
+        return libFile;
+    
+    InitializeCriticalSection(&qAxModuleSection);
+    
+    libFile = QString::fromLocal8Bit(qAxModuleFilename);
+    libFile = libFile.toLower();
+    if (LoadTypeLibEx((TCHAR*)libFile.utf16(), REGKIND_NONE, &qAxTypeLibrary) == S_OK)
+        return libFile;
+
+    int lastDot = libFile.lastIndexOf(QLatin1Char('.'));
+    libFile = libFile.left(lastDot) + QLatin1String(".tlb");
+    if (LoadTypeLibEx((TCHAR*)libFile.utf16(), REGKIND_NONE, &qAxTypeLibrary) == S_OK)
+        return libFile;
+
+    lastDot = libFile.lastIndexOf(QLatin1Char('.'));
+    libFile = libFile.left(lastDot) + QLatin1String(".olb");
+    if (LoadTypeLibEx((TCHAR*)libFile.utf16(), REGKIND_NONE, &qAxTypeLibrary) == S_OK)
+        return libFile;
+
+    libFile = QString();
+    return libFile;
+}
+
+void qAxCleanup()
+{
+    if (!initCount)
+        qWarning("qAxInit/qAxCleanup mismatch");
+    
+    if (--initCount)
+        return;
+
+    delete qax_factory;
+    qax_factory = 0;
+    
+    if (qAxTypeLibrary) {
+        qAxTypeLibrary->Release();
+        qAxTypeLibrary = 0;
+    }
+    
+    DeleteCriticalSection(&qAxModuleSection);
+}
+
+unsigned long qAxLock()
+{
+    EnterCriticalSection(&qAxModuleSection);
+    unsigned long ref = ++qAxModuleRef;
+    LeaveCriticalSection(&qAxModuleSection);
+    return ref;
+}
+
+unsigned long qAxUnlock()
+{
+    if (!initCount) // cleaned up already
+        return 0;
+
+    EnterCriticalSection(&qAxModuleSection);
+    unsigned long ref = --qAxModuleRef;
+    LeaveCriticalSection(&qAxModuleSection);
+    
+    if (!ref)
+        qax_shutDown();
+    return ref;
+}
+
+unsigned long qAxLockCount()
+{
+    return qAxModuleRef;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Registry
+/////////////////////////////////////////////////////////////////////////////
+
+extern bool qax_disable_inplaceframe;
+
+QString qax_clean_type(const QString &type, const QMetaObject *mo)
+{
+    if (mo) {
+        int classInfoIdx = mo->indexOfClassInfo("CoClassAlias");
+        if (classInfoIdx != -1) {
+            const QMetaClassInfo classInfo = mo->classInfo(classInfoIdx);
+            return QLatin1String(classInfo.value());
+        }
+    }
+
+    QString alias(type);
+    alias.remove(QLatin1String("::"));
+    return alias;
+}
+
+// (Un)Register the ActiveX server in the registry.
+// The QAxFactory implementation provides the information.
+HRESULT UpdateRegistry(BOOL bRegister)
+{
+    qAxIsServer = false;
+    QString file = QString::fromLocal8Bit(qAxModuleFilename);
+    QString path = file.left(file.lastIndexOf(QLatin1String("\\"))+1);
+    QString module = file.right(file.length() - path.length());
+    module = module.left(module.lastIndexOf(QLatin1String(".")));
+    
+    const QString appId = qAxFactory()->appID().toString().toUpper();
+    const QString libId = qAxFactory()->typeLibID().toString().toUpper();
+    
+    QString libFile = qAxInit();
+    QString typeLibVersion;
+
+    TLIBATTR *libAttr = 0;
+    if (qAxTypeLibrary)
+        qAxTypeLibrary->GetLibAttr(&libAttr);
+    if (!libAttr)
+        return SELFREG_E_TYPELIB;
+
+    DWORD major = libAttr->wMajorVerNum;
+    DWORD minor = libAttr->wMinorVerNum;
+    typeLibVersion = QString::number((uint)major) + QLatin1String(".") + QString::number((uint)minor);
+
+    if (bRegister)
+        RegisterTypeLib(qAxTypeLibrary, (TCHAR*)libFile.utf16(), 0);
+    else
+        UnRegisterTypeLib(libAttr->guid, libAttr->wMajorVerNum, libAttr->wMinorVerNum, libAttr->lcid, libAttr->syskind);
+
+    qAxTypeLibrary->ReleaseTLibAttr(libAttr);
+
+    if (typeLibVersion.isEmpty())
+        typeLibVersion = QLatin1String("1.0");
+
+    // check whether the user has permission to write to HKLM\Software\Classes
+    // if not, use HKCU\Software\Classes
+    QString keyPath(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes"));
+    QSettings test(keyPath, QSettings::NativeFormat);
+    if (!test.isWritable())
+        keyPath = QLatin1String("HKEY_CURRENT_USER\\Software\\Classes");
+
+    QSettings settings(keyPath, QSettings::NativeFormat);
+    
+    // we try to create the ActiveX widgets later on...
+    bool delete_qApp = false;
+    if (!qApp) {
+        int argc = 0;
+        (void)new QApplication(argc, 0);
+        delete_qApp = true;
+    }
+    
+    if (bRegister) {
+        if (qAxOutProcServer) {
+            settings.setValue(QLatin1String("/AppID/") + appId + QLatin1String("/."), module);
+            settings.setValue(QLatin1String("/AppID/") + module + QLatin1String(".EXE/AppID"), appId);
+        }
+
+        QStringList keys = qAxFactory()->featureList();
+        for (QStringList::Iterator key = keys.begin(); key != keys.end(); ++key) {
+            QString className = *key;
+            QObject *object = qAxFactory()->createObject(className);
+            const QMetaObject *mo = qAxFactory()->metaObject(className);
+            const QString classId = qAxFactory()->classID(className).toString().toUpper();
+
+            className = qax_clean_type(className, mo);
+
+            if (object) { // don't register subobject classes
+                QString classVersion = mo ? QString(QLatin1String(mo->classInfo(mo->indexOfClassInfo("Version")).value())) : QString();
+                if (classVersion.isNull())
+                    classVersion = QLatin1String("1.0");
+                bool insertable = mo && !qstricmp(mo->classInfo(mo->indexOfClassInfo("Insertable")).value(), "yes");
+                bool control = object->isWidgetType();
+                const QString classMajorVersion = classVersion.left(classVersion.indexOf(QLatin1String(".")));
+                uint olemisc = OLEMISC_SETCLIENTSITEFIRST
+                    |OLEMISC_ACTIVATEWHENVISIBLE
+                    |OLEMISC_INSIDEOUT
+                    |OLEMISC_CANTLINKINSIDE
+                    |OLEMISC_RECOMPOSEONRESIZE;
+                if (!control)
+                    olemisc |= OLEMISC_INVISIBLEATRUNTIME;
+                else if (qFindChild<QMenuBar*>(object) && !qax_disable_inplaceframe)
+                    olemisc |= OLEMISC_WANTSTOMENUMERGE;
+                
+                settings.setValue(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion + QLatin1String("/."), className + QLatin1String(" Class"));
+                settings.setValue(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion + QLatin1String("/CLSID/."), classId);
+                if (insertable)
+                    settings.setValue(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion + QLatin1String("/Insertable/."), QVariant(QLatin1String("")));
+                
+                settings.setValue(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String("/."), className + QLatin1String(" Class"));
+                settings.setValue(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String("/CLSID/."), classId);
+                settings.setValue(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String("/CurVer/."), module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion);
+                
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/."), className + QLatin1String(" Class"));
+                if (file.right(3).toLower() == QLatin1String("exe"))
+                    settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/AppID"), appId);
+                if (control)
+                    settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/Control/."), QVariant(QLatin1String("")));
+                if (insertable)
+                    settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/Insertable/."), QVariant(QLatin1String("")));
+                if (file.right(3).toLower() == QLatin1String("dll"))
+                    settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/InProcServer32/."), file);
+                else
+                    settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/LocalServer32/."),
+                                      QLatin1String("\"") + file + QLatin1String("\" -activex"));
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/MiscStatus/."), control ? QLatin1String("1") : QLatin1String("0"));
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/MiscStatus/1/."), QString::number(olemisc));
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/Programmable/."), QVariant(QLatin1String("")));
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/ToolboxBitmap32/."), QLatin1String("\"") +
+                                  file + QLatin1String("\", 101"));
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/TypeLib/."), libId); settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/Version/."), classVersion);
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/VersionIndependentProgID/."), module + QLatin1String(".") + className);
+                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/ProgID/."), module + QLatin1String(".") + className + QLatin1String(".") + classVersion.left(classVersion.indexOf(QLatin1Char('.'))));
+
+                QString mime = QLatin1String(mo->classInfo(mo->indexOfClassInfo("MIME")).value());
+                if (!mime.isEmpty()) {
+                    QStringList mimeTypes = mime.split(QLatin1Char(';'));
+                    for (int m = 0; m < mimeTypes.count(); ++m) {
+                        mime = mimeTypes.at(m);
+                        if (mime.isEmpty())
+                            continue;
+                        QString extension;
+                        while (mime.contains(QLatin1Char(':'))) {
+                            extension = mime.mid(mime.lastIndexOf(QLatin1Char(':')) + 1);
+                            mime = mime.left(mime.length() - extension.length() - 1);
+                            // Prepend '.' before extension, if required.
+                            extension = extension.trimmed();
+                            if (extension[0] != QChar(QLatin1Char('.')))
+                                extension = QLatin1String(".") + extension;
+                        }
+
+                        if (!extension.isEmpty()) {
+                            settings.setValue(QLatin1String("/") + extension + QLatin1String("/."), module + QLatin1String(".") + className);
+                            settings.setValue(QLatin1String("/") + extension + QLatin1String("/Content Type"), mime);
+
+                            mime = mime.replace(QLatin1String("/"), QLatin1String("\\"));
+                            settings.setValue(QLatin1String("/MIME/Database/Content Type/") + mime + QLatin1String("/CLSID"), classId);
+                            settings.setValue(QLatin1String("/MIME/Database/Content Type/") + mime + QLatin1String("/Extension"), extension);
+                        }
+                    }
+                }
+
+                delete object;
+            }
+
+            qAxFactory()->registerClass(*key, &settings);
+        }
+    } else {
+        QStringList keys = qAxFactory()->featureList();
+        for (QStringList::Iterator key = keys.begin(); key != keys.end(); ++key) {
+            QString className = *key;
+            const QMetaObject *mo = qAxFactory()->metaObject(className);
+            const QString classId = qAxFactory()->classID(className).toString().toUpper();
+            className = qax_clean_type(className, mo);
+            
+            QString classVersion = mo ? QString(QLatin1String(mo->classInfo(mo->indexOfClassInfo("Version")).value())) : QString();
+            if (classVersion.isNull())
+                classVersion = QLatin1String("1.0");
+            const QString classMajorVersion = classVersion.left(classVersion.indexOf(QLatin1String(".")));
+            
+            qAxFactory()->unregisterClass(*key, &settings);
+            
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion + QLatin1String("/CLSID/."));
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion + QLatin1String("/Insertable/."));
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion + QLatin1String("/."));
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String(".") + classMajorVersion);
+            
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String("/CLSID/."));
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String("/CurVer/."));
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className + QLatin1String("/."));
+            settings.remove(QLatin1String("/") + module + QLatin1String(".") + className);
+            
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/AppID"));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/Control/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/Insertable/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/InProcServer32/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/LocalServer32/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/MiscStatus/1/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/MiscStatus/."));	    
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/Programmable/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/ToolboxBitmap32/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/TypeLib/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/Version/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/VersionIndependentProgID/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/ProgID/."));
+            settings.remove(QLatin1String("/CLSID/") + classId + QLatin1String("/."));
+            settings.remove(QLatin1String("/CLSID/") + classId);
+
+            QString mime = QLatin1String(mo->classInfo(mo->indexOfClassInfo("MIME")).value());
+            if (!mime.isEmpty()) {
+                QStringList mimeTypes = mime.split(QLatin1Char(';'));
+                for (int m = 0; m < mimeTypes.count(); ++m) {
+                    mime = mimeTypes.at(m);
+                    if (mime.isEmpty())
+                        continue;
+                    QString extension;
+                    while (mime.contains(QLatin1Char(':'))) {
+                        extension = mime.mid(mime.lastIndexOf(QLatin1Char(':')) + 1);
+                        mime = mime.left(mime.length() - extension.length() - 1);
+                        // Prepend '.' before extension, if required.
+                        extension = extension.trimmed();
+                        if (extension[0] != QChar(QLatin1Char('.')))
+                            extension = QLatin1String(".") + extension;
+                    }
+                    if (!extension.isEmpty()) {
+                        settings.remove(QLatin1String("/") + extension + QLatin1String("/Content Type"));
+                        settings.remove(QLatin1String("/") + extension + QLatin1String("/."));
+                        settings.remove(QLatin1String("/") + extension);
+                        mime = mime.replace(QLatin1String("/"), QLatin1String("\\"));
+                        settings.remove(QLatin1String("/MIME/Database/Content Type/") + mime + QLatin1String("/Extension"));
+                        settings.remove(QLatin1String("/MIME/Database/Content Type/") + mime + QLatin1String("/CLSID"));
+                        settings.remove(QLatin1String("/MIME/Database/Content Type/") + mime + QLatin1String("/."));
+                        settings.remove(QLatin1String("/MIME/Database/Content Type/") + mime);
+                    }
+                }
+            }
+        }
+    }
+    
+    if (delete_qApp)
+        delete qApp;
+
+    qAxCleanup();
+    if (settings.status() == QSettings::NoError)
+        return S_OK;
+    return SELFREG_E_CLASS;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// IDL generator
+/////////////////////////////////////////////////////////////////////////////
+
+static QList<QByteArray> enums;
+static QList<QByteArray> enumValues;
+static QList<QByteArray> subtypes;
+
+static const char* const type_map[][2] =
+{
+    // QVariant/Qt Value data types
+    { "QString",	"BSTR" },
+    { "QCString",	"BSTR" },
+    { "bool",		"VARIANT_BOOL" },
+    { "int",		"int" },
+    { "uint",		"unsigned int" },
+    { "double",		"double" }, 
+    { "QColor",		"OLE_COLOR" },
+    { "QDate",		"DATE" },
+    { "QTime",		"DATE" },
+    { "QDateTime",	"DATE" },
+    { "QFont",		"IFontDisp*" },
+    { "QPixmap",	"IPictureDisp*" },
+    { "QVariant",	"VARIANT" },
+    { "QVariantList",	"SAFEARRAY(VARIANT)" },
+    { "QList<QVariant>","SAFEARRAY(VARIANT)" },
+    { "quint64",	"CY" },
+    { "qint64",	        "CY" },
+    { "qulonglong",	"CY" },
+    { "qlonglong",	"CY" },
+    { "QByteArray",	"SAFEARRAY(BYTE)" },
+    { "QStringList",	"SAFEARRAY(BSTR)" },
+    // Userdefined Qt datatypes - some not on Borland though
+    { "QCursor",        "enum MousePointer" },
+    { "Qt::FocusPolicy","enum FocusPolicy" },
+#ifndef Q_CC_BOR
+# if __REQUIRED_RPCNDR_H_VERSION__ >= Q_REQUIRED_RPCNDR_H_VERSION
+    { "QRect",		"struct QRect" },
+    { "QSize",		"struct QSize" },
+    { "QPoint",		"struct QPoint" },
+# endif
+#endif
+    // And we support COM data types
+    { "BOOL",		"BOOL" },
+    { "BSTR",		"BSTR" },
+    { "OLE_COLOR",	"OLE_COLOR" },
+    { "DATE",		"DATE" },
+    { "VARIANT",	"VARIANT" },
+    { "IDispatch",	"IDispatch*" },
+    { "IUnknown",	"IUnknown*" },
+    { "IDispatch*",	"IDispatch*" },
+    { "IUnknown*",	"IUnknown*" },
+    { 0,		0 }
+};
+
+static QByteArray convertTypes(const QByteArray &qtype, bool *ok)
+{
+    qRegisterMetaType("IDispatch*", (void**)0);
+    qRegisterMetaType("IUnknown*", (void**)0);
+
+    *ok = false;
+    
+    int i = 0;
+    while (type_map[i][0]) {
+        if (qtype == type_map[i][0] && type_map[i][1]) {
+            *ok = true;
+            return type_map[i][1];	    
+        }
+        ++i;
+    }
+    if (enums.contains(qtype)) {
+        *ok = true;
+        return "enum " + qtype;
+    }
+    if (subtypes.contains(qtype)) {
+        *ok = true;
+    } else if (qtype.endsWith('*')) {
+        QByteArray cleanType = qtype.left(qtype.length() - 1);
+        const QMetaObject *mo = qAxFactory()->metaObject(QString::fromLatin1(cleanType.constData()));
+        if (mo) {
+            cleanType = qax_clean_type(QString::fromLatin1(cleanType), mo).toLatin1();
+            if (subtypes.contains(cleanType)) {
+                *ok = true;
+                return cleanType + '*';
+            }
+        }
+    }
+    return qtype;
+}
+
+static const char* const keyword_map[][2] =
+{
+    { "aggregatable",	"aggregating"	    },
+    { "allocate",	"alloc"		    },
+    { "appobject",	"appObject"	    },
+    { "arrays",		"array"		    },
+    { "async",		"asynchronous"	    },
+    { "bindable",	"binding"	    },
+    { "Boolean",	"boolval"	    },
+    { "boolean",	"boolval"	    },
+    { "broadcast",	"broadCast"	    },
+    { "callback",	"callBack"	    },
+    { "decode",		"deCode"	    },
+    { "default",	"defaulted"	    },
+    { "defaultbind",	"defaultBind"	    },
+    { "defaultvalue",	"defaultValue"	    },
+    { "encode"		"enCode"	    },
+    { "endpoint",	"endPoint"	    },
+    { "hidden",		"isHidden"	    },
+    { "ignore",		"ignore_"	    },
+    { "local",		"local_"	    },
+    { "notify",		"notify_"	    },
+    { "object",		"object_"	    },
+    { "optimize",	"optimize_"	    },
+    { "optional",	"optional_"	    },
+    { "out",		"out_"		    },
+    { "pipe",		"pipe_"		    },
+    { "proxy",		"proxy_"	    },
+    { "ptr",		"pointer"	    },
+    { "readonly",	"readOnly"	    },
+    { "small",		"small_"	    },
+    { "source",		"source_"	    },
+    { "string",		"string_"	    },
+    { "uuid",		"uuid_"		    },
+    { 0,		0		    }
+};
+
+static QByteArray replaceKeyword(const QByteArray &name)
+{
+    int i = 0;
+    while (keyword_map[i][0]) {
+        if (name == keyword_map[i][0] && keyword_map[i][1])
+            return keyword_map[i][1];
+        ++i;
+    }
+    return name;
+}
+
+static QMap<QByteArray, int> mapping;
+
+static QByteArray renameOverloads(const QByteArray &name)
+{
+    QByteArray newName = name;
+    
+    int n = mapping.value(name);
+    if (mapping.contains(name)) {
+        int n = mapping.value(name);
+        newName = name + "_" + QByteArray::number(n);
+        mapping.insert(name, n+1);
+    } else {
+        mapping.insert(name, 1);
+    }
+    
+    return newName;
+}
+
+// filter out some properties
+static const char* const ignore_props[] =
+{
+    "name",
+    "objectName",
+    "isTopLevel",
+    "isDialog",
+    "isModal",
+    "isPopup",
+    "isDesktop",
+    "geometry",
+    "pos",
+    "frameSize",
+    "frameGeometry",
+    "size",
+    "sizeHint",
+    "minimumSizeHint",
+    "microFocusHint",
+    "rect",
+    "childrenRect",
+    "childrenRegion",
+    "minimumSize",
+    "maximumSize",
+    "sizeIncrement",
+    "baseSize",
+    "ownPalette",
+    "ownFont",
+    "ownCursor",
+    "visibleRect",
+    "isActiveWindow",
+    "underMouse",
+    "visible",
+    "hidden",
+    "minimized",
+    "focus",
+    "focusEnabled",
+    "customWhatsThis",
+    "shown",
+    "windowOpacity",
+    0
+};
+
+// filter out some slots
+static const char* const ignore_slots[] =
+{
+    "deleteLater",
+    "setMouseTracking",
+    "update",
+    "repaint",
+    "iconify",
+    "showMinimized",
+    "showMaximized",
+    "showFullScreen",
+    "showNormal",
+    "polish",
+    "constPolish",
+    "stackUnder",
+    "setShown",
+    "setHidden",
+    "move_1",
+    "resize_1",
+    "setGeometry_1",
+    0
+};
+
+static bool ignore(const char *test, const char *const *table)
+{
+    if (!test)
+        return true;
+    int i = 0;
+    while (table[i]) {
+        if (!strcmp(test, table[i]))
+            return true;
+        ++i;
+    }
+    return false;
+}
+
+bool ignoreSlots(const char *test)
+{
+    return ignore(test, ignore_slots);
+}
+
+bool ignoreProps(const char *test)
+{
+    return ignore(test, ignore_props);
+}
+
+#define STRIPCB(x) x = x.mid(1, x.length()-2)
+
+static QByteArray prototype(const QList<QByteArray> &parameterTypes, const QList<QByteArray> &parameterNames, bool *ok)
+{
+    QByteArray prototype;
+    
+    for (int p = 0; p < parameterTypes.count() && *ok; ++p) {
+        bool out = false;
+        QByteArray type(parameterTypes.at(p));
+        QByteArray name(parameterNames.at(p));
+        
+        if (type.endsWith("&")) {
+            out = true;
+            type.truncate(type.length() - 1);
+        } else if (type.endsWith("**")) {
+            out = true;
+            type.truncate(type.length() - 1);
+        } else if (type.endsWith("*") && !subtypes.contains(type)) {
+            type.truncate(type.length() - 1);
+        }
+        if (type.isEmpty()) {
+            *ok = false;
+            break;
+        }
+        type = convertTypes(type, ok);
+        if (!out)
+            prototype += "[in] " + type + " ";
+        else
+            prototype += "[in,out] " + type + " ";
+        
+        if (out)
+            prototype += "*";
+        if (name.isEmpty())
+            prototype += "p" + QByteArray::number(p);
+        else
+            prototype += "p_" + replaceKeyword(name);
+        
+        if (p < parameterTypes.count() - 1)
+            prototype += ", ";
+    }
+    
+    return prototype;
+}
+
+static QByteArray addDefaultArguments(const QByteArray &prototype, int numDefArgs)
+{
+    // nothing to do, or unsupported anyway
+    if (!numDefArgs || prototype.contains("/**"))
+        return prototype;
+
+    QByteArray ptype(prototype);
+    int in = -1;
+    while (numDefArgs) {
+        in = ptype.lastIndexOf("]", in);
+        ptype.replace(in, 1, ",optional]");
+        in = ptype.indexOf(' ', in) + 1;
+        QByteArray type = ptype.mid(in, ptype.indexOf(' ', in) - in);
+        if (type == "enum")
+            type += " " + ptype.mid(in + 5, ptype.indexOf(' ', in + 5) - in - 5);
+        ptype.replace(in, type.length(), QByteArray("VARIANT /*was: ") + type + "*/");
+        --numDefArgs;
+    }
+
+    return ptype;
+}
+
+static HRESULT classIDL(QObject *o, const QMetaObject *mo, const QString &className, bool isBindable, QTextStream &out)
+{
+    int id = 1;
+    int i = 0;
+    if (!mo)
+        return 3;
+    
+    QString topclass = qAxFactory()->exposeToSuperClass(className);
+    if (topclass.isEmpty())
+        topclass = QLatin1String("QObject");
+    bool hasStockEvents = qAxFactory()->hasStockEvents(className);
+    
+    const QMetaObject *pmo = mo;
+    do {
+        pmo = pmo->superClass();
+    } while (pmo && topclass != QString::fromLatin1(pmo->className()));
+    
+    int enumoff = pmo ? pmo->enumeratorOffset() : mo->enumeratorOffset();
+    int methodoff = pmo ? pmo->methodOffset() : mo->methodOffset();
+    int propoff = pmo ? pmo->propertyOffset() : mo->propertyOffset();
+    
+    int qtProps = 0;
+    int qtSlots = 0;
+
+    bool control = false;
+    
+    if (o && o->isWidgetType()) {
+        qtProps = QWidget::staticMetaObject.propertyCount();
+        qtSlots = QWidget::staticMetaObject.methodCount();
+        control = true;
+    }
+    
+    QString classID = qAxFactory()->classID(className).toString().toUpper();
+    if (QUuid(classID).isNull())
+        return 4;
+    STRIPCB(classID);
+    QString interfaceID = qAxFactory()->interfaceID(className).toString().toUpper();
+    if (QUuid(interfaceID).isNull())
+        return 5;
+    STRIPCB(interfaceID);
+    QString eventsID = qAxFactory()->eventsID(className).toString().toUpper();
+    bool hasEvents = !QUuid(eventsID).isNull();
+    STRIPCB(eventsID);
+    
+    QString cleanClassName = qax_clean_type(className, mo);
+    QString defProp(QLatin1String(mo->classInfo(mo->indexOfClassInfo("DefaultProperty")).value()));
+    QString defSignal(QLatin1String(mo->classInfo(mo->indexOfClassInfo("DefaultSignal")).value()));
+    
+    for (i = enumoff; i < mo->enumeratorCount(); ++i) {
+        const QMetaEnum enumerator = mo->enumerator(i);
+        if (enums.contains(enumerator.name()))
+            continue;
+        
+        enums.append(enumerator.name());
+        
+        out << "\tenum " << enumerator.name() << " {" << endl;
+        
+        for (int j = 0; j < enumerator.keyCount(); ++j) {
+            QByteArray key(enumerator.key(j));
+            while (enumValues.contains(key)) {
+                key += "_";
+            }
+            enumValues.append(key);
+            uint value = (uint)enumerator.value(j);
+            key = key.leftJustified(20);
+            out << "\t\t" << key << "\t= ";
+            if (enumerator.isFlag())
+                out << "0x" << QByteArray::number(value, 16).rightJustified(8, '0');
+            else
+                out << value;
+            if (j < enumerator.keyCount()-1)
+                out << ", ";
+            out << endl;
+        }
+        out << "\t};" << endl << endl;
+    }
+
+    // mouse cursor enum for QCursor support
+    if (!enums.contains("MousePointer")) {
+        enums.append("MousePointer");
+        out << "\tenum MousePointer {" << endl;
+        out << "\t\tArrowCursor             = " << Qt::ArrowCursor << "," << endl;
+        out << "\t\tUpArrowCursor           = " << Qt::UpArrowCursor << "," << endl;
+        out << "\t\tCrossCursor             = " << Qt::CrossCursor << "," << endl;
+        out << "\t\tWaitCursor              = " << Qt::WaitCursor << "," << endl;
+        out << "\t\tIBeamCursor             = " << Qt::IBeamCursor << "," << endl;
+        out << "\t\tSizeVerCursor           = " << Qt::SizeVerCursor << "," << endl;
+        out << "\t\tSizeHorCursor           = " << Qt::SizeHorCursor << "," << endl;
+        out << "\t\tSizeBDiagCursor         = " << Qt::SizeBDiagCursor << "," << endl;
+        out << "\t\tSizeFDiagCursor         = " << Qt::SizeFDiagCursor << "," << endl;
+        out << "\t\tSizeAllCursor           = " << Qt::SizeAllCursor << "," << endl;
+        out << "\t\tBlankCursor             = " << Qt::BlankCursor << "," << endl;
+        out << "\t\tSplitVCursor            = " << Qt::SplitVCursor << "," << endl;
+        out << "\t\tSplitHCursor            = " << Qt::SplitHCursor << "," << endl;
+        out << "\t\tPointingHandCursor      = " << Qt::PointingHandCursor << "," << endl;
+        out << "\t\tForbiddenCursor         = " << Qt::ForbiddenCursor << "," << endl;
+        out << "\t\tWhatsThisCursor         = " << Qt::WhatsThisCursor << "," << endl;
+        out << "\t\tBusyCursor\t= " << Qt::BusyCursor << endl;
+        out << "\t};" << endl << endl;
+    }
+    if (!enums.contains("FocusPolicy")) {
+        enums.append("FocusPolicy");
+        out << "\tenum FocusPolicy {" << endl;
+        out << "\t\tNoFocus             = " << Qt::NoFocus << "," << endl;
+        out << "\t\tTabFocus            = " << Qt::TabFocus << "," << endl;
+        out << "\t\tClickFocus          = " << Qt::ClickFocus << "," << endl;
+        out << "\t\tStrongFocus         = " << Qt::StrongFocus << "," << endl;
+        out << "\t\tWheelFocus          = " << Qt::WheelFocus << endl;
+        out << "\t};" << endl << endl;
+    }
+
+    out << endl;
+    out << "\t[" << endl;
+    out << "\t\tuuid(" << interfaceID << ")," << endl;
+    out << "\t\thelpstring(\"" << cleanClassName << " Interface\")" << endl;
+    out << "\t]" << endl;
+    out << "\tdispinterface I" << cleanClassName  << endl;
+    out << "\t{" << endl;
+    
+    out << "\tproperties:" << endl;
+    for (i = propoff; i < mo->propertyCount(); ++i) {
+        const QMetaProperty property = mo->property(i);
+        /*	if (property.testFlags(QMetaProperty::Override))
+        continue;*/
+        if (i <= qtProps && ignoreProps(property.name()))
+            continue;
+        if (!property.name() || mo->indexOfProperty(property.name()) > i)
+            continue;
+        
+        bool ok = true;
+        QByteArray type(convertTypes(property.typeName(), &ok));
+        QByteArray name(replaceKeyword(property.name()));
+        
+        if (!ok)
+            out << "\t/****** Property is of unsupported datatype" << endl;
+        
+        out << "\t\t[id(" << id << ")";
+        if (!property.isWritable())
+            out << ", readonly";
+        if (isBindable && property.isScriptable(o))
+            out << ", bindable";
+        if (!property.isDesignable(o))
+            out << ", nonbrowsable";
+        if (isBindable)
+            out << ", requestedit";
+        if (defProp == QString::fromLatin1(name.constData()))
+            out << ", uidefault";
+        out << "] " << type << " " << name << ";" << endl;
+        
+        if (!ok)
+            out << "\t******/" << endl;
+        ++id;
+    }
+    out << endl;
+    out << "\tmethods:" << endl;
+    int numDefArgs = 0;
+    QByteArray outBuffer;
+    for (i = methodoff; i < mo->methodCount(); ++i) {
+        const QMetaMethod slot = mo->method(i);
+        if (slot.access() != QMetaMethod::Public || slot.methodType() == QMetaMethod::Signal)
+            continue;
+
+        if (slot.attributes() & QMetaMethod::Cloned) {
+            ++numDefArgs;
+            continue;
+        }
+        if (!outBuffer.isEmpty()) {
+            outBuffer = addDefaultArguments(outBuffer, numDefArgs);
+            numDefArgs = 0;
+            out << outBuffer;
+            outBuffer = QByteArray();
+        }
+        
+        QByteArray signature(slot.signature());
+        QByteArray name(signature.left(signature.indexOf('(')));
+        if (i <= qtSlots && ignoreSlots(name))
+            continue;
+
+        signature = signature.mid(name.length() + 1);
+        signature.truncate(signature.length() - 1);
+        name = renameOverloads(replaceKeyword(name));
+        if (ignoreSlots(name))
+            continue;
+
+        QList<QByteArray> parameterTypes(slot.parameterTypes());
+        QList<QByteArray> parameterNames(slot.parameterNames());
+        
+        bool ok = true;
+        QByteArray type = slot.typeName();
+        if (type.isEmpty())
+            type = "void";
+        else
+            type = convertTypes(type, &ok);
+        
+        QByteArray ptype(prototype(parameterTypes, parameterNames, &ok));
+        if (!ok)
+            outBuffer += "\t/****** Slot parameter uses unsupported datatype\n";
+        
+        outBuffer += "\t\t[id(" + QString::number(id).toLatin1() + ")] " + type + " " + name + "(" + ptype + ");\n";
+        
+        if (!ok)
+            outBuffer += "\t******/\n";
+        ++id;
+    }
+    if (!outBuffer.isEmpty()) {
+        outBuffer = addDefaultArguments(outBuffer, numDefArgs);
+        numDefArgs = 0;
+        out << outBuffer;
+        outBuffer = QByteArray();
+    }
+    out << "\t};" << endl << endl;
+
+    mapping.clear();
+    id = 1;
+    
+    if (hasEvents) {
+        out << "\t[" << endl;
+        out << "\t\tuuid(" << eventsID << ")," << endl;
+        out << "\t\thelpstring(\"" << cleanClassName << " Events Interface\")" << endl;
+        out << "\t]" << endl;
+        out << "\tdispinterface I" << cleanClassName << "Events" << endl;
+        out << "\t{" << endl;
+        out << "\tproperties:" << endl;
+        out << "\tmethods:" << endl;
+        
+        if (hasStockEvents) {
+            out << "\t/****** Stock events ******/" << endl;
+            out << "\t\t[id(DISPID_CLICK)] void Click();" << endl;
+            out << "\t\t[id(DISPID_DBLCLICK)] void DblClick();" << endl;
+            out << "\t\t[id(DISPID_KEYDOWN)] void KeyDown(short* KeyCode, short Shift);" << endl;
+            out << "\t\t[id(DISPID_KEYPRESS)] void KeyPress(short* KeyAscii);" << endl;
+            out << "\t\t[id(DISPID_KEYUP)] void KeyUp(short* KeyCode, short Shift);" << endl;
+            out << "\t\t[id(DISPID_MOUSEDOWN)] void MouseDown(short Button, short Shift, OLE_XPOS_PIXELS x, OLE_YPOS_PIXELS y);" << endl;
+            out << "\t\t[id(DISPID_MOUSEMOVE)] void MouseMove(short Button, short Shift, OLE_XPOS_PIXELS x, OLE_YPOS_PIXELS y);" << endl;
+            out << "\t\t[id(DISPID_MOUSEUP)] void MouseUp(short Button, short Shift, OLE_XPOS_PIXELS x, OLE_YPOS_PIXELS y);" << endl << endl;
+        }
+        
+        for (i = methodoff; i < mo->methodCount(); ++i) {
+            const QMetaMethod signal = mo->method(i);
+            if (signal.methodType() != QMetaMethod::Signal)
+                continue;
+            
+            QByteArray signature(signal.signature());
+            QByteArray name(signature.left(signature.indexOf('(')));
+            signature = signature.mid(name.length() + 1);
+            signature.truncate(signature.length() - 1);
+
+            QList<QByteArray> parameterTypes(signal.parameterTypes());
+            QList<QByteArray> parameterNames(signal.parameterNames());
+            
+            bool isDefault = defSignal == QString::fromLatin1(name.constData());
+            name = renameOverloads(replaceKeyword(name));
+            bool ok = true;
+            
+            QByteArray type = signal.typeName();
+            if (!type.isEmpty()) // signals with return value not supported
+                continue;
+            
+            QByteArray ptype(prototype(parameterTypes, parameterNames, &ok));
+            if (!ok)
+                out << "\t/****** Signal parameter uses unsupported datatype" << endl;
+            
+            out << "\t\t[id(" << id << ")";
+            if (isDefault)
+                out << ", uidefault";
+            out << "] void " << name << "(" << ptype << ");" << endl;
+            
+            if (!ok)
+                out << "\t******/" << endl;
+            ++id;
+        }
+        out << "\t};" << endl << endl;
+    }
+    
+    out << "\t[" << endl;
+    
+    if (qstricmp(mo->classInfo(mo->indexOfClassInfo("Aggregatable")).value(), "no"))
+        out << "\t\taggregatable," << endl;
+    if (!qstricmp(mo->classInfo(mo->indexOfClassInfo("RegisterObject")).value(), "yes"))
+        out << "\t\tappobject," << endl;
+    if (mo->classInfo(mo->indexOfClassInfo("LicenseKey")).value())
+        out << "\t\tlicensed," << endl;
+    const char *helpString = mo->classInfo(mo->indexOfClassInfo("Description")).value();
+    if (helpString)
+        out << "\t\thelpstring(\"" << helpString << "\")," << endl;
+    else
+        out << "\t\thelpstring(\"" << cleanClassName << " Class\")," << endl;
+    const char *classVersion = mo->classInfo(mo->indexOfClassInfo("Version")).value();
+    if (classVersion)
+        out << "\t\tversion(" << classVersion << ")," << endl;
+    out << "\t\tuuid(" << classID << ")";
+    if (control) {
+        out << ", " << endl;
+        out << "\t\tcontrol";
+    } else if (!o) {
+        out << ", " << endl;
+        out << "\t\tnoncreatable";
+    }
+    out << endl;
+    out << "\t]" << endl;
+    out << "\tcoclass " << cleanClassName << endl;
+    out << "\t{" << endl;
+    out << "\t\t[default] dispinterface I" << cleanClassName << ";" << endl;
+    if (hasEvents)
+        out << "\t\t[default, source] dispinterface I" << cleanClassName << "Events;" << endl;
+    out << "\t};" << endl;
+    
+    return S_OK;
+}
+
+#if defined(Q_CC_BOR)
+extern "C" __stdcall HRESULT DumpIDL(const QString &outfile, const QString &ver)
+#else
+extern "C" HRESULT __stdcall DumpIDL(const QString &outfile, const QString &ver)
+#endif
+{
+    qAxIsServer = false;
+    QTextStream out;
+    if (outfile.contains(QLatin1String("\\"))) {
+        QString outpath = outfile.left(outfile.lastIndexOf(QLatin1String("\\")));
+        QDir dir;
+        dir.mkpath(outpath);
+    }
+    QFile file(outfile);
+    file.remove();
+    
+    QString filebase = QString::fromLocal8Bit(qAxModuleFilename);
+    filebase = filebase.left(filebase.lastIndexOf(QLatin1String(".")));
+    
+    QString appID = qAxFactory()->appID().toString().toUpper();
+    if (QUuid(appID).isNull())
+        return 1;
+    STRIPCB(appID);
+    QString typeLibID = qAxFactory()->typeLibID().toString().toUpper();
+    if (QUuid(typeLibID).isNull())
+        return 2;
+    STRIPCB(typeLibID);
+    QString typelib = filebase.right(filebase.length() - filebase.lastIndexOf(QLatin1String("\\"))-1);
+    
+    if (!file.open(QIODevice::WriteOnly))
+        return -1;
+    
+    out.setDevice(&file);
+    
+    QString version(ver.unicode(), ver.length());
+    while (version.count(QLatin1Char('.')) > 1) {
+        int lastdot = version.lastIndexOf(QLatin1Char('.'));
+        version = version.left(lastdot) + version.right(version.length() - lastdot - 1);
+    }
+    if (version.isEmpty())
+        version = QLatin1String("1.0");
+    
+    QString idQRect(QUuid(CLSID_QRect).toString());
+    STRIPCB(idQRect);
+    QString idQSize(QUuid(CLSID_QSize).toString());
+    STRIPCB(idQSize);
+    QString idQPoint(QUuid(CLSID_QPoint).toString());
+    STRIPCB(idQPoint);
+    
+    out << "/****************************************************************************" << endl;
+    out << "** Interface definition generated for ActiveQt project" << endl;
+    out << "**" << endl;
+    out << "**     '" << qAxModuleFilename << "'" << endl;
+    out << "**" << endl;
+    out << "** Created:  " << QDateTime::currentDateTime().toString() << endl;
+    out << "**" << endl;
+    out << "** WARNING! All changes made in this file will be lost!" << endl;
+    out << "****************************************************************************/" << endl << endl;
+    
+    out << "import \"ocidl.idl\";" << endl;
+    out << "#include <olectl.h>" << endl << endl;
+    
+    // dummy application to create widgets
+    bool delete_qApp = false;
+    if (!qApp) {
+        int argc;
+        (void)new QApplication(argc, 0);
+        delete_qApp = true;
+    }
+    
+    out << "[" << endl;
+    out << "\tuuid(" << typeLibID << ")," << endl;
+    out << "\tversion(" << version << ")," << endl;
+    out << "\thelpstring(\"" << typelib << " " << version << " Type Library\")" << endl;
+    out << "]" << endl;
+    out << "library " << typelib << "Lib" << endl;
+    out << "{" << endl;
+    out << "\timportlib(\"stdole32.tlb\");" << endl;
+    out << "\timportlib(\"stdole2.tlb\");" << endl << endl;
+    
+    QStringList keys = qAxFactory()->featureList();
+    QStringList::ConstIterator key;
+    
+    out << "\t/************************************************************************" << endl;
+    out << "\t** If this causes a compile error in MIDL you need to upgrade the" << endl;
+    out << "\t** Platform SDK you are using. Download the SDK from msdn.microsoft.com" << endl;
+    out << "\t** and make sure that both the system and the Visual Studio environment" << endl;
+    out << "\t** use the correct files." << endl;
+    out << "\t**" << endl;
+    
+#ifndef Q_CC_BOR
+#if __REQUIRED_RPCNDR_H_VERSION__ < Q_REQUIRED_RPCNDR_H_VERSION
+    out << "\t** Required version of MIDL could not be verified. QRect, QSize and QPoint" << endl;
+    out << "\t** support needs an updated Platform SDK to be installed." << endl;
+    out << "\t*************************************************************************" << endl;
+#else
+    out << "\t************************************************************************/" << endl;
+#endif
+    
+    out << endl;
+    out << "\t[uuid(" << idQRect << ")]" << endl;
+    out << "\tstruct QRect {" << endl;
+    out << "\t\tint left;" << endl;
+    out << "\t\tint top;" << endl;
+    out << "\t\tint right;" << endl;
+    out << "\t\tint bottom;" << endl;
+    out << "\t};" << endl << endl;
+    
+    out << "\t[uuid(" << idQSize << ")]" << endl;
+    out << "\tstruct QSize {" << endl;
+    out << "\t\tint width;" << endl;
+    out << "\t\tint height;" << endl;
+    out << "\t};" << endl << endl;
+    
+    out << "\t[uuid(" << idQPoint << ")]" << endl;
+    out << "\tstruct QPoint {" << endl;
+    out << "\t\tint x;" << endl;
+    out << "\t\tint y;" << endl;
+    out << "\t};" << endl;
+#if __REQUIRED_RPCNDR_H_VERSION__ < Q_REQUIRED_RPCNDR_H_VERSION
+    out << "\t*/" << endl;
+#endif
+#else
+    out << "\t** Custom data types not supported with Borland." << endl;
+    out << "\t*************************************************************************" << endl;
+#endif
+    out << endl;
+    
+    out << "\t/* Forward declaration of classes that might be used as parameters */" << endl << endl;
+    
+    int res = S_OK;
+    for (key = keys.begin(); key != keys.end(); ++key) {
+        QByteArray className = (*key).toLatin1();
+        const QMetaObject *mo = qAxFactory()->metaObject(QString::fromLatin1(className.constData()));
+        // We have meta object information for this type. Forward declare it.
+        if (mo) {
+            QByteArray cleanType = qax_clean_type(*key, mo).toLatin1();
+            out << "\tcoclass " << cleanType << ";" << endl;
+            subtypes.append(cleanType);
+            subtypes.append(cleanType + "*");
+            qRegisterMetaType(cleanType, (void**)0);
+            qRegisterMetaType(cleanType + "*", (void**)0);
+        }
+    }
+    out << endl;
+
+    for (key = keys.begin(); key != keys.end(); ++key) {
+        QByteArray className = (*key).toLatin1();
+        const QMetaObject *mo = qAxFactory()->metaObject(QString::fromLatin1(className.constData()));
+        // We have meta object information for this type. Define it.
+        if (mo) {
+            QObject *o = qAxFactory()->createObject(QString::fromLatin1(className.constData()));
+            // It's not a control class, so it is actually a subtype. Define it.
+            if (!o)
+                res = classIDL(0, mo, QString::fromLatin1(className), false, out);
+            delete o;
+        }
+    }
+
+    out << endl;
+    if (res != S_OK)
+        goto ErrorInClass;
+    
+    for (key = keys.begin(); key != keys.end(); ++key) {
+        QByteArray className = (*key).toLatin1();
+        QObject *o = qAxFactory()->createObject(QString::fromLatin1(className.constData()));
+        if (!o)
+            continue;
+        const QMetaObject *mo = o->metaObject();
+        QAxBindable *bind = (QAxBindable*)o->qt_metacast("QAxBindable");
+        bool isBindable =  bind != 0;
+
+        QByteArray cleanType = qax_clean_type(*key, mo).toLatin1();
+        subtypes.append(cleanType);
+        subtypes.append(cleanType + "*");
+        res = classIDL(o, mo, QString::fromLatin1(className.constData()), isBindable, out);
+        delete o;
+        if (res != S_OK)
+            break;
+    }
+    
+    out << "};" << endl;
+    out.flush();
+    
+ErrorInClass:
+    if (delete_qApp)
+        delete qApp;
+
+    if (res != S_OK) {
+        file.close();
+        file.remove();
+    }
+    
+    return res;
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/control/qaxserver.def b/src/activeqt/control/qaxserver.def
new file mode 100644
index 0000000..a00638d
--- /dev/null
+++ b/src/activeqt/control/qaxserver.def
@@ -0,0 +1,8 @@
+; mfc_test.def : Declares the module parameters.
+
+EXPORTS
+	DllCanUnloadNow	     PRIVATE
+	DllGetClassObject    PRIVATE
+	DllRegisterServer    PRIVATE
+	DllUnregisterServer  PRIVATE
+	DumpIDL		     PRIVATE
diff --git a/src/activeqt/control/qaxserver.ico b/src/activeqt/control/qaxserver.ico
new file mode 100644
index 0000000..c80d36a
--- /dev/null
+++ b/src/activeqt/control/qaxserver.ico
diff --git a/src/activeqt/control/qaxserver.rc b/src/activeqt/control/qaxserver.rc
new file mode 100644
index 0000000..390e481
--- /dev/null
+++ b/src/activeqt/control/qaxserver.rc
@@ -0,0 +1,2 @@
+1 TYPELIB "qaxserver.rc"
+1 ICON DISCARDABLE "qaxserver.ico"
diff --git a/src/activeqt/control/qaxserverbase.cpp b/src/activeqt/control/qaxserverbase.cpp
new file mode 100644
index 0000000..f3e1dff
--- /dev/null
+++ b/src/activeqt/control/qaxserverbase.cpp
@@ -0,0 +1,4490 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 QT_NO_CAST_TO_ASCII
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qabstracteventdispatcher.h>
+#include <qapplication.h>
+#include <qbuffer.h>
+#include <qdatastream.h>
+#include <qdebug.h>
+#include <qevent.h>
+#include <qeventloop.h>
+#include <qfile.h>
+#include <qpointer.h>
+#include <qhash.h>
+#include <qmap.h>
+#include <qmenubar.h>
+#include <qmenu.h>
+#include <qmetaobject.h>
+#include <qpixmap.h>
+#include <qstatusbar.h>
+#include <qwhatsthis.h>
+#include <ocidl.h>
+#include <olectl.h>
+#include <private/qcoreapplication_p.h>
+
+#include "qaxfactory.h"
+#include "qaxbindable.h"
+#include "qaxaggregated.h"
+
+#include "../shared/qaxtypes.h"
+
+#if defined Q_CC_GNU
+#   include <w32api.h>
+#endif
+
+#ifndef Q_OS_WIN64
+#define ULONG_PTR DWORD
+#endif
+
+QT_BEGIN_NAMESPACE
+
+extern HHOOK qax_hhook;
+
+// in qaxserver.cpp
+extern ITypeLib *qAxTypeLibrary;
+extern QAxFactory *qAxFactory();
+extern unsigned long qAxLock();
+extern unsigned long qAxUnlock();
+extern HANDLE qAxInstance;
+extern bool qAxOutProcServer;
+
+static int invokeCount = 0;
+
+#ifdef QT_DEBUG
+unsigned long qaxserverbase_instance_count = 0;
+#endif
+
+// in qaxserverdll.cpp
+extern bool qax_ownQApp;
+
+struct QAxExceptInfo
+{
+    QAxExceptInfo(int c, const QString &s, const QString &d, const QString &x)
+	: code(c), src(s), desc(d), context(x)
+    {
+    }
+    int code;
+    QString src;
+    QString desc;
+    QString context;
+};
+
+
+bool qt_sendSpontaneousEvent(QObject*, QEvent*);
+
+/*
+    \class QAxServerBase
+    \brief The QAxServerBase class is an ActiveX control hosting a QWidget.
+
+    \internal
+*/
+class QAxServerBase :
+    public QObject,
+    public IAxServerBase,
+    public IDispatch,
+    public IOleObject,
+    public IOleControl,
+#if defined Q_CC_GNU
+#   if (__W32API_MAJOR_VERSION < 2 || (__W32API_MAJOR_VERSION == 2 && __W32API_MINOR_VERSION < 5))
+    public IViewObject, // this should not be needed as IViewObject2 is meant to inherit from this,
+                        // untill the mingw headers are fixed this will need to stay.
+#   endif
+#endif
+    public IViewObject2,
+    public IOleInPlaceObject,
+    public IOleInPlaceActiveObject,
+    public IProvideClassInfo2,
+    public IConnectionPointContainer,
+    public IPersistStream,
+    public IPersistStreamInit,
+    public IPersistStorage,
+    public IPersistPropertyBag,
+    public IPersistFile,
+    public IDataObject
+{
+public:
+    typedef QMap<QUuid,IConnectionPoint*> ConnectionPoints;
+    typedef QMap<QUuid,IConnectionPoint*>::Iterator ConnectionPointsIterator;
+
+    QAxServerBase(const QString &classname, IUnknown *outerUnknown);
+    QAxServerBase(QObject *o);
+
+    void init();
+
+    ~QAxServerBase();
+
+// Window creation
+    HWND create(HWND hWndParent, RECT& rcPos);
+    HMENU createPopup(QMenu *popup, HMENU oldMenu = 0);
+    void createMenu(QMenuBar *menuBar);
+    void removeMenu();
+
+    static LRESULT CALLBACK ActiveXProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+
+// Object registration with OLE
+    void registerActiveObject(IUnknown *object);
+    void revokeActiveObject();
+
+// IUnknown
+    unsigned long WINAPI AddRef()
+    {
+	if (m_outerUnknown)
+	    return m_outerUnknown->AddRef();
+
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = ++ref;
+	LeaveCriticalSection(&refCountSection);
+
+	return r;
+    }
+    unsigned long WINAPI Release()
+    {
+    	if (m_outerUnknown)
+	    return m_outerUnknown->Release();
+
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = --ref;
+	LeaveCriticalSection(&refCountSection);
+
+	if (!r) {
+	    delete this;
+	    return 0;
+	}
+	return r;
+    }
+    HRESULT WINAPI QueryInterface(REFIID iid, void **iface);
+    HRESULT InternalQueryInterface(REFIID iid, void **iface);
+
+// IAxServerBase
+    IUnknown *clientSite() const
+    {
+	return m_spClientSite;
+    }
+
+    void emitPropertyChanged(const char*);
+    bool emitRequestPropertyChange(const char*);
+    QObject *qObject() const
+    {
+	return theObject;
+    }
+    void ensureMetaData();
+    bool isPropertyExposed(int index);
+
+    void reportError(int code, const QString &src, const QString &desc, const QString &context)
+    {
+        if (exception)
+            delete exception;
+        exception = new QAxExceptInfo(code, src, desc, context);
+    }
+
+// IDispatch
+    STDMETHOD(GetTypeInfoCount)(UINT* pctinfo);
+    STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo** pptinfo);
+    STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgdispid);
+    STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid,
+		LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,
+		EXCEPINFO* pexcepinfo, UINT* puArgErr);
+
+// IProvideClassInfo
+    STDMETHOD(GetClassInfo)(ITypeInfo** pptinfo);
+
+// IProvideClassInfo2
+    STDMETHOD(GetGUID)(DWORD dwGuidKind, GUID* pGUID);
+
+// IOleObject
+    STDMETHOD(Advise)(IAdviseSink* pAdvSink, DWORD* pdwConnection);
+    STDMETHOD(Close)(DWORD dwSaveOption);
+    STDMETHOD(DoVerb)(LONG iVerb, LPMSG lpmsg, IOleClientSite* pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect);
+    STDMETHOD(EnumAdvise)(IEnumSTATDATA** ppenumAdvise);
+    STDMETHOD(EnumVerbs)(IEnumOLEVERB** ppEnumOleVerb);
+    STDMETHOD(GetClientSite)(IOleClientSite** ppClientSite);
+    STDMETHOD(GetClipboardData)(DWORD dwReserved, IDataObject** ppDataObject);
+    STDMETHOD(GetExtent)(DWORD dwDrawAspect, SIZEL* psizel);
+    STDMETHOD(GetMiscStatus)(DWORD dwAspect, DWORD *pdwStatus);
+    STDMETHOD(GetMoniker)(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker** ppmk);
+    STDMETHOD(GetUserClassID)(CLSID* pClsid);
+    STDMETHOD(GetUserType)(DWORD dwFormOfType, LPOLESTR *pszUserType);
+    STDMETHOD(InitFromData)(IDataObject* pDataObject, BOOL fCreation, DWORD dwReserved);
+    STDMETHOD(IsUpToDate)();
+    STDMETHOD(SetClientSite)(IOleClientSite* pClientSite);
+    STDMETHOD(SetColorScheme)(LOGPALETTE* pLogPal);
+    STDMETHOD(SetExtent)(DWORD dwDrawAspect, SIZEL* psizel);
+    STDMETHOD(SetHostNames)(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj);
+    STDMETHOD(SetMoniker)(DWORD dwWhichMoniker, IMoniker* ppmk);
+    STDMETHOD(Unadvise)(DWORD dwConnection);
+    STDMETHOD(Update)();
+
+// IViewObject
+    STDMETHOD(Draw)(DWORD dwAspect, LONG lIndex, void *pvAspect, DVTARGETDEVICE *ptd,
+		    HDC hicTargetDevice, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds,
+		    BOOL(__stdcall*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue);
+    STDMETHOD(GetColorSet)(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
+		    HDC hicTargetDev, LOGPALETTE **ppColorSet);
+    STDMETHOD(Freeze)(DWORD dwAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze);
+    STDMETHOD(Unfreeze)(DWORD dwFreeze);
+    STDMETHOD(SetAdvise)(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink);
+    STDMETHOD(GetAdvise)(DWORD *aspects, DWORD *advf, IAdviseSink **pAdvSink);
+
+// IViewObject2
+    STDMETHOD(GetExtent)(DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel);
+
+// IOleControl
+    STDMETHOD(FreezeEvents)(BOOL);
+    STDMETHOD(GetControlInfo)(LPCONTROLINFO);
+    STDMETHOD(OnAmbientPropertyChange)(DISPID);
+    STDMETHOD(OnMnemonic)(LPMSG);
+
+// IOleWindow
+    STDMETHOD(GetWindow)(HWND *pHwnd);
+    STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);
+
+// IOleInPlaceObject
+    STDMETHOD(InPlaceDeactivate)();
+    STDMETHOD(UIDeactivate)();
+    STDMETHOD(SetObjectRects)(LPCRECT lprcPosRect, LPCRECT lprcClipRect);
+    STDMETHOD(ReactivateAndUndo)();
+
+// IOleInPlaceActiveObject
+    STDMETHOD(TranslateAcceleratorW)(MSG *pMsg);
+    STDMETHOD(TranslateAcceleratorA)(MSG *pMsg);
+    STDMETHOD(OnFrameWindowActivate)(BOOL);
+    STDMETHOD(OnDocWindowActivate)(BOOL fActivate);
+    STDMETHOD(ResizeBorder)(LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow);
+    STDMETHOD(EnableModeless)(BOOL);
+
+// IConnectionPointContainer
+    STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**);
+    STDMETHOD(FindConnectionPoint)(REFIID, IConnectionPoint**);
+
+// IPersist
+    STDMETHOD(GetClassID)(GUID*clsid)
+    {
+	*clsid = qAxFactory()->classID(class_name);
+	return S_OK;
+    }
+
+// IPersistStreamInit
+    STDMETHOD(InitNew)(VOID);
+    STDMETHOD(IsDirty)();
+    STDMETHOD(Load)(IStream *pStm);
+    STDMETHOD(Save)(IStream *pStm, BOOL fClearDirty);
+    STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize);
+
+// IPersistPropertyBag
+    STDMETHOD(Load)(IPropertyBag *, IErrorLog *);
+    STDMETHOD(Save)(IPropertyBag *, BOOL, BOOL);
+
+// IPersistStorage
+    STDMETHOD(InitNew)(IStorage *pStg);
+    STDMETHOD(Load)(IStorage *pStg);
+    STDMETHOD(Save)(IStorage *pStg, BOOL fSameAsLoad);
+    STDMETHOD(SaveCompleted)(IStorage *pStgNew);
+    STDMETHOD(HandsOffStorage)();
+
+// IPersistFile
+    STDMETHOD(SaveCompleted)(LPCOLESTR fileName);
+    STDMETHOD(GetCurFile)(LPOLESTR *currentFile);
+    STDMETHOD(Load)(LPCOLESTR fileName, DWORD mode);
+    STDMETHOD(Save)(LPCOLESTR fileName, BOOL fRemember);
+
+// IDataObject
+    STDMETHOD(GetData)(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);
+    STDMETHOD(GetDataHere)(FORMATETC* /* pformatetc */, STGMEDIUM* /* pmedium */);
+    STDMETHOD(QueryGetData)(FORMATETC* /* pformatetc */);
+    STDMETHOD(GetCanonicalFormatEtc)(FORMATETC* /* pformatectIn */,FORMATETC* /* pformatetcOut */);
+    STDMETHOD(SetData)(FORMATETC* /* pformatetc */, STGMEDIUM* /* pmedium */, BOOL /* fRelease */);
+    STDMETHOD(EnumFormatEtc)(DWORD /* dwDirection */, IEnumFORMATETC** /* ppenumFormatEtc */);
+    STDMETHOD(DAdvise)(FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection);
+    STDMETHOD(DUnadvise)(DWORD dwConnection);
+    STDMETHOD(EnumDAdvise)(IEnumSTATDATA **ppenumAdvise);
+
+// QObject
+    int qt_metacall(QMetaObject::Call, int index, void **argv);
+
+    bool eventFilter(QObject *o, QEvent *e);
+private:
+    void update();
+    void resize(const QSize &newSize);
+    void updateGeometry();
+    void updateMask();
+    bool internalCreate();
+    void internalBind();
+    void internalConnect();
+    HRESULT internalActivate();
+
+    friend class QAxBindable;
+    friend class QAxPropertyPage;
+
+    QAxAggregated *aggregatedObject;
+    ConnectionPoints points;
+
+    union {
+	QWidget *widget;
+	QObject *object;
+    } qt;
+    QPointer<QObject> theObject;
+    unsigned isWidget		:1;
+    unsigned ownObject		:1;
+    unsigned initNewCalled	:1;
+    unsigned dirtyflag		:1;
+    unsigned hasStockEvents	:1;
+    unsigned stayTopLevel	:1;
+    unsigned isInPlaceActive	:1;
+    unsigned isUIActive		:1;
+    unsigned wasUIActive	:1;
+    unsigned inDesignMode	:1;
+    unsigned canTakeFocus	:1;
+    short freezeEvents;
+
+    HWND m_hWnd;
+
+    HMENU hmenuShared;
+    HOLEMENU holemenu;
+    HWND hwndMenuOwner;
+    QMap<HMENU, QMenu*> menuMap;
+    QMap<UINT, QAction*> actionMap;
+    QPointer<QMenuBar> menuBar;
+    QPointer<QStatusBar> statusBar;
+    QPointer<QMenu> currentPopup;
+    QAxExceptInfo *exception;
+
+    CRITICAL_SECTION refCountSection;
+    CRITICAL_SECTION createWindowSection;
+
+    unsigned long ref;
+    unsigned long ole_ref;
+
+    QString class_name;
+    QString currentFileName;
+
+    QHash<long, int> indexCache;
+    QHash<int,DISPID> signalCache;
+
+    IUnknown *m_outerUnknown;
+    IAdviseSink *m_spAdviseSink;
+    QList<STATDATA> adviseSinks;
+    IOleClientSite *m_spClientSite;
+    IOleInPlaceSiteWindowless *m_spInPlaceSite;
+    IOleInPlaceFrame *m_spInPlaceFrame;
+    ITypeInfo *m_spTypeInfo;
+    IStorage *m_spStorage;
+    QSize m_currentExtent;
+};
+
+class QAxServerAggregate : public IUnknown
+{
+public:
+    QAxServerAggregate(const QString &className, IUnknown *outerUnknown)
+	: m_outerUnknown(outerUnknown), ref(0)
+    {
+	object = new QAxServerBase(className, outerUnknown);
+	object->registerActiveObject(this);
+
+	InitializeCriticalSection(&refCountSection);
+	InitializeCriticalSection(&createWindowSection);
+    }
+    ~QAxServerAggregate()
+    {
+	DeleteCriticalSection(&refCountSection);
+	DeleteCriticalSection(&createWindowSection);
+
+	delete object;
+    }
+
+// IUnknown
+    unsigned long WINAPI AddRef()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = ++ref;
+	LeaveCriticalSection(&refCountSection);
+
+	return r;
+    }
+    unsigned long WINAPI Release()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = --ref;
+	LeaveCriticalSection(&refCountSection);
+
+	if (!r) {
+	    delete this;
+	    return 0;
+	}
+	return r;
+    }
+    HRESULT WINAPI QueryInterface(REFIID iid, void **iface)
+    {
+	*iface = 0;
+
+	HRESULT res = E_NOINTERFACE;
+	if (iid == IID_IUnknown) {
+	    *iface = (IUnknown*)this;
+	    AddRef();
+	    return S_OK;
+	}
+	return object->InternalQueryInterface(iid, iface);
+    }
+
+private:
+    QAxServerBase *object;
+    IUnknown *m_outerUnknown;
+    unsigned long ref;
+
+    CRITICAL_SECTION refCountSection;
+    CRITICAL_SECTION createWindowSection;
+};
+
+bool QAxFactory::createObjectWrapper(QObject *object, IDispatch **wrapper)
+{
+    *wrapper = 0;
+    QAxServerBase *obj = new QAxServerBase(object);
+    obj->QueryInterface(IID_IDispatch, (void**)wrapper);
+    if (*wrapper)
+	return true;
+
+    delete obj;
+    return false;
+}
+
+
+/*
+    Helper class to enumerate all supported event interfaces.
+*/
+class QAxSignalVec : public IEnumConnectionPoints
+{
+public:
+    QAxSignalVec(const QAxServerBase::ConnectionPoints &points)
+	: cpoints(points), ref(0)
+    {
+	InitializeCriticalSection(&refCountSection);
+	for (QAxServerBase::ConnectionPointsIterator i = cpoints.begin(); i != cpoints.end(); ++i)
+	    (*i)->AddRef();
+    }
+    QAxSignalVec(const QAxSignalVec &old)
+    {
+	InitializeCriticalSection(&refCountSection);
+	ref = 0;
+	cpoints = old.cpoints;
+	for (QAxServerBase::ConnectionPointsIterator i = cpoints.begin(); i != cpoints.end(); ++i)
+	    (*i)->AddRef();
+	it = old.it;
+    }
+    ~QAxSignalVec()
+    {
+	for (QAxServerBase::ConnectionPointsIterator i = cpoints.begin(); i != cpoints.end(); ++i)
+	    (*i)->Release();
+
+	DeleteCriticalSection(&refCountSection);
+    }
+
+    unsigned long __stdcall AddRef()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = ++ref;
+	LeaveCriticalSection(&refCountSection);
+	return ++r;
+    }
+    unsigned long __stdcall Release()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = --ref;
+	LeaveCriticalSection(&refCountSection);
+
+	if (!r) {
+	    delete this;
+	    return 0;
+	}
+	return r;
+    }
+    STDMETHOD(QueryInterface)(REFIID iid, void **iface)
+    {
+	*iface = 0;
+	if (iid == IID_IUnknown)
+	    *iface = this;
+	else if (iid == IID_IEnumConnectionPoints)
+	    *iface = this;
+	else
+	    return E_NOINTERFACE;
+
+	AddRef();
+	return S_OK;
+    }
+    STDMETHOD(Next)(ULONG cConnections, IConnectionPoint **cpoint, ULONG *pcFetched)
+    {
+	unsigned long i;
+	for (i = 0; i < cConnections; i++) {
+	    if (it == cpoints.end())
+		break;
+	    IConnectionPoint *cp = *it;
+	    cp->AddRef();
+	    cpoint[i] = cp;
+	    ++it;
+	}
+	*pcFetched = i;
+	return i == cConnections ? S_OK : S_FALSE;
+    }
+    STDMETHOD(Skip)(ULONG cConnections)
+    {
+	while (cConnections) {
+	    ++it;
+	    --cConnections;
+	    if (it == cpoints.end())
+		return S_FALSE;
+	}
+	return S_OK;
+    }
+    STDMETHOD(Reset)()
+    {
+	it = cpoints.begin();
+
+	return S_OK;
+    }
+    STDMETHOD(Clone)(IEnumConnectionPoints **ppEnum)
+    {
+	*ppEnum = new QAxSignalVec(*this);
+	(*ppEnum)->AddRef();
+
+	return S_OK;
+    }
+
+    QAxServerBase::ConnectionPoints cpoints;
+    QAxServerBase::ConnectionPointsIterator it;
+
+private:
+    CRITICAL_SECTION refCountSection;
+
+    unsigned long ref;
+};
+
+/*
+    Helper class to store and enumerate all connected event listeners.
+*/
+class QAxConnection : public IConnectionPoint,
+		      public IEnumConnections
+{
+public:
+    typedef QList<CONNECTDATA> Connections;
+    typedef QList<CONNECTDATA>::Iterator Iterator;
+
+    QAxConnection(QAxServerBase *parent, const QUuid &uuid)
+	: that(parent), iid(uuid), ref(1)
+    {
+	InitializeCriticalSection(&refCountSection);
+    }
+    QAxConnection(const QAxConnection &old)
+    {
+	InitializeCriticalSection(&refCountSection);
+	ref = 0;
+	connections = old.connections;
+	it = old.it;
+	that = old.that;
+	iid = old.iid;
+	QList<CONNECTDATA>::Iterator it = connections.begin();
+	while (it != connections.end()) {
+	    CONNECTDATA connection = *it;
+	    ++it;
+	    connection.pUnk->AddRef();
+	}
+    }
+    ~QAxConnection()
+    {
+	DeleteCriticalSection(&refCountSection);
+    }
+
+    unsigned long __stdcall AddRef()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = ++ref;
+	LeaveCriticalSection(&refCountSection);
+	return r;
+    }
+    unsigned long __stdcall Release()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = --ref;
+	LeaveCriticalSection(&refCountSection);
+
+	if (!r) {
+	    delete this;
+	    return 0;
+	}
+	return r;
+    }
+    STDMETHOD(QueryInterface)(REFIID iid, void **iface)
+    {
+	*iface = 0;
+	if (iid == IID_IUnknown)
+	    *iface = (IConnectionPoint*)this;
+	else if (iid == IID_IConnectionPoint)
+	    *iface = this;
+	else if (iid == IID_IEnumConnections)
+	    *iface = this;
+	else
+	    return E_NOINTERFACE;
+
+	AddRef();
+	return S_OK;
+    }
+    STDMETHOD(GetConnectionInterface)(IID *pIID)
+    {
+	*pIID = iid;
+	return S_OK;
+    }
+    STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer **ppCPC)
+    {
+	return that->QueryInterface(IID_IConnectionPointContainer, (void**)ppCPC);
+    }
+    STDMETHOD(Advise)(IUnknown*pUnk, DWORD *pdwCookie)
+    {
+	{
+	    IDispatch *checkImpl = 0;
+	    pUnk->QueryInterface(iid, (void**)&checkImpl);
+	    if (!checkImpl)
+		return CONNECT_E_CANNOTCONNECT;
+	    checkImpl->Release();
+	}
+
+	CONNECTDATA cd;
+	cd.dwCookie = connections.count()+1;
+	cd.pUnk = pUnk;
+	cd.pUnk->AddRef();
+	connections.append(cd);
+
+	*pdwCookie = cd.dwCookie;
+	return S_OK;
+    }
+    STDMETHOD(Unadvise)(DWORD dwCookie)
+    {
+	QList<CONNECTDATA>::Iterator it = connections.begin();
+	while (it != connections.end()) {
+	    CONNECTDATA cd = *it;
+	    if (cd.dwCookie == dwCookie) {
+		cd.pUnk->Release();
+		connections.erase(it);
+		return S_OK;
+	    }
+	    ++it;
+	}
+	return CONNECT_E_NOCONNECTION;
+    }
+    STDMETHOD(EnumConnections)(IEnumConnections **ppEnum)
+    {
+	*ppEnum = this;
+	AddRef();
+
+	return S_OK;
+    }
+    STDMETHOD(Next)(ULONG cConnections, CONNECTDATA *cd, ULONG *pcFetched)
+    {
+	unsigned long i;
+	for (i = 0; i < cConnections; i++) {
+	    if (it == connections.end())
+		break;
+	    cd[i] = *it;
+	    cd[i].pUnk->AddRef();
+	    ++it;
+	}
+	if (pcFetched)
+	    *pcFetched = i;
+	return i == cConnections ? S_OK : S_FALSE;
+    }
+    STDMETHOD(Skip)(ULONG cConnections)
+    {
+	while (cConnections) {
+	    ++it;
+	    --cConnections;
+	    if (it == connections.end())
+		return S_FALSE;
+	}
+	return S_OK;
+    }
+    STDMETHOD(Reset)()
+    {
+	it = connections.begin();
+
+	return S_OK;
+    }
+    STDMETHOD(Clone)(IEnumConnections **ppEnum)
+    {
+	*ppEnum = new QAxConnection(*this);
+	(*ppEnum)->AddRef();
+
+	return S_OK;
+    }
+
+private:
+    QAxServerBase *that;
+    QUuid iid;
+    Connections connections;
+    Iterator it;
+
+    CRITICAL_SECTION refCountSection;
+    unsigned long ref;
+};
+
+// callback for DLL server to hook into non-Qt eventloop
+LRESULT CALLBACK axs_FilterProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (qApp && !invokeCount)
+        qApp->sendPostedEvents();
+
+    return CallNextHookEx(qax_hhook, nCode, wParam, lParam);
+}
+
+// filter for executable case to hook into Qt eventloop
+// for DLLs the client calls TranslateAccelerator
+bool qax_winEventFilter(void *message)
+{
+    MSG *pMsg = (MSG*)message;
+    if (pMsg->message < WM_KEYFIRST || pMsg->message > WM_KEYLAST)
+	return false;
+
+    bool ret = false;
+    QWidget *aqt = QWidget::find(pMsg->hwnd);
+    if (!aqt)
+	return ret;
+
+    HWND baseHwnd = ::GetParent(aqt->winId());
+    QAxServerBase *axbase = 0;
+    while (!axbase && baseHwnd) {
+#ifdef GWLP_USERDATA
+        QT_WA({
+            axbase = (QAxServerBase*)GetWindowLongPtrW(baseHwnd, GWLP_USERDATA);
+        }, {
+            axbase = (QAxServerBase*)GetWindowLongPtrA(baseHwnd, GWLP_USERDATA);
+        });
+#else
+        QT_WA({
+            axbase = (QAxServerBase*)GetWindowLongW(baseHwnd, GWL_USERDATA);
+        }, {
+            axbase = (QAxServerBase*)GetWindowLongA(baseHwnd, GWL_USERDATA);
+        });
+#endif
+
+	baseHwnd = ::GetParent(baseHwnd);
+    }
+    if (!axbase)
+	return ret;
+
+    HRESULT hres = axbase->TranslateAcceleratorW(pMsg);
+    return hres == S_OK;
+}
+
+extern void qWinMsgHandler(QtMsgType t, const char* str);
+
+// COM Factory class, mapping COM requests to ActiveQt requests.
+// One instance of this class for each ActiveX the server can provide.
+class QClassFactory : public IClassFactory2
+{
+public:
+    QClassFactory(CLSID clsid)
+	: ref(0), licensed(false)
+    {
+	InitializeCriticalSection(&refCountSection);
+
+	// COM only knows the CLSID, but QAxFactory is class name based...
+	QStringList keys = qAxFactory()->featureList();
+	for (QStringList::Iterator  key = keys.begin(); key != keys.end(); ++key) {
+	    if (qAxFactory()->classID(*key) == clsid) {
+		className = *key;
+		break;
+	    }
+	}
+
+	const QMetaObject *mo = qAxFactory()->metaObject(className);
+	if (mo) {
+	    classKey = QLatin1String(mo->classInfo(mo->indexOfClassInfo("LicenseKey")).value());
+	    licensed = !classKey.isEmpty();
+	}
+    }
+
+    ~QClassFactory()
+    {
+	DeleteCriticalSection(&refCountSection);
+    }
+
+    // IUnknown
+    unsigned long WINAPI AddRef()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = ++ref;
+	LeaveCriticalSection(&refCountSection);
+	return ++r;
+    }
+    unsigned long WINAPI Release()
+    {
+	EnterCriticalSection(&refCountSection);
+	unsigned long r = --ref;
+	LeaveCriticalSection(&refCountSection);
+
+	if (!r) {
+	    delete this;
+	    return 0;
+	}
+	return r;
+    }
+    HRESULT WINAPI QueryInterface(REFIID iid, LPVOID *iface)
+    {
+	*iface = 0;
+	if (iid == IID_IUnknown)
+	    *iface = (IUnknown*)this;
+	else if (iid == IID_IClassFactory)
+	    *iface = (IClassFactory*)this;
+	else if (iid == IID_IClassFactory2 && licensed)
+	    *iface = (IClassFactory2*)this;
+	else
+	    return E_NOINTERFACE;
+
+	AddRef();
+	return S_OK;
+    }
+
+    HRESULT WINAPI CreateInstanceHelper(IUnknown *pUnkOuter, REFIID iid, void **ppObject)
+    {
+	if (pUnkOuter) {
+	    if (iid != IID_IUnknown)
+		return CLASS_E_NOAGGREGATION;
+	    const QMetaObject *mo = qAxFactory()->metaObject(className);
+	    if (mo && !qstricmp(mo->classInfo(mo->indexOfClassInfo("Aggregatable")).value(), "no"))
+		return CLASS_E_NOAGGREGATION;
+	}
+
+    	// Make sure a QApplication instance is present (inprocess case)
+        if (!qApp) {
+            qInstallMsgHandler(qWinMsgHandler);
+            qax_ownQApp = true;
+            int argc = 0;
+            QApplication *app = new QApplication(argc, 0);
+        }
+        qApp->setQuitOnLastWindowClosed(false);
+
+        if (qAxOutProcServer)
+            QAbstractEventDispatcher::instance()->setEventFilter(qax_winEventFilter);
+        else
+            QApplication::instance()->d_func()->in_exec = true;
+
+        // hook into eventloop; this allows a server to create his own QApplication object
+        if (!qax_hhook && qax_ownQApp) {
+            QT_WA({
+                qax_hhook = SetWindowsHookExW(WH_GETMESSAGE, axs_FilterProc, 0, GetCurrentThreadId());
+            }, {
+                qax_hhook = SetWindowsHookExA(WH_GETMESSAGE, axs_FilterProc, 0, GetCurrentThreadId());
+            });
+        }
+
+	HRESULT res;
+	// Create the ActiveX wrapper - aggregate if requested
+	if (pUnkOuter) {
+	    QAxServerAggregate *aggregate = new QAxServerAggregate(className, pUnkOuter);
+	    res = aggregate->QueryInterface(iid, ppObject);
+	    if (FAILED(res))
+		delete aggregate;
+	} else {
+	    QAxServerBase *activeqt = new QAxServerBase(className, pUnkOuter);
+	    res = activeqt->QueryInterface(iid, ppObject);
+	    if (FAILED(res))
+		delete activeqt;
+	    else
+		activeqt->registerActiveObject((IUnknown*)(IDispatch*)activeqt);
+	}
+	return res;
+    }
+
+    // IClassFactory
+    HRESULT WINAPI CreateInstance(IUnknown *pUnkOuter, REFIID iid, void **ppObject)
+    {
+	// class is licensed
+	if (licensed && !qAxFactory()->validateLicenseKey(className, QString()))
+	    return CLASS_E_NOTLICENSED;
+
+	return CreateInstanceHelper(pUnkOuter, iid, ppObject);
+    }
+    HRESULT WINAPI LockServer(BOOL fLock)
+    {
+	if (fLock)
+	    qAxLock();
+	else
+	    qAxUnlock();
+
+	return S_OK;
+    }
+
+    // IClassFactory2
+    HRESULT WINAPI RequestLicKey(DWORD, BSTR *pKey)
+    {
+	if (!pKey)
+	    return E_POINTER;
+	*pKey = 0;
+
+	// This of course works only on fully licensed machines
+	if (!qAxFactory()->validateLicenseKey(className, QString()))
+	    return CLASS_E_NOTLICENSED;
+
+	*pKey = QStringToBSTR(classKey);
+	return S_OK;
+    }
+
+    HRESULT WINAPI GetLicInfo(LICINFO *pLicInfo)
+    {
+	if (!pLicInfo)
+	    return E_POINTER;
+	pLicInfo->cbLicInfo = sizeof(LICINFO);
+
+	// class specific license key?
+	const QMetaObject *mo = qAxFactory()->metaObject(className);
+	const char *key = mo->classInfo(mo->indexOfClassInfo("LicenseKey")).value();
+	pLicInfo->fRuntimeKeyAvail = key && key[0];
+
+	// machine fully licensed?
+	pLicInfo->fLicVerified = qAxFactory()->validateLicenseKey(className, QString());
+
+	return S_OK;
+    }
+
+    HRESULT WINAPI CreateInstanceLic(IUnknown *pUnkOuter, IUnknown *pUnkReserved, REFIID iid, BSTR bKey, PVOID *ppObject)
+    {
+        QString licenseKey = QString::fromUtf16((const ushort *)bKey);
+	if (!qAxFactory()->validateLicenseKey(className, licenseKey))
+	    return CLASS_E_NOTLICENSED;
+	return CreateInstanceHelper(pUnkOuter, iid, ppObject);
+    }
+
+    QString className;
+
+protected:
+    CRITICAL_SECTION refCountSection;
+    unsigned long ref;
+    bool licensed;
+    QString classKey;
+};
+
+// Create a QClassFactory object for class \a iid
+HRESULT GetClassObject(REFIID clsid, REFIID iid, void **ppUnk)
+{
+    QClassFactory *factory = new QClassFactory(clsid);
+    if (!factory)
+	return E_OUTOFMEMORY;
+    if (factory->className.isEmpty()) {
+	delete factory;
+	return E_NOINTERFACE;
+    }
+    HRESULT res = factory->QueryInterface(iid, ppUnk);
+    if (res != S_OK)
+	delete factory;
+    return res;
+}
+
+
+/*!
+    Constructs a QAxServerBase object wrapping the QWidget \a
+    classname into an ActiveX control.
+
+    The constructor is called by the QClassFactory object provided by
+    the COM server for the respective CLSID.
+*/
+QAxServerBase::QAxServerBase(const QString &classname, IUnknown *outerUnknown)
+: aggregatedObject(0), ref(0), ole_ref(0), class_name(classname),
+  m_hWnd(0), hmenuShared(0), hwndMenuOwner(0),
+  m_outerUnknown(outerUnknown)
+{
+    init();
+
+    internalCreate();
+}
+
+/*!
+    Constructs a QAxServerBase object wrapping \a o.
+*/
+QAxServerBase::QAxServerBase(QObject *o)
+: aggregatedObject(0), ref(0), ole_ref(0),
+  m_hWnd(0), hmenuShared(0), hwndMenuOwner(0),
+  m_outerUnknown(0)
+{
+    init();
+
+    qt.object = o;
+    if (o) {
+	theObject = o;
+	isWidget = false;
+	class_name = QLatin1String(o->metaObject()->className());
+    }
+    internalBind();
+    internalConnect();
+}
+
+/*!
+    Initializes data members.
+*/
+void QAxServerBase::init()
+{
+    qt.object = 0;
+    isWidget		= false;
+    ownObject		= false;
+    initNewCalled	= false;
+    dirtyflag		= false;
+    hasStockEvents	= false;
+    stayTopLevel	= false;
+    isInPlaceActive	= false;
+    isUIActive		= false;
+    wasUIActive		= false;
+    inDesignMode	= false;
+    canTakeFocus	= false;
+    freezeEvents = 0;
+    exception = 0;
+
+    m_spAdviseSink = 0;
+    m_spClientSite = 0;
+    m_spInPlaceSite = 0;
+    m_spInPlaceFrame = 0;
+    m_spTypeInfo = 0;
+    m_spStorage = 0;
+
+    InitializeCriticalSection(&refCountSection);
+    InitializeCriticalSection(&createWindowSection);
+
+#ifdef QT_DEBUG
+    EnterCriticalSection(&refCountSection);
+    ++qaxserverbase_instance_count;
+    LeaveCriticalSection(&refCountSection);
+#endif
+
+    qAxLock();
+
+    points[IID_IPropertyNotifySink] = new QAxConnection(this, IID_IPropertyNotifySink);
+}
+
+/*!
+    Destroys the QAxServerBase object, releasing all allocated
+    resources and interfaces.
+*/
+QAxServerBase::~QAxServerBase()
+{
+#ifdef QT_DEBUG
+    EnterCriticalSection(&refCountSection);
+    --qaxserverbase_instance_count;
+    LeaveCriticalSection(&refCountSection);
+#endif
+
+    revokeActiveObject();
+
+    for (QAxServerBase::ConnectionPointsIterator it = points.begin(); it != points.end(); ++it) {
+	if (it.value())
+	    (*it)->Release();
+    }
+    delete aggregatedObject;
+    aggregatedObject = 0;
+    if (theObject) {
+	qt.object->disconnect(this);
+	QObject *aqt = qt.object;
+	qt.object = 0;
+	if (ownObject)
+	    delete aqt;
+    }
+
+    if (m_spAdviseSink) m_spAdviseSink->Release();
+    m_spAdviseSink = 0;
+    for (int i = 0; i < adviseSinks.count(); ++i) {
+        adviseSinks.at(i).pAdvSink->Release();
+    }
+    if (m_spClientSite) m_spClientSite->Release();
+    m_spClientSite = 0;
+    if (m_spInPlaceFrame) m_spInPlaceFrame->Release();
+    m_spInPlaceFrame = 0;
+    if (m_spInPlaceSite) m_spInPlaceSite->Release();
+    m_spInPlaceSite = 0;
+    if (m_spTypeInfo) m_spTypeInfo->Release();
+    m_spTypeInfo = 0;
+    if (m_spStorage) m_spStorage->Release();
+    m_spStorage = 0;
+
+    DeleteCriticalSection(&refCountSection);
+    DeleteCriticalSection(&createWindowSection);
+
+    qAxUnlock();
+}
+
+/*
+    Registering with OLE
+*/
+void QAxServerBase::registerActiveObject(IUnknown *object)
+{
+    if (ole_ref || !qt.object || !qAxOutProcServer)
+	return;
+
+    const QMetaObject *mo = qt.object->metaObject();
+    if (!qstricmp(mo->classInfo(mo->indexOfClassInfo("RegisterObject")).value(), "yes"))
+	RegisterActiveObject(object, qAxFactory()->classID(class_name), ACTIVEOBJECT_WEAK, &ole_ref);
+}
+
+void QAxServerBase::revokeActiveObject()
+{
+    if (!ole_ref)
+	return;
+
+    RevokeActiveObject(ole_ref, 0);
+    ole_ref = 0;
+}
+
+/*
+    QueryInterface implementation.
+*/
+HRESULT WINAPI QAxServerBase::QueryInterface(REFIID iid, void **iface)
+{
+    if (m_outerUnknown)
+	return m_outerUnknown->QueryInterface(iid, iface);
+
+    return InternalQueryInterface(iid, iface);
+}
+
+HRESULT QAxServerBase::InternalQueryInterface(REFIID iid, void **iface)
+{
+    *iface = 0;
+
+    if (iid == IID_IUnknown) {
+	*iface = (IUnknown*)(IDispatch*)this;
+    } else {
+	HRESULT res = S_OK;
+	if (aggregatedObject)
+	    res = aggregatedObject->queryInterface(iid, iface);
+	if (*iface)
+	    return res;
+    }
+
+    if (!(*iface)) {
+	if (iid == qAxFactory()->interfaceID(class_name))
+	    *iface = (IDispatch*)this;
+	if (iid == IID_IDispatch)
+	    *iface = (IDispatch*)this;
+	else if (iid == IID_IAxServerBase)
+	    *iface = (IAxServerBase*)this;
+	else if (iid == IID_IOleObject)
+	    *iface = (IOleObject*)this;
+	else if (iid == IID_IConnectionPointContainer)
+	    *iface = (IConnectionPointContainer*)this;
+	else if (iid == IID_IProvideClassInfo)
+	    *iface = (IProvideClassInfo*)this;
+	else if (iid == IID_IProvideClassInfo2)
+	    *iface = (IProvideClassInfo2*)this;
+	else if (iid == IID_IPersist)
+	    *iface = (IPersist*)(IPersistStream*)this;
+	else if (iid == IID_IPersistStream)
+	    *iface = (IPersistStream*)this;
+	else if (iid == IID_IPersistStreamInit)
+	    *iface = (IPersistStreamInit*)this;
+	else if (iid == IID_IPersistStorage)
+	    *iface = (IPersistStorage*)this;
+	else if (iid == IID_IPersistPropertyBag)
+	    *iface = (IPersistPropertyBag*)this;
+        else if (iid == IID_IPersistFile &&
+            qAxFactory()->metaObject(class_name)->indexOfClassInfo("MIME") != -1)
+            *iface = (IPersistFile*)this;
+	else if (iid == IID_IViewObject)
+	    *iface = (IViewObject*)this;
+	else if (iid == IID_IViewObject2)
+	    *iface = (IViewObject2*)this;
+	else if (isWidget) {
+	    if (iid == IID_IOleControl)
+		*iface = (IOleControl*)this;
+	    else if (iid == IID_IOleWindow)
+		*iface = (IOleWindow*)(IOleInPlaceObject*)this;
+	    else if (iid == IID_IOleInPlaceObject)
+		*iface = (IOleInPlaceObject*)this;
+	    else if (iid == IID_IOleInPlaceActiveObject)
+		*iface = (IOleInPlaceActiveObject*)this;
+	    else if (iid == IID_IDataObject)
+		*iface = (IDataObject*)this;
+	}
+    }
+    if (!*iface)
+	return E_NOINTERFACE;
+
+    AddRef();
+    return S_OK;
+}
+
+/*!
+    Detects and initilaizes implementation of QAxBindable in objects.
+*/
+void QAxServerBase::internalBind()
+{
+    QAxBindable *axb = (QAxBindable*)qt.object->qt_metacast("QAxBindable");
+    if (axb) {
+	// no addref; this is aggregated
+	axb->activex = this;
+	if (!aggregatedObject)
+	    aggregatedObject = axb->createAggregate();
+	if (aggregatedObject) {
+	    aggregatedObject->controlling_unknown = (IUnknown*)(IDispatch*)this;
+	    aggregatedObject->the_object = qt.object;
+	}
+    }
+}
+
+/*!
+    Connects object signals to event dispatcher.
+*/
+void QAxServerBase::internalConnect()
+{
+    QUuid eventsID = qAxFactory()->eventsID(class_name);
+    if (!eventsID.isNull()) {
+	if (!points[eventsID])
+	    points[eventsID] = new QAxConnection(this, eventsID);
+
+	// connect the generic slot to all signals of qt.object
+	const QMetaObject *mo = qt.object->metaObject();
+        for (int isignal = mo->methodCount()-1; isignal >= 0; --isignal) {
+            if (mo->method(isignal).methodType() == QMetaMethod::Signal)
+	        QMetaObject::connect(qt.object, isignal, this, isignal);
+        }
+    }
+}
+
+/*!
+    Creates the QWidget for the classname passed to the c'tor.
+
+    All signals of the widget class are connected to the internal event mapper.
+    If the widget implements QAxBindable, stock events are also connected.
+*/
+bool QAxServerBase::internalCreate()
+{
+    if (qt.object)
+	return true;
+
+    qt.object = qAxFactory()->createObject(class_name);
+    Q_ASSERT(qt.object);
+    if (!qt.object)
+	return false;
+
+    theObject = qt.object;
+    ownObject = true;
+    isWidget = qt.object->isWidgetType();
+    hasStockEvents = qAxFactory()->hasStockEvents(class_name);
+    stayTopLevel = qAxFactory()->stayTopLevel(class_name);
+
+    internalBind();
+    if (isWidget) {
+	if (!stayTopLevel) {
+	    QEvent e(QEvent::EmbeddingControl);
+	    QApplication::sendEvent(qt.widget, &e);
+	    QT_WA({
+		::SetWindowLongW(qt.widget->winId(), GWL_STYLE, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
+	    }, {
+		::SetWindowLongA(qt.widget->winId(), GWL_STYLE, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS);
+	    });
+	}
+        qt.widget->setAttribute(Qt::WA_QuitOnClose, false);
+        qt.widget->move(0, 0);
+
+        // initialize to sizeHint, but don't set resized flag so that container has a chance to override
+        bool wasResized = qt.widget->testAttribute(Qt::WA_Resized);
+        updateGeometry();
+        if (!wasResized && qt.widget->testAttribute(Qt::WA_Resized)
+            && qt.widget->sizePolicy() != QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed)) {
+            qt.widget->setAttribute(Qt::WA_Resized, false);
+        }
+    }
+
+    internalConnect();
+    // install an event filter for stock events
+    if (isWidget) {
+        qt.object->installEventFilter(this);
+        const QList<QWidget*> children = qFindChildren<QWidget*>(qt.object);
+        QList<QWidget*>::ConstIterator it = children.constBegin();
+        while (it != children.constEnd()) {
+            (*it)->installEventFilter(this);
+            ++it;
+        }
+    }
+    return true;
+}
+
+/*
+class HackMenuData : public QMenuData
+{
+    friend class QAxServerBase;
+};
+*/
+
+class HackWidget : public QWidget
+{
+    friend class QAxServerBase;
+};
+/*
+    Message handler. \a hWnd is always the ActiveX widget hosting the Qt widget.
+    \a uMsg is handled as follows
+    \list
+    \i WM_CREATE The ActiveX control is created
+    \i WM_DESTROY The QWidget is destroyed
+    \i WM_SHOWWINDOW The QWidget is parented into the ActiveX window
+    \i WM_PAINT The QWidget is updated
+    \i WM_SIZE The QWidget is resized to the new size
+    \i WM_SETFOCUS and
+    \i WM_KILLFOCUS The client site is notified about the focus transfer
+    \i WM_MOUSEACTIVATE The ActiveX is activated
+    \endlist
+
+    The semantics of \a wParam and \a lParam depend on the value of \a uMsg.
+*/
+LRESULT CALLBACK QAxServerBase::ActiveXProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    if (uMsg == WM_CREATE) {
+	QAxServerBase *that;
+	QT_WA({
+	    CREATESTRUCTW *cs = (CREATESTRUCTW*)lParam;
+	    that = (QAxServerBase*)cs->lpCreateParams;
+	}, {
+	    CREATESTRUCTA *cs = (CREATESTRUCTA*)lParam;
+	    that = (QAxServerBase*)cs->lpCreateParams;
+	});
+
+#ifdef GWLP_USERDATA
+        QT_WA({
+            SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)that);
+        }, {
+            SetWindowLongPtrA(hWnd, GWLP_USERDATA, (LONG_PTR)that);
+        });
+#else
+        QT_WA({
+            SetWindowLongW(hWnd, GWL_USERDATA, (LONG)that);
+        }, {
+            SetWindowLongA(hWnd, GWL_USERDATA, (LONG)that);
+        });
+#endif
+
+	that->m_hWnd = hWnd;
+
+	QT_WA({
+	    return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+	}, {
+	    return ::DefWindowProcA(hWnd, uMsg, wParam, lParam);
+	});
+    }
+
+    QAxServerBase *that = 0;
+
+#ifdef GWLP_USERDATA
+    QT_WA({
+        that = (QAxServerBase*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);
+    }, {
+        that = (QAxServerBase*)GetWindowLongPtrA(hWnd, GWLP_USERDATA);
+    });
+#else
+    QT_WA({
+        that = (QAxServerBase*)GetWindowLongW(hWnd, GWL_USERDATA);
+    }, {
+        that = (QAxServerBase*)GetWindowLongA(hWnd, GWL_USERDATA);
+    });
+#endif
+
+    if (that) {
+        int width = that->qt.widget ? that->qt.widget->width() : 0;
+        int height = that->qt.widget ? that->qt.widget->height() : 0;
+        RECT rcPos = {0, 0, width + 1, height + 1};
+
+        switch (uMsg) {
+        case WM_NCDESTROY:
+	    that->m_hWnd = 0;
+	    break;
+
+        case WM_QUERYENDSESSION:
+        case WM_DESTROY:
+            // save the window handle
+            if (that->qt.widget) {
+                that->qt.widget->hide();
+                ::SetParent(that->qt.widget->winId(), 0);
+            }
+	    break;
+
+        case WM_SHOWWINDOW:
+	    if(wParam) {
+	        that->internalCreate();
+	        if (!that->stayTopLevel) {
+		    ::SetParent(that->qt.widget->winId(), that->m_hWnd);
+		    that->qt.widget->raise();
+		    that->qt.widget->move(0, 0);
+	        }
+	        that->qt.widget->show();
+	    } else if (that->qt.widget) {
+	        that->qt.widget->hide();
+	    }
+	    break;
+
+        case WM_ERASEBKGND:
+	    that->updateMask();
+	    break;
+
+        case WM_SIZE:
+            that->resize(QSize(LOWORD(lParam), HIWORD(lParam)));
+	    break;
+
+        case WM_SETFOCUS:
+	    if (that->isInPlaceActive && that->m_spClientSite && !that->inDesignMode && that->canTakeFocus) {
+	        that->DoVerb(OLEIVERB_UIACTIVATE, NULL, that->m_spClientSite, 0, that->m_hWnd, &rcPos);
+	        if (that->isUIActive) {
+		    IOleControlSite *spSite = 0;
+		    that->m_spClientSite->QueryInterface(IID_IOleControlSite, (void**)&spSite);
+		    if (spSite) {
+		        spSite->OnFocus(true);
+		        spSite->Release();
+		    }
+                    QWidget *candidate = that->qt.widget;
+                    while (!(candidate->focusPolicy() & Qt::TabFocus)) {
+                        candidate = candidate->nextInFocusChain();
+                        if (candidate == that->qt.widget) {
+                            candidate = 0;
+                            break;
+                        }
+                    }
+                    if (candidate) {
+                        candidate->setFocus();
+                        HackWidget *widget = (HackWidget*)that->qt.widget;
+                        if (::GetKeyState(VK_SHIFT) < 0)
+                            widget->focusNextPrevChild(false);
+                    }
+	        }
+	    }
+	    break;
+
+        case WM_KILLFOCUS:
+	    if (that->isInPlaceActive && that->isUIActive && that->m_spClientSite) {
+	        IOleControlSite *spSite = 0;
+	        that->m_spClientSite->QueryInterface(IID_IOleControlSite, (void**)&spSite);
+	        if (spSite) {
+		    if (!::IsChild(that->m_hWnd, ::GetFocus()))
+		        spSite->OnFocus(false);
+		    spSite->Release();
+	        }
+	    }
+	    break;
+
+        case WM_MOUSEACTIVATE:
+	    that->DoVerb(OLEIVERB_UIACTIVATE, NULL, that->m_spClientSite, 0, that->m_hWnd, &rcPos);
+	    break;
+
+        case WM_INITMENUPOPUP:
+	    if (that->qt.widget) {
+	        that->currentPopup = that->menuMap[(HMENU)wParam];
+	        if (!that->currentPopup)
+		    break;
+	        const QMetaObject *mo = that->currentPopup->metaObject();
+	        int index = mo->indexOfSignal("aboutToShow()");
+	        if (index < 0)
+		    break;
+
+	        that->currentPopup->qt_metacall(QMetaObject::InvokeMetaMethod, index, 0);
+	        that->createPopup(that->currentPopup, (HMENU)wParam);
+	        return 0;
+	    }
+	    break;
+
+        case WM_MENUSELECT:
+        case WM_COMMAND:
+	    if (that->qt.widget) {
+	        QMenuBar *menuBar = that->menuBar;
+	        if (!menuBar)
+		    break;
+
+                QObject *menuObject = 0;
+	        bool menuClosed = false;
+
+                if (uMsg == WM_COMMAND) {
+		    menuObject = that->actionMap.value(wParam);
+                } else if (!lParam) {
+		    menuClosed = true;
+                    menuObject = that->currentPopup;
+                } else {
+                    menuObject = that->actionMap.value(LOWORD(wParam));
+                }
+
+	        if (menuObject) {
+		    const QMetaObject *mo = menuObject->metaObject();
+		    int index = -1;
+
+		    if (uMsg == WM_COMMAND)
+		        index = mo->indexOfSignal("activated()");
+		    else if (menuClosed)
+		        index = mo->indexOfSignal("aboutToHide()");
+		    else
+		        index = mo->indexOfSignal("hovered()");
+
+		    if (index < 0)
+		        break;
+
+		    menuObject->qt_metacall(QMetaObject::InvokeMetaMethod, index, 0);
+                    if (menuClosed || uMsg == WM_COMMAND)
+                        that->currentPopup = 0;
+		    return 0;
+	        }
+	    }
+	    break;
+
+        default:
+	    break;
+        }
+    }
+
+    QT_WA({
+	return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+    }, {
+	return ::DefWindowProcA(hWnd, uMsg, wParam, lParam);
+    });
+}
+
+/*!
+    Creates the window hosting the QWidget.
+*/
+HWND QAxServerBase::create(HWND hWndParent, RECT& rcPos)
+{
+    Q_ASSERT(isWidget && qt.widget);
+
+    static ATOM atom = 0;
+    HINSTANCE hInst = (HINSTANCE)qAxInstance;
+    EnterCriticalSection(&createWindowSection);
+    QString cn(QLatin1String("QAxControl"));
+    cn += QString::number((int)ActiveXProc);
+    if (!atom) {
+	QT_WA({
+	    WNDCLASSW wcTemp;
+	    wcTemp.style = CS_DBLCLKS;
+	    wcTemp.cbClsExtra = 0;
+	    wcTemp.cbWndExtra = 0;
+	    wcTemp.hbrBackground = 0;
+	    wcTemp.hCursor = 0;
+	    wcTemp.hIcon = 0;
+	    wcTemp.hInstance = hInst;
+	    wcTemp.lpszClassName = (wchar_t*)cn.utf16();
+	    wcTemp.lpszMenuName = 0;
+	    wcTemp.lpfnWndProc = ActiveXProc;
+
+	    atom = RegisterClassW(&wcTemp);
+	}, {
+            QByteArray cna = cn.toLatin1();
+	    WNDCLASSA wcTemp;
+	    wcTemp.style = CS_DBLCLKS;
+	    wcTemp.cbClsExtra = 0;
+	    wcTemp.cbWndExtra = 0;
+	    wcTemp.hbrBackground = 0;
+	    wcTemp.hCursor = 0;
+	    wcTemp.hIcon = 0;
+	    wcTemp.hInstance = hInst;
+	    wcTemp.lpszClassName = cna.data();
+	    wcTemp.lpszMenuName = 0;
+	    wcTemp.lpfnWndProc = ActiveXProc;
+
+	    atom = RegisterClassA(&wcTemp);
+	});
+    }
+    LeaveCriticalSection(&createWindowSection);
+    if (!atom  && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
+	return 0;
+
+    Q_ASSERT(!m_hWnd);
+    HWND hWnd = 0;
+    QT_WA({
+	hWnd = ::CreateWindowW((wchar_t*)cn.utf16(), 0,
+	    WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+	    rcPos.left, rcPos.top, rcPos.right - rcPos.left,
+	    rcPos.bottom - rcPos.top, hWndParent, 0, hInst, this);
+    }, {
+	hWnd = ::CreateWindowA(cn.toLatin1().data(), 0,
+	    WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+	    rcPos.left, rcPos.top, rcPos.right - rcPos.left,
+	    rcPos.bottom - rcPos.top, hWndParent, 0, hInst, this);
+    });
+
+    Q_ASSERT(m_hWnd == hWnd);
+
+    updateMask();
+    EnableWindow(m_hWnd, qt.widget->isEnabled());
+
+    return hWnd;
+}
+
+/*
+    Recoursively creates Win32 submenus.
+*/
+HMENU QAxServerBase::createPopup(QMenu *popup, HMENU oldMenu)
+{
+    HMENU popupMenu = oldMenu ? oldMenu : CreatePopupMenu();
+    menuMap.insert(popupMenu, popup);
+
+    if (oldMenu) while (GetMenuItemCount(oldMenu)) {
+	DeleteMenu(oldMenu, 0, MF_BYPOSITION);
+    }
+
+    const QList<QAction*> actions = popup->actions();
+    for (int i = 0; i < actions.count(); ++i) {
+        QAction *action = actions.at(i);
+
+        uint flags = action->isEnabled() ? MF_ENABLED : MF_GRAYED;
+        if (action->isSeparator())
+            flags |= MF_SEPARATOR;
+        else if (action->menu())
+            flags |= MF_POPUP;
+        else
+            flags |= MF_STRING;
+        if (action->isChecked())
+            flags |= MF_CHECKED;
+
+	ushort itemId;
+        if (flags & MF_POPUP) {
+            itemId = static_cast<ushort>(
+                reinterpret_cast<ulong>(createPopup(action->menu()))
+            );
+        } else {
+            itemId = static_cast<ushort>(reinterpret_cast<ulong>(action));
+            actionMap.remove(itemId);
+            actionMap.insert(itemId, action);
+        }
+        QT_WA({
+            AppendMenuW(popupMenu, flags, itemId, (TCHAR*)action->text().utf16());
+        }, {
+            AppendMenuA(popupMenu, flags, itemId, action->text().toLocal8Bit());
+        });
+    }
+    if (oldMenu)
+        DrawMenuBar(hwndMenuOwner);
+    return popupMenu;
+}
+
+/*!
+    Creates a Win32 menubar.
+*/
+void QAxServerBase::createMenu(QMenuBar *menuBar)
+{
+    hmenuShared = ::CreateMenu();
+
+    int edit = 0;
+    int object = 0;
+    int help = 0;
+
+    const QList<QAction*> actions = menuBar->actions();
+    for (int i = 0; i < actions.count(); ++i) {
+        QAction *action = actions.at(i);
+
+        uint flags = action->isEnabled() ? MF_ENABLED : MF_GRAYED;
+	if (action->isSeparator())
+	    flags |= MF_SEPARATOR;
+	else if (action->menu())
+	    flags |= MF_POPUP;
+	else
+	    flags |= MF_STRING;
+
+	if (action->text() == QCoreApplication::translate(qt.widget->metaObject()->className(), "&Edit"))
+	    edit++;
+	else if (action->text() == QCoreApplication::translate(qt.widget->metaObject()->className(), "&Help"))
+	    help++;
+	else
+	    object++;
+
+	ushort itemId;
+        if (flags & MF_POPUP) {
+            itemId = static_cast<ushort>(
+                reinterpret_cast<ulong>(createPopup(action->menu()))
+            );
+        } else {
+            itemId = static_cast<ushort>(reinterpret_cast<ulong>(action));
+            actionMap.insert(itemId, action);
+        }
+	QT_WA({
+	    AppendMenuW(hmenuShared, flags, itemId, (TCHAR*)action->text().utf16());
+	} , {
+	    AppendMenuA(hmenuShared, flags, itemId, action->text().toLocal8Bit());
+	});
+    }
+
+    OLEMENUGROUPWIDTHS menuWidths = {0,edit,0,object,0,help};
+    HRESULT hres = m_spInPlaceFrame->InsertMenus(hmenuShared, &menuWidths);
+    if (FAILED(hres)) {
+	::DestroyMenu(hmenuShared);
+	hmenuShared = 0;
+	return;
+    }
+
+    m_spInPlaceFrame->GetWindow(&hwndMenuOwner);
+
+    holemenu = OleCreateMenuDescriptor(hmenuShared, &menuWidths);
+    hres = m_spInPlaceFrame->SetMenu(hmenuShared, holemenu, m_hWnd);
+    if (FAILED(hres)) {
+	::DestroyMenu(hmenuShared);
+	hmenuShared = 0;
+	OleDestroyMenuDescriptor(holemenu);
+    }
+}
+
+/*!
+    Remove the Win32 menubar.
+*/
+void QAxServerBase::removeMenu()
+{
+    if (hmenuShared)
+	m_spInPlaceFrame->RemoveMenus(hmenuShared);
+    holemenu = 0;
+    m_spInPlaceFrame->SetMenu(0, 0, m_hWnd);
+    if (hmenuShared) {
+	DestroyMenu(hmenuShared);
+	hmenuShared = 0;
+	menuMap.clear();
+    }
+    hwndMenuOwner = 0;
+}
+
+extern bool ignoreSlots(const char *test);
+extern bool ignoreProps(const char *test);
+
+/*!
+    Makes sure the type info is loaded
+*/
+void QAxServerBase::ensureMetaData()
+{
+    if (!m_spTypeInfo) {
+	qAxTypeLibrary->GetTypeInfoOfGuid(qAxFactory()->interfaceID(class_name), &m_spTypeInfo);
+	m_spTypeInfo->AddRef();
+    }
+}
+
+/*!
+    \internal
+    Returns true if the property \a index is exposed to COM and should
+    be saved/loaded.
+*/
+bool QAxServerBase::isPropertyExposed(int index)
+{
+    if (!theObject)
+	return false;
+
+    bool result = false;
+    const QMetaObject *mo = theObject->metaObject();
+
+    int qtProps = 0;
+    if (theObject->isWidgetType())
+	qtProps = QWidget::staticMetaObject.propertyCount();
+    QMetaProperty property = mo->property(index);
+    if (index <= qtProps && ignoreProps(property.name()))
+	return result;
+
+    BSTR bstrNames = QStringToBSTR(QLatin1String(property.name()));
+    DISPID dispId;
+    GetIDsOfNames(IID_NULL, (BSTR*)&bstrNames, 1, LOCALE_USER_DEFAULT, &dispId);
+    result = dispId != DISPID_UNKNOWN;
+    SysFreeString(bstrNames);
+
+    return result;
+}
+
+
+/*!
+    \internal
+    Updates the view, or asks the client site to do so.
+*/
+void QAxServerBase::update()
+{
+    if (isInPlaceActive) {
+	if (m_hWnd)
+	    ::InvalidateRect(m_hWnd, 0, true);
+	else if (m_spInPlaceSite)
+	    m_spInPlaceSite->InvalidateRect(NULL, true);
+    } else if (m_spAdviseSink) {
+        m_spAdviseSink->OnViewChange(DVASPECT_CONTENT, -1);
+        for (int i = 0; i < adviseSinks.count(); ++i) {
+	    adviseSinks.at(i).pAdvSink->OnViewChange(DVASPECT_CONTENT, -1);
+        }
+    }
+}
+
+/*!
+    Resizes the control, faking a QResizeEvent if required
+*/
+void QAxServerBase::resize(const QSize &size)
+{
+    if (!isWidget || !qt.widget || !size.isValid() || size == QSize(0, 0))
+        return;
+
+    QSize oldSize = qt.widget->size();
+    qt.widget->resize(size);
+    QSize newSize = qt.widget->size();
+    // make sure we get a resize event even if not embedded as a control
+    if (!m_hWnd && !qt.widget->isVisible() && newSize != oldSize) {
+        QResizeEvent resizeEvent(newSize, oldSize);
+#ifndef QT_DLL // import from static library
+        extern bool qt_sendSpontaneousEvent(QObject*,QEvent*);
+#endif
+        qt_sendSpontaneousEvent(qt.widget, &resizeEvent);
+    }
+    m_currentExtent = qt.widget->size();
+}
+
+/*!
+    \internal
+
+    Updates the internal size values.
+*/
+void QAxServerBase::updateGeometry()
+{
+    if (!isWidget || !qt.widget)
+	return;
+
+    const QSize sizeHint = qt.widget->sizeHint();
+    const QSize size = qt.widget->size();
+    if (sizeHint.isValid()) { // if provided, adjust to sizeHint
+        QSize newSize = size;
+        if (!qt.widget->testAttribute(Qt::WA_Resized)) {
+            newSize = sizeHint;
+        } else { // according to sizePolicy rules if already resized
+            QSizePolicy sizePolicy = qt.widget->sizePolicy();
+            if (sizeHint.width() > size.width() && !(sizePolicy.horizontalPolicy() & QSizePolicy::ShrinkFlag))
+	        newSize.setWidth(sizeHint.width());
+            if (sizeHint.width() < size.width() && !(sizePolicy.horizontalPolicy() & QSizePolicy::GrowFlag))
+                newSize.setWidth(sizeHint.width());
+            if (sizeHint.height() > size.height() && !(sizePolicy.verticalPolicy() & QSizePolicy::ShrinkFlag))
+	        newSize.setHeight(sizeHint.height());
+            if (sizeHint.height() < size.height() && !(sizePolicy.verticalPolicy() & QSizePolicy::GrowFlag))
+                newSize.setHeight(sizeHint.height());
+        }
+        resize(newSize);
+
+    // set an initial size suitable for embedded controls
+    } else if (!qt.widget->testAttribute(Qt::WA_Resized)) {
+        resize(QSize(100, 100));
+        qt.widget->setAttribute(Qt::WA_Resized, false);
+    }
+}
+
+/*!
+    \internal
+
+    Updates the mask of the widget parent.
+*/
+void QAxServerBase::updateMask()
+{
+    if (!isWidget || !qt.widget || qt.widget->mask().isEmpty())
+	return;
+
+    QRegion rgn = qt.widget->mask();
+    HRGN hrgn = rgn.handle();
+
+    // Since SetWindowRegion takes ownership
+    HRGN wr = CreateRectRgn(0,0,0,0);
+    CombineRgn(wr, hrgn, 0, RGN_COPY);
+    SetWindowRgn(m_hWnd, wr, true);
+}
+
+static bool checkHRESULT(HRESULT hres)
+{
+    const char *name = 0;
+    switch(hres) {
+    case S_OK:
+	return true;
+    case DISP_E_BADPARAMCOUNT:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Bad parameter count", name);
+#endif
+	return false;
+    case DISP_E_BADVARTYPE:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Bad variant type", name);
+#endif
+	return false;
+    case DISP_E_EXCEPTION:
+#if defined(QT_CHECK_STATE)
+	    qWarning("QAxBase: Error calling IDispatch member %s: Exception thrown by server", name);
+#endif
+	return false;
+    case DISP_E_MEMBERNOTFOUND:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Member not found", name);
+#endif
+	return false;
+    case DISP_E_NONAMEDARGS:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: No named arguments", name);
+#endif
+	return false;
+    case DISP_E_OVERFLOW:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Overflow", name);
+#endif
+	return false;
+    case DISP_E_PARAMNOTFOUND:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Parameter not found", name);
+#endif
+	return false;
+    case DISP_E_TYPEMISMATCH:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Type mismatch", name);
+#endif
+	return false;
+    case DISP_E_UNKNOWNINTERFACE:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Unknown interface", name);
+#endif
+	return false;
+    case DISP_E_UNKNOWNLCID:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Unknown locale ID", name);
+#endif
+	return false;
+    case DISP_E_PARAMNOTOPTIONAL:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Non-optional parameter missing", name);
+#endif
+	return false;
+    default:
+#if defined(QT_CHECK_STATE)
+	qWarning("QAxBase: Error calling IDispatch member %s: Unknown error", name);
+#endif
+	return false;
+    }
+}
+
+static inline QByteArray paramType(const QByteArray &ptype, bool *out)
+{
+    *out = ptype.endsWith('&') || ptype.endsWith("**");
+    if (*out) {
+        QByteArray res(ptype);
+	res.truncate(res.length() - 1);
+        return res;
+    }
+
+    return ptype;
+}
+
+/*!
+    Catches all signals emitted by the Qt widget and fires the respective COM event.
+
+    \a isignal is the Qt Meta Object index of the received signal, and \a _o the
+    signal parameters.
+*/
+int QAxServerBase::qt_metacall(QMetaObject::Call call, int index, void **argv)
+{
+    Q_ASSERT(call == QMetaObject::InvokeMetaMethod);
+
+    if (index == -1) {
+        if (sender() && m_spInPlaceFrame) {
+            if (qobject_cast<QStatusBar*>(sender()) != statusBar)
+                return true;
+
+            if (statusBar->isHidden()) {
+                QString message = *(QString*)argv[1];
+                m_spInPlaceFrame->SetStatusText(QStringToBSTR(message));
+            }
+        }
+        return true;
+    }
+
+    if (freezeEvents || inDesignMode)
+        return true;
+
+    ensureMetaData();
+
+    // get the signal information.
+    const QMetaObject *mo = qt.object->metaObject();
+    QMetaMethod signal;
+    DISPID eventId = index;
+    int pcount = 0;
+    QByteArray type;
+    QList<QByteArray> ptypes;
+
+    switch(index) {
+    case DISPID_KEYDOWN:
+    case DISPID_KEYUP:
+        pcount = 2;
+        ptypes << "int&" << "int";
+        break;
+    case DISPID_KEYPRESS:
+        pcount = 1;
+        ptypes << "int&";
+        break;
+    case DISPID_MOUSEDOWN:
+    case DISPID_MOUSEMOVE:
+    case DISPID_MOUSEUP:
+        pcount = 4;
+        ptypes << "int" << "int" << "int" << "int";
+        break;
+    case DISPID_CLICK:
+        pcount = 0;
+        break;
+    case DISPID_DBLCLICK:
+        pcount = 0;
+        break;
+    default:
+        {
+            signal = mo->method(index);
+            Q_ASSERT(signal.methodType() == QMetaMethod::Signal);
+            type = signal.typeName();
+            QByteArray signature(signal.signature());
+            QByteArray name(signature);
+            name.truncate(name.indexOf('('));
+
+            eventId = signalCache.value(index, -1);
+            if (eventId == -1) {
+                ITypeInfo *eventInfo = 0;
+                qAxTypeLibrary->GetTypeInfoOfGuid(qAxFactory()->eventsID(class_name), &eventInfo);
+                if (eventInfo) {
+                    QString uni_name = QLatin1String(name);
+                    const OLECHAR *olename = reinterpret_cast<const OLECHAR *>(uni_name.utf16());
+                    eventInfo->GetIDsOfNames((OLECHAR**)&olename, 1, &eventId);
+                    eventInfo->Release();
+                }
+            }
+
+            signature = signature.mid(name.length() + 1);
+            signature.truncate(signature.length() - 1);
+
+            if (!signature.isEmpty())
+                ptypes = signature.split(',');
+
+            pcount = ptypes.count();
+        }
+        break;
+    }
+    if (pcount && !argv) {
+        qWarning("QAxServerBase::qt_metacall: Missing %d arguments", pcount);
+        return false;
+    }
+    if (eventId == -1)
+        return false;
+
+    // For all connected event sinks...
+    IConnectionPoint *cpoint = 0;
+    GUID IID_QAxEvents = qAxFactory()->eventsID(class_name);
+    FindConnectionPoint(IID_QAxEvents, &cpoint);
+    if (cpoint) {
+        IEnumConnections *clist = 0;
+        cpoint->EnumConnections(&clist);
+        if (clist) {
+            clist->Reset();
+            ULONG cc = 1;
+            CONNECTDATA c[1];
+            clist->Next(cc, (CONNECTDATA*)&c, &cc);
+            if (cc) {
+                // setup parameters
+                unsigned int argErr = 0;
+                DISPPARAMS dispParams;
+                dispParams.cArgs = pcount;
+                dispParams.cNamedArgs = 0;
+                dispParams.rgdispidNamedArgs = 0;
+                dispParams.rgvarg = 0;
+
+                if (pcount) // Use malloc/free for eval package compatibility
+                    dispParams.rgvarg = (VARIANTARG*)malloc(pcount * sizeof(VARIANTARG));
+                int p = 0;
+                for (p = 0; p < pcount; ++p) {
+                    VARIANT *arg = dispParams.rgvarg + (pcount - p - 1);
+                    VariantInit(arg);
+
+                    bool out;
+                    QByteArray ptype = paramType(ptypes.at(p), &out);
+                    QVariant variant;
+                    if (mo->indexOfEnumerator(ptype) != -1) {
+                        // convert enum values to int
+                        variant = QVariant(*reinterpret_cast<int *>(argv[p+1]));
+                    } else {
+                        QVariant::Type vt = QVariant::nameToType(ptype);
+                        if (vt == QVariant::UserType) {
+                            if (ptype.endsWith('*')) {
+                                variant = QVariant(QMetaType::type(ptype), (void**)argv[p+1]);
+                                // qVariantSetValue(variant, *(void**)(argv[p + 1]), ptype);
+                            } else {
+                                variant = QVariant(QMetaType::type(ptype), argv[p+1]);
+                                // qVariantSetValue(variant, argv[p + 1], ptype);
+                            }
+                        } else {
+                            variant = QVariant(vt, argv[p + 1]);
+                        }
+                    }
+
+                    QVariantToVARIANT(variant, *arg, type, out);
+                }
+
+                VARIANT retval;
+                VariantInit(&retval);
+                VARIANT *pretval = 0;
+                if (!type.isEmpty())
+                    pretval = &retval;
+
+                // call listeners (through IDispatch)
+                while (cc) {
+                    if (c->pUnk) {
+                        IDispatch *disp = 0;
+                        c->pUnk->QueryInterface(IID_QAxEvents, (void**)&disp);
+                        if (disp) {
+                            disp->Invoke(eventId, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &dispParams, pretval, 0, &argErr);
+
+                            // update out-parameters and return value
+                            if (index > 0) {
+                                for (p = 0; p < pcount; ++p) {
+                                    bool out;
+                                    QByteArray ptype = paramType(ptypes.at(p), &out);
+                                    if (out)
+                                        QVariantToVoidStar(VARIANTToQVariant(dispParams.rgvarg[pcount - p - 1], ptype), argv[p+1], ptype);
+                                }
+                                if (pretval)
+                                    QVariantToVoidStar(VARIANTToQVariant(retval, type), argv[0], type);
+                            }
+                            disp->Release();
+                        }
+                        c->pUnk->Release(); // AddRef'ed by clist->Next implementation
+                    }
+                    clist->Next(cc, (CONNECTDATA*)&c, &cc);
+                }
+
+                // clean up
+                for (p = 0; p < pcount; ++p)
+                    clearVARIANT(dispParams.rgvarg+p);
+                free(dispParams.rgvarg);
+            }
+            clist->Release();
+        }
+        cpoint->Release();
+    }
+
+    return true;
+}
+
+/*!
+    Call IPropertyNotifySink of connected clients.
+    \a dispId specifies the ID of the property that changed.
+*/
+bool QAxServerBase::emitRequestPropertyChange(const char *property)
+{
+    long dispId = -1;
+
+    IConnectionPoint *cpoint = 0;
+    FindConnectionPoint(IID_IPropertyNotifySink, &cpoint);
+    if (cpoint) {
+	IEnumConnections *clist = 0;
+	cpoint->EnumConnections(&clist);
+	if (clist) {
+	    clist->Reset();
+	    ULONG cc = 1;
+	    CONNECTDATA c[1];
+	    clist->Next(cc, (CONNECTDATA*)&c, &cc);
+	    if (cc) {
+		if (dispId == -1) {
+		    BSTR bstr = QStringToBSTR(QLatin1String(property));
+		    GetIDsOfNames(IID_NULL, &bstr, 1, LOCALE_USER_DEFAULT, &dispId);
+		    SysFreeString(bstr);
+		}
+		if (dispId != -1) while (cc) {
+		    if (c->pUnk) {
+			IPropertyNotifySink *sink = 0;
+			c->pUnk->QueryInterface(IID_IPropertyNotifySink, (void**)&sink);
+			bool disallows = sink && sink->OnRequestEdit(dispId) == S_FALSE;
+			sink->Release();
+			c->pUnk->Release();
+			if (disallows) { // a client disallows the property to change
+			    clist->Release();
+			    cpoint->Release();
+			    return false;
+			}
+		    }
+		    clist->Next(cc, (CONNECTDATA*)&c, &cc);
+		}
+	    }
+	    clist->Release();
+	}
+	cpoint->Release();
+    }
+    dirtyflag = true;
+    return true;
+}
+
+/*!
+    Call IPropertyNotifySink of connected clients.
+    \a dispId specifies the ID of the property that changed.
+*/
+void QAxServerBase::emitPropertyChanged(const char *property)
+{
+    long dispId = -1;
+
+    IConnectionPoint *cpoint = 0;
+    FindConnectionPoint(IID_IPropertyNotifySink, &cpoint);
+    if (cpoint) {
+	IEnumConnections *clist = 0;
+	cpoint->EnumConnections(&clist);
+	if (clist) {
+	    clist->Reset();
+	    ULONG cc = 1;
+	    CONNECTDATA c[1];
+	    clist->Next(cc, (CONNECTDATA*)&c, &cc);
+	    if (cc) {
+		if (dispId == -1) {
+		    BSTR bstr = QStringToBSTR(QLatin1String(property));
+		    GetIDsOfNames(IID_NULL, &bstr, 1, LOCALE_USER_DEFAULT, &dispId);
+		    SysFreeString(bstr);
+		}
+		if (dispId != -1) while (cc) {
+		    if (c->pUnk) {
+			IPropertyNotifySink *sink = 0;
+			c->pUnk->QueryInterface(IID_IPropertyNotifySink, (void**)&sink);
+			if (sink) {
+			    sink->OnChanged(dispId);
+			    sink->Release();
+			}
+			c->pUnk->Release();
+		    }
+		    clist->Next(cc, (CONNECTDATA*)&c, &cc);
+		}
+	    }
+	    clist->Release();
+	}
+	cpoint->Release();
+    }
+    dirtyflag = true;
+}
+
+//**** IProvideClassInfo
+/*
+    Provide the ITypeInfo implementation for the COM class.
+*/
+HRESULT WINAPI QAxServerBase::GetClassInfo(ITypeInfo** pptinfo)
+{
+    if (!pptinfo)
+	return E_POINTER;
+
+    *pptinfo = 0;
+    if (!qAxTypeLibrary)
+	return DISP_E_BADINDEX;
+
+    return qAxTypeLibrary->GetTypeInfoOfGuid(qAxFactory()->classID(class_name), pptinfo);
+}
+
+//**** IProvideClassInfo2
+/*
+    Provide the ID of the event interface.
+*/
+HRESULT WINAPI QAxServerBase::GetGUID(DWORD dwGuidKind, GUID* pGUID)
+{
+    if (!pGUID)
+	return E_POINTER;
+
+    if (dwGuidKind == GUIDKIND_DEFAULT_SOURCE_DISP_IID) {
+	*pGUID = qAxFactory()->eventsID(class_name);
+	return S_OK;
+    }
+    *pGUID = GUID_NULL;
+    return E_FAIL;
+}
+
+//**** IDispatch
+/*
+    Returns the number of class infos for this IDispatch.
+*/
+HRESULT WINAPI QAxServerBase::GetTypeInfoCount(UINT* pctinfo)
+{
+    if (!pctinfo)
+	return E_POINTER;
+
+    *pctinfo = qAxTypeLibrary ? 1 : 0;
+    return S_OK;
+}
+
+/*
+    Provides the ITypeInfo for this IDispatch implementation.
+*/
+HRESULT WINAPI QAxServerBase::GetTypeInfo(UINT itinfo, LCID /*lcid*/, ITypeInfo** pptinfo)
+{
+    if (!pptinfo)
+	return E_POINTER;
+
+    if (!qAxTypeLibrary)
+	return DISP_E_BADINDEX;
+
+    ensureMetaData();
+
+    *pptinfo = m_spTypeInfo;
+    (*pptinfo)->AddRef();
+
+    return S_OK;
+}
+
+/*
+    Provides the names of the methods implemented in this IDispatch implementation.
+*/
+HRESULT WINAPI QAxServerBase::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
+				     LCID /*lcid*/, DISPID* rgdispid)
+{
+    if (!rgszNames || !rgdispid)
+	return E_POINTER;
+
+    if (!qAxTypeLibrary)
+	return DISP_E_UNKNOWNNAME;
+
+    ensureMetaData();
+    if (!m_spTypeInfo)
+	return DISP_E_UNKNOWNNAME;
+
+    return m_spTypeInfo->GetIDsOfNames(rgszNames, cNames, rgdispid);
+}
+
+/*
+    Map the COM call to the Qt slot/property for \a dispidMember.
+*/
+HRESULT WINAPI QAxServerBase::Invoke(DISPID dispidMember, REFIID riid,
+		  LCID /*lcid*/, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pvarResult,
+		  EXCEPINFO* pexcepinfo, UINT* puArgErr)
+{
+    if (riid != IID_NULL)
+	return DISP_E_UNKNOWNINTERFACE;
+    if (!theObject)
+	return E_UNEXPECTED;
+
+    HRESULT res = DISP_E_MEMBERNOTFOUND;
+
+    bool uniqueIndex = wFlags == DISPATCH_PROPERTYGET || wFlags == DISPATCH_PROPERTYPUT || wFlags == DISPATCH_METHOD;
+
+    int index = uniqueIndex ? indexCache.value(dispidMember, -1) : -1;
+    QByteArray name;
+    if (index == -1) {
+	ensureMetaData();
+
+        // This property or method is invoked when an ActiveX client specifies
+        // the object name without a property or method. We only support property.
+        if (dispidMember == DISPID_VALUE && (wFlags == DISPATCH_PROPERTYGET || wFlags == DISPATCH_PROPERTYPUT)) {
+            const QMetaObject *mo = qt.object->metaObject();
+            index = mo->indexOfClassInfo("DefaultProperty");
+            if (index != -1) {
+                name  = mo->classInfo(index).value();
+                index = mo->indexOfProperty(name);
+            }
+        } else {
+	    BSTR bname;
+	    UINT cname = 0;
+	    if (m_spTypeInfo)
+	        m_spTypeInfo->GetNames(dispidMember, &bname, 1, &cname);
+	    if (!cname)
+	        return res;
+
+            name = QString::fromUtf16((const ushort *)bname).toLatin1();
+	    SysFreeString(bname);
+        }
+    }
+
+    const QMetaObject *mo = qt.object->metaObject();
+    QSize oldSizeHint;
+    if (isWidget)
+	oldSizeHint = qt.widget->sizeHint();
+
+    switch (wFlags) {
+    case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
+    case DISPATCH_PROPERTYGET:
+	{
+	    if (index == -1) {
+		index = mo->indexOfProperty(name);
+		if (index == -1 && wFlags == DISPATCH_PROPERTYGET)
+		    return res;
+	    }
+
+	    QMetaProperty property;
+            if (index < mo->propertyCount())
+                property = mo->property(index);
+
+	    if (property.isReadable()) {
+		if (!pvarResult)
+		    return DISP_E_PARAMNOTOPTIONAL;
+		if (pDispParams->cArgs ||
+		     pDispParams->cNamedArgs)
+		    return DISP_E_BADPARAMCOUNT;
+
+		QVariant var = qt.object->property(property.name());
+		if (!var.isValid())
+		    res =  DISP_E_MEMBERNOTFOUND;
+		else if (!QVariantToVARIANT(var, *pvarResult))
+		    res = DISP_E_TYPEMISMATCH;
+		else
+		    res = S_OK;
+		break;
+	    } else if (wFlags == DISPATCH_PROPERTYGET) {
+		break;
+	    }
+	}
+	// FALLTHROUGH if wFlags == DISPATCH_PROPERTYGET|DISPATCH_METHOD AND not a property.
+    case DISPATCH_METHOD:
+	{
+            int nameLength = 0;
+	    if (index == -1) {
+	        nameLength = name.length();
+	        name += "(";
+		// no parameter - shortcut
+		if (!pDispParams->cArgs)
+		    index = mo->indexOfSlot((name + ")"));
+		// search
+		if (index == -1) {
+		    for (int i = 0; i < mo->methodCount(); ++i) {
+                        const QMetaMethod slot(mo->method(i));
+                        if (slot.methodType() == QMetaMethod::Slot && QByteArray(slot.signature()).startsWith(name)) {
+			    index = i;
+			    break;
+			}
+		    }
+                    // resolve overloads
+                    if (index == -1) {
+                        QRegExp regexp(QLatin1String("_([0-9])\\("));
+                        if (regexp.lastIndexIn(QString::fromLatin1(name.constData())) != -1) {
+                            name = name.left(name.length() - regexp.cap(0).length()) + "(";
+                            int overload = regexp.cap(1).toInt() + 1;
+
+                            for (int s = 0; s < qt.object->metaObject()->methodCount(); ++s) {
+                                QMetaMethod slot = qt.object->metaObject()->method(s);
+                                if (slot.methodType() == QMetaMethod::Slot && QByteArray(slot.signature()).startsWith(name)) {
+                                    if (!--overload) {
+                                        index = s;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+		    if (index == -1)
+			return res;
+		}
+	    }
+
+            int lookupIndex = index;
+
+	    // get slot info
+	    QMetaMethod slot(mo->method(index));
+            Q_ASSERT(slot.methodType() == QMetaMethod::Slot);
+	    QByteArray type = slot.typeName();
+	    name = slot.signature();
+            nameLength = name.indexOf('(');
+	    QByteArray prototype = name.mid(nameLength + 1);
+	    prototype.truncate(prototype.length() - 1);
+	    QList<QByteArray> ptypes;
+	    if (!prototype.isEmpty())
+		ptypes = prototype.split(',');
+	    int pcount = ptypes.count();
+
+	    // verify parameter count
+            if (pcount > pDispParams->cArgs) {
+                // count cloned slots immediately following the real thing
+                int defArgs = 0;
+                while (index < mo->methodCount()) {
+                    ++index;
+                    slot = mo->method(index);
+                    if (!(slot.attributes() & QMetaMethod::Cloned))
+                        break;
+                    --pcount;
+                    // found a matching overload. ptypes still valid
+                    if (pcount <= pDispParams->cArgs)
+                        break;
+                }
+                // still wrong :(
+                if (pcount > pDispParams->cArgs)
+		    return DISP_E_PARAMNOTOPTIONAL;
+            } else if (pcount < pDispParams->cArgs) {
+		return DISP_E_BADPARAMCOUNT;
+            }
+
+	    // setup parameters (pcount + return)
+	    bool ok = true;
+            void *static_argv[QAX_NUM_PARAMS + 1];
+            QVariant static_varp[QAX_NUM_PARAMS + 1];
+            void *static_argv_pointer[QAX_NUM_PARAMS + 1];
+
+            int totalParam = pcount;
+            if (!type.isEmpty())
+                ++totalParam;
+
+	    void **argv = 0; // the actual array passed into qt_metacall
+            void **argv_pointer = 0; // in case we need an additional level of indirection
+	    QVariant *varp = 0; // QVariants to hold the temporary Qt data object for us
+
+            if (totalParam) {
+                if (totalParam <= 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_pointer[0] = 0;
+            }
+
+	    for (int p = 0; p < pcount; ++p) {
+		// map the VARIANT to the void*
+		bool out;
+		QByteArray ptype = paramType(ptypes.at(p), &out);
+		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 {
+		    if (puArgErr)
+			*puArgErr = pcount-p-1;
+		    ok = false;
+		}
+	    }
+
+            // return value
+	    if (!type.isEmpty()) {
+                QVariant::Type vt = QVariant::nameToType(type);
+                if (vt == QVariant::UserType)
+                    vt = QVariant::Invalid;
+                varp[0] = QVariant(vt);
+                if (varp[0].type() == QVariant::Invalid && mo->indexOfEnumerator(slot.typeName()) != -1)
+                    varp[0] = QVariant(QVariant::Int);
+
+                if (varp[0].type() == QVariant::Invalid) {
+                    if (type == "QVariant")
+                        argv[0] = varp;
+                    else
+                        argv[0] = 0;
+                } else {
+                    argv[0] = const_cast<void*>(varp[0].constData());
+                }
+                if (type.endsWith("*")) {
+                    argv_pointer[0] = argv[0];
+                    argv[0] = argv_pointer;
+                }
+	    }
+
+	    // call the slot if everthing went fine.
+	    if (ok) {
+            ++invokeCount;
+            qt.object->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);
+            if (--invokeCount < 0)
+                invokeCount = 0;
+
+		// update reference parameters and return value
+		for (int p = 0; p < pcount; ++p) {
+		    bool out;
+		    QByteArray ptype = paramType(ptypes.at(p), &out);
+		    if (out) {
+			if (!QVariantToVARIANT(varp[p + 1], pDispParams->rgvarg[pcount - p - 1], ptype, out))
+			    ok = false;
+		    }
+		}
+                if (!type.isEmpty() && pvarResult) {
+                    if (!varp[0].isValid() && type != "QVariant")
+                        varp[0] = QVariant(QMetaType::type(type), argv_pointer);
+//                        qVariantSetValue(varp[0], argv_pointer[0], type);
+		    ok = QVariantToVARIANT(varp[0], *pvarResult, type);
+                }
+	    }
+            if (argv && argv != static_argv) {
+                delete []argv;
+                delete []argv_pointer;
+                delete []varp;
+            }
+
+	    res = ok ? S_OK : DISP_E_TYPEMISMATCH;
+
+            // reset in case index changed for default-arg handling
+            index = lookupIndex;
+	}
+	break;
+    case DISPATCH_PROPERTYPUT:
+    case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF:
+	{
+            if (index == -1) {
+                index = mo->indexOfProperty(name);
+                if (index == -1)
+                    return res;
+            }
+
+            QMetaProperty property;
+            if (index < mo->propertyCount())
+                property = mo->property(index);
+            if (!property.isWritable())
+                return DISP_E_MEMBERNOTFOUND;
+            if (!pDispParams->cArgs)
+                return DISP_E_PARAMNOTOPTIONAL;
+            if (pDispParams->cArgs != 1 ||
+                pDispParams->cNamedArgs != 1 ||
+                *pDispParams->rgdispidNamedArgs != DISPID_PROPERTYPUT)
+                return DISP_E_BADPARAMCOUNT;
+
+            QVariant var = VARIANTToQVariant(*pDispParams->rgvarg, property.typeName(), property.type());
+            if (!var.isValid()) {
+                if (puArgErr)
+                    *puArgErr = 0;
+                return DISP_E_BADVARTYPE;
+            }
+            if (!qt.object->setProperty(property.name(), var)) {
+                if (puArgErr)
+                    *puArgErr = 0;
+                return DISP_E_TYPEMISMATCH;
+            }
+
+            res = S_OK;
+	}
+	break;
+
+    default:
+	break;
+    }
+
+    // maybe calling a setter? Notify client about changes
+    switch(wFlags) {
+    case DISPATCH_METHOD:
+    case DISPATCH_PROPERTYPUT:
+    case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF:
+        if (m_spAdviseSink || adviseSinks.count()) {
+            FORMATETC fmt;
+            fmt.cfFormat = 0;
+            fmt.ptd = 0;
+            fmt.dwAspect = DVASPECT_CONTENT;
+            fmt.lindex = -1;
+            fmt.tymed = TYMED_NULL;
+
+            STGMEDIUM stg;
+            stg.tymed = TYMED_NULL;
+            stg.pUnkForRelease = 0;
+            stg.hBitmap = 0; // initializes the whole union
+
+            if (m_spAdviseSink) {
+                m_spAdviseSink->OnViewChange(DVASPECT_CONTENT, -1);
+                m_spAdviseSink->OnDataChange(&fmt, &stg);
+            }
+            for (int i = 0; i < adviseSinks.count(); ++i) {
+                adviseSinks.at(i).pAdvSink->OnDataChange(&fmt, &stg);
+            }
+        }
+
+        dirtyflag = true;
+        break;
+    default:
+        break;
+    }
+
+    if (index != -1 && uniqueIndex)
+	indexCache.insert(dispidMember, index);
+
+    if (exception) {
+	if (pexcepinfo) {
+	    memset(pexcepinfo, 0, sizeof(EXCEPINFO));
+
+	    pexcepinfo->wCode = exception->code;
+	    if (!exception->src.isNull())
+		pexcepinfo->bstrSource = QStringToBSTR(exception->src);
+	    if (!exception->desc.isNull())
+		pexcepinfo->bstrDescription = QStringToBSTR(exception->desc);
+	    if (!exception->context.isNull()) {
+		QString context = exception->context;
+		int contextID = 0;
+		int br = context.indexOf(QLatin1Char('['));
+		if (br != -1) {
+		    context = context.mid(br+1);
+		    context = context.left(context.length() - 1);
+		    contextID = context.toInt();
+
+		    context = exception->context;
+		    context = context.left(br-1);
+		}
+		pexcepinfo->bstrHelpFile = QStringToBSTR(context);
+		pexcepinfo->dwHelpContext = contextID;
+	    }
+	}
+	delete exception;
+	exception = 0;
+	return DISP_E_EXCEPTION;
+    } else if (isWidget) {
+	QSize sizeHint = qt.widget->sizeHint();
+	if (oldSizeHint != sizeHint) {
+	    updateGeometry();
+	    if (m_spInPlaceSite) {
+                RECT rect = {0, 0, sizeHint.width(), sizeHint.height()};
+		m_spInPlaceSite->OnPosRectChange(&rect);
+	    }
+	}
+	updateMask();
+    }
+
+    return res;
+}
+
+//**** IConnectionPointContainer
+/*
+    Provide the IEnumConnectionPoints implemented in the QAxSignalVec class.
+*/
+HRESULT WINAPI QAxServerBase::EnumConnectionPoints(IEnumConnectionPoints **epoints)
+{
+    if (!epoints)
+	return E_POINTER;
+    *epoints = new QAxSignalVec(points);
+    (*epoints)->AddRef();
+    return S_OK;
+}
+
+/*
+    Provide the IConnectionPoint implemented in the QAxConnection for \a iid.
+*/
+HRESULT WINAPI QAxServerBase::FindConnectionPoint(REFIID iid, IConnectionPoint **cpoint)
+{
+    if (!cpoint)
+	return E_POINTER;
+
+    IConnectionPoint *cp = points[iid];
+    *cpoint = cp;
+    if (cp) {
+	cp->AddRef();
+	return S_OK;
+    }
+    return CONNECT_E_NOCONNECTION;
+}
+
+//**** IPersistStream
+/*
+    \reimp
+
+    See documentation of IPersistStorage::IsDirty.
+*/
+HRESULT WINAPI QAxServerBase::IsDirty()
+{
+    return dirtyflag ? S_OK : S_FALSE;
+}
+
+HRESULT WINAPI QAxServerBase::Load(IStream *pStm)
+{
+    STATSTG stat;
+    HRESULT hres = pStm->Stat(&stat, STATFLAG_DEFAULT);
+    bool openAsText = false;
+    QByteArray qtarray;
+    if (hres == S_OK) {
+        QString streamName = QString::fromUtf16((const ushort *)stat.pwcsName);
+        CoTaskMemFree(stat.pwcsName);
+        openAsText = streamName == QLatin1String("SomeStreamName");
+	if (stat.cbSize.HighPart) // more than 4GB - too large!
+	    return S_FALSE;
+
+	qtarray.resize(stat.cbSize.LowPart);
+        ULONG read;
+	pStm->Read(qtarray.data(), stat.cbSize.LowPart, &read);
+    }
+    const QMetaObject *mo = qt.object->metaObject();
+
+    QBuffer qtbuffer(&qtarray);
+    QByteArray mimeType = mo->classInfo(mo->indexOfClassInfo("MIME")).value();
+    if (!mimeType.isEmpty()) {
+        mimeType = mimeType.left(mimeType.indexOf(':')); // first type
+        QAxBindable *axb = (QAxBindable*)qt.object->qt_metacast("QAxBindable");
+        if (axb && axb->readData(&qtbuffer, QString::fromLatin1(mimeType)))
+            return S_OK;
+    }
+
+    qtbuffer.close(); // resets
+    qtbuffer.open(openAsText ? (QIODevice::ReadOnly | QIODevice::Text) : QIODevice::ReadOnly);
+
+    QDataStream qtstream(&qtbuffer);
+    int version;
+    qtstream >> version;
+    qtstream.setVersion(version);
+    int more = 0;
+    qtstream >> more;
+
+    while (!qtbuffer.atEnd() && more) {
+	QString propname;
+	QVariant value;
+	qtstream >> propname;
+	if (propname.isEmpty())
+	    break;
+	qtstream >> value;
+	qtstream >> more;
+
+	int idx = mo->indexOfProperty(propname.toLatin1());
+	QMetaProperty property = mo->property(idx);
+	if (property.isWritable())
+	    qt.object->setProperty(propname.toLatin1(), value);
+    }
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::Save(IStream *pStm, BOOL clearDirty)
+{
+    const QMetaObject *mo = qt.object->metaObject();
+
+    QBuffer qtbuffer;
+    bool saved = false;
+    QByteArray mimeType = mo->classInfo(mo->indexOfClassInfo("MIME")).value();
+    if (!mimeType.isEmpty()) {
+        QAxBindable *axb = (QAxBindable*)qt.object->qt_metacast("QAxBindable");
+        saved = axb && axb->writeData(&qtbuffer);
+        qtbuffer.close();
+    }
+
+    if (!saved) {
+        qtbuffer.open(QIODevice::WriteOnly);
+        QDataStream qtstream(&qtbuffer);
+        qtstream << qtstream.version();
+
+        for (int prop = 0; prop < mo->propertyCount(); ++prop) {
+	    if (!isPropertyExposed(prop))
+	        continue;
+	    QMetaProperty metaprop = mo->property(prop);
+            if (QByteArray(metaprop.typeName()).endsWith('*'))
+                continue;
+	    QString property = QLatin1String(metaprop.name());
+	    QVariant qvar = qt.object->property(metaprop.name());
+	    if (qvar.isValid()) {
+	        qtstream << int(1);
+	        qtstream << property;
+	        qtstream << qvar;
+	    }
+        }
+
+        qtstream << int(0);
+        qtbuffer.close();
+    }
+
+    QByteArray qtarray = qtbuffer.buffer();
+    ULONG written = 0;
+    const char *data = qtarray.constData();
+    ULARGE_INTEGER newsize;
+    newsize.HighPart = 0;
+    newsize.LowPart = qtarray.size();
+    pStm->SetSize(newsize);
+    pStm->Write(data, qtarray.size(), &written);
+    pStm->Commit(STGC_ONLYIFCURRENT);
+
+    if (clearDirty)
+        dirtyflag = false;
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::GetSizeMax(ULARGE_INTEGER *pcbSize)
+{
+    const QMetaObject *mo = qt.object->metaObject();
+
+    int np = mo->propertyCount();
+    pcbSize->HighPart = 0;
+    pcbSize->LowPart = np * 50;
+
+    return S_OK;
+}
+
+//**** IPersistStorage
+
+HRESULT WINAPI QAxServerBase::InitNew(IStorage *pStg)
+{
+    if (initNewCalled)
+	return CO_E_ALREADYINITIALIZED;
+
+    dirtyflag = false;
+    initNewCalled = true;
+
+    m_spStorage = pStg;
+    if (m_spStorage)
+	m_spStorage->AddRef();
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::Load(IStorage *pStg)
+{
+    if (InitNew(pStg) != S_OK)
+	return CO_E_ALREADYINITIALIZED;
+
+    IStream *spStream = 0;
+    QString streamName = QLatin1String(qt.object->metaObject()->className());
+    streamName.replace(QLatin1Char(':'), QLatin1Char('.'));
+    /* Also invalid, but not relevant
+    streamName.replace(QLatin1Char('/'), QLatin1Char('_'));
+    streamName.replace(QLatin1Char('\\'), QLatin1Char('_'));
+    */
+    streamName += QLatin1String("_Stream4.2");
+
+    pStg->OpenStream((const WCHAR *)streamName.utf16(), 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &spStream);
+    if (!spStream) // support for streams saved with 4.1 and earlier
+        pStg->OpenStream(L"SomeStreamName", 0, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &spStream);
+    if (!spStream)
+	return E_FAIL;
+
+    Load(spStream);
+    spStream->Release();
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::Save(IStorage *pStg, BOOL fSameAsLoad)
+{
+    IStream *spStream = 0;
+    QString streamName = QLatin1String(qt.object->metaObject()->className());
+    streamName.replace(QLatin1Char(':'), QLatin1Char('.'));
+    /* Also invalid, but not relevant
+    streamName.replace(QLatin1Char('/'), QLatin1Char('_'));
+    streamName.replace(QLatin1Char('\\'), QLatin1Char('_'));
+    */
+    streamName += QLatin1String("_Stream4.2");
+
+    pStg->CreateStream((const WCHAR *)streamName.utf16(), STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &spStream);
+    if (!spStream)
+	return E_FAIL;
+
+    Save(spStream, true);
+
+    spStream->Release();
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::SaveCompleted(IStorage *pStgNew)
+{
+    if (pStgNew) {
+	if (m_spStorage)
+	    m_spStorage->Release();
+	m_spStorage = pStgNew;
+	m_spStorage->AddRef();
+    }
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::HandsOffStorage()
+{
+    if (m_spStorage) m_spStorage->Release();
+    m_spStorage = 0;
+
+    return S_OK;
+}
+
+//**** IPersistPropertyBag
+/*
+    Initialize the properties of the Qt widget.
+*/
+HRESULT WINAPI QAxServerBase::InitNew()
+{
+    if (initNewCalled)
+	return CO_E_ALREADYINITIALIZED;
+
+    dirtyflag = false;
+    initNewCalled = true;
+    return S_OK;
+}
+
+/*
+    Set the properties of the Qt widget to the values provided in the \a bag.
+*/
+HRESULT WINAPI QAxServerBase::Load(IPropertyBag *bag, IErrorLog * /*log*/)
+{
+    if (!bag)
+	return E_POINTER;
+
+    if (InitNew() != S_OK)
+	return E_UNEXPECTED;
+
+    bool error = false;
+    const QMetaObject *mo = qt.object->metaObject();
+    for (int prop = 0; prop < mo->propertyCount(); ++prop) {
+	if (!isPropertyExposed(prop))
+	    continue;
+	QMetaProperty property = mo->property(prop);
+	const char* pname = property.name();
+	BSTR bstr = QStringToBSTR(QLatin1String(pname));
+	VARIANT var;
+	var.vt = VT_EMPTY;
+	HRESULT res = bag->Read(bstr, &var, 0);
+	if (property.isWritable() && var.vt != VT_EMPTY) {
+	    if (res != S_OK || !qt.object->setProperty(pname, VARIANTToQVariant(var, property.typeName(), property.type())))
+		error = true;
+	}
+	SysFreeString(bstr);
+    }
+
+    updateGeometry();
+
+    return /*error ? E_FAIL :*/ S_OK;
+}
+
+/*
+    Save the properties of the Qt widget into the \a bag.
+*/
+HRESULT WINAPI QAxServerBase::Save(IPropertyBag *bag, BOOL clearDirty, BOOL /*saveAll*/)
+{
+    if (!bag)
+	return E_POINTER;
+
+    if (clearDirty)
+	dirtyflag = false;
+    bool error = false;
+    const QMetaObject *mo = qt.object->metaObject();
+    for (int prop = 0; prop < mo->propertyCount(); ++prop) {
+	if (!isPropertyExposed(prop))
+	    continue;
+	QMetaProperty property = mo->property(prop);
+        if (QByteArray(property.typeName()).endsWith('*'))
+            continue;
+
+	BSTR bstr = QStringToBSTR(QLatin1String(property.name()));
+	QVariant qvar = qt.object->property(property.name());
+	if (!qvar.isValid())
+	    error = true;
+	VARIANT var;
+	QVariantToVARIANT(qvar, var);
+	bag->Write(bstr, &var);
+	SysFreeString(bstr);
+    }
+    return /*error ? E_FAIL :*/ S_OK;
+}
+
+//**** IPersistFile
+/*
+*/
+HRESULT WINAPI QAxServerBase::SaveCompleted(LPCOLESTR fileName)
+{
+    if (qt.object->metaObject()->indexOfClassInfo("MIME") == -1)
+        return E_NOTIMPL;
+
+    currentFileName = QString::fromUtf16(reinterpret_cast<const ushort *>(fileName));
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::GetCurFile(LPOLESTR *currentFile)
+{
+    if (qt.object->metaObject()->indexOfClassInfo("MIME") == -1)
+        return E_NOTIMPL;
+
+    if (currentFileName.isEmpty()) {
+        *currentFile = 0;
+        return S_FALSE;
+    }
+    IMalloc *malloc = 0;
+    CoGetMalloc(1, &malloc);
+    if (!malloc)
+        return E_OUTOFMEMORY;
+
+    *currentFile = static_cast<WCHAR *>(malloc->Alloc(currentFileName.length() * 2));
+    malloc->Release();
+    memcpy(*currentFile, currentFileName.unicode(), currentFileName.length() * 2);
+
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::Load(LPCOLESTR fileName, DWORD mode)
+{
+    const QMetaObject *mo = qt.object->metaObject();
+    int mimeIndex = mo->indexOfClassInfo("MIME");
+    if (mimeIndex == -1)
+        return E_NOTIMPL;
+
+    QAxBindable *axb = (QAxBindable*)qt.object->qt_metacast("QAxBindable");
+    if (!axb) {
+        qWarning() << class_name << ": No QAxBindable implementation for mime-type handling";
+        return E_NOTIMPL;
+    }
+
+    QString loadFileName = QString::fromUtf16(reinterpret_cast<const ushort *>(fileName));
+    QString fileExtension = loadFileName.mid(loadFileName.lastIndexOf(QLatin1Char('.')) + 1);
+    QFile file(loadFileName);
+
+    QString mimeType = QLatin1String(mo->classInfo(mimeIndex).value());
+    QStringList mimeTypes = mimeType.split(QLatin1Char(';'));
+    for (int m = 0; m < mimeTypes.count(); ++m) {
+        QString mime = mimeTypes.at(m);
+        if (mime.count(QLatin1Char(':')) != 2) {
+            qWarning() << class_name << ": Invalid syntax in Q_CLASSINFO for MIME";
+            continue;
+        }
+
+        mimeType = mime.left(mimeType.indexOf(QLatin1Char(':'))); // first type
+        if (mimeType.isEmpty()) {
+            qWarning() << class_name << ": Invalid syntax in Q_CLASSINFO for MIME";
+            continue;
+        }
+        QString mimeExtension = mime.mid(mimeType.length() + 1);
+        mimeExtension = mimeExtension.left(mimeExtension.indexOf(QLatin1Char(':')));
+        if (mimeExtension != fileExtension)
+            continue;
+
+        if (axb->readData(&file, mimeType)) {
+            currentFileName = loadFileName;
+            return S_OK;
+        }
+    }
+
+    return E_FAIL;
+}
+
+HRESULT WINAPI QAxServerBase::Save(LPCOLESTR fileName, BOOL fRemember)
+{
+    const QMetaObject *mo = qt.object->metaObject();
+    int mimeIndex = mo->indexOfClassInfo("MIME");
+    if (mimeIndex == -1)
+        return E_NOTIMPL;
+
+    QAxBindable *axb = (QAxBindable*)qt.object->qt_metacast("QAxBindable");
+    if (!axb) {
+        qWarning() << class_name << ": No QAxBindable implementation for mime-type handling";
+        return E_NOTIMPL;
+    }
+
+    QString saveFileName = QString::fromUtf16(reinterpret_cast<const ushort *>(fileName));
+    QString fileExtension = saveFileName.mid(saveFileName.lastIndexOf(QLatin1Char('.')) + 1);
+    QFile file(saveFileName);
+
+    QString mimeType = QLatin1String(mo->classInfo(mimeIndex).value());
+    QStringList mimeTypes = mimeType.split(QLatin1Char(';'));
+    for (int m = 0; m < mimeTypes.count(); ++m) {
+        QString mime = mimeTypes.at(m);
+        if (mime.count(QLatin1Char(':')) != 2) {
+            qWarning() << class_name << ": Invalid syntax in Q_CLASSINFO for MIME";
+            continue;
+        }
+        mimeType = mime.left(mimeType.indexOf(QLatin1Char(':'))); // first type
+        if (mimeType.isEmpty()) {
+            qWarning() << class_name << ": Invalid syntax in Q_CLASSINFO for MIME";
+            continue;
+        }
+        QString mimeExtension = mime.mid(mimeType.length() + 1);
+        mimeExtension = mimeExtension.left(mimeExtension.indexOf(QLatin1Char(':')));
+        if (mimeExtension != fileExtension)
+            continue;
+        if (axb->writeData(&file)) {
+            if (fRemember)
+                currentFileName = saveFileName;
+            return S_OK;
+        }
+    }
+    return E_FAIL;
+}
+
+//**** IViewObject
+/*
+    Draws the widget into the provided device context.
+*/
+HRESULT WINAPI QAxServerBase::Draw(DWORD dwAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
+		HDC hicTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL /*lprcWBounds*/,
+		BOOL(__stdcall* /*pfnContinue*/)(ULONG_PTR), ULONG_PTR /*dwContinue*/)
+{
+    if (!lprcBounds)
+	return E_INVALIDARG;
+
+    internalCreate();
+    if (!isWidget || !qt.widget)
+	return OLE_E_BLANK;
+
+    switch (dwAspect) {
+    case DVASPECT_CONTENT:
+    case DVASPECT_OPAQUE:
+    case DVASPECT_TRANSPARENT:
+	break;
+    default:
+	return DV_E_DVASPECT;
+    }
+    if (!ptd)
+	hicTargetDev = 0;
+
+    bool bDeleteDC = false;
+    if (!hicTargetDev) {
+	hicTargetDev = ::CreateDCA("DISPLAY", NULL, NULL, NULL);
+	bDeleteDC = (hicTargetDev != hdcDraw);
+    }
+
+    RECTL rc = *lprcBounds;
+    bool bMetaFile = GetDeviceCaps(hdcDraw, TECHNOLOGY) == DT_METAFILE;
+    if (!bMetaFile)
+        ::LPtoDP(hicTargetDev, (LPPOINT)&rc, 2);
+
+    QPixmap pm = QPixmap::grabWidget(qt.widget);
+    HBITMAP hbm = pm.toWinHBITMAP();
+    HDC hdc = CreateCompatibleDC(0);
+    SelectObject(hdc, hbm);
+    ::StretchBlt(hdcDraw, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, hdc, 0, 0,pm.width(), pm.height(), SRCCOPY);
+    DeleteDC(hdc);
+    DeleteObject(hbm);
+
+    if (bDeleteDC)
+	DeleteDC(hicTargetDev);
+
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::GetColorSet(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,
+		HDC hicTargetDev, LOGPALETTE **ppColorSet)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::Freeze(DWORD dwAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::Unfreeze(DWORD dwFreeze)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Stores the provided advise sink.
+*/
+HRESULT WINAPI QAxServerBase::SetAdvise(DWORD /*aspects*/, DWORD /*advf*/, IAdviseSink *pAdvSink)
+{
+    if (m_spAdviseSink) m_spAdviseSink->Release();
+
+    m_spAdviseSink = pAdvSink;
+    if (m_spAdviseSink) m_spAdviseSink->AddRef();
+    return S_OK;
+}
+
+/*
+    Returns the advise sink.
+*/
+HRESULT WINAPI QAxServerBase::GetAdvise(DWORD* /*aspects*/, DWORD* /*advf*/, IAdviseSink **ppAdvSink)
+{
+    if (!ppAdvSink)
+	return E_POINTER;
+
+    *ppAdvSink = m_spAdviseSink;
+    if (*ppAdvSink)
+	(*ppAdvSink)->AddRef();
+    return S_OK;
+}
+
+//**** IViewObject2
+/*
+    Returns the current size ONLY if the widget has already been sized.
+*/
+HRESULT WINAPI QAxServerBase::GetExtent(DWORD dwAspect, LONG /*lindex*/, DVTARGETDEVICE* /*ptd*/, LPSIZEL lpsizel)
+{
+    if (!isWidget || !qt.widget || !qt.widget->testAttribute(Qt::WA_Resized))
+        return OLE_E_BLANK;
+
+    return GetExtent(dwAspect, lpsizel);
+}
+
+//**** IOleControl
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::GetControlInfo(LPCONTROLINFO)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Turns event firing on and off.
+*/
+HRESULT WINAPI QAxServerBase::FreezeEvents(BOOL bFreeze)
+{
+    // member of CComControl
+    if (bFreeze)
+	freezeEvents++;
+    else
+	freezeEvents--;
+
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::OnMnemonic(LPMSG)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Update the ambient properties of the Qt widget.
+*/
+HRESULT WINAPI QAxServerBase::OnAmbientPropertyChange(DISPID dispID)
+{
+    if (!m_spClientSite || !theObject)
+	return S_OK;
+
+    IDispatch *disp = 0;
+    m_spClientSite->QueryInterface(IID_IDispatch, (void**)&disp);
+    if (!disp)
+	return S_OK;
+
+    VARIANT var;
+    VariantInit(&var);
+    DISPPARAMS params = { 0, 0, 0, 0 };
+    disp->Invoke(dispID, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &params, &var, 0, 0);
+    disp->Release();
+    disp = 0;
+
+    switch(dispID) {
+    case DISPID_AMBIENT_APPEARANCE:
+	break;
+    case DISPID_AMBIENT_AUTOCLIP:
+	break;
+    case DISPID_AMBIENT_BACKCOLOR:
+    case DISPID_AMBIENT_FORECOLOR:
+	if (isWidget) {
+	    long rgb;
+	    if (var.vt == VT_UI4)
+		rgb = var.ulVal;
+	    else if (var.vt == VT_I4)
+		rgb = var.lVal;
+	    else
+		break;
+	    QPalette pal = qt.widget->palette();
+	    pal.setColor(dispID == DISPID_AMBIENT_BACKCOLOR ? QPalette::Window : QPalette::WindowText,
+		OLEColorToQColor(rgb));
+	    qt.widget->setPalette(pal);
+	}
+	break;
+    case DISPID_AMBIENT_DISPLAYASDEFAULT:
+	break;
+    case DISPID_AMBIENT_DISPLAYNAME:
+	if (var.vt != VT_BSTR || !isWidget)
+	    break;
+	qt.widget->setWindowTitle(QString::fromUtf16((const ushort *)var.bstrVal));
+	break;
+    case DISPID_AMBIENT_FONT:
+	if (var.vt != VT_DISPATCH || !isWidget)
+	    break;
+	{
+            QVariant qvar = VARIANTToQVariant(var, "QFont", QVariant::Font);
+            QFont qfont = qVariantValue<QFont>(qvar);
+            qt.widget->setFont(qfont);
+	}
+	break;
+    case DISPID_AMBIENT_LOCALEID:
+	break;
+    case DISPID_AMBIENT_MESSAGEREFLECT:
+	if (var.vt != VT_BOOL)
+	    break;
+	if (var.boolVal)
+	    qt.widget->installEventFilter(this);
+	else
+	    qt.widget->removeEventFilter(this);
+	break;
+    case DISPID_AMBIENT_PALETTE:
+	break;
+    case DISPID_AMBIENT_SCALEUNITS:
+	break;
+    case DISPID_AMBIENT_SHOWGRABHANDLES:
+	break;
+    case DISPID_AMBIENT_SHOWHATCHING:
+	break;
+    case DISPID_AMBIENT_SUPPORTSMNEMONICS:
+	break;
+    case DISPID_AMBIENT_TEXTALIGN:
+	break;
+    case DISPID_AMBIENT_UIDEAD:
+	if (var.vt != VT_BOOL || !isWidget)
+	    break;
+	qt.widget->setEnabled(!var.boolVal);
+	break;
+    case DISPID_AMBIENT_USERMODE:
+	if (var.vt != VT_BOOL)
+	    break;
+	inDesignMode = !var.boolVal;
+	break;
+    case DISPID_AMBIENT_RIGHTTOLEFT:
+	if (var.vt != VT_BOOL)
+	    break;
+	qApp->setLayoutDirection(var.boolVal?Qt::RightToLeft:Qt::LeftToRight);
+	break;
+    }
+
+    return S_OK;
+}
+
+//**** IOleWindow
+/*
+    Returns the HWND of the control.
+*/
+HRESULT WINAPI QAxServerBase::GetWindow(HWND *pHwnd)
+{
+    if (!pHwnd)
+	return E_POINTER;
+    *pHwnd = m_hWnd;
+    return S_OK;
+}
+
+/*
+    Enters What's This mode.
+*/
+HRESULT WINAPI QAxServerBase::ContextSensitiveHelp(BOOL fEnterMode)
+{
+    if (fEnterMode)
+	QWhatsThis::enterWhatsThisMode();
+    else
+	QWhatsThis::leaveWhatsThisMode();
+    return S_OK;
+}
+
+//**** IOleInPlaceObject
+/*
+    Deactivates the control in place.
+*/
+HRESULT WINAPI QAxServerBase::InPlaceDeactivate()
+{
+    if (!isInPlaceActive)
+	return S_OK;
+    UIDeactivate();
+
+    isInPlaceActive = false;
+
+    // if we have a window, tell it to go away.
+    if (m_hWnd) {
+	if (::IsWindow(m_hWnd))
+	    ::DestroyWindow(m_hWnd);
+	m_hWnd = 0;
+    }
+
+    if (m_spInPlaceSite)
+	m_spInPlaceSite->OnInPlaceDeactivate();
+
+    return S_OK;
+}
+
+/*
+    Deactivates the control's user interface.
+*/
+HRESULT WINAPI QAxServerBase::UIDeactivate()
+{
+    // if we're not UIActive, not much to do.
+    if (!isUIActive || !m_spInPlaceSite)
+	return S_OK;
+
+    isUIActive = false;
+
+    // notify frame windows, if appropriate, that we're no longer ui-active.
+    HWND hwndParent;
+    if (m_spInPlaceSite->GetWindow(&hwndParent) == S_OK) {
+	if (m_spInPlaceFrame) m_spInPlaceFrame->Release();
+	m_spInPlaceFrame = 0;
+	IOleInPlaceUIWindow *spInPlaceUIWindow = 0;
+        RECT rcPos, rcClip;
+        OLEINPLACEFRAMEINFO frameInfo;
+        frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
+
+	m_spInPlaceSite->GetWindowContext(&m_spInPlaceFrame, &spInPlaceUIWindow, &rcPos, &rcClip, &frameInfo);
+	if (spInPlaceUIWindow) {
+	    spInPlaceUIWindow->SetActiveObject(0, 0);
+	    spInPlaceUIWindow->Release();
+	}
+	if (m_spInPlaceFrame) {
+	    removeMenu();
+            if (menuBar) {
+                menuBar->removeEventFilter(this);
+                menuBar = 0;
+            }
+            if (statusBar) {
+                statusBar->removeEventFilter(this);
+		const int index = statusBar->metaObject()->indexOfSignal("messageChanged(QString)");
+		QMetaObject::disconnect(statusBar, index, this, -1);
+	        statusBar = 0;
+            }
+	    m_spInPlaceFrame->SetActiveObject(0, 0);
+	    m_spInPlaceFrame->Release();
+	    m_spInPlaceFrame = 0;
+	}
+    }
+    // we don't need to explicitly release the focus here since somebody
+    // else grabbing the focus is usually why we are getting called at all
+    m_spInPlaceSite->OnUIDeactivate(false);
+
+    return S_OK;
+}
+
+/*
+    Positions the control, and applies requested clipping.
+*/
+HRESULT WINAPI QAxServerBase::SetObjectRects(LPCRECT prcPos, LPCRECT prcClip)
+{
+    if (prcPos == 0 || prcClip == 0)
+	return E_POINTER;
+
+    if (m_hWnd) {
+	// the container wants us to clip, so figure out if we really need to
+	RECT rcIXect;
+	BOOL b = IntersectRect(&rcIXect, prcPos, prcClip);
+	HRGN tempRgn = 0;
+	if (b && !EqualRect(&rcIXect, prcPos)) {
+	    OffsetRect(&rcIXect, -(prcPos->left), -(prcPos->top));
+	    tempRgn = CreateRectRgnIndirect(&rcIXect);
+	}
+
+	::SetWindowRgn(m_hWnd, tempRgn, true);
+	::SetWindowPos(m_hWnd, 0, prcPos->left, prcPos->top,
+            prcPos->right - prcPos->left, prcPos->bottom - prcPos->top,
+	    SWP_NOZORDER | SWP_NOACTIVATE);
+    }
+
+    //Save the new extent.
+    m_currentExtent.rwidth() = qBound(qt.widget->minimumWidth(), int(prcPos->right - prcPos->left), qt.widget->maximumWidth());
+    m_currentExtent.rheight() = qBound(qt.widget->minimumHeight(), int(prcPos->bottom - prcPos->top), qt.widget->maximumHeight());
+
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::ReactivateAndUndo()
+{
+    return E_NOTIMPL;
+}
+
+//**** IOleInPlaceActiveObject
+
+Q_GUI_EXPORT int qt_translateKeyCode(int);
+
+HRESULT WINAPI QAxServerBase::TranslateAcceleratorW(MSG *pMsg)
+{
+    if (pMsg->message != WM_KEYDOWN || !isWidget)
+	return S_FALSE;
+
+    DWORD dwKeyMod = 0;
+    if (::GetKeyState(VK_SHIFT) < 0)
+	dwKeyMod |= 1;	// KEYMOD_SHIFT
+    if (::GetKeyState(VK_CONTROL) < 0)
+	dwKeyMod |= 2;	// KEYMOD_CONTROL
+    if (::GetKeyState(VK_MENU) < 0)
+	dwKeyMod |= 4;	// KEYMOD_ALT
+
+    switch (LOWORD(pMsg->wParam)) {
+    case VK_TAB:
+	if (isUIActive) {
+	    bool shift = ::GetKeyState(VK_SHIFT) < 0;
+	    bool giveUp = true;
+            QWidget *curFocus = qt.widget->focusWidget();
+            if (curFocus) {
+	        if (shift) {
+                    if (!curFocus->isWindow()) {
+                        QWidget *nextFocus = curFocus->nextInFocusChain();
+                        QWidget *prevFocus = 0;
+                        QWidget *topLevel = 0;
+                        while (nextFocus != curFocus) {
+                            if (nextFocus->focusPolicy() & Qt::TabFocus) {
+                                prevFocus = nextFocus;
+                                topLevel = 0;
+                            } else if (nextFocus->isWindow()) {
+                                topLevel = nextFocus;
+                            }
+                            nextFocus = nextFocus->nextInFocusChain();
+                        }
+
+                        if (!topLevel) {
+                            giveUp = false;
+                            ((HackWidget*)curFocus)->focusNextPrevChild(false);
+                        }
+                    }
+	        } else {
+                    QWidget *nextFocus = curFocus;
+                    while (1) {
+                        nextFocus = nextFocus->nextInFocusChain();
+                        if (nextFocus->isWindow())
+                            break;
+                        if (nextFocus->focusPolicy() & Qt::TabFocus) {
+                            giveUp = false;
+                            ((HackWidget*)curFocus)->focusNextPrevChild(true);
+                            break;
+                        }
+                    }
+	        }
+            }
+	    if (giveUp) {
+		HWND hwnd = ::GetParent(m_hWnd);
+		::SetFocus(hwnd);
+	    } else {
+		return S_OK;
+	    }
+
+	}
+	break;
+
+    case VK_LEFT:
+    case VK_RIGHT:
+    case VK_UP:
+    case VK_DOWN:
+	if (isUIActive)
+	    return S_FALSE;
+	break;
+
+    default:
+	if (isUIActive && qt.widget->focusWidget()) {
+            int state = Qt::NoButton;
+	    if (dwKeyMod & 1)
+		state |= Qt::ShiftModifier;
+	    if (dwKeyMod & 2)
+		state |= Qt::ControlModifier;
+	    if (dwKeyMod & 4)
+		state |= Qt::AltModifier;
+
+	    int key = pMsg->wParam;
+            if (!(key >= 'A' && key <= 'Z') && !(key >= '0' && key <= '9'))
+                key = qt_translateKeyCode(pMsg->wParam);
+
+	    QKeyEvent override(QEvent::ShortcutOverride, key, (Qt::KeyboardModifiers)state);
+	    override.ignore();
+	    QApplication::sendEvent(qt.widget->focusWidget(), &override);
+	    if (override.isAccepted())
+		return S_FALSE;
+	}
+	break;
+    }
+
+    if (!m_spClientSite)
+	return S_FALSE;
+
+    IOleControlSite *controlSite = 0;
+    m_spClientSite->QueryInterface(IID_IOleControlSite, (void**)&controlSite);
+    if (!controlSite)
+	return S_FALSE;
+
+    HRESULT hres = controlSite->TranslateAcceleratorW(pMsg, dwKeyMod);
+
+    controlSite->Release();
+
+    return hres;
+}
+
+HRESULT WINAPI QAxServerBase::TranslateAcceleratorA(MSG *pMsg)
+{
+    return TranslateAcceleratorW(pMsg);
+}
+
+HRESULT WINAPI QAxServerBase::OnFrameWindowActivate(BOOL fActivate)
+{
+    if (fActivate) {
+	if (wasUIActive)
+	    ::SetFocus(m_hWnd);
+    } else {
+	wasUIActive = isUIActive;
+    }
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::OnDocWindowActivate(BOOL fActivate)
+{
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow)
+{
+    return S_OK;
+}
+
+HRESULT WINAPI QAxServerBase::EnableModeless(BOOL fEnable)
+{
+    if (!isWidget)
+	return S_OK;
+
+    EnableWindow(qt.widget->winId(), fEnable);
+    return S_OK;
+}
+
+//**** IOleObject
+
+static inline LPOLESTR QStringToOLESTR(const QString &qstring)
+{
+    LPOLESTR olestr = (wchar_t*)CoTaskMemAlloc(qstring.length()*2+2);
+    memcpy(olestr, (ushort*)qstring.unicode(), qstring.length()*2);
+    olestr[qstring.length()] = 0;
+    return olestr;
+}
+
+/*
+    \reimp
+
+    See documentation of IOleObject::GetUserType.
+*/
+HRESULT WINAPI QAxServerBase::GetUserType(DWORD dwFormOfType, LPOLESTR *pszUserType)
+{
+    if (!pszUserType)
+	return E_POINTER;
+
+    switch (dwFormOfType) {
+    case USERCLASSTYPE_FULL:
+	*pszUserType = QStringToOLESTR(class_name);
+	break;
+    case USERCLASSTYPE_SHORT:
+	if (!qt.widget || !isWidget || qt.widget->windowTitle().isEmpty())
+	    *pszUserType = QStringToOLESTR(class_name);
+	else
+	    *pszUserType = QStringToOLESTR(qt.widget->windowTitle());
+	break;
+    case USERCLASSTYPE_APPNAME:
+	*pszUserType = QStringToOLESTR(qApp->objectName());
+	break;
+    }
+
+    return S_OK;
+}
+
+/*
+    Returns the status flags registered for this control.
+*/
+HRESULT WINAPI QAxServerBase::GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus)
+{
+    return OleRegGetMiscStatus(qAxFactory()->classID(class_name), dwAspect, pdwStatus);
+}
+
+/*
+    Stores the provided advise sink.
+*/
+HRESULT WINAPI QAxServerBase::Advise(IAdviseSink* pAdvSink, DWORD* pdwConnection)
+{
+    *pdwConnection = adviseSinks.count() + 1;
+    STATDATA data = { {0, 0, DVASPECT_CONTENT, -1, TYMED_NULL} , 0, pAdvSink, *pdwConnection };
+    adviseSinks.append(data);
+    pAdvSink->AddRef();
+    return S_OK;
+}
+
+/*
+    Closes the control.
+*/
+HRESULT WINAPI QAxServerBase::Close(DWORD dwSaveOption)
+{
+    if (dwSaveOption != OLECLOSE_NOSAVE && m_spClientSite)
+	m_spClientSite->SaveObject();
+    if (isInPlaceActive) {
+	HRESULT hr = InPlaceDeactivate();
+	if (FAILED(hr))
+	    return hr;
+    }
+    if (m_hWnd) {
+	if (IsWindow(m_hWnd))
+	    DestroyWindow(m_hWnd);
+	m_hWnd = 0;
+	if (m_spClientSite)
+	    m_spClientSite->OnShowWindow(false);
+    }
+
+    if (m_spInPlaceSite) m_spInPlaceSite->Release();
+    m_spInPlaceSite = 0;
+
+    if (m_spAdviseSink)
+	m_spAdviseSink->OnClose();
+    for (int i = 0; i < adviseSinks.count(); ++i) {
+        adviseSinks.at(i).pAdvSink->OnClose();
+    }
+
+    return S_OK;
+}
+
+bool qax_disable_inplaceframe = true;
+
+/*
+    Executes the steps to activate the control.
+*/
+HRESULT QAxServerBase::internalActivate()
+{
+    if (!m_spClientSite)
+	return S_OK;
+    if (!m_spInPlaceSite)
+        m_spClientSite->QueryInterface(IID_IOleInPlaceSite, (void**)&m_spInPlaceSite);
+    if (!m_spInPlaceSite)
+	return E_FAIL;
+
+    HRESULT hr = E_FAIL;
+    if (!isInPlaceActive) {
+	BOOL bNoRedraw = false;
+	hr = m_spInPlaceSite->CanInPlaceActivate();
+	if (FAILED(hr))
+	    return hr;
+	if (hr != S_OK)
+	    return E_FAIL;
+	m_spInPlaceSite->OnInPlaceActivate();
+    }
+
+    isInPlaceActive = true;
+    OnAmbientPropertyChange(DISPID_AMBIENT_USERMODE);
+
+    if (isWidget) {
+        IOleInPlaceUIWindow *spInPlaceUIWindow = 0;
+        HWND hwndParent;
+        if (m_spInPlaceSite->GetWindow(&hwndParent) == S_OK) {
+            // get location in the parent window, as well as some information about the parent
+            if (m_spInPlaceFrame) m_spInPlaceFrame->Release();
+            m_spInPlaceFrame = 0;
+            RECT rcPos, rcClip;
+            OLEINPLACEFRAMEINFO frameInfo;
+            frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
+            m_spInPlaceSite->GetWindowContext(&m_spInPlaceFrame, &spInPlaceUIWindow, &rcPos, &rcClip, &frameInfo);
+            if (m_hWnd) {
+                ::ShowWindow(m_hWnd, SW_SHOW);
+                if (!::IsChild(m_hWnd, ::GetFocus()) && qt.widget->focusPolicy() != Qt::NoFocus)
+                    ::SetFocus(m_hWnd);
+            } else {
+                create(hwndParent, rcPos);
+            }
+        }
+
+	// Gone active by now, take care of UIACTIVATE
+	canTakeFocus = qt.widget->focusPolicy() != Qt::NoFocus && !inDesignMode;
+	if (!canTakeFocus && !inDesignMode) {
+	    QList<QWidget*> widgets = qFindChildren<QWidget*>(qt.widget);
+	    for (int w = 0; w < widgets.count(); ++w) {
+		QWidget *widget = widgets[w];
+		canTakeFocus = widget->focusPolicy() != Qt::NoFocus;
+                if (canTakeFocus)
+                    break;
+	    }
+	}
+	if (!isUIActive && canTakeFocus) {
+	    isUIActive = true;
+	    hr = m_spInPlaceSite->OnUIActivate();
+	    if (FAILED(hr)) {
+		if (m_spInPlaceFrame) m_spInPlaceFrame->Release();
+		m_spInPlaceFrame = 0;
+		if (spInPlaceUIWindow) spInPlaceUIWindow->Release();
+		return hr;
+	    }
+
+	    if (isInPlaceActive) {
+		if (!::IsChild(m_hWnd, ::GetFocus()))
+		    ::SetFocus(m_hWnd);
+	    }
+
+	    if (m_spInPlaceFrame) {
+		hr = m_spInPlaceFrame->SetActiveObject(this, QStringToBSTR(class_name));
+		if (!FAILED(hr)) {
+		    menuBar = (qt.widget && !qax_disable_inplaceframe) ? qFindChild<QMenuBar*>(qt.widget) : 0;
+		    if (menuBar && !menuBar->isVisible()) {
+			createMenu(menuBar);
+			menuBar->hide();
+			menuBar->installEventFilter(this);
+		    }
+		    statusBar = qt.widget ? qFindChild<QStatusBar*>(qt.widget) : 0;
+		    if (statusBar && !statusBar->isVisible()) {
+			const int index = statusBar->metaObject()->indexOfSignal("messageChanged(QString)");
+			QMetaObject::connect(statusBar, index, this, -1);
+			statusBar->hide();
+			statusBar->installEventFilter(this);
+		    }
+		}
+	    }
+	    if (spInPlaceUIWindow) {
+		spInPlaceUIWindow->SetActiveObject(this, QStringToBSTR(class_name));
+		spInPlaceUIWindow->SetBorderSpace(0);
+	    }
+	}
+        if (spInPlaceUIWindow) spInPlaceUIWindow->Release();
+	ShowWindow(m_hWnd, SW_NORMAL);
+    }
+
+    m_spClientSite->ShowObject();
+
+    return S_OK;
+}
+
+/*
+    Executes the "verb" \a iVerb.
+*/
+HRESULT WINAPI QAxServerBase::DoVerb(LONG iVerb, LPMSG /*lpmsg*/, IOleClientSite* /*pActiveSite*/, LONG /*lindex*/,
+			       HWND /*hwndParent*/, LPCRECT /*prcPosRect*/)
+{
+    HRESULT hr = E_NOTIMPL;
+    switch (iVerb)
+    {
+    case OLEIVERB_SHOW:
+	hr = internalActivate();
+	if (SUCCEEDED(hr))
+	    hr = S_OK;
+	break;
+
+    case OLEIVERB_PRIMARY:
+    case OLEIVERB_INPLACEACTIVATE:
+	hr = internalActivate();
+	if (SUCCEEDED(hr)) {
+	    hr = S_OK;
+	    update();
+	}
+	break;
+
+    case OLEIVERB_UIACTIVATE:
+	if (!isUIActive) {
+	    hr = internalActivate();
+	    if (SUCCEEDED(hr))
+		hr = S_OK;
+	}
+	break;
+
+    case OLEIVERB_HIDE:
+	UIDeactivate();
+	if (m_hWnd)
+	    ::ShowWindow(m_hWnd, SW_HIDE);
+	hr = S_OK;
+	return hr;
+
+    default:
+	break;
+    }
+    return hr;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::EnumAdvise(IEnumSTATDATA** /*ppenumAdvise*/)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Returns an enumerator for the verbs registered for this class.
+*/
+HRESULT WINAPI QAxServerBase::EnumVerbs(IEnumOLEVERB** ppEnumOleVerb)
+{
+    if (!ppEnumOleVerb)
+	return E_POINTER;
+    return OleRegEnumVerbs(qAxFactory()->classID(class_name), ppEnumOleVerb);
+}
+
+/*
+    Returns the current client site..
+*/
+HRESULT WINAPI QAxServerBase::GetClientSite(IOleClientSite** ppClientSite)
+{
+    if (!ppClientSite)
+	return E_POINTER;
+    *ppClientSite = m_spClientSite;
+    if (*ppClientSite)
+	(*ppClientSite)->AddRef();
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::GetClipboardData(DWORD, IDataObject**)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Returns the current extent.
+*/
+HRESULT WINAPI QAxServerBase::GetExtent(DWORD dwDrawAspect, SIZEL* psizel)
+{
+    if (dwDrawAspect != DVASPECT_CONTENT || !isWidget || !qt.widget)
+	return E_FAIL;
+    if (!psizel)
+	return E_POINTER;
+
+    psizel->cx = MAP_PIX_TO_LOGHIM(m_currentExtent.width(), qt.widget->logicalDpiX());
+    psizel->cy = MAP_PIX_TO_LOGHIM(m_currentExtent.height(), qt.widget->logicalDpiY());
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::GetMoniker(DWORD, DWORD, IMoniker** )
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Returns the CLSID of this class.
+*/
+HRESULT WINAPI QAxServerBase::GetUserClassID(CLSID* pClsid)
+{
+    if (!pClsid)
+	return E_POINTER;
+    *pClsid = qAxFactory()->classID(class_name);
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::InitFromData(IDataObject*, BOOL, DWORD)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::IsUpToDate()
+{
+    return S_OK;
+}
+
+/*
+    Stores the client site.
+*/
+HRESULT WINAPI QAxServerBase::SetClientSite(IOleClientSite* pClientSite)
+{
+    // release all client site interfaces
+    if (m_spClientSite) m_spClientSite->Release();
+    if (m_spInPlaceSite) m_spInPlaceSite->Release();
+    m_spInPlaceSite = 0;
+    if (m_spInPlaceFrame) m_spInPlaceFrame->Release();
+    m_spInPlaceFrame = 0;
+
+    m_spClientSite = pClientSite;
+    if (m_spClientSite) {
+        m_spClientSite->AddRef();
+	m_spClientSite->QueryInterface(IID_IOleInPlaceSite, (void **)&m_spInPlaceSite);
+    }
+
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::SetColorScheme(LOGPALETTE*)
+{
+    return E_NOTIMPL;
+}
+
+
+#ifdef QT_DLL // avoid conflict with symbol in static lib
+bool qt_sendSpontaneousEvent(QObject *o, QEvent *e)
+{
+    return QCoreApplication::sendSpontaneousEvent(o, e);
+}
+#endif
+
+/*
+    Tries to set the size of the control.
+*/
+HRESULT WINAPI QAxServerBase::SetExtent(DWORD dwDrawAspect, SIZEL* psizel)
+{
+    if (dwDrawAspect != DVASPECT_CONTENT)
+	return DV_E_DVASPECT;
+    if (!psizel)
+	return E_POINTER;
+
+    if (!isWidget || !qt.widget) // nothing to do
+	return S_OK;
+
+    QSize proposedSize(MAP_LOGHIM_TO_PIX(psizel->cx, qt.widget->logicalDpiX()),
+        MAP_LOGHIM_TO_PIX(psizel->cy, qt.widget->logicalDpiY()));
+
+    // can the widget be resized at all?
+    if (qt.widget->minimumSize() == qt.widget->maximumSize() && qt.widget->minimumSize() != proposedSize)
+        return E_FAIL;
+    //Save the extent, bound to the widget restrictions.
+    m_currentExtent.rwidth() = qBound(qt.widget->minimumWidth(), proposedSize.width(), qt.widget->maximumWidth());
+    m_currentExtent.rheight() = qBound(qt.widget->minimumHeight(), proposedSize.height(), qt.widget->maximumHeight());
+
+    resize(proposedSize);
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::SetHostNames(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
+{
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::SetMoniker(DWORD, IMoniker*)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Disconnects an advise sink.
+*/
+HRESULT WINAPI QAxServerBase::Unadvise(DWORD dwConnection)
+{
+    for (int i = 0; i < adviseSinks.count(); ++i) {
+        STATDATA entry = adviseSinks.at(i);
+        if (entry.dwConnection == dwConnection) {
+            entry.pAdvSink->Release();
+            adviseSinks.removeAt(i);
+            return S_OK;
+        }
+    }
+    return OLE_E_NOCONNECTION;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::Update()
+{
+    return S_OK;
+}
+
+//**** IDataObject
+/*
+    Calls IViewObject::Draw after setting up the parameters.
+*/
+HRESULT WINAPI QAxServerBase::GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
+{
+    if (!pmedium)
+	return E_POINTER;
+    if ((pformatetcIn->tymed & TYMED_MFPICT) == 0)
+	return DATA_E_FORMATETC;
+
+    internalCreate();
+    if (!isWidget || !qt.widget)
+	return E_UNEXPECTED;
+
+    // Container wants to draw, but the size is not defined yet - ask container
+    if (m_spInPlaceSite && !qt.widget->testAttribute(Qt::WA_Resized)) {
+	IOleInPlaceUIWindow *spInPlaceUIWindow = 0;
+        RECT rcPos, rcClip;
+        OLEINPLACEFRAMEINFO frameInfo;
+        frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
+
+	HRESULT hres = m_spInPlaceSite->GetWindowContext(&m_spInPlaceFrame, &spInPlaceUIWindow, &rcPos, &rcClip, &frameInfo);
+        if (hres == S_OK) {
+            QSize size(rcPos.right - rcPos.left, rcPos.bottom - rcPos.top);
+            resize(size);
+        } else {
+            qt.widget->adjustSize();
+        }
+        if (spInPlaceUIWindow) spInPlaceUIWindow->Release(); // no need for it
+    }
+
+    int width = qt.widget->width();
+    int height = qt.widget->height();
+    RECTL rectl = {0, 0, width, height};
+
+    HDC hdc = CreateMetaFile(0);
+    SaveDC(hdc);
+    SetWindowOrgEx(hdc, 0, 0, 0);
+    SetWindowExtEx(hdc, rectl.right, rectl.bottom, 0);
+
+    Draw(pformatetcIn->dwAspect, pformatetcIn->lindex, 0, pformatetcIn->ptd, 0, hdc, &rectl, &rectl, 0, 0);
+
+    RestoreDC(hdc, -1);
+    HMETAFILE hMF = CloseMetaFile(hdc);
+    if (!hMF)
+	return E_UNEXPECTED;
+
+    HGLOBAL hMem = GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE, sizeof(METAFILEPICT));
+    if (!hMem) {
+	DeleteMetaFile(hMF);
+	return ResultFromScode(STG_E_MEDIUMFULL);
+    }
+
+    LPMETAFILEPICT pMF = (LPMETAFILEPICT)GlobalLock(hMem);
+    pMF->hMF = hMF;
+    pMF->mm = MM_ANISOTROPIC;
+    pMF->xExt = MAP_PIX_TO_LOGHIM(width, qt.widget->logicalDpiX());
+    pMF->yExt = MAP_PIX_TO_LOGHIM(height, qt.widget->logicalDpiY());
+    GlobalUnlock(hMem);
+
+    memset(pmedium, 0, sizeof(STGMEDIUM));
+    pmedium->tymed = TYMED_MFPICT;
+    pmedium->hGlobal = hMem;
+    pmedium->pUnkForRelease = 0;
+
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::DAdvise(FORMATETC *pformatetc, DWORD advf,
+				      IAdviseSink *pAdvSink, DWORD *pdwConnection)
+{
+    if (pformatetc->dwAspect != DVASPECT_CONTENT)
+        return E_FAIL;
+
+    *pdwConnection = adviseSinks.count() + 1;
+    STATDATA data = {
+        {pformatetc->cfFormat,pformatetc->ptd,pformatetc->dwAspect,pformatetc->lindex,pformatetc->tymed},
+        advf, pAdvSink, *pdwConnection
+    };
+    adviseSinks.append(data);
+    pAdvSink->AddRef();
+    return S_OK;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::DUnadvise(DWORD dwConnection)
+{
+    return Unadvise(dwConnection);
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::EnumDAdvise(IEnumSTATDATA ** /*ppenumAdvise*/)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::GetDataHere(FORMATETC* /* pformatetc */, STGMEDIUM* /* pmedium */)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::QueryGetData(FORMATETC* /* pformatetc */)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::GetCanonicalFormatEtc(FORMATETC* /* pformatectIn */,FORMATETC* /* pformatetcOut */)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::SetData(FORMATETC* /* pformatetc */, STGMEDIUM* /* pmedium */, BOOL /* fRelease */)
+{
+    return E_NOTIMPL;
+}
+
+/*
+    Not implemented.
+*/
+HRESULT WINAPI QAxServerBase::EnumFormatEtc(DWORD /* dwDirection */, IEnumFORMATETC** /* ppenumFormatEtc */)
+{
+    return E_NOTIMPL;
+}
+
+
+
+static int mapModifiers(int state)
+{
+    int ole = 0;
+    if (state & Qt::ShiftModifier)
+	ole |= 1;
+    if (state & Qt::ControlModifier)
+	ole |= 2;
+    if (state & Qt::AltModifier)
+	ole |= 4;
+
+    return ole;
+}
+
+/*
+    \reimp
+*/
+bool QAxServerBase::eventFilter(QObject *o, QEvent *e)
+{
+    if (!theObject)
+	return QObject::eventFilter(o, e);
+
+    if ((e->type() == QEvent::Show || e->type() == QEvent::Hide) && (o == statusBar || o == menuBar)) {
+	if (o == menuBar) {
+	    if (e->type() == QEvent::Hide) {
+		createMenu(menuBar);
+	    } else if (e->type() == QEvent::Show) {
+		removeMenu();
+	    }
+	} else if (statusBar) {
+	    statusBar->setSizeGripEnabled(false);
+	}
+	updateGeometry();
+	if (m_spInPlaceSite && qt.widget->sizeHint().isValid()) {
+            RECT rect = {0, 0, qt.widget->sizeHint().width(), qt.widget->sizeHint().height()};
+	    m_spInPlaceSite->OnPosRectChange(&rect);
+	}
+    }
+    switch (e->type()) {
+    case QEvent::ChildAdded:
+	static_cast<QChildEvent*>(e)->child()->installEventFilter(this);
+	break;
+    case QEvent::ChildRemoved:
+	static_cast<QChildEvent*>(e)->child()->removeEventFilter(this);
+	break;
+    case QEvent::KeyPress:
+	if (o == qt.object && hasStockEvents) {
+	    QKeyEvent *ke = (QKeyEvent*)e;
+	    int key = ke->key();
+	    int state = ke->modifiers();
+	    void *argv[] = {
+		0,
+		&key,
+		&state
+	    };
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_KEYDOWN, argv);
+	    if (!ke->text().isEmpty())
+		qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_KEYPRESS, argv);
+	}
+	break;
+    case QEvent::KeyRelease:
+	if (o == qt.object && hasStockEvents) {
+	    QKeyEvent *ke = (QKeyEvent*)e;
+	    int key = ke->key();
+	    int state = ke->modifiers();
+	    void *argv[] = {
+		0,
+		&key,
+		&state
+	    };
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_KEYUP, argv);
+	}
+	break;
+    case QEvent::MouseMove:
+	if (o == qt.object && hasStockEvents) {
+	    QMouseEvent *me = (QMouseEvent*)e;
+            int button = me->buttons() & Qt::MouseButtonMask;
+	    int state = mapModifiers(me->modifiers());
+	    int x = me->x();
+	    int y = me->y();
+	    void *argv[] = {
+		0,
+		&button,
+		&state,
+		&x,
+		&y
+	    };
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_MOUSEMOVE, argv);
+	}
+	break;
+    case QEvent::MouseButtonRelease:
+	if (o == qt.object && hasStockEvents) {
+	    QMouseEvent *me = (QMouseEvent*)e;
+	    int button = me->button();
+	    int state = mapModifiers(me->modifiers());
+	    int x = me->x();
+	    int y = me->y();
+	    void *argv[] = {
+		0,
+		&button,
+		&state,
+		&x,
+		&y
+	    };
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_MOUSEUP, argv);
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_CLICK, 0);
+	}
+	break;
+    case QEvent::MouseButtonDblClick:
+	if (o == qt.object && hasStockEvents) {
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_DBLCLICK, 0);
+	}
+	break;
+    case QEvent::MouseButtonPress:
+        if (m_spInPlaceSite && !isUIActive) {
+            internalActivate();
+        }
+	if (o == qt.widget && hasStockEvents) {
+	    QMouseEvent *me = (QMouseEvent*)e;
+	    int button = me->button();
+	    int state = mapModifiers(me->modifiers());
+	    int x = me->x();
+	    int y = me->y();
+	    void *argv[] = {
+		0,
+		&button,
+		&state,
+		&x,
+		&y
+	    };
+	    qt_metacall(QMetaObject::InvokeMetaMethod, DISPID_MOUSEDOWN, argv);
+	}
+	break;
+    case QEvent::Show:
+	if (m_hWnd && o == qt.widget)
+	    ShowWindow(m_hWnd, SW_SHOW);
+	updateMask();
+	break;
+    case QEvent::Hide:
+	if (m_hWnd && o == qt.widget)
+	    ShowWindow(m_hWnd, SW_HIDE);
+	break;
+
+    case QEvent::EnabledChange:
+        if (m_hWnd && o == qt.widget)
+            EnableWindow(m_hWnd, qt.widget->isEnabled());
+        // Fall Through
+    case QEvent::FontChange:
+    case QEvent::ActivationChange:
+    case QEvent::StyleChange:
+    case QEvent::IconTextChange:
+    case QEvent::ModifiedChange:
+    case QEvent::Resize:
+	updateMask();
+	break;
+    case QEvent::WindowBlocked: {
+        if (!m_spInPlaceFrame)
+            break;
+        m_spInPlaceFrame->EnableModeless(FALSE);
+        MSG msg;
+        // Visual Basic 6.0 posts the message WM_USER+3078 from the EnableModeless().
+        // While handling this message, VB will disable all current top-levels. After 
+        // this we have to re-enable the Qt modal widget to receive input events. 
+        if (PeekMessage(&msg, 0, WM_USER+3078, WM_USER+3078, PM_REMOVE)) {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+            QWidget *modalWidget = QApplication::activeModalWidget();
+            if (modalWidget && modalWidget->isVisible() && modalWidget->isEnabled() 
+                && !IsWindowEnabled(modalWidget->effectiveWinId()))
+                EnableWindow(modalWidget->effectiveWinId(), TRUE);
+        }
+        break;
+        }
+    case QEvent::WindowUnblocked:
+        if (!m_spInPlaceFrame)
+            break;
+        m_spInPlaceFrame->EnableModeless(TRUE);
+        break;
+    default:
+	break;
+    }
+    return QObject::eventFilter(o, e);
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/control/qaxserverdll.cpp b/src/activeqt/control/qaxserverdll.cpp
new file mode 100644
index 0000000..1263863
--- /dev/null
+++ b/src/activeqt/control/qaxserverdll.cpp
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qapplication.h>
+#include <qwidget.h>
+
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+bool qax_ownQApp = false;
+HHOOK qax_hhook = 0;
+
+// in qaxserver.cpp
+extern char qAxModuleFilename[MAX_PATH];
+extern bool qAxIsServer;
+extern ITypeLib *qAxTypeLibrary;
+extern unsigned long qAxLockCount();
+extern QString qAxInit();
+extern void qAxCleanup();
+extern HANDLE qAxInstance;
+static uint qAxThreadId = 0;
+
+extern HRESULT UpdateRegistry(int bRegister);
+extern HRESULT GetClassObject(const GUID &clsid, const GUID &iid, void **ppUnk);
+
+STDAPI DllRegisterServer()
+{
+    return UpdateRegistry(true);
+}
+
+STDAPI DllUnregisterServer()
+{
+    return UpdateRegistry(false);
+}
+
+STDAPI DllGetClassObject(const GUID &clsid, const GUID &iid, void** ppv)
+{
+    if (!qAxThreadId)
+        qAxThreadId = GetCurrentThreadId();
+    else if (GetCurrentThreadId() != qAxThreadId)
+        return E_FAIL; 
+
+    GetClassObject(clsid, iid, ppv);
+    if (!*ppv)
+        return CLASS_E_CLASSNOTAVAILABLE;
+    return S_OK;
+}
+
+STDAPI DllCanUnloadNow()
+{
+    if (GetCurrentThreadId() != qAxThreadId)
+        return S_FALSE;
+    if (qAxLockCount())
+        return S_FALSE;
+    if (!qax_ownQApp)
+        return S_OK;
+    
+    // check if qApp still runs widgets (in other DLLs)
+    QWidgetList widgets = qApp->allWidgets();
+    int count = widgets.count();
+    for (int w = 0; w < widgets.count(); ++w) {
+        // remove all Qt generated widgets
+        QWidget *widget = widgets.at(w);
+        if (widget->windowType() == Qt::Desktop || widget->objectName() == QLatin1String("Qt internal tablet widget"))
+            count--;
+    }
+    if (count)
+        return S_FALSE;
+    
+    // no widgets left - destroy qApp
+    if (qax_hhook)
+        UnhookWindowsHookEx(qax_hhook);
+    
+    delete qApp;
+    qax_ownQApp = false;
+    
+    // never allow unloading - safety net for Internet Explorer
+    return S_FALSE;
+}
+
+
+EXTERN_C BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpvReserved)
+{
+    GetModuleFileNameA(hInstance, qAxModuleFilename, MAX_PATH-1);
+    qAxInstance = hInstance;
+    qAxIsServer = true;
+    
+    if (dwReason == DLL_PROCESS_ATTACH) {
+        DisableThreadLibraryCalls(hInstance);
+        qAxInit();
+    } else if (dwReason == DLL_PROCESS_DETACH) {
+        qAxCleanup();
+    }
+    
+    return true;
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/control/qaxservermain.cpp b/src/activeqt/control/qaxservermain.cpp
new file mode 100644
index 0000000..a50fef0
--- /dev/null
+++ b/src/activeqt/control/qaxservermain.cpp
@@ -0,0 +1,279 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#include <qstringlist.h>
+#include <qvector.h>
+
+#include "qaxfactory.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qt_windows.h>
+
+QT_BEGIN_NAMESPACE
+
+static DWORD *classRegistration = 0;
+static DWORD dwThreadID;
+static bool qAxActivity = false;
+static HANDLE hEventShutdown;
+
+#ifdef QT_DEBUG
+QT_STATIC_CONST DWORD dwTimeOut = 1000;
+QT_STATIC_CONST DWORD dwPause = 500;
+#else
+QT_STATIC_CONST DWORD dwTimeOut = 5000; // time for EXE to be idle before shutting down
+QT_STATIC_CONST DWORD dwPause = 1000; // time to wait for threads to finish up
+#endif
+
+extern HANDLE hEventShutdown;
+extern bool qAxActivity;
+extern HANDLE qAxInstance;
+extern bool qAxIsServer;
+extern bool qAxOutProcServer;
+extern char qAxModuleFilename[MAX_PATH];
+extern QString qAxInit();
+extern void qAxCleanup();
+extern HRESULT UpdateRegistry(BOOL bRegister);
+extern HRESULT GetClassObject(const GUID &clsid, const GUID &iid, void **ppUnk);
+extern ulong qAxLockCount();
+extern bool qax_winEventFilter(void *message);
+
+#if defined(Q_CC_BOR)
+extern "C" __stdcall HRESULT DumpIDL(const QString &outfile, const QString &ver);
+#else
+STDAPI DumpIDL(const QString &outfile, const QString &ver);
+#endif
+
+// Monitors the shutdown event
+static DWORD WINAPI MonitorProc(void* pv)
+{
+    while (1) {
+        WaitForSingleObject(hEventShutdown, INFINITE);
+        DWORD dwWait=0;
+        do {
+            qAxActivity = false;
+            dwWait = WaitForSingleObject(hEventShutdown, dwTimeOut);
+        } while (dwWait == WAIT_OBJECT_0);
+        // timed out
+        if (!qAxActivity && !qAxLockCount()) // if no activity let's really bail
+            break;
+    }
+    CloseHandle(hEventShutdown);
+    PostThreadMessage(dwThreadID, WM_QUIT, 0, 0);
+    PostQuitMessage(0);
+    
+    return 0;
+}
+
+// Starts the monitoring thread
+static bool StartMonitor()
+{
+    dwThreadID = GetCurrentThreadId();
+    hEventShutdown = CreateEventA(0, false, false, 0);
+    if (hEventShutdown == 0)
+        return false;
+    DWORD dwThreadID;
+    HANDLE h = CreateThread(0, 0, MonitorProc, 0, 0, &dwThreadID);
+    return (h != NULL);
+}
+
+void qax_shutDown()
+{
+    qAxActivity = true;
+    if (hEventShutdown)
+        SetEvent(hEventShutdown); // tell monitor that we transitioned to zero
+}
+
+/*
+    Start the COM server (if necessary).
+*/
+bool qax_startServer(QAxFactory::ServerType type)
+{
+    if (qAxIsServer)
+        return true;
+    
+    const QStringList keys = qAxFactory()->featureList();
+    if (!keys.count())
+        return false;
+    
+    if (!qAxFactory()->isService())
+        StartMonitor();
+    
+    classRegistration = new DWORD[keys.count()];
+    int object = 0;
+    for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object) {
+        IUnknown* p = 0;
+        CLSID clsid = qAxFactory()->classID(*key);
+        
+        // Create a QClassFactory (implemented in qaxserverbase.cpp)
+        HRESULT hRes = GetClassObject(clsid, IID_IClassFactory, (void**)&p);
+        if (SUCCEEDED(hRes))
+            hRes = CoRegisterClassObject(clsid, p, CLSCTX_LOCAL_SERVER,
+                type == QAxFactory::MultipleInstances ? REGCLS_MULTIPLEUSE : REGCLS_SINGLEUSE,
+                classRegistration+object);
+        if (p)
+            p->Release();
+    }
+
+    qAxIsServer = true;
+    return true;
+}
+
+/*
+    Stop the COM server (if necessary).
+*/
+bool qax_stopServer()
+{
+    if (!qAxIsServer || !classRegistration)
+        return true;
+    
+    qAxIsServer = false;
+    
+    const QStringList keys = qAxFactory()->featureList();
+    int object = 0;
+    for (QStringList::ConstIterator key = keys.begin(); key != keys.end(); ++key, ++object)
+        CoRevokeClassObject(classRegistration[object]);
+    
+    delete []classRegistration;
+    classRegistration = 0;
+    
+    Sleep(dwPause); //wait for any threads to finish
+    
+    return true;
+}
+
+#if defined(Q_OS_WINCE)
+extern void __cdecl qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
+#else
+extern void qWinMain(HINSTANCE, HINSTANCE, LPSTR, int, int &, QVector<char *> &);
+#endif
+
+QT_END_NAMESPACE
+
+#if defined(QT_NEEDS_QMAIN)
+int qMain(int, char **);
+#define main qMain
+#else
+#if defined(Q_OS_WINCE)
+extern "C" int __cdecl main(int, char **);
+#else
+extern "C" int main(int, char **);
+#endif
+#endif
+
+
+EXTERN_C int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR, int nShowCmd)
+{
+    QT_USE_NAMESPACE 
+
+    qAxOutProcServer = true;
+    GetModuleFileNameA(0, qAxModuleFilename, MAX_PATH-1);
+    qAxInstance = hInstance;
+
+    QByteArray cmdParam;
+    QT_WA({
+        LPTSTR cmdline = GetCommandLineW();
+        cmdParam = QString::fromUtf16((const ushort *)cmdline).toLocal8Bit();
+    }, {
+        cmdParam = GetCommandLineA();
+    });
+    
+    QList<QByteArray> cmds = cmdParam.split(' ');
+    QByteArray unprocessed;
+
+    int nRet = 0;
+    bool run = true;
+    bool runServer = false;
+    for (int i = 0; i < cmds.count(); ++i) {
+        QByteArray cmd = cmds.at(i).toLower();
+        if (cmd == "-activex" || cmd == "/activex" || cmd == "-embedding" || cmd == "/embedding") {
+            runServer = true;
+        } else if (cmd == "-unregserver" || cmd == "/unregserver") {
+            nRet = UpdateRegistry(false);
+            run = false;
+            break;
+        } else if (cmd == "-regserver" || cmd == "/regserver") {
+            nRet = UpdateRegistry(true);
+            run = false;
+            break;
+        } else if (cmd == "-dumpidl" || cmd == "/dumpidl") {
+            ++i;
+            if (i < cmds.count()) {
+                QByteArray outfile = cmds.at(i);
+                ++i;
+                QByteArray version;
+                if (i < cmds.count() && (cmds.at(i) == "-version" || cmds.at(i) == "/version")) {
+                    ++i;
+                    if (i < cmds.count())
+                        version = cmds.at(i);
+                    else
+                        version = "1.0";
+                }
+                
+                nRet = DumpIDL(QString::fromLatin1(outfile.constData()), QString::fromLatin1(version.constData()));
+            } else {
+                qWarning("Wrong commandline syntax: <app> -dumpidl <idl file> [-version <x.y.z>]");
+            }
+            run = false;
+            break;
+        } else {
+            unprocessed += cmds.at(i) + " ";
+        }
+    }
+    
+    if (run) {
+        HRESULT hRes = CoInitialize(0);
+
+        int argc;
+        QVector<char*> argv(8);
+        qWinMain(hInstance, hPrevInstance, unprocessed.data(), nShowCmd, argc, argv);
+        qAxInit();
+        if (runServer)
+            QAxFactory::startServer();
+        nRet = ::main(argc, argv.data());
+        QAxFactory::stopServer();
+        qAxCleanup();
+        CoUninitialize();
+        
+    }
+    
+    return nRet;
+}
+
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/shared/qaxtypes.cpp b/src/activeqt/shared/qaxtypes.cpp
new file mode 100644
index 0000000..ace81e7
--- /dev/null
+++ b/src/activeqt/shared/qaxtypes.cpp
@@ -0,0 +1,1486 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+
+#include <ocidl.h>
+#include <olectl.h>
+
+#include "qaxtypes.h"
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+#include <qcolormap.h>
+#include <qcursor.h>
+#include <qpixmap.h>
+#include <qpainter.h>
+#include <qobject.h>
+#ifdef QAX_SERVER
+#   include <qaxfactory.h>
+#   include <qlibrary.h>
+#else
+#   include <quuid.h>
+#   include <qaxobject.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifdef QAX_SERVER
+extern ITypeLib *qAxTypeLibrary;
+
+CLSID CLSID_QRect = { 0x34030f30, 0xe359, 0x4fe6, {0xab, 0x82, 0x39, 0x76, 0x6f, 0x5d, 0x91, 0xee } };
+CLSID CLSID_QSize = { 0xcb5f84b3, 0x29e5, 0x491d, {0xba, 0x18, 0x54, 0x72, 0x48, 0x8e, 0xef, 0xba } };
+CLSID CLSID_QPoint = { 0x3be838a3, 0x3fac, 0xbfc4, {0x4c, 0x6c, 0x37, 0xc4, 0x4d, 0x03, 0x02, 0x52 } };
+
+GUID IID_IAxServerBase = { 0xbd2ec165, 0xdfc9, 0x4319, { 0x8b, 0x9b, 0x60, 0xa5, 0x74, 0x78, 0xe9, 0xe3} };
+#else
+extern void *qax_createObjectWrapper(int metaType, IUnknown *iface);
+#endif
+
+static IFontDisp *QFontToIFont(const QFont &font)
+{
+#if defined(Q_OS_WINCE)
+    Q_UNUSED(font);
+    return 0;
+#else
+    FONTDESC fdesc;
+    memset(&fdesc, 0, sizeof(fdesc));
+    fdesc.cbSizeofstruct = sizeof(FONTDESC);
+    fdesc.cySize.Lo = font.pointSize() * 10000;
+    fdesc.fItalic = font.italic();
+    fdesc.fStrikethrough = font.strikeOut();
+    fdesc.fUnderline = font.underline();
+    fdesc.lpstrName = QStringToBSTR(font.family());
+    fdesc.sWeight = font.weight() * 10;
+    
+    IFontDisp *f;
+    HRESULT res = OleCreateFontIndirect(&fdesc, IID_IFontDisp, (void**)&f);
+    if (res != S_OK) {
+        if (f) f->Release();
+        f = 0;
+#if defined(QT_CHECK_STATE)
+        qWarning("QFontToIFont: Failed to create IFont");
+#endif
+    }
+    return f;
+#endif
+}
+
+static QFont IFontToQFont(IFont *f)
+{
+    BSTR name;
+    BOOL bold;
+    SHORT charset;
+    BOOL italic;
+    CY size;
+    BOOL strike;
+    BOOL underline;
+    SHORT weight;
+    f->get_Name(&name);
+    f->get_Bold(&bold);
+    f->get_Charset(&charset);
+    f->get_Italic(&italic);
+    f->get_Size(&size);
+    f->get_Strikethrough(&strike);
+    f->get_Underline(&underline);
+    f->get_Weight(&weight);
+    QFont font(QString::fromUtf16((const ushort *)name), size.Lo/9750, weight / 97, italic);
+    font.setBold(bold);
+    font.setStrikeOut(strike);
+    font.setUnderline(underline);
+    SysFreeString(name);
+    
+    return font;
+}
+
+static IPictureDisp *QPixmapToIPicture(const QPixmap &pixmap)
+{
+#if defined(Q_OS_WINCE)
+    Q_UNUSED(pixmap);
+    return 0;
+#else
+    IPictureDisp *pic = 0;
+    
+    PICTDESC desc;
+    desc.cbSizeofstruct = sizeof(PICTDESC);
+    desc.picType = PICTYPE_BITMAP;
+    
+    desc.bmp.hbitmap = 0;
+    desc.bmp.hpal = QColormap::hPal();
+    
+    if (!pixmap.isNull()) {
+        desc.bmp.hbitmap = pixmap.toWinHBITMAP();
+        Q_ASSERT(desc.bmp.hbitmap);
+    }
+
+    HRESULT res = OleCreatePictureIndirect(&desc, IID_IPictureDisp, true, (void**)&pic);
+    if (res != S_OK) {
+        if (pic) pic->Release();
+        pic = 0;
+#if defined(QT_CHECK_STATE)
+        qWarning("QPixmapToIPicture: Failed to create IPicture");
+#endif
+    }
+    return pic;
+#endif
+}
+
+static QPixmap IPictureToQPixmap(IPicture *ipic)
+{
+    SHORT type;
+    ipic->get_Type(&type);
+    if (type != PICTYPE_BITMAP)
+        return QPixmap();
+
+    HBITMAP hbm = 0;
+    ipic->get_Handle((OLE_HANDLE*)&hbm);
+    if (!hbm)
+        return QPixmap();
+
+    return QPixmap::fromWinHBITMAP(hbm);
+}
+
+static QDateTime DATEToQDateTime(DATE ole)
+{
+    SYSTEMTIME stime;
+    if (ole >= 949998 || VariantTimeToSystemTime(ole, &stime) == false)
+        return QDateTime();
+    
+    QDate date(stime.wYear, stime.wMonth, stime.wDay);
+    QTime time(stime.wHour, stime.wMinute, stime.wSecond, stime.wMilliseconds);
+    return QDateTime(date, time);
+}
+
+static DATE QDateTimeToDATE(const QDateTime &dt)
+{
+    if (!dt.isValid() || dt.isNull())
+        return 949998;
+    
+    SYSTEMTIME stime;
+    memset(&stime, 0, sizeof(stime));
+    QDate date = dt.date();
+    QTime time = dt.time();
+    if (date.isValid() && !date.isNull()) {
+        stime.wDay = date.day();
+        stime.wMonth = date.month();
+        stime.wYear = date.year();
+    }
+    if (time.isValid() && !time.isNull()) {
+        stime.wMilliseconds = time.msec();
+        stime.wSecond = time.second();
+        stime.wMinute = time.minute();
+        stime.wHour = time.hour();
+    }
+    
+    double vtime;
+    SystemTimeToVariantTime(&stime, &vtime);
+    
+    return vtime;
+}
+
+QColor OLEColorToQColor(uint col)
+{
+#if defined(Q_OS_WINCE)
+    return QColor(GetBValue(col),GetGValue(col),GetRValue(col));
+#else
+    COLORREF cref;
+    OleTranslateColor(col, QColormap::hPal(), &cref);
+    return QColor(GetRValue(cref),GetGValue(cref),GetBValue(cref));
+#endif
+}
+
+/*
+    Converts \a var to \a arg, and tries to coerce \a arg to \a type.
+
+    Used by
+
+    QAxServerBase:
+        - QAxServerBase::qt_metacall
+        - IDispatch::Invoke(PROPERTYGET, METHOD)
+        - IPersistPropertyBag::Save
+
+    QAxBase:
+        - IDispatch::Invoke (QAxEventSink)
+        - QAxBase::internalProperty(WriteProperty)
+        - QAxBase::internalInvoke()
+        - QAxBase::dynamicCallHelper()
+        - IPropertyBag::Read (QtPropertyBag)
+
+    Also called recoursively for lists.
+*/
+bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName, bool out)
+{
+    QVariant qvar = var;
+    // "type" is the expected type, so coerce if necessary
+    QVariant::Type proptype = typeName.isEmpty() ? QVariant::Invalid : QVariant::nameToType(typeName);
+    if (proptype == QVariant::UserType && !typeName.isEmpty()) {
+        if (typeName == "short" || typeName == "char")
+            proptype = QVariant::Int;
+        else if (typeName == "float")
+            proptype = QVariant::Double;
+    }
+    if (proptype != QVariant::Invalid && proptype != QVariant::UserType && proptype != qvar.type()) {
+        if (qvar.canConvert(proptype))
+            qvar.convert(proptype);
+        else
+            qvar = QVariant(proptype);
+    }
+
+    if (out && arg.vt == (VT_VARIANT|VT_BYREF) && arg.pvarVal) {
+        return QVariantToVARIANT(var, *arg.pvarVal, typeName, false);
+    }
+
+    if (out && proptype == QVariant::Invalid && typeName == "QVariant") {
+        VARIANT *pVariant = new VARIANT;
+        QVariantToVARIANT(var, *pVariant, QByteArray(), false);
+        arg.vt = VT_VARIANT|VT_BYREF;
+        arg.pvarVal = pVariant;
+        return true;
+    }
+
+    switch ((int)qvar.type()) {
+    case QVariant::String:
+        if (out && arg.vt == (VT_BSTR|VT_BYREF)) {
+            if (*arg.pbstrVal)
+                SysFreeString(*arg.pbstrVal);
+            *arg.pbstrVal = QStringToBSTR(qvar.toString());
+            arg.vt = VT_BSTR|VT_BYREF;
+        } else {
+            arg.vt = VT_BSTR;
+            arg.bstrVal = QStringToBSTR(qvar.toString());
+            if (out) {
+                arg.pbstrVal = new BSTR(arg.bstrVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+        
+    case QVariant::Int:
+        if (out && arg.vt == (VT_I4|VT_BYREF)) {
+            *arg.plVal = qvar.toInt();
+        } else {
+            arg.vt = VT_I4;
+            arg.lVal = qvar.toInt();
+            if (out) {
+                if (typeName == "short") {
+                    arg.vt = VT_I2;
+                    arg.piVal = new short(arg.lVal);
+                } else if (typeName == "char") {
+                    arg.vt = VT_I1;
+                    arg.pcVal= new char(arg.lVal);
+                } else {
+                    arg.plVal = new long(arg.lVal);
+                }
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+        
+    case QVariant::UInt:
+        if (out && (arg.vt == (VT_UINT|VT_BYREF) || arg.vt == (VT_I4|VT_BYREF))) {
+            *arg.puintVal = qvar.toUInt();
+        } else {
+            arg.vt = VT_UINT;
+            arg.uintVal = qvar.toUInt();
+            if (out) {
+                arg.puintVal = new uint(arg.uintVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+        
+    case QVariant::LongLong:
+        if (out && arg.vt == (VT_CY|VT_BYREF)) {
+            arg.pcyVal->int64 = qvar.toLongLong();
+#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
+        } else if (out && arg.vt == (VT_I8|VT_BYREF)) {
+            *arg.pllVal = qvar.toLongLong();
+        } else {
+            arg.vt = VT_I8;
+            arg.llVal = qvar.toLongLong();
+            if (out) {
+                arg.pllVal = new LONGLONG(arg.llVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+#else
+        } else {
+            arg.vt = VT_CY;
+            arg.cyVal.int64 = qvar.toLongLong();
+            if (out) {
+                arg.pcyVal = new CY(arg.cyVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+#endif
+        break;
+        
+    case QVariant::ULongLong:
+        if (out && arg.vt == (VT_CY|VT_BYREF)) {
+            arg.pcyVal->int64 = qvar.toULongLong();
+#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
+        } else if (out && arg.vt == (VT_UI8|VT_BYREF)) {
+            *arg.pullVal = qvar.toULongLong();
+        } else {
+            arg.vt = VT_UI8;
+            arg.ullVal = qvar.toULongLong();
+            if (out) {
+                arg.pullVal = new ULONGLONG(arg.ullVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+#else
+        } else {
+            arg.vt = VT_CY;
+            arg.cyVal.int64 = qvar.toULongLong();
+            if (out) {
+                arg.pcyVal = new CY(arg.cyVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+
+#endif
+
+        break;
+        
+    case QVariant::Bool:
+        if (out && arg.vt == (VT_BOOL|VT_BYREF)) {
+            *arg.pboolVal = qvar.toBool() ? VARIANT_TRUE : VARIANT_FALSE;
+        } else {
+            arg.vt = VT_BOOL;
+            arg.boolVal = qvar.toBool() ? VARIANT_TRUE : VARIANT_FALSE;
+            if (out) {
+                arg.pboolVal = new short(arg.boolVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+    case QVariant::Double:
+        if (out && arg.vt == (VT_R8|VT_BYREF)) {
+            *arg.pdblVal = qvar.toDouble();
+        } else {
+            arg.vt = VT_R8;
+            arg.dblVal = qvar.toDouble();
+            if (out) {
+                if (typeName == "float") {
+                    arg.vt = VT_R4;
+                    arg.pfltVal = new float(arg.dblVal);                    
+                } else {
+                    arg.pdblVal = new double(arg.dblVal);
+                }
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+    case QVariant::Color:
+        if (out && arg.vt == (VT_COLOR|VT_BYREF)) {
+            
+            *arg.plVal = QColorToOLEColor(qvariant_cast<QColor>(qvar));
+        } else {
+            arg.vt = VT_COLOR;
+            arg.lVal = QColorToOLEColor(qvariant_cast<QColor>(qvar));
+            if (out) {
+                arg.plVal = new long(arg.lVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+        
+    case QVariant::Date:
+    case QVariant::Time:
+    case QVariant::DateTime:
+        if (out && arg.vt == (VT_DATE|VT_BYREF)) {
+            *arg.pdate = QDateTimeToDATE(qvar.toDateTime());
+        } else {
+            arg.vt = VT_DATE;
+            arg.date = QDateTimeToDATE(qvar.toDateTime());
+            if (out) {
+                arg.pdate = new DATE(arg.date);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+    case QVariant::Font:
+        if (out && arg.vt == (VT_DISPATCH|VT_BYREF)) {
+            if (*arg.ppdispVal)
+                (*arg.ppdispVal)->Release();
+            *arg.ppdispVal = QFontToIFont(qvariant_cast<QFont>(qvar));
+        } else {
+            arg.vt = VT_DISPATCH;
+            arg.pdispVal = QFontToIFont(qvariant_cast<QFont>(qvar));
+            if (out) {
+                arg.ppdispVal = new IDispatch*(arg.pdispVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+        
+    case QVariant::Pixmap:
+        if (out && arg.vt == (VT_DISPATCH|VT_BYREF)) {
+            if (*arg.ppdispVal)
+                (*arg.ppdispVal)->Release();
+            *arg.ppdispVal = QPixmapToIPicture(qvariant_cast<QPixmap>(qvar));
+        } else {
+            arg.vt = VT_DISPATCH;
+            arg.pdispVal = QPixmapToIPicture(qvariant_cast<QPixmap>(qvar));
+            if (out) {
+                arg.ppdispVal = new IDispatch*(arg.pdispVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+
+    case QVariant::Cursor:
+        {
+#ifndef QT_NO_CURSOR
+            int shape = qvariant_cast<QCursor>(qvar).shape();
+            if (out && (arg.vt & VT_BYREF)) {
+                switch(arg.vt & ~VT_BYREF) {
+                case VT_I4:
+                    *arg.plVal = shape;
+                    break;
+                case VT_I2:
+                    *arg.piVal = shape;
+                    break;
+                case VT_UI4:
+                    *arg.pulVal = shape;
+                    break;
+                case VT_UI2:
+                    *arg.puiVal = shape;
+                    break;
+                case VT_INT:
+                    *arg.pintVal = shape;
+                    break;
+                case VT_UINT:
+                    *arg.puintVal = shape;
+                    break;
+                }
+            } else {
+                arg.vt = VT_I4;
+                arg.lVal = shape;
+                if (out) {
+                    arg.plVal = new long(arg.lVal);
+                    arg.vt |= VT_BYREF;
+                }
+            }
+#endif
+        }
+        break;
+        
+    case QVariant::List:
+        {
+            const QList<QVariant> list = qvar.toList();
+            const int count = list.count();
+            VARTYPE vt = VT_VARIANT;
+            QVariant::Type listType = QVariant::LastType; // == QVariant
+            if (!typeName.isEmpty() && typeName.startsWith("QList<")) {
+                const QByteArray listTypeName = typeName.mid(6, typeName.length() - 7); // QList<int> -> int
+                listType = QVariant::nameToType(listTypeName);
+            }
+
+            VARIANT variant;
+            void *pElement = &variant;
+            switch(listType) {
+            case QVariant::Int:
+                vt = VT_I4;
+                pElement = &variant.lVal;
+                break;
+            case QVariant::Double:
+                vt = VT_R8;
+                pElement = &variant.dblVal;
+                break;
+            case QVariant::DateTime:
+                vt = VT_DATE;
+                pElement = &variant.date;
+                break;
+            case QVariant::Bool:
+                vt = VT_BOOL;
+                pElement = &variant.boolVal;
+                break;
+            case QVariant::LongLong:
+#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
+                vt = VT_I8;
+                pElement = &variant.llVal;
+#else
+                vt = VT_CY;
+                pElement = &variant.cyVal;
+#endif
+                break;
+            default:
+                break;
+            }
+            SAFEARRAY *array = 0;
+            bool is2D = false;
+            // If the first element in the array is a list the whole list is 
+            // treated as a 2D array. The colum count is taken from the 1st element.
+            if (count) {
+                QVariantList col = list.at(0).toList();
+                int maxColumns = col.count();
+                if (maxColumns) {
+                    is2D = true;
+                    SAFEARRAYBOUND rgsabound[2] = {0};
+                    rgsabound[0].cElements = count;
+                    rgsabound[1].cElements = maxColumns;
+                    array = SafeArrayCreate(VT_VARIANT, 2, rgsabound);
+                    LONG rgIndices[2];
+                    for (LONG i = 0; i < count; ++i) {
+                        rgIndices[0] = i;
+                        QVariantList columns = list.at(i).toList();
+                        int columnCount = qMin(maxColumns, columns.count());
+                        for (LONG j = 0;  j < columnCount; ++j) {
+                            QVariant elem = columns.at(j);
+                            VariantInit(&variant);
+                            QVariantToVARIANT(elem, variant, elem.typeName());
+                            rgIndices[1] = j;
+                            SafeArrayPutElement(array, rgIndices, pElement);
+                            clearVARIANT(&variant);
+                        }
+                    }
+
+                }
+            }
+            if (!is2D) {
+                array = SafeArrayCreateVector(vt, 0, count);
+                for (LONG index = 0; index < count; ++index) {
+                    QVariant elem = list.at(index);
+                    if (listType != QVariant::LastType)
+                        elem.convert(listType);
+                    VariantInit(&variant);
+                    QVariantToVARIANT(elem, variant, elem.typeName());
+                    SafeArrayPutElement(array, &index, pElement);
+                    clearVARIANT(&variant);
+                }
+            }
+            if (out && arg.vt == (VT_ARRAY|vt|VT_BYREF)) {
+                if (*arg.pparray)
+                    SafeArrayDestroy(*arg.pparray);
+                *arg.pparray = array;
+            } else {
+                arg.vt = VT_ARRAY|vt;
+                arg.parray = array;
+                if (out) {
+                    arg.pparray = new SAFEARRAY*(arg.parray);
+                    arg.vt |= VT_BYREF;
+                }
+            }
+        }
+        break;
+        
+    case QVariant::StringList:
+        {
+            const QStringList list = qvar.toStringList();
+            const int count = list.count();
+            SAFEARRAY *array = SafeArrayCreateVector(VT_BSTR, 0, count);
+            for (LONG index = 0; index < count; ++index) {
+                QString elem = list.at(index);
+                BSTR bstr = QStringToBSTR(elem);
+                SafeArrayPutElement(array, &index, bstr);
+                SysFreeString(bstr);
+            }
+            
+            if (out && arg.vt == (VT_ARRAY|VT_BSTR|VT_BYREF)) {
+                if (*arg.pparray)
+                    SafeArrayDestroy(*arg.pparray);
+                *arg.pparray = array;
+            } else {
+                arg.vt = VT_ARRAY|VT_BSTR;
+                arg.parray = array;
+                if (out) {
+                    arg.pparray = new SAFEARRAY*(arg.parray);
+                    arg.vt |= VT_BYREF;
+                }
+            }
+        }
+        break;
+        
+    case QVariant::ByteArray:
+        {
+            const QByteArray bytes = qvar.toByteArray();
+            const uint count = bytes.count();
+            SAFEARRAY *array =	SafeArrayCreateVector(VT_UI1, 0, count);
+            if (count) {
+                const char *data = bytes.constData();
+                char *dest;
+                SafeArrayAccessData(array, (void **)&dest);
+                memcpy(dest, data, count);
+                SafeArrayUnaccessData(array);
+            }
+            
+            if (out && arg.vt == (VT_ARRAY|VT_UI1|VT_BYREF)) {
+                if (*arg.pparray)
+                    SafeArrayDestroy(*arg.pparray);
+                *arg.pparray = array;
+            } else {
+                arg.vt = VT_ARRAY|VT_UI1;
+                arg.parray = array;
+                if (out) {
+                    arg.pparray = new SAFEARRAY*(arg.parray);
+                    arg.vt |= VT_BYREF;
+                }
+            }
+        }
+        break;
+        
+#ifdef QAX_SERVER
+    case QVariant::Rect:
+    case QVariant::Size:
+    case QVariant::Point:
+        {
+            typedef HRESULT(WINAPI* PGetRecordInfoFromTypeInfo)(ITypeInfo *, IRecordInfo **);
+            static PGetRecordInfoFromTypeInfo pGetRecordInfoFromTypeInfo = 0;
+            static bool resolved = false;
+            if (!resolved) {
+                resolved = true;
+                pGetRecordInfoFromTypeInfo = (PGetRecordInfoFromTypeInfo)QLibrary::resolve(QLatin1String("oleaut32"),
+                                              "GetRecordInfoFromTypeInfo");
+            }
+            if (!pGetRecordInfoFromTypeInfo)
+                break;
+            
+            ITypeInfo *typeInfo = 0;
+            IRecordInfo *recordInfo = 0;
+            CLSID clsid = qvar.type() == QVariant::Rect ? CLSID_QRect
+                :qvar.type() == QVariant::Size ? CLSID_QSize
+                :CLSID_QPoint;
+            qAxTypeLibrary->GetTypeInfoOfGuid(clsid, &typeInfo);
+            if (!typeInfo)
+                break;
+            pGetRecordInfoFromTypeInfo(typeInfo, &recordInfo);
+            typeInfo->Release();
+            if (!recordInfo)
+                break;
+            
+            void *record = 0;
+            switch (qvar.type()) {
+            case QVariant::Rect:
+                {
+                    QRect qrect(qvar.toRect());
+                    recordInfo->RecordCreateCopy(&qrect, &record);
+                }
+                break;
+            case QVariant::Size:
+                {
+                    QSize qsize(qvar.toSize());
+                    recordInfo->RecordCreateCopy(&qsize, &record);
+                }
+                break;
+            case QVariant::Point:
+                {
+                    QPoint qpoint(qvar.toPoint());
+                    recordInfo->RecordCreateCopy(&qpoint, &record);
+                }
+                break;
+            }
+            
+            arg.vt = VT_RECORD;
+            arg.pRecInfo = recordInfo,
+            arg.pvRecord = record;
+            if (out) {
+                qWarning("QVariantToVARIANT: out-parameter not supported for records");
+                return false;
+           }
+        }
+        break;
+#endif // QAX_SERVER
+    case QVariant::UserType:
+        {
+            QByteArray subType = qvar.typeName();
+#ifdef QAX_SERVER
+            if (subType.endsWith('*'))
+                subType.truncate(subType.length() - 1);
+#endif
+            if (!qstrcmp(qvar.typeName(), "IDispatch*")) {
+                arg.vt = VT_DISPATCH;
+                arg.pdispVal = *(IDispatch**)qvar.data();
+                if (arg.pdispVal)
+                    arg.pdispVal->AddRef();
+                if (out) {
+                    qWarning("QVariantToVARIANT: out-parameter not supported for IDispatch");
+                    return false;
+                }
+            } else if (!qstrcmp(qvar.typeName(), "IDispatch**")) {
+                arg.vt = VT_DISPATCH;
+                arg.ppdispVal = *(IDispatch***)qvar.data();
+                if (out)
+                    arg.vt |= VT_BYREF;
+            } else if (!qstrcmp(qvar.typeName(), "IUnknown*")) {
+                arg.vt = VT_UNKNOWN;
+                arg.punkVal = *(IUnknown**)qvar.data();
+                if (arg.punkVal)
+                    arg.punkVal->AddRef();
+                if (out) {
+                    qWarning("QVariantToVARIANT: out-parameter not supported for IUnknown");
+                    return false;
+                }
+#ifdef QAX_SERVER
+            } else if (qAxFactory()->metaObject(QString::fromLatin1(subType.constData()))) {
+                arg.vt = VT_DISPATCH;
+                void *user = *(void**)qvar.constData();
+//                qVariantGet(qvar, user, qvar.typeName());
+                if (!user) {
+                    arg.pdispVal = 0;
+                } else {
+                    qAxFactory()->createObjectWrapper(static_cast<QObject*>(user), &arg.pdispVal);
+                }
+                if (out) {
+                    qWarning("QVariantToVARIANT: out-parameter not supported for subtype");
+                    return false;
+                }
+#else
+            } else if (QMetaType::type(subType)) {
+                QAxObject *object = *(QAxObject**)qvar.constData();
+//                qVariantGet(qvar, object, subType);
+                arg.vt = VT_DISPATCH;
+                object->queryInterface(IID_IDispatch, (void**)&arg.pdispVal);
+                if (out) {
+                    qWarning("QVariantToVARIANT: out-parameter not supported for subtype");
+                    return false;
+                }
+#endif
+            } else {
+                return false;
+            }
+        }
+        break;
+    case QVariant::Invalid: // default-parameters not set
+        if (out && arg.vt == (VT_ERROR|VT_BYREF)) {
+            *arg.plVal = DISP_E_PARAMNOTFOUND;
+        } else {
+            arg.vt = VT_ERROR;
+            arg.lVal = DISP_E_PARAMNOTFOUND;
+            if (out) {
+                arg.plVal = new long(arg.lVal);
+                arg.vt |= VT_BYREF;
+            }
+        }
+        break;
+
+    default:
+        return false;
+    }
+    
+    Q_ASSERT(!out || (arg.vt & VT_BYREF));
+    return true;
+}
+
+/*!
+    Copies the data in \a var into \a data.
+
+    Used by
+
+    QAxServerBase:
+        - QAxServerBase::qt_metacall (update out parameters/return value)
+
+    QAxBase:
+        - internalProperty(ReadProperty)
+        - internalInvoke(update out parameters/return value)
+
+*/
+bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, uint type)
+{
+    if (!data)
+        return true;
+
+    if (type == QVariant::LastType || (type == 0 && typeName == "QVariant")) {
+        *(QVariant*)data = var;
+        return true;
+    }
+
+    switch (var.type()) {
+    case QVariant::Invalid:
+        break;
+    case QVariant::String:
+        *(QString*)data = var.toString();
+        break;
+    case QVariant::Int:
+        *(int*)data = var.toInt();
+        break;
+    case QVariant::UInt:
+        *(uint*)data = var.toUInt();
+        break;
+    case QVariant::Bool:
+        *(bool*)data = var.toBool();
+        break;
+    case QVariant::Double:
+        *(double*)data = var.toDouble();
+        break;
+    case QVariant::Color:
+        *(QColor*)data = qvariant_cast<QColor>(var);
+        break;
+    case QVariant::Date:
+        *(QDate*)data = var.toDate();
+        break;
+    case QVariant::Time:
+        *(QTime*)data = var.toTime();
+        break;
+    case QVariant::DateTime:
+        *(QDateTime*)data = var.toDateTime();
+        break;
+    case QVariant::Font:
+        *(QFont*)data = qvariant_cast<QFont>(var);
+        break;
+    case QVariant::Pixmap:
+        *(QPixmap*)data = qvariant_cast<QPixmap>(var);
+        break;
+#ifndef QT_NO_CURSOR
+    case QVariant::Cursor:
+        *(QCursor*)data = qvariant_cast<QCursor>(var);
+        break;
+#endif
+    case QVariant::List:
+        *(QList<QVariant>*)data = var.toList();
+        break;
+    case QVariant::StringList:
+        *(QStringList*)data = var.toStringList();
+        break;
+    case QVariant::ByteArray:
+        *(QByteArray*)data = var.toByteArray();
+        break;
+    case QVariant::LongLong:
+        *(qint64*)data = var.toLongLong();
+        break;
+    case QVariant::ULongLong:
+        *(quint64*)data = var.toULongLong();
+        break;
+    case QVariant::Rect:
+        *(QRect*)data = var.toRect();
+        break;
+    case QVariant::Size:
+        *(QSize*)data = var.toSize();
+        break;
+    case QVariant::Point:
+        *(QPoint*)data = var.toPoint();
+        break;
+    case QVariant::UserType:
+        *(void**)data = *(void**)var.constData();
+//        qVariantGet(var, *(void**)data, typeName);
+        break;
+    default:
+        qWarning("QVariantToVoidStar: Unhandled QVariant type");
+        return false;
+    }
+    
+    return true;
+}
+  
+/*!
+    Returns \a arg as a QVariant of type \a type.
+
+    Used by
+
+    QAxServerBase:
+        - QAxServerBase::qt_metacall(update out parameters/return value)
+        - IDispatch::Invoke(METHOD, PROPERTYPUT)
+        - IPersistPropertyBag::Load
+
+    QAxBase:
+        - IDispatch::Invoke (QAxEventSink)
+        - QAxBase::internalProperty(ReadProperty)
+        - QAxBase::internalInvoke(update out parameters/return value)
+        - QAxBase::dynamicCallHelper(update out parameters)
+        - QAxBase::dynamicCall(return value)
+        - IPropertyBag::Write (QtPropertyBag)
+*/
+QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint type)
+{
+    QVariant var;
+    switch(arg.vt) {
+    case VT_BSTR:
+        var = QString::fromUtf16((const ushort *)arg.bstrVal);
+        break;
+    case VT_BSTR|VT_BYREF:
+        var = QString::fromUtf16((const ushort *)*arg.pbstrVal);
+        break;
+    case VT_BOOL:
+        var = QVariant((bool)arg.boolVal);
+        break;
+    case VT_BOOL|VT_BYREF:
+        var = QVariant((bool)*arg.pboolVal);
+        break;
+    case VT_I1:
+        var = arg.cVal;
+        if (typeName == "char")
+            type = QVariant::Int;
+        break;
+    case VT_I1|VT_BYREF:
+        var = *arg.pcVal;
+        if (typeName == "char")
+            type = QVariant::Int;
+        break;
+    case VT_I2:
+        var = arg.iVal;
+        if (typeName == "short")
+            type = QVariant::Int;
+        break;
+    case VT_I2|VT_BYREF:
+        var = *arg.piVal;
+        if (typeName == "short")
+            type = QVariant::Int;
+        break;
+    case VT_I4:
+        if (type == QVariant::Color || (!type && typeName == "QColor"))
+            var = qVariantFromValue(OLEColorToQColor(arg.lVal));
+#ifndef QT_NO_CURSOR
+        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+            var = qVariantFromValue(QCursor(static_cast<Qt::CursorShape>(arg.lVal)));
+#endif
+        else
+            var = (int)arg.lVal;
+        break;
+    case VT_I4|VT_BYREF:
+        if (type == QVariant::Color || (!type && typeName == "QColor"))
+            var = qVariantFromValue(OLEColorToQColor((int)*arg.plVal));
+#ifndef QT_NO_CURSOR
+        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+            var = qVariantFromValue(QCursor(static_cast<Qt::CursorShape>(*arg.plVal)));
+#endif
+        else
+            var = (int)*arg.plVal;
+        break;
+    case VT_INT:
+        var = arg.intVal;
+        break;
+    case VT_INT|VT_BYREF:
+        var = *arg.pintVal;
+        break;
+    case VT_UI1:
+        var = arg.bVal;
+        break;
+    case VT_UI1|VT_BYREF:
+        var = *arg.pbVal;
+        break;
+    case VT_UI2:
+        var = arg.uiVal;
+        break;
+    case VT_UI2|VT_BYREF:
+        var = *arg.puiVal;
+        break;
+    case VT_UI4:
+        if (type == QVariant::Color || (!type && typeName == "QColor"))
+            var = qVariantFromValue(OLEColorToQColor(arg.ulVal));
+#ifndef QT_NO_CURSOR
+        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+            var = qVariantFromValue(QCursor(static_cast<Qt::CursorShape>(arg.ulVal)));
+#endif
+        else
+            var = (int)arg.ulVal;
+        break;
+    case VT_UI4|VT_BYREF:
+        if (type == QVariant::Color || (!type && typeName == "QColor"))
+            var = qVariantFromValue(OLEColorToQColor((uint)*arg.pulVal));
+#ifndef QT_NO_CURSOR
+        else if (type == QVariant::Cursor || (!type && (typeName == "QCursor" || typeName == "QCursor*")))
+            var = qVariantFromValue(QCursor(static_cast<Qt::CursorShape>(*arg.pulVal)));
+#endif
+        else
+            var = (int)*arg.pulVal;
+        break;
+    case VT_UINT:
+        var = arg.uintVal;
+        break;
+    case VT_UINT|VT_BYREF:
+        var = *arg.puintVal;
+        break;
+    case VT_CY:
+        var = arg.cyVal.int64;
+        break;
+    case VT_CY|VT_BYREF:
+        var = arg.pcyVal->int64;
+        break;
+#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
+    case VT_I8:
+        var = arg.llVal;
+        break;
+    case VT_I8|VT_BYREF:
+        var = *arg.pllVal;
+        break;
+    case VT_UI8:
+        var = arg.ullVal;
+        break;
+    case VT_UI8|VT_BYREF:
+        var = *arg.pullVal;
+        break;
+#endif
+    case VT_R4:
+        var = arg.fltVal;
+        break;
+    case VT_R4|VT_BYREF:
+        var = *arg.pfltVal;
+        break;
+    case VT_R8:
+        var = arg.dblVal;
+        break;
+    case VT_R8|VT_BYREF:
+        var = *arg.pdblVal;
+        break;
+    case VT_DATE:
+        var = DATEToQDateTime(arg.date);
+        if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) {
+            var.convert(QVariant::Date);
+        } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) {
+            var.convert(QVariant::Time);
+        }
+        break;
+    case VT_DATE|VT_BYREF:
+        var = DATEToQDateTime(*arg.pdate);
+        if (type == QVariant::Date || (!type && (typeName == "QDate" || typeName == "QDate*"))) {
+            var.convert(QVariant::Date);
+        } else if (type == QVariant::Time || (!type && (typeName == "QTime" || typeName == "QTime*"))) {
+            var.convert(QVariant::Time);
+        }
+        break;
+    case VT_VARIANT:
+    case VT_VARIANT|VT_BYREF:
+        if (arg.pvarVal)
+            var = VARIANTToQVariant(*arg.pvarVal, typeName);
+        break;
+        
+    case VT_DISPATCH:
+    case VT_DISPATCH|VT_BYREF:
+        {
+            // pdispVal and ppdispVal are a union
+            IDispatch *disp = 0;
+            if (arg.vt & VT_BYREF)
+                disp = *arg.ppdispVal;
+            else
+                disp = arg.pdispVal;
+            if (type == QVariant::Font || (!type && (typeName == "QFont" || typeName == "QFont*"))) {
+                IFont *ifont = 0;
+                if (disp)
+                    disp->QueryInterface(IID_IFont, (void**)&ifont);
+                if (ifont) {
+                    var = qVariantFromValue(IFontToQFont(ifont));
+                    ifont->Release();
+                } else {
+                    var = qVariantFromValue(QFont());
+                }
+            } else if (type == QVariant::Pixmap || (!type && (typeName == "QPixmap" || typeName == "QPixmap*"))) {
+                IPicture *ipic = 0;
+                if (disp)
+                    disp->QueryInterface(IID_IPicture, (void**)&ipic);
+                if (ipic) {
+                    var = qVariantFromValue(IPictureToQPixmap(ipic));
+                    ipic->Release();
+                } else {
+                    var = qVariantFromValue(QPixmap());
+                }
+            } else {
+#ifdef QAX_SERVER
+                IAxServerBase *iface = 0;
+                if (disp && typeName != "IDispatch*")
+                    disp->QueryInterface(IID_IAxServerBase, (void**)&iface);
+                if (iface) {
+                    QObject *qObj = iface->qObject();
+                    iface->Release();
+                    var = QVariant(qRegisterMetaType<QObject*>(qObj ? QByteArray(qObj->metaObject()->className()) + "*" : typeName), &qObj);
+                } else
+#endif
+                {
+                    if (!typeName.isEmpty()) {
+                        if (arg.vt & VT_BYREF) {
+                            var = QVariant(qRegisterMetaType<IDispatch**>("IDispatch**"), &arg.ppdispVal);
+                        } else {
+#ifndef QAX_SERVER
+                            if (typeName == "QVariant") {
+                                QAxObject *object = new QAxObject(disp);
+                                var = qVariantFromValue<QAxObject*>(object);
+                            } else if (typeName != "IDispatch*" && QMetaType::type(typeName)) {
+                                QByteArray typeNameStr = QByteArray(typeName);
+                                int pIndex = typeName.lastIndexOf('*');
+                                if (pIndex != -1)
+                                    typeNameStr = typeName.left(pIndex);
+                                int metaType = QMetaType::type(typeNameStr);
+                                Q_ASSERT(metaType != 0);
+                                QAxObject *object = (QAxObject*)qax_createObjectWrapper(metaType, disp);
+                                var = QVariant(QMetaType::type(typeName), &object);
+                            } else
+#endif
+                                var = QVariant(qRegisterMetaType<IDispatch*>(typeName), &disp);
+                        }
+                    }
+                }
+            }
+        }
+        break;
+    case VT_UNKNOWN:
+    case VT_UNKNOWN|VT_BYREF:
+        {
+            IUnknown *unkn = 0;
+            if (arg.vt & VT_BYREF)
+                unkn = *arg.ppunkVal;
+            else
+                unkn = arg.punkVal;
+            qVariantSetValue(var, unkn);
+        }
+        break;
+    case VT_ARRAY|VT_VARIANT:
+    case VT_ARRAY|VT_VARIANT|VT_BYREF:
+	{
+	    SAFEARRAY *array = 0;
+	    if ( arg.vt & VT_BYREF )
+		array = *arg.pparray;
+	    else
+		array = arg.parray;
+
+            UINT cDims = array ? SafeArrayGetDim(array) : 0;
+            switch(cDims) {
+            case 1:
+                {
+                    QVariantList list;
+
+	            long lBound, uBound;
+	            SafeArrayGetLBound( array, 1, &lBound );
+	            SafeArrayGetUBound( array, 1, &uBound );
+
+	            for ( long i = lBound; i <= uBound; ++i ) {
+		        VARIANT var;
+		        VariantInit( &var );
+		        SafeArrayGetElement( array, &i, &var );
+
+		        QVariant qvar = VARIANTToQVariant( var, 0 );
+		        clearVARIANT( &var );
+		        list << qvar;
+	            }
+
+                    var = list;
+                }
+                break;
+
+            case 2:
+                {
+                    QVariantList listList; //  a list of lists
+                    long dimIndices[2];
+
+                    long xlBound, xuBound, ylBound, yuBound;
+	            SafeArrayGetLBound(array, 1, &xlBound);
+	            SafeArrayGetUBound(array, 1, &xuBound);
+	            SafeArrayGetLBound(array, 2, &ylBound);
+	            SafeArrayGetUBound(array, 2, &yuBound);
+
+                    for (long x = xlBound; x <= xuBound; ++x) {
+                        QVariantList list;
+
+                        dimIndices[0] = x;
+	                for (long y = ylBound; y <= yuBound; ++y) {
+		            VARIANT var;
+		            VariantInit(&var);
+                            dimIndices[1] = y;
+		            SafeArrayGetElement(array, dimIndices, &var);
+
+		            QVariant qvar = VARIANTToQVariant(var, 0);
+		            clearVARIANT(&var);
+		            list << qvar;
+                        }
+
+                        listList << QVariant(list);
+                    }
+                    var = listList;
+                }
+                break;
+            default:
+                var = QVariantList();
+                break;
+            }
+	}
+        break;
+        
+    case VT_ARRAY|VT_BSTR:
+    case VT_ARRAY|VT_BSTR|VT_BYREF:
+        {
+            SAFEARRAY *array = 0;
+            if (arg.vt & VT_BYREF)
+                array = *arg.pparray;
+            else
+                array = arg.parray;
+            
+            QStringList strings;
+            if (!array || array->cDims != 1) {
+                var = strings;
+                break;
+            }
+            
+            long lBound, uBound;
+            SafeArrayGetLBound(array, 1, &lBound);
+            SafeArrayGetUBound(array, 1, &uBound);
+            
+            for (long i = lBound; i <= uBound; ++i) {
+                BSTR bstr;
+                SafeArrayGetElement(array, &i, &bstr);
+                strings << QString::fromUtf16((const ushort *)bstr);
+                SysFreeString(bstr);
+            }
+            
+            var = strings;
+        }
+        break;
+        
+    case VT_ARRAY|VT_UI1:
+    case VT_ARRAY|VT_UI1|VT_BYREF:
+        {
+            SAFEARRAY *array = 0;
+            if (arg.vt & VT_BYREF)
+                array = *arg.pparray;
+            else
+                array = arg.parray;
+            
+            QByteArray bytes;
+            if (!array || array->cDims != 1) {
+                var = bytes;
+                break;
+            }
+            
+            long lBound, uBound;
+            SafeArrayGetLBound(array, 1, &lBound);
+            SafeArrayGetUBound(array, 1, &uBound);
+            
+            if (uBound != -1) { // non-empty array
+                bytes.resize(uBound - lBound + 1);
+                char *data = bytes.data();
+                char *src;
+                SafeArrayAccessData(array, (void**)&src);
+                memcpy(data, src, bytes.size());
+                SafeArrayUnaccessData(array);
+            }
+            
+            var = bytes;
+        }
+        break;
+        
+#if defined(QAX_SERVER)
+    case VT_RECORD:
+    case VT_RECORD|VT_BYREF:
+        if (arg.pvRecord && arg.pRecInfo) {
+            IRecordInfo *recordInfo = arg.pRecInfo;
+            void *record = arg.pvRecord;
+            GUID guid;
+            recordInfo->GetGuid(&guid);
+            
+            if (guid == CLSID_QRect) {
+                QRect qrect;
+                recordInfo->RecordCopy(record, &qrect);
+                var = qrect;
+            } else if (guid == CLSID_QSize) {
+                QSize qsize;
+                recordInfo->RecordCopy(record, &qsize);
+                var = qsize;
+            } else if (guid == CLSID_QPoint) {
+                QPoint qpoint;
+                recordInfo->RecordCopy(record, &qpoint);
+                var = qpoint;
+            }
+        }
+        break;
+#endif // QAX_SERVER
+    default:
+#if !defined(Q_OS_WINCE)
+        // support for any SAFEARRAY(Type) where Type can be converted to a QVariant 
+        // -> QVariantList
+        if (arg.vt & VT_ARRAY) {
+            SAFEARRAY *array = 0;
+            if (arg.vt & VT_BYREF)
+                array = *arg.pparray;
+            else
+                array = arg.parray;
+
+            QVariantList list;
+            if (!array || array->cDims != 1) {
+                var = list;
+                break;
+            }
+
+            // find out where to store the element
+            VARTYPE vt;
+            VARIANT variant;
+            SafeArrayGetVartype(array, &vt);
+
+            void *pElement = 0;
+            switch(vt) {
+            case VT_BSTR: Q_ASSERT(false); break; // already covered
+            case VT_BOOL: pElement = &variant.boolVal; break;
+            case VT_I1: pElement = &variant.cVal; break;
+            case VT_I2: pElement = &variant.iVal; break;
+            case VT_I4: pElement = &variant.lVal; break;
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+            case VT_I8: pElement = &variant.llVal; break;
+            case VT_UI8: pElement = &variant.ullVal; break;
+#endif
+            case VT_INT: pElement = &variant.intVal; break;
+            case VT_UI1: Q_ASSERT(false); break; // already covered
+            case VT_UI2: pElement = &variant.uiVal; break;
+            case VT_UI4: pElement = &variant.ulVal; break;
+            case VT_UINT: pElement = &variant.uintVal; break;
+            case VT_CY: pElement = &variant.cyVal; break;
+            case VT_R4: pElement = &variant.fltVal; break;
+            case VT_R8: pElement = &variant.dblVal; break;
+            case VT_DATE: pElement = &variant.date; break;
+            case VT_VARIANT: Q_ASSERT(false); break; // already covered
+            default:
+                break;
+            }
+            if (!pElement) {
+                var = list;
+                break;
+            }
+
+            long lBound, uBound;
+            SafeArrayGetLBound( array, 1, &lBound );
+            SafeArrayGetUBound( array, 1, &uBound );
+
+	    for ( long i = lBound; i <= uBound; ++i ) {
+                variant.vt = vt;
+		SafeArrayGetElement(array, &i, pElement);
+		QVariant qvar = VARIANTToQVariant(variant, 0);
+		clearVARIANT(&variant);
+		list << qvar;
+	    }
+
+            var = list;
+        }
+#endif
+        break;
+    }
+    
+    QVariant::Type proptype = (QVariant::Type)type;
+    if (proptype == QVariant::Invalid && !typeName.isEmpty())
+        proptype = QVariant::nameToType(typeName);
+    if (proptype != QVariant::LastType && proptype != QVariant::Invalid && var.type() != proptype) {
+        if (var.canConvert(proptype)) {
+            QVariant oldvar = var;
+            if (oldvar.convert(proptype))
+                var = oldvar;
+        } else if (proptype == QVariant::StringList && var.type() == QVariant::List) {
+            bool allStrings = true;
+            QStringList strings;
+            const QList<QVariant> list(var.toList());
+            for (QList<QVariant>::ConstIterator it(list.begin()); it != list.end(); ++it) {
+                QVariant variant = *it;
+                if (variant.canConvert(QVariant::String))
+                    strings << variant.toString();
+                else
+                    allStrings = false;
+            }
+            if (allStrings)
+                var = strings;
+        } else {
+            var = QVariant();
+        }
+    }
+    return var;
+}
+
+void clearVARIANT(VARIANT *var)
+{
+    if (var->vt & VT_BYREF) {
+        switch(var->vt) {
+        case VT_BSTR|VT_BYREF:
+            SysFreeString(*var->pbstrVal);
+            delete var->pbstrVal;
+            break;
+        case VT_BOOL|VT_BYREF:
+            delete var->pboolVal;
+            break;
+        case VT_I1|VT_BYREF:
+            delete var->pcVal;
+            break;
+        case VT_I2|VT_BYREF:
+            delete var->piVal;
+            break;
+        case VT_I4|VT_BYREF:
+            delete var->plVal;
+            break;
+        case VT_INT|VT_BYREF:
+            delete var->pintVal;
+            break;
+        case VT_UI1|VT_BYREF:
+            delete var->pbVal;
+            break;
+        case VT_UI2|VT_BYREF:
+            delete var->puiVal;
+            break;
+        case VT_UI4|VT_BYREF:
+            delete var->pulVal;
+            break;
+        case VT_UINT|VT_BYREF:
+            delete var->puintVal;
+            break;
+#if !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
+        case VT_I8|VT_BYREF:
+            delete var->pllVal;
+            break;
+        case VT_UI8|VT_BYREF:
+            delete var->pullVal;
+            break;
+#endif
+        case VT_CY|VT_BYREF:
+            delete var->pcyVal;
+            break;
+        case VT_R4|VT_BYREF:
+            delete var->pfltVal;
+            break;
+        case VT_R8|VT_BYREF:
+            delete var->pdblVal;
+            break;
+        case VT_DATE|VT_BYREF:
+            delete var->pdate;
+            break;
+        case VT_DISPATCH|VT_BYREF:
+            (*var->ppdispVal)->Release();
+            delete var->ppdispVal;
+            break;
+        case VT_ARRAY|VT_VARIANT|VT_BYREF:
+        case VT_ARRAY|VT_UI1|VT_BYREF:
+        case VT_ARRAY|VT_BSTR|VT_BYREF:
+            SafeArrayDestroy(*var->pparray);
+            delete var->pparray;
+            break;
+        case VT_VARIANT|VT_BYREF:
+            delete var->pvarVal;
+            break;
+        }
+        VariantInit(var);
+    } else {
+        VariantClear(var);
+    }
+}
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
diff --git a/src/activeqt/shared/qaxtypes.h b/src/activeqt/shared/qaxtypes.h
new file mode 100644
index 0000000..a29030f
--- /dev/null
+++ b/src/activeqt/shared/qaxtypes.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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$
+**
+****************************************************************************/
+
+#ifndef QAXTYPES_H
+#define QAXTYPES_H
+
+#if !defined(_WINDOWS_) && !defined(_WINDOWS_H) && !defined(__WINDOWS__)
+#error Must include windows.h first!
+#endif
+
+#include <QtGui/qcolor.h>
+#include <QtGui/qfont.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qvariant.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(ActiveQt)
+
+#ifndef QT_NO_WIN_ACTIVEQT
+
+extern GUID IID_IAxServerBase;
+struct IAxServerBase : public IUnknown
+{
+    virtual IUnknown *clientSite() const = 0;
+    virtual void emitPropertyChanged(const char*) = 0;
+    virtual bool emitRequestPropertyChange(const char*) = 0;
+    virtual QObject *qObject() const = 0;
+    virtual void reportError(int code, const QString &src, const QString &desc, const QString &context) = 0;
+};
+
+#define HIMETRIC_PER_INCH   2540
+#define MAP_PIX_TO_LOGHIM(x,ppli)   ((HIMETRIC_PER_INCH*(x) + ((ppli)>>1)) / (ppli))
+#define MAP_LOGHIM_TO_PIX(x,ppli)   (((ppli)*(x) + HIMETRIC_PER_INCH/2) / HIMETRIC_PER_INCH)
+#define QAX_NUM_PARAMS 8
+
+static inline BSTR QStringToBSTR(const QString &str)
+{
+    return SysAllocStringLen((OLECHAR*)str.unicode(), str.length());
+}
+
+static inline uint QColorToOLEColor(const QColor &col)
+{
+    return qRgba(col.blue(), col.green(), col.red(), 0x00);
+}
+
+extern QColor OLEColorToQColor(uint col);
+
+extern bool QVariantToVARIANT(const QVariant &var, VARIANT &arg, const QByteArray &typeName = 0, bool out = false);
+extern QVariant VARIANTToQVariant(const VARIANT &arg, const QByteArray &typeName, uint type = 0);
+extern bool QVariantToVoidStar(const QVariant &var, void *data, const QByteArray &typeName, uint type = 0);
+extern void clearVARIANT(VARIANT *var);
+
+QT_END_NAMESPACE
+#endif // QT_NO_WIN_ACTIVEQT
+
+QT_END_HEADER
+
+#endif // QAXTYPES_H