--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/activeqt/container/qaxscript.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,1290 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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;
+ 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_t*)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_t*)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 + QLatin1Char(')');
+ }
+ allFiles += QLatin1Char(')');
+
+ 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