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

**

** 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 "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::fromWCharArray(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::fromWCharArray(exception->bstrSource),

        QString::fromWCharArray(exception->bstrDescription),

        QString::fromWCharArray(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::fromWCharArray(bstrLineText);

        SysFreeString(bstrLineText);

    }

    SysFreeString(exception.bstrSource);

    SysFreeString(exception.bstrDescription);

    SysFreeString(exception.bstrHelpFile);

    emit script->error(exception.wCode, QString::fromWCharArray(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_t*)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;