/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the ActiveQt framework of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:BSD$

** You may use this file under the terms of the BSD license as follows:

**

** "Redistribution and use in source and binary forms, with or without

** modification, are permitted provided that the following conditions are

** met:

**   * Redistributions of source code must retain the above copyright

**     notice, this list of conditions and the following disclaimer.

**   * Redistributions in binary form must reproduce the above copyright

**     notice, this list of conditions and the following disclaimer in

**     the documentation and/or other materials provided with the

**     distribution.

**   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor

**     the names of its contributors may be used to endorse or promote

**     products derived from this software without specific prior written

**     permission.

**

** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

** $QT_END_LICENSE$

**

****************************************************************************/

//#define QAX_NO_CLASSINFO

#define QT_CHECK_STATE

#include "qaxobject.h"

#ifndef QT_NO_WIN_ACTIVEQT

#include <qfile.h>

#include <qwidget.h>

#include <quuid.h>

#include <qhash.h>

#include <qset.h>

#include <qpair.h>

#include <qmetaobject.h>

#include <qsettings.h>

#ifndef QT_NO_THREAD

#   include <qmutex.h>

#endif

#include <qt_windows.h>

#include <ocidl.h>

#include <ctype.h>

#include "../shared/qaxtypes.h"

QT_BEGIN_NAMESPACE

/*

    \internal

    \class QAxMetaObject

    \brief The QAxMetaObject class stores extended information

*/

struct QAxMetaObject : public QMetaObject

{

    QAxMetaObject()

    {

        d.data = 0;

        d.stringdata = 0;

    }

    ~QAxMetaObject()

    {

        delete [] (int*)d.data;

        delete [] (char*)d.stringdata;

    }

    int numParameter(const QByteArray &prototype);

    QByteArray paramType(const QByteArray &signature, int index, bool *out = 0);

    QByteArray propertyType(const QByteArray &propertyName);

    void parsePrototype(const QByteArray &prototype);

    DISPID dispIDofName(const QByteArray &name, IDispatch *disp);

private:

    friend class MetaObjectGenerator;

    // save information about QAxEventSink connections, and connect when found in cache

    QList<QUuid> connectionInterfaces;

    // DISPID -> signal name

    QMap< QUuid, QMap<DISPID, QByteArray> > sigs;

    // DISPID -> property changed signal name

    QMap< QUuid, QMap<DISPID, QByteArray> > propsigs;

    // DISPID -> property name

    QMap< QUuid, QMap<DISPID, QByteArray> > props;

    // Prototype -> member info

    QHash<QByteArray, QList<QByteArray> > memberInfo;

    QMap<QByteArray, QByteArray> realPrototype;

    // DISPID cache

    QHash<QByteArray, DISPID> dispIDs;

};

void QAxMetaObject::parsePrototype(const QByteArray &prototype)

{

    QByteArray realProto = realPrototype.value(prototype, prototype);

    QByteArray parameters = realProto.mid(realProto.indexOf('(') + 1);

    parameters.truncate(parameters.length() - 1);

    if (parameters.isEmpty()) {

        memberInfo.insert(prototype, QList<QByteArray>());

    } else {

        QList<QByteArray> plist = parameters.split(',');

        memberInfo.insert(prototype, plist);

    }

}

inline QByteArray QAxMetaObject::propertyType(const QByteArray &propertyName)

{

    return realPrototype.value(propertyName);

}

int QAxMetaObject::numParameter(const QByteArray &prototype)

{

    if (!memberInfo.contains(prototype))

        parsePrototype(prototype);

    return memberInfo.value(prototype).count();

}

QByteArray QAxMetaObject::paramType(const QByteArray &prototype, int index, bool *out)

{

    if (!memberInfo.contains(prototype))

        parsePrototype(prototype);

    if (out)

        *out = false;

    QList<QByteArray> plist = memberInfo.value(prototype);

    if (index > plist.count() - 1)

        return QByteArray();

    QByteArray param(plist.at(index));

    if (param.isEmpty())

        return QByteArray();

    bool byRef = param.endsWith('&') || param.endsWith("**");

    if (byRef) {

        param.truncate(param.length() - 1);

        if (out)

            *out = true;

    }

    return param;

}

inline DISPID QAxMetaObject::dispIDofName(const QByteArray &name, IDispatch *disp)

{

    DISPID dispid = dispIDs.value(name, DISPID_UNKNOWN);

    if (dispid == DISPID_UNKNOWN) {

        // get the Dispatch ID from the object

        QString unicodeName = QLatin1String(name);

        OLECHAR *names = (wchar_t*)unicodeName.utf16();

        disp->GetIDsOfNames(IID_NULL, &names, 1, LOCALE_USER_DEFAULT, &dispid);

        if (dispid != DISPID_UNKNOWN)

            dispIDs.insert(name, dispid);

    }

    return dispid;

}

static QHash<QString, QAxMetaObject*> mo_cache;

static QHash<QUuid, QMap<QByteArray, QList<QPair<QByteArray, int> > > > enum_cache;

static int mo_cache_ref = 0;

static QMutex cache_mutex;

static const char *const type_conversion[][2] =

{

    { "float", "double"},

    { "short", "int"},

    { "char", "int"},

    { "QList<int>", "QVariantList" },

    { "QList<uint>", "QVariantList" },

    { "QList<double>", "QVariantList" },

    { "QList<bool>", "QVariantList" },

    { "QList<QDateTime>", "QVariantList" },

    { "QList<qlonglong>", "QVariantList" },

    { 0, 0 }

};

/*

    \internal

    \class QAxEventSink

    \brief The QAxEventSink class implements the event sink for all

	   IConnectionPoints implemented in the COM object.

*/

class QAxEventSink : public IDispatch, public IPropertyNotifySink

{

public:

    QAxEventSink(QAxBase *com)

        : cpoint(0), ciid(IID_NULL), combase(com), ref(1)

    {}

    virtual ~QAxEventSink()

    {

        Q_ASSERT(!cpoint);

    }

    QUuid connectionInterface() const

    {

        return ciid;

    }

    QMap<DISPID, QByteArray> signalMap() const

    {

        return sigs;

    }

    QMap<DISPID, QByteArray> propertyMap() const

    {

        return props;

    }

    QMap<DISPID, QByteArray> propSignalMap() const

    {

        return propsigs;

    }

    // add a connection

    void advise(IConnectionPoint *cp, IID iid)

    {

        cpoint = cp;

        cpoint->AddRef();

        ciid = iid;

        cpoint->Advise((IUnknown*)(IDispatch*)this, &cookie);

    }

    // disconnect from all connection points

    void unadvise()

    {

        combase = 0;

        if (cpoint) {

            cpoint->Unadvise(cookie);

            cpoint->Release();

            cpoint = 0;

        }

    }

    void addSignal(DISPID memid, const char *name)

    {

	QByteArray signalname = name;

	int pi = signalname.indexOf('(');

        int i = 0;

        while (type_conversion[i][0]) {

            int ti = pi;

            int len = int(strlen(type_conversion[i][0]));

            while ((ti = signalname.indexOf(type_conversion[i][0], ti)) != -1)

	        signalname.replace(ti, len, type_conversion[i][1]);

            ++i;

        }

        sigs.insert(memid, signalname);

        QMap<DISPID,QByteArray>::ConstIterator it;

        DISPID id = -1;

        for (it = propsigs.constBegin(); it!= propsigs.constEnd(); ++it) {

            if (it.value() == signalname) {

                id = it.key();

                break;

            }

        }

        if (id != -1)

            propsigs.remove(id);

    }

    void addProperty(DISPID propid, const char *name, const char *signal)

    {

        props.insert(propid, name);

        propsigs.insert(propid, signal);

    }

    // IUnknown

    unsigned long __stdcall AddRef()

    {

        return ref++;

    }

    unsigned long __stdcall Release()

    {

        if (!--ref) {

            delete this;

            return 0;

        }

        return ref;

    }

    HRESULT __stdcall QueryInterface(REFIID riid, void **ppvObject)

    {

        *ppvObject = 0;

        if (riid == IID_IUnknown)

            *ppvObject = (IUnknown*)(IDispatch*)this;

        else if (riid == IID_IDispatch)

            *ppvObject = (IDispatch*)this;

        else if (riid == IID_IPropertyNotifySink)

            *ppvObject = (IPropertyNotifySink*)this;

        else if (ciid == riid)

            *ppvObject = (IDispatch*)this;

        else

            return E_NOINTERFACE;

        AddRef();

        return S_OK;

    }

    // IDispatch

    HRESULT __stdcall GetTypeInfoCount(unsigned int *) { return E_NOTIMPL; }

    HRESULT __stdcall GetTypeInfo(UINT, LCID, ITypeInfo **) { return E_NOTIMPL; }

    HRESULT __stdcall GetIDsOfNames(const _GUID &, wchar_t **, unsigned int, unsigned long, long *) { return E_NOTIMPL; }

    HRESULT __stdcall Invoke(DISPID dispIdMember,

                            REFIID riid,

                            LCID,

                            WORD wFlags,

                            DISPPARAMS *pDispParams,

                            VARIANT*,

                            EXCEPINFO*,

                            UINT*)

    {

        // verify input

        if (riid != IID_NULL)

            return DISP_E_UNKNOWNINTERFACE;

        if (!(wFlags & DISPATCH_METHOD))

            return DISP_E_MEMBERNOTFOUND;

        if (!combase)

            return E_UNEXPECTED;

        QByteArray signame = sigs.value(dispIdMember);

        if (signame.isEmpty())

            return DISP_E_MEMBERNOTFOUND;

        QObject *qobject = combase->qObject();

        if (qobject->signalsBlocked())

            return S_OK;

        QAxMetaObject *axmeta = combase->internalMetaObject();

        const QMetaObject *meta = combase->metaObject();

        int index = -1;

        // emit the generic signal "as is"

        if (signalHasReceivers(qobject, "signal(QString,int,void*)")) {

            index = meta->indexOfSignal("signal(QString,int,void*)");

            Q_ASSERT(index != -1);

            QString nameString = QLatin1String(signame);

            void *argv[] = {0, &nameString, &pDispParams->cArgs, &pDispParams->rgvarg};

            combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);

        }

        HRESULT hres = S_OK;

        // get the signal information from the metaobject

        index = -1;

        if (signalHasReceivers(qobject, signame)) {

            index = meta->indexOfSignal(signame);

            Q_ASSERT(index != -1);

            const QMetaMethod signal = meta->method(index);

            Q_ASSERT(signal.methodType() == QMetaMethod::Signal);

            Q_ASSERT(signame == signal.signature());

            // verify parameter count

            int pcount = axmeta->numParameter(signame);

            int argcount = pDispParams->cArgs;

            if (pcount > argcount)

                return DISP_E_PARAMNOTOPTIONAL;

            else if (pcount < argcount)

                return DISP_E_BADPARAMCOUNT;

            // setup parameters (no return values in signals)

            bool ok = true;

            void *static_argv[QAX_NUM_PARAMS + 1];

            void *static_argv_pointer[QAX_NUM_PARAMS + 1];

            QVariant static_varp[QAX_NUM_PARAMS + 1];

            void **argv = 0;

            void **argv_pointer = 0; // in case we need an additional level of indirection

            QVariant *varp = 0;

            if (pcount) {

                if (pcount <= QAX_NUM_PARAMS) {

                    argv = static_argv;

                    argv_pointer = static_argv_pointer;

                    varp = static_varp;

                } else {

                    argv = new void*[pcount + 1];

                    argv_pointer = new void*[pcount + 1];

                    varp = new QVariant[pcount + 1];

                }

                argv[0] = 0;

                argv_pointer[0] = 0;

            }

            int p;

            for (p = 0; p < pcount && ok; ++p) {

                // map the VARIANT to the void*

                QByteArray ptype = axmeta->paramType(signame, p);

                varp[p + 1] = VARIANTToQVariant(pDispParams->rgvarg[pcount - p - 1], ptype);

                argv_pointer[p + 1] = 0;

                if (varp[p + 1].isValid()) {

                    if (varp[p + 1].type() == QVariant::UserType) {

                        argv[p + 1] = varp[p + 1].data();

                    } else if (ptype == "QVariant") {

                        argv[p + 1] = varp + p + 1;

                    } else {

                        argv[p + 1] = const_cast<void*>(varp[p + 1].constData());

                        if (ptype.endsWith('*')) {

                            argv_pointer[p + 1] = argv[p + 1];

                            argv[p + 1] = argv_pointer + p + 1;

                        }

                    }

                } else if (ptype == "QVariant") {

                    argv[p + 1] = varp + p + 1;

                } else {

                    ok = false;

                }

            }

            if (ok) {

                // emit the generated signal if everything went well

                combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);

                // update the VARIANT for references and free memory

                for (p = 0; p < pcount; ++p) {

                    bool out;

                    QByteArray ptype = axmeta->paramType(signame, p, &out);

                    if (out) {

                        if (!QVariantToVARIANT(varp[p + 1], pDispParams->rgvarg[pcount - p - 1], ptype, out))

                            ok = false;

                    }

                }

            }

            if (argv != static_argv) {

                delete [] argv;

                delete [] argv_pointer;

                delete [] varp;

            }

            hres = ok ? S_OK : (ok ? DISP_E_MEMBERNOTFOUND : DISP_E_TYPEMISMATCH);

        }

        return hres;

    }

    QByteArray findProperty(DISPID dispID);

    // IPropertyNotifySink

    HRESULT __stdcall OnChanged(DISPID dispID)

    {

        // verify input

        if (dispID == DISPID_UNKNOWN || !combase)

            return S_OK;

        const QMetaObject *meta = combase->metaObject();

        if (!meta)

            return S_OK;

        QByteArray propname(findProperty(dispID));

        if (propname.isEmpty())

            return S_OK;

        QObject *qobject = combase->qObject();

        if (qobject->signalsBlocked())

            return S_OK;

        // emit the generic signal

        int index = meta->indexOfSignal("propertyChanged(QString)");

        if (index != -1) {

            QString propnameString = QString::fromLatin1(propname);

            void *argv[] = {0, &propnameString};

            combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);

        }

        QByteArray signame = propsigs.value(dispID);

        if (signame.isEmpty())

            return S_OK;

        index = meta->indexOfSignal(signame);

        if (index == -1) // bindable but not marked as bindable in typelib

            return S_OK;

        // get the signal information from the metaobject

        if (signalHasReceivers(qobject, signame)) {

            index = meta->indexOfSignal(signame);

            Q_ASSERT(index != -1);

            // setup parameters

            QVariant var = qobject->property(propname);

            if (!var.isValid())

                return S_OK;

            const QMetaProperty metaProp = meta->property(meta->indexOfProperty(propname));

            void *argv[] = {0, var.data()};

            if (metaProp.type() == QVariant::LastType)

                argv[1] = &var;

            // emit the "changed" signal

            combase->qt_metacall(QMetaObject::InvokeMetaMethod, index, argv);

        }

        return S_OK;

    }

    HRESULT __stdcall OnRequestEdit(DISPID dispID)

    {

        if (dispID == DISPID_UNKNOWN || !combase)

            return S_OK;

        QByteArray propname(findProperty(dispID));

        if (propname.isEmpty())

            return S_OK;

        return combase->propertyWritable(propname) ? S_OK : S_FALSE;

    }

    static bool signalHasReceivers(QObject *qobject, const char *signalName)

    {

        Q_ASSERT(qobject);