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

**

** All rights reserved.

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

**

** This file is part of the tools applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include <QAxObject>

#include <QFile>

#include <QMetaObject>

#include <QMetaEnum>

#include <QTextStream>

#include <QSettings>

#include <QStringList>

#include <QUuid>

#include <QWidget>

#include <qt_windows.h>

#include <ocidl.h>

QT_BEGIN_NAMESPACE

static ITypeInfo *currentTypeInfo = 0;

enum ObjectCategory

{

    DefaultObject    = 0x00,

    SubObject        = 0x001,

    ActiveX          = 0x002,

    NoMetaObject     = 0x004,

    NoImplementation = 0x008,

    NoDeclaration    = 0x010,

    NoInlines        = 0x020,

    OnlyInlines      = 0x040,

    DoNothing        = 0x080,

    Licensed         = 0x100,

    TypeLibID        = 0x101

};

// this comes from moc/qmetaobject.cpp

enum ProperyFlags  {

    Invalid = 0x00000000,

    Readable = 0x00000001,

    Writable = 0x00000002,

    Resetable = 0x00000004,

    EnumOrFlag = 0x00000008,

    StdCppSet = 0x00000100,

    Override = 0x00000200,

    Designable = 0x00001000,

    ResolveDesignable = 0x00002000,

    Scriptable = 0x00004000,

    ResolveScriptable = 0x00008000,

    Stored = 0x00010000,

    ResolveStored = 0x00020000,

    Editable = 0x00040000,

    ResolveEditable = 0x00080000

};

enum MemberFlags {

    AccessPrivate = 0x00,

    AccessProtected = 0x01,

    AccessPublic = 0x02,

    MemberMethod = 0x00,

    MemberSignal = 0x04,

    MemberSlot = 0x08,

    MemberCompatibility = 0x10,

    MemberCloned = 0x20,

    MemberScriptable = 0x40,

};

extern QMetaObject *qax_readEnumInfo(ITypeLib *typeLib, const QMetaObject *parentObject);

extern QMetaObject *qax_readClassInfo(ITypeLib *typeLib, ITypeInfo *typeInfo, const QMetaObject *parentObject);

extern QMetaObject *qax_readInterfaceInfo(ITypeLib *typeLib, ITypeInfo *typeInfo, const QMetaObject *parentObject);

extern QList<QByteArray> qax_qualified_usertypes;

extern QString qax_docuFromName(ITypeInfo *typeInfo, const QString &name);

extern bool qax_dispatchEqualsIDispatch;

QByteArray nameSpace;

QMap<QByteArray, QByteArray> namespaceForType;

void writeEnums(QTextStream &out, const QMetaObject *mo)

{

    // enums

    for (int ienum = mo->enumeratorOffset(); ienum < mo->enumeratorCount(); ++ienum) {

        QMetaEnum metaEnum = mo->enumerator(ienum);

        out << "    enum " << metaEnum.name() << " {" << endl;

        for (int k = 0; k < metaEnum.keyCount(); ++k) {

            QByteArray key(metaEnum.key(k));

            out << "        " << key.leftJustified(24) << "= " << metaEnum.value(k);

            if (k < metaEnum.keyCount() - 1)

                out << ",";

            out << endl;

        }

        out << "    };" << endl;

        out << endl;

    }

}

void writeHeader(QTextStream &out, const QByteArray &nameSpace)

{

    out << "#ifndef QAX_DUMPCPP_" << nameSpace.toUpper() << "_H" << endl;

    out << "#define QAX_DUMPCPP_" << nameSpace.toUpper() << "_H" << endl;

    out << endl;

    out << "// Define this symbol to __declspec(dllexport) or __declspec(dllimport)" << endl;

    out << "#ifndef " << nameSpace.toUpper() << "_EXPORT" << endl;

    out << "#define " << nameSpace.toUpper() << "_EXPORT" << endl;

    out << "#endif" << endl;

    out << endl;

    out << "#include <qaxobject.h>" << endl;

    out << "#include <qaxwidget.h>" << endl;

    out << "#include <qdatetime.h>" << endl;

    out << "#include <qpixmap.h>" << endl;

    out << endl;

    out << "struct IDispatch;" << endl;

    out << endl;

}

void generateNameSpace(QTextStream &out, const QMetaObject *mo, const QByteArray &nameSpace)

{

    out << "namespace " << nameSpace << " {" << endl;

    out << endl;

    writeEnums(out, mo);

    // don't close on purpose

}

static QByteArray joinParameterNames(const QList<QByteArray> &parameterNames)

{

    QByteArray slotParameters;

    for (int p = 0; p < parameterNames.count(); ++p) {

        slotParameters += parameterNames.at(p);

        if (p < parameterNames.count() - 1)

            slotParameters += ',';

    }

    return slotParameters;

}

QByteArray constRefify(const QByteArray &type)

{

    QByteArray ctype(type);

    if (type == "QString" || type == "QPixmap" 

        || type == "QVariant" || type == "QDateTime"

        || type == "QColor" || type == "QFont"

        || type == "QByteArray" || type == "QValueList<QVariant>"

        || type == "QStringList")

        ctype = "const " + ctype + "&";

    return ctype;

}

void generateClassDecl(QTextStream &out, const QString &controlID, const QMetaObject *mo, const QByteArray &className, const QByteArray &nameSpace, ObjectCategory category)

{

    QList<QByteArray> functions;

    QByteArray indent;

    if (!(category & OnlyInlines))

        indent = "    ";

    if (!(category & OnlyInlines)) {

        // constructors

        out << "class " << nameSpace.toUpper() << "_EXPORT " << className << " : public ";

        if (category & ActiveX)

            out << "QAxWidget";

        else

            out << "QAxObject";

        out << endl;

        out << "{" << endl;

        out << "public:" << endl;

        out << "    " << className << "(";

        if (category & Licensed)

            out << "const QString &licenseKey = QString(), ";

        if (category & ActiveX)

            out << "QWidget *parent = 0, Qt::WindowFlags f";

        else if (category & SubObject)

            out << "IDispatch *subobject = 0, QAxObject *parent";

        else

            out << "QObject *parent";

        out << " = 0)" << endl;

        out << "    : ";

        if (category & ActiveX)

            out << "QAxWidget(parent, f";

        else if (category & SubObject)

            out << "QAxObject((IUnknown*)subobject, parent";

        else

            out << "QAxObject(parent";

        out << ")" << endl;

        out << "    {" << endl;

        if (category & SubObject)

            out << "        internalRelease();" << endl;

        else if (category & Licensed) {

            out << "        if (licenseKey.isEmpty())" << endl;

            out << "            setControl(\"" << controlID << "\");" << endl;

            out << "        else" << endl;

            out << "            setControl(\"" << controlID << ":\" + licenseKey);" << endl;

        } else {

            out << "        setControl(\"" << controlID << "\");" << endl;

        }

        out << "    }" << endl;

        out << endl;

        for (int ci = mo->classInfoOffset(); ci < mo->classInfoCount(); ++ci) {

            QMetaClassInfo info = mo->classInfo(ci);

            QByteArray iface_name = info.name();

            if (iface_name.startsWith("Event "))

                continue;

            QByteArray iface_class = info.value();

            out << "    " << className << "(" << iface_class << " *iface)" << endl;

            if (category & ActiveX)

                out << "    : QAxWidget()" << endl;

            else

                out << "    : QAxObject()" << endl;

            out << "    {" << endl;

            out << "        initializeFrom(iface);" << endl;

            out << "        delete iface;" << endl;

            out << "    }" << endl;

            out << endl;

        }

    }

    functions << className;

    // enums

    if (nameSpace.isEmpty() && !(category & OnlyInlines)) {

        for (int ienum = mo->enumeratorOffset(); ienum < mo->enumeratorCount(); ++ienum) {

            QMetaEnum metaEnum = mo->enumerator(ienum);

            out << "    enum " << metaEnum.name() << " {" << endl;

            for (int k = 0; k < metaEnum.keyCount(); ++k) {

                QByteArray key(metaEnum.key(k));

                out << "        " << key.leftJustified(24) << "= " << metaEnum.value(k);

                if (k < metaEnum.keyCount() - 1)

                    out << ",";

                out << endl;

            }

            out << "    };" << endl;

            out << endl;

        }

    }

    // QAxBase public virtual functions.

    QList<QByteArray> axBase_vfuncs;

    axBase_vfuncs.append("metaObject");

    axBase_vfuncs.append("qObject");

    axBase_vfuncs.append("className");

    axBase_vfuncs.append("propertyWritable");

    axBase_vfuncs.append("setPropertyWritable");

    // properties

    for (int iprop = mo->propertyOffset(); iprop < mo->propertyCount(); ++iprop) {

        QMetaProperty property = mo->property(iprop);

        if (!property.isReadable())

            continue;

        QByteArray propertyName(property.name());

        if (propertyName == "control" || propertyName == className)

            continue;

        if (!(category & OnlyInlines)) {

            out << indent << "/*" << endl << indent << "Property " << propertyName << endl;

            QString documentation = qax_docuFromName(currentTypeInfo, QString::fromLatin1(propertyName.constData()));

            if (!documentation.isEmpty()) {

                out << endl;

                out << indent << documentation << endl;

            }

            out << indent << "*/" << endl;

        }

        // Check whether the new function conflicts with any of QAxBase public virtual functions.

        // If so, prepend the function name with '<classname>_'. Since all internal metaobject magic 

        // remains the same, we have to use the original name when used with QObject::connect or QMetaObject

        QByteArray propertyFunctionName(propertyName);

        if (axBase_vfuncs.contains(propertyFunctionName)) {

            propertyFunctionName = className + "_" + propertyName;

            qWarning("property conflits with QAXBase: %s changed to %s", propertyName.constData(), propertyFunctionName.constData());

        }

        QByteArray propertyType(property.typeName());

        QByteArray castType(propertyType);

        QByteArray simplePropType = propertyType;

        simplePropType.replace('*', "");

        out << indent << "inline ";

        bool foreignNamespace = true;

        if (!propertyType.contains("::") && 

            (qax_qualified_usertypes.contains(simplePropType) || qax_qualified_usertypes.contains("enum "+ simplePropType))

           ) {

            propertyType = nameSpace + "::" + propertyType;

            foreignNamespace = false;

        }

        out << propertyType << " ";

        if (category & OnlyInlines)

            out << className << "::";

        out << propertyFunctionName << "() const";

        if (!(category & NoInlines)) {

            out << endl << indent << "{" << endl;

            if (qax_qualified_usertypes.contains(simplePropType)) {

                out << indent << "    " << propertyType << " qax_pointer = 0;" << endl;

                out << indent << "    qRegisterMetaType(\"" << property.typeName() << "\", &qax_pointer);" << endl;

                if (foreignNamespace)

                    out << "#ifdef QAX_DUMPCPP_" << propertyType.left(propertyType.indexOf("::")).toUpper() << "_H" << endl;

                out << indent << "    qRegisterMetaType(\"" << simplePropType << "\", qax_pointer);" << endl;

                if (foreignNamespace)

                    out << "#endif" << endl;

            }

            out << indent << "    QVariant qax_result = property(\"" << propertyName << "\");" << endl;

            if (propertyType.length() && propertyType.at(propertyType.length()-1) == '*')

                out << indent << "    if (!qax_result.constData()) return 0;" << endl;

            out << indent << "    Q_ASSERT(qax_result.isValid());" << endl;

            if (qax_qualified_usertypes.contains(simplePropType)) {

                simplePropType = propertyType;

                simplePropType.replace('*', "");

                if (foreignNamespace)

                    out << "#ifdef QAX_DUMPCPP_" << propertyType.left(propertyType.indexOf("::")).toUpper() << "_H" << endl;

                out << indent << "    return *(" << propertyType << "*)qax_result.constData();" << endl;

                if (foreignNamespace) {

                    out << "#else" << endl;

                    out << indent << "    return 0; // foreign namespace not included" << endl;

                    out << "#endif" << endl;

                }

            } else {

                out << indent << "    return *(" << propertyType << "*)qax_result.constData();" << endl;

            }

            out << indent << "}" << endl;

        } else {

            out << "; //Returns the value of " << propertyName << endl;

        }

        functions << propertyName;

        if (property.isWritable()) {

            QByteArray setter(propertyName);

            QChar firstChar = QLatin1Char(setter.at(0));

            if (isupper(setter.at(0))) {

                setter = "Set" + setter;

            } else {

                setter[0] = toupper(setter[0]);

                setter = "set" + setter;

            }

            out << indent << "inline " << "void ";

            if (category & OnlyInlines)

                out << className << "::";

            out << setter << "(" << constRefify(propertyType) << " value)";

            if (!(category & NoInlines)) {

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

                    out << "{" << endl;

                    out << "    int typeId = qRegisterMetaType(\"" << propertyType << "\", &value);" << endl;

                    out << "    setProperty(\"" << propertyName << "\", QVariant(typeId, &value));" << endl;

                    out << "}" << endl;

                } else {

                    out << "{ setProperty(\"" << propertyName << "\", QVariant(value)); }" << endl;

                }

            } else {

                out << "; //Sets the value of the " << propertyName << " property" << endl;

            }

            functions << setter;

        }

        out << endl;

    }

    // slots - but not property setters

    int defaultArguments = 0;

    for (int islot = mo->methodOffset(); islot < mo->methodCount(); ++islot) {

        const QMetaMethod slot(mo->method(islot));

        if (slot.methodType() != QMetaMethod::Slot)

            continue;

#if 0

        // makes not sense really to respect default arguments...

        if (slot.attributes() & Cloned) {

            ++defaultArguments;

            continue;

        }

#endif

        QByteArray slotSignature(slot.signature());

        QByteArray slotName = slotSignature.left(slotSignature.indexOf('('));

        if (functions.contains(slotName))

            continue;

        if (!(category & OnlyInlines)) {

            out << indent << "/*" << endl << indent << "Method " << slotName << endl;

            QString documentation = qax_docuFromName(currentTypeInfo, QString::fromLatin1(slotName.constData()));

            if (!documentation.isEmpty()) {

                out << endl;

                out << indent << documentation << endl;

            }

            out << indent << "*/" << endl;

        }

        QByteArray slotParameters(joinParameterNames(slot.parameterNames()));

        QByteArray slotTag(slot.tag());

        QByteArray slotType(slot.typeName());

        QByteArray simpleSlotType = slotType;

        simpleSlotType.replace('*', "");

        if (!slotType.contains("::") && qax_qualified_usertypes.contains(simpleSlotType))

            slotType = nameSpace + "::" + slotType;

        QByteArray slotNamedSignature;

        if (slotSignature.endsWith("()")) { // no parameters - no names

            slotNamedSignature = slotSignature;

        } else {

            slotNamedSignature = slotSignature.left(slotSignature.indexOf('(') + 1);

            QByteArray slotSignatureTruncated(slotSignature.mid(slotNamedSignature.length()));

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

            QList<QByteArray> signatureSplit = slotSignatureTruncated.split(',');

            QList<QByteArray> parameterSplit;

            if (slotParameters.isEmpty()) { // generate parameter names

                for (int i = 0; i < signatureSplit.count(); ++i)

                    parameterSplit << QByteArray("p") + QByteArray::number(i);

            } else {

                parameterSplit = slotParameters.split(',');

            }

            for (int i = 0; i < signatureSplit.count(); ++i) {

                QByteArray parameterType = signatureSplit.at(i);

                if (!parameterType.contains("::") && namespaceForType.contains(parameterType))

                    parameterType = namespaceForType.value(parameterType) + "::" + parameterType;

                slotNamedSignature += constRefify(parameterType);

                slotNamedSignature += " ";

                slotNamedSignature += parameterSplit.at(i);

                if (defaultArguments >= signatureSplit.count() - i) {

                    slotNamedSignature += " = ";

                    slotNamedSignature += parameterType + "()";

                }

                if (i + 1 < signatureSplit.count())

                    slotNamedSignature += ", ";

            }

            slotNamedSignature += ')';

        }

        out << indent << "inline ";

        if (!slotTag.isEmpty())

            out << slotTag << " ";

        if (slotType.isEmpty())

            out << "void ";

        else

            out << slotType << " ";

        if (category & OnlyInlines)

            out << className << "::";

        // Update function name in case of conflicts with QAxBase public virtual functions.

        int parnIdx = slotNamedSignature.indexOf('(');

        QByteArray slotOriginalName =  slotNamedSignature.left(parnIdx);

        if (axBase_vfuncs.contains(slotOriginalName)) {

            QByteArray newSignature = className + "_" + slotOriginalName;

            newSignature += slotNamedSignature.mid(parnIdx);

            qWarning("function name conflits with QAXBase %s changed to %s", slotNamedSignature.constData(), newSignature.constData());

            slotNamedSignature = newSignature;

        }

        out << slotNamedSignature;

        if (category & NoInlines) {

            out << ";" << endl;

        } else {

            out << endl;

            out << indent << "{" << endl;

            if (!slotType.isEmpty()) {

                out << indent << "    " << slotType << " qax_result";

                if (slotType.endsWith('*'))

                    out << " = 0";

                out << ";" << endl;

                if (qax_qualified_usertypes.contains(simpleSlotType)) {

                    out << indent << "    qRegisterMetaType(\"" << simpleSlotType << "*\", &qax_result);" << endl;

                    bool foreignNamespace = simpleSlotType.contains("::");

                    if (foreignNamespace)

                        out << "#ifdef QAX_DUMPCPP_" << simpleSlotType.left(simpleSlotType.indexOf(':')).toUpper() << "_H" << endl;

                    out << indent << "    qRegisterMetaType(\"" << simpleSlotType << "\", qax_result);" << endl;

                    if (foreignNamespace)

                        out << "#endif" << endl;

                }

            }

            out << indent << "    void *_a[] = {";

            if (!slotType.isEmpty())

                out << "(void*)&qax_result";

            else

                out << "0";