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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** 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$

**

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

#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;

wchar_t 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 + QLatin1Char('*')).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::fromWCharArray(qAxModuleFilename);

    libFile = libFile.toLower();

    if (LoadTypeLibEx((wchar_t*)libFile.utf16(), REGKIND_NONE, &qAxTypeLibrary) == S_OK)

        return libFile;

    int lastDot = libFile.lastIndexOf(QLatin1Char('.'));

    libFile = libFile.left(lastDot) + QLatin1String(".tlb");

    if (LoadTypeLibEx((wchar_t*)libFile.utf16(), REGKIND_NONE, &qAxTypeLibrary) == S_OK)

        return libFile;

    lastDot = libFile.lastIndexOf(QLatin1Char('.'));

    libFile = libFile.left(lastDot) + QLatin1String(".olb");

    if (LoadTypeLibEx((wchar_t*)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::fromWCharArray(qAxModuleFilename);

    QString path = file.left(file.lastIndexOf(QLatin1Char('\\'))+1);

    QString module = file.right(file.length() - path.length());

    module = module.left(module.lastIndexOf(QLatin1Char('.')));

    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) + QLatin1Char('.') + QString::number((uint)minor);

    if (bRegister)

        RegisterTypeLib(qAxTypeLibrary, (wchar_t*)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::fromLatin1(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(QLatin1Char('.')));

                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(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion + QLatin1String("/."), className + QLatin1String(" Class"));

                settings.setValue(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion + QLatin1String("/CLSID/."), classId);

                if (insertable)

                    settings.setValue(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion + QLatin1String("/Insertable/."), QVariant(QLatin1String("")));

                settings.setValue(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1String("/."), className + QLatin1String(" Class"));

                settings.setValue(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1String("/CLSID/."), classId);

                settings.setValue(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1String("/CurVer/."), module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion);

                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/."), className + QLatin1String(" Class"));

                if (file.endsWith(QLatin1String("exe"), Qt::CaseInsensitive))

                    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/."),

                                      QLatin1Char('\"') + 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/."), QLatin1Char('\"') +

                                  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 + QLatin1Char('.') + className);

                settings.setValue(QLatin1String("/CLSID/") + classId + QLatin1String("/ProgID/."), module + QLatin1Char('.') + className + QLatin1Char('.') + 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] != QLatin1Char('.'))

                                extension = QLatin1Char('.') + extension;

                        }

                        if (!extension.isEmpty()) {

                            settings.setValue(QLatin1Char('/') + extension + QLatin1String("/."), module + QLatin1Char('.') + className);

                            settings.setValue(QLatin1Char('/') + extension + QLatin1String("/Content Type"), mime);

                            mime = mime.replace(QLatin1Char('/'), QLatin1Char('\\'));

                            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 {

        if (qAxOutProcServer) {

            settings.remove(QLatin1String("/AppID/") + appId + QLatin1String("/."));

            settings.remove(QLatin1String("/AppID/") + module + QLatin1String(".EXE"));

        }

        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::fromLatin1(mo->classInfo(mo->indexOfClassInfo("Version")).value()) : QString();

            if (classVersion.isNull())

                classVersion = QLatin1String("1.0");

            const QString classMajorVersion = classVersion.left(classVersion.indexOf(QLatin1Char('.')));

            qAxFactory()->unregisterClass(*key, &settings);

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion + QLatin1String("/CLSID/."));

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion + QLatin1String("/Insertable/."));

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion + QLatin1String("/."));

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1Char('.') + classMajorVersion);

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1String("/CLSID/."));

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1String("/CurVer/."));

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + className + QLatin1String("/."));

            settings.remove(QLatin1Char('/') + module + QLatin1Char('.') + 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] != QLatin1Char('.'))

                            extension.prepend(QLatin1Char('.'));

                    }

                    if (!extension.isEmpty()) {

                        settings.remove(QLatin1Char('/') + extension + QLatin1String("/Content Type"));

                        settings.remove(QLatin1Char('/') + extension + QLatin1String("/."));

                        settings.remove(QLatin1Char('/') + extension);

                        mime.replace(QLatin1Char('/'), QLatin1Char('\\'));

                        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;

}