void Environment::handleEvent(QContext2DCanvas *canvas, QKeyEvent *e)
{
QString type;
switch (e->type()) {
case QEvent::KeyPress:
type = "keydown"; break;
case QEvent::KeyRelease:
type = "keyup"; break;
default: break;
}
if (type.isEmpty())
return;
QScriptValue handlerObject;
QScriptValue handler = eventHandler(canvas, type, &handlerObject);
if (!handler.isFunction())
return;
QScriptValue scriptEvent = newFakeDomEvent(type, toWrapper(canvas));
// KeyEvent
scriptEvent.setProperty("isChar", !e->text().isEmpty());
scriptEvent.setProperty("charCode", e->text());
scriptEvent.setProperty("keyCode", FakeDomEvent::qtToDomKey(e->key()));
scriptEvent.setProperty("which", e->key());
handler.call(handlerObject, QScriptValueList() << scriptEvent);
maybeEmitScriptError();
}
// Call a function by name
static bool callFunction(QScriptEngine *engine, const QString &function, const QScriptValueList &args, bool required = false)
{
code_part level = required ? LOG_ERROR : LOG_WARNING;
QScriptValue value = engine->globalObject().property(function);
if (!value.isValid() || !value.isFunction())
{
// not necessarily an error, may just be a trigger that is not defined (ie not needed)
// or it could be a typo in the function name or ...
debug(level, "called function (%s) not defined", function.toUtf8().constData());
return false;
}
int ticks = wzGetTicks();
QScriptValue result = value.call(QScriptValue(), args);
ticks = wzGetTicks() - ticks;
if (ticks > MAX_MS)
{
debug(LOG_SCRIPT, "%s took %d ms at time %d", function.toAscii().constData(), ticks, wzGetTicks());
}
if (engine->hasUncaughtException())
{
int line = engine->uncaughtExceptionLineNumber();
QStringList bt = engine->uncaughtExceptionBacktrace();
for (int i = 0; i < bt.size(); i++)
{
debug(LOG_ERROR, "%d : %s", i, bt.at(i).toAscii().constData());
}
ASSERT(false, "Uncaught exception calling function \"%s\" at line %d: %s",
function.toAscii().constData(), line, result.toString().toAscii().constData());
engine->clearExceptions();
return false;
}
return true;
}
void Session::processSignIn(const QString &data) {
try {
switch (m_sessionState) {
case SessionClosed:
break;
case SigningIn: {
QScriptValue processSignIn = m_scriptObject.property("processSignIn");
QScriptValueList args;
args.append(data.trimmed());
processSignIn.call(m_scriptObject, args);
break;
}
case SignedIn: {
CommandEvent event(m_player, data);
event.process();
break;
}
}
ScriptEngine *engine = ScriptEngine::instance();
if (engine->hasUncaughtException()) {
LogUtil::logException("Script Exception: %1\n"
"In Session::processSignIn()", engine->uncaughtException());
}
} catch (GameException &exception) {
LogUtil::logError("Exception in Session::processSignIn(): %1", exception.what());
}
}
void MainWindow::loadApplicationData()
{
// Loading the headers
QFile headersFile( m_appDir.absoluteFilePath( QLatin1String("headers.js") ) );
headersFile.open(QFile::ReadOnly);
const QString script = QTextStream( &headersFile ).readAll();
headersFile.close();
QScriptEngine engine;
engine.evaluate(script);
QScriptValue function = engine.globalObject().property( QLatin1String("headers") );
QStringList headers = function.call().toString().split( QLatin1String(", ") );
m_table->setColumnCount(headers.size());
m_table->setHorizontalHeaderLabels(headers);
// Loading the stylesheet
if ( m_appDir.exists( QLatin1String("application.qss") ) ) {
QFile styleFile( m_appDir.absoluteFilePath( QLatin1String("application.qss") ) );
styleFile.open(QFile::ReadOnly);
const QString stylesheet = QTextStream( &styleFile ).readAll();
styleFile.close();
qApp->setStyleSheet(stylesheet);
}
else {
qApp->setStyleSheet( QString() );
}
}
QScriptValue scriptRequestInfo(QScriptContext *context, QScriptEngine *engine)
{
if (context->argumentCount() < 2)
return context->throwError("qutim.requestInfo() takes at least 2 arguments");
QObject *object = context->argument(0).toQObject();
if (!object)
return context->throwError("First argument must be QObject");
QScriptValue func = context->argument(1);
if (!func.isFunction())
return context->throwError("Second argument must be callback");
InfoRequestFactory *factory = InfoRequestFactory::factory(object);
QScriptValue errorFunc = context->argument(2);
if (!factory || factory->supportLevel(object) <= InfoRequestFactory::Unavailable) {
if (errorFunc.isFunction()) {
qDebug() << Q_FUNC_INFO;
QScriptValue error = engine->newObject();
error.setProperty(QLatin1String("name"), QLatin1String("NotSupported"));
error.setProperty(QLatin1String("text"), QLatin1String("Unit does not support information request"));
QList<QScriptValue> args;
args << error;
errorFunc.call(errorFunc, args);
}
return engine->undefinedValue();
}
InfoRequest *request = factory->createrDataFormRequest(object);
new ScriptInfoRequest(func, errorFunc, request);
return engine->undefinedValue();
}
void Session::open() {
try {
setSessionState(SigningIn);
ScriptEngine *engine = ScriptEngine::instance();
m_scriptObject = engine->evaluate("new SessionHandler()");
if (engine->hasUncaughtException()) {
LogUtil::logException("Script Exception: %1\n"
"In Session::open()", engine->uncaughtException());
return;
}
QScriptValue setSession = m_scriptObject.property("setSession");
QScriptValueList args;
args.append(engine->toScriptValue(this));
setSession.call(m_scriptObject, args);
if (engine->hasUncaughtException()) {
LogUtil::logException("Script Exception: %1\n"
"In Session::open()", engine->uncaughtException());
}
} catch (GameException &exception) {
LogUtil::logError("Exception in Session::open(): %1", exception.what());
}
}
void CustomScriptSearchProvider::parseAsJson(QNetworkReply* pReply)
{
if (m_pEngine)
{
QScriptValue globalObject = m_pEngine->globalObject();
QScriptValue json = globalObject.property("JSON");
if (json.isObject())
{
QScriptValue parseFunk = json.property("parse");
if (parseFunk.isFunction())
{
QString jsonStr = pReply->readAll();
QScriptValue object = parseFunk.call(json, QScriptValueList() << jsonStr);
QScriptValue thisObj = m_scriptVal;
if (thisObj.isObject() && thisObj.isValid())
{
thisObj.setProperty("jsonResult", object);
emit JsonResultReady();
}
}
}
}
}
void leave(TreeItem * item){
Q_ASSERT(_qengine);
QObject * scriptitem = new ScriptObjectTreeItem(item);
QScriptValue itemvalue = _qengine->newQObject(scriptitem, QScriptEngine::ScriptOwnership);
QScriptValue funcEnd = _qengine->globalObject().property("onLeftItem");
funcEnd.call(QScriptValue(),QScriptValueList() << itemvalue);
}
QScriptValue QtScriptEngine::printFunction(QScriptContext *context, QScriptEngine *engine)
{
QScriptValue debugPrintFunc = engine->globalObject().property("printDebug");
if (debugPrintFunc.isValid())
{
debugPrintFunc.call(context->thisObject(), context->argumentsObject());
}
QString output;
for (int i = 0; i < context->argumentCount(); i++)
{
if (i > 0)
{
output += " ";
}
output += context->argument(i).toString();
}
static_cast<MyQScriptEngine*>(engine)->wrapperEngine->callEventHandlers(
IScriptEngine::Information, NULL, -1, output.toUtf8().constData());
return engine->undefinedValue();
}
QString netease_encrypt::EncryptPassword(const QString& password)
{
QScriptValue global_ob = m_engine->globalObject();
QScriptValue func = global_ob.property("getSP");
if (!func.isValid())
{
return "";
}
QScriptValueList args;
args << password ;
QScriptValue v = func.call(QScriptValue(), args);
if(v.isError()) {//解析js文件是否有错误
QMessageBox::critical(0, "Hello Script",
QString::fromLatin1("%0:%1: %2")
.arg(m_file_name)//文件名
.arg(v.property("lineNumber").toInt32())//错误行号
.arg(v.toString()));//错误信息
return "";
}
return v.toString();
}
//! [37]
QScriptValue Employee_ctor(QScriptContext *context, QScriptEngine *engine)
{
QScriptValue super = context->callee().property("prototype").property("constructor");
super.call(context->thisObject(), QScriptValueList() << context->argument(0));
context->thisObject().setProperty("salary", context->argument(1));
return engine->undefinedValue();
}
QString KateTemplateScript::invoke(KateView* view, const QString& functionName, const QString &srcText) {
if(!setView(view))
return QString();
clearExceptions();
QScriptValue myFunction = function(functionName);
if(!myFunction.isValid()) {
return QString();
}
QScriptValueList arguments;
arguments << QScriptValue(m_engine, srcText);
QScriptValue result = myFunction.call(QScriptValue(), arguments);
if(m_engine->hasUncaughtException()) {
displayBacktrace(result, "Error while calling helper function");
return QString();
}
if (result.isNull()) {
return QString();
}
return result.toString();
}
QVariant EcmaScript::callFunction(const QString& name, const QVariantList& args)
{
if( ! d->m_engine && ! d->init() ) {
d->handleException();
return QVariant();
}
QScriptValue obj = d->m_engine->globalObject();
QScriptValue function = obj.property(name);
if( ! function.isFunction() ) {
QString err = QString("No such function '%1'").arg(name);
qrosswarning( QString("EcmaScript::callFunction %1").arg(err) );
setError(err);
return QVariant();
}
QScriptValueList arguments;
foreach(const QVariant &v, args)
arguments << d->m_engine->toScriptValue(v);
QScriptValue result = function.call(obj, arguments);
if( d->m_engine->hasUncaughtException() ) {
d->handleException();
return QVariant();
}
return result.toVariant();
}
void QDeclarativeInclude::callback(QScriptEngine *engine, QScriptValue &callback, QScriptValue &status)
{
if (callback.isValid()) {
QScriptValue args = engine->newArray(1);
args.setProperty(0, status);
callback.call(QScriptValue(), args);
}
}
void tst_QScriptContext::parentContextCallee_QT2270()
{
QScriptEngine engine;
engine.globalObject().setProperty("getParentContextCallee", engine.newFunction(getParentContextCallee));
QScriptValue fun = engine.evaluate("(function() { return getParentContextCallee(); })");
QVERIFY(fun.isFunction());
QScriptValue callee = fun.call();
QVERIFY(callee.equals(fun));
}
static QScriptValue qscript_TestCase(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue origTestCaseCtor = ctx->callee().data();
QScriptValue kase = ctx->thisObject();
QScriptValue ret = origTestCaseCtor.call(kase, ctx->argumentsObject());
QScriptContextInfo info(ctx->parentContext());
kase.setProperty("__lineNumber__", QScriptValue(eng, info.lineNumber()));
return ret;
}
bool QtScriptForceCondition3D::isApplied(msh::PointPointer point)
{
QScriptValue func = engine_.globalObject().property("isApplied");
QScriptValue result = func.call(object_, QScriptValueList() << point->x() << point->y() << point->z());
x_ = point->x();
y_ = point->y();
z_ = point->z();
return result.toBool();
}
//----------------------------------------------------------------------------
QString voUtils::stringify(QScriptEngine* scriptEngine, const QScriptValue& scriptValue)
{
if (!scriptEngine)
{
return QString();
}
QScriptValue stringify = scriptEngine->evaluate("(function(obj) { return JSON.stringify(obj); })");
return stringify.call(QScriptValue(), QScriptValueList() << scriptValue).toString();
}
void ScShiftDatabase::computeNode(const SPropertyInstanceInformation *instanceInfo, SPropertyContainer *node)
{
ScProfileFunction
const QVariant &val = instanceInfo->data()[g_computeKey];
QScriptValue compute = qvariant_cast<QScriptValue>(val);
xAssert(compute.isFunction());
// call with this as the node being computed, and no arguments.
compute.call(ScEmbeddedTypes::packValue(node));
}
QString Json::encode(const QMap<QString,QVariant> &map)
{
QScriptEngine engine;
engine.evaluate("function toString() { return JSON.stringify(this) }");
QScriptValue toString = engine.globalObject().property("toString");
QScriptValue obj = encodeInner(map, &engine);
return toString.call(obj).toString();
}
JsonValue *JsonValue::create(const QString &s, JsonMemoryPool *pool)
{
QScriptEngine engine;
QScriptValue jsonParser = engine.evaluate(QLatin1String("JSON.parse"));
QScriptValue value = jsonParser.call(QScriptValue(), QScriptValueList() << s);
if (engine.hasUncaughtException() || !value.isValid())
return 0;
return build(value.toVariant(), pool);
}
double testF (QScriptValue callback, QScriptValue act, unsigned n, const double * arr)
{
QTextStream (stdout) << "testF called: n = " << n << '\n';
QScriptValueList args;
for (unsigned i = 0; i < n; ++i) {
args << arr[i];
}
auto ret = callback.call(act, args);
QTextStream (stdout) << "ok\n";
return ret.toNumber();
}
static QScriptValue qscript_fail(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue realFail = ctx->callee().data();
Q_ASSERT(realFail.isFunction());
QScriptValue ret = realFail.call(ctx->thisObject(), ctx->argumentsObject());
Q_ASSERT(eng->hasUncaughtException());
ret.setProperty("expected", ctx->argument(0));
ret.setProperty("actual", ctx->argument(1));
QScriptContextInfo info(ctx->parentContext()->parentContext());
ret.setProperty("lineNumber", info.lineNumber());
return ret;
}
TraversalType visit(TreeItem * item){
Q_ASSERT(_qengine);
QObject * scriptitem = new ScriptObjectTreeItem(item);
QScriptValue itemvalue = _qengine->newQObject(scriptitem, QScriptEngine::ScriptOwnership);
QScriptValue funcEnd = _qengine->globalObject().property("onEnteredItem");
funcEnd.call(QScriptValue(),QScriptValueList() << itemvalue);
return _apiimpl->isAborted() || _qengine->hasUncaughtException() ?
AbstractTreeModelVisitor::TraversalEnd :
AbstractTreeModelVisitor::TraversalContinue;
}
static QScriptValue native_recurse(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue func = ctx->argumentsObject().property(0);
QScriptValue n = ctx->argumentsObject().property(1);
if(n.toUInt32() <= 1) {
return func.call(QScriptValue(), QScriptValueList());
} else {
return eng->evaluate("native_recurse").call(QScriptValue(),
QScriptValueList() << func << QScriptValue(n.toUInt32() - 1));
}
}
// Check the overhead of the extension "call"
void tst_QScriptClass::call()
{
QScriptEngine eng;
ExtensionScriptClass cls(&eng);
QScriptValue obj = eng.newObject(&cls);
QScriptValue thisObject;
QScriptValueList args;
args.append(123);
QBENCHMARK {
for (int i = 0; i < iterationNumber; ++i)
(void)obj.call(thisObject, args);
}
}
QScriptValue& DerivedNetworkValue::getValue() {
if (!_value.isValid() && _baseValue->isLoaded()) {
RootNetworkValue* root = static_cast<RootNetworkValue*>(_baseValue.data());
ScriptCache* cache = root->getProgram()->getCache();
QScriptValue generator = _baseValue->getValue().property(cache->getGeneratorString());
if (generator.isFunction()) {
QScriptValueList arguments;
foreach (const ParameterInfo& parameter, root->getParameterInfo()) {
arguments.append(cache->getEngine()->newVariant(_parameters.value(parameter.name)));
}
_value = generator.call(QScriptValue(), arguments);
} else {
void ScriptEngine::timerFired() {
QTimer* callingTimer = reinterpret_cast<QTimer*>(sender());
// call the associated JS function, if it exists
QScriptValue timerFunction = _timerFunctionMap.value(callingTimer);
if (timerFunction.isValid()) {
timerFunction.call();
}
if (!callingTimer->isActive()) {
// this timer is done, we can kill it
delete callingTimer;
}
}
void ScriptEngine::hostInfo_Ready(const QHostInfo &myInfo)
{
QScriptValue myVal = myHostLookups.take(myInfo.lookupId());
if(myVal.isString()) {
QString info = myInfo.hostName();
eval("var name = '"+info+"';"+myVal.toString());
} else {
if(myVal.isFunction()) {
QScriptValueList arguments;
arguments << QString(myInfo.hostName());
myVal.call(QScriptValue(), arguments);
}
}
}
void GeoHelper::searchFinishedSlot(QGeoSearchReply *reply)
{
if (reply->error() == QGeoSearchReply::NoError)
{
QScriptEngine scriptEngine;
QScriptValue replyObject = scriptEngine.newArray();
QList<QGeoPlace> places = reply->places();
for (int i = 0; i < places.count(); i++)
{
QScriptValue placeObject = scriptEngine.newObject();
QScriptValue coordinateObject = scriptEngine.newObject();
QGeoCoordinate coordinate = places[i].coordinate();
coordinateObject.setProperty("latitude", QScriptValue(coordinate.latitude()));
coordinateObject.setProperty("longitude", QScriptValue(coordinate.longitude()));
placeObject.setProperty("coordinate", coordinateObject);
QScriptValue addressObject = scriptEngine.newObject();
QGeoAddress address = places[i].address();
if (!address.isEmpty())
{
addressObject.setProperty("country", address.country());
addressObject.setProperty("countryCode", address.countryCode());
addressObject.setProperty("state", address.state());
addressObject.setProperty("county", address.county());
addressObject.setProperty("city", address.city());
addressObject.setProperty("district", address.district());
addressObject.setProperty("street", address.street());
addressObject.setProperty("postcode", address.postcode());
}
placeObject.setProperty("address", addressObject);
replyObject.setProperty(i, placeObject);
}
QScriptValue fun = scriptEngine.evaluate("(function(a) { return JSON.stringify(a); })");
QScriptValueList args;
args << replyObject;
QScriptValue result = fun.call(QScriptValue(), args);
emit searchReply(result.toString());
}
}
