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 ProcessCommand::fillFromScriptValue(const QScriptValue *scriptValue, const CodeLocation &codeLocation)
{
AbstractCommand::fillFromScriptValue(scriptValue, codeLocation);
m_program = scriptValue->property(QLatin1String("program")).toString();
m_arguments = scriptValue->property(QLatin1String("arguments")).toVariant().toStringList();
m_workingDir = scriptValue->property(QLatin1String("workingDirectory")).toString();
m_maxExitCode = scriptValue->property(QLatin1String("maxExitCode")).toInt32();
QScriptValue stdoutFilterFunction =
scriptValue->property(QLatin1String("stdoutFilterFunction")).toString();
if (stdoutFilterFunction.isFunction())
m_stdoutFilterFunction = QLatin1String("(") + stdoutFilterFunction.toString()
+ QLatin1String(")()");
else
m_stdoutFilterFunction = stdoutFilterFunction.toString();
QScriptValue stderrFilterFunction =
scriptValue->property(QLatin1String("stderrFilterFunction")).toString();
if (stderrFilterFunction.isFunction())
m_stderrFilterFunction = QLatin1String("(") + stderrFilterFunction.toString()
+ QLatin1String(")()");
else
m_stderrFilterFunction = stderrFilterFunction.toString();
m_responseFileThreshold = scriptValue->property(QLatin1String("responseFileThreshold"))
.toInt32();
m_responseFileArgumentIndex = scriptValue->property(QLatin1String("responseFileArgumentIndex"))
.toInt32();
m_responseFileUsagePrefix = scriptValue->property(QLatin1String("responseFileUsagePrefix"))
.toString();
QStringList envList = scriptValue->property(QLatin1String("environment")).toVariant()
.toStringList();
getEnvironmentFromList(envList);
m_stdoutFilePath = scriptValue->property(QLatin1String("stdoutFilePath")).toString();
m_stderrFilePath = scriptValue->property(QLatin1String("stderrFilePath")).toString();
m_predefinedProperties
<< QLatin1String("program")
<< QLatin1String("arguments")
<< QLatin1String("workingDirectory")
<< QLatin1String("maxExitCode")
<< QLatin1String("stdoutFilterFunction")
<< QLatin1String("stderrFilterFunction")
<< QLatin1String("responseFileThreshold")
<< QLatin1String("responseFileArgumentIndex")
<< QLatin1String("responseFileUsagePrefix")
<< QLatin1String("environment")
<< QLatin1String("stdoutFilePath")
<< QLatin1String("stderrFilePath");
applyCommandProperties(scriptValue);
}
// 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 addFunction(const QString &name, const QString &code)
{
QScriptValue f = m_engine->evaluate(code);
QBS_ASSERT(f.isFunction(), return);
m_descriptor.setProperty(QLatin1String("value"), f);
m_engine->defineProperty(m_proto, name, m_descriptor);
}
void tst_QScriptContext::qobjectAsActivationObject()
{
QScriptEngine eng;
QObject object;
QScriptValue scriptObject = eng.newQObject(&object);
QScriptContext *ctx = eng.pushContext();
ctx->setActivationObject(scriptObject);
QVERIFY(ctx->activationObject().equals(scriptObject));
QVERIFY(!scriptObject.property("foo").isValid());
eng.evaluate("function foo() { return 123; }");
{
QScriptValue val = scriptObject.property("foo");
QVERIFY(val.isValid());
QVERIFY(val.isFunction());
}
QVERIFY(!eng.globalObject().property("foo").isValid());
QVERIFY(!scriptObject.property("bar").isValid());
eng.evaluate("var bar = 123");
{
QScriptValue val = scriptObject.property("bar");
QVERIFY(val.isValid());
QVERIFY(val.isNumber());
QCOMPARE(val.toInt32(), 123);
}
QVERIFY(!eng.globalObject().property("bar").isValid());
{
QScriptValue val = eng.evaluate("delete foo");
QVERIFY(val.isBool());
QVERIFY(val.toBool());
QVERIFY(!scriptObject.property("foo").isValid());
}
}
void tst_QScriptContext::inheritActivationAndThisObject()
{
QScriptEngine eng;
eng.globalObject().setProperty("myEval", eng.newFunction(myEval));
{
QScriptValue ret = eng.evaluate("var a = 123; myEval('a')");
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
{
QScriptValue ret = eng.evaluate("(function() { return myEval('this'); }).call(Number)");
QVERIFY(ret.isFunction());
QVERIFY(ret.equals(eng.globalObject().property("Number")));
}
{
QScriptValue ret = eng.evaluate("(function(a) { return myEval('a'); })(123)");
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
// QT-2219
{
eng.globalObject().setProperty("a", 123);
QScriptValue ret = eng.evaluate("(function() { myEval('var a = 456'); return a; })()");
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 456);
QEXPECT_FAIL("", "QT-2219: Wrong activation object is returned from native function's parent context", Continue);
QVERIFY(eng.globalObject().property("a").strictlyEquals(123));
}
}
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 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();
}
}
}
}
}
QScriptValue KateScript::function(const QString &name)
{
QScriptValue value = global(name);
if(!value.isFunction())
return QScriptValue();
return value;
}
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();
}
void tst_QScriptContext::callee()
{
QScriptEngine eng;
{
QScriptValue fun = eng.newFunction(get_callee);
fun.setProperty("foo", QScriptValue(&eng, "bar"));
eng.globalObject().setProperty("get_callee", fun);
QScriptValue result = eng.evaluate("get_callee()");
QCOMPARE(result.isFunction(), true);
QCOMPARE(result.property("foo").toString(), QString("bar"));
}
// callee when toPrimitive() is called internally
{
QScriptValue fun = eng.newFunction(store_callee_and_return_primitive);
QScriptValue obj = eng.newObject();
obj.setProperty("toString", fun);
QVERIFY(!obj.property("callee").isValid());
(void)obj.toString();
QVERIFY(obj.property("callee").isFunction());
QVERIFY(obj.property("callee").strictlyEquals(fun));
obj.setProperty("callee", QScriptValue());
QVERIFY(!obj.property("callee").isValid());
obj.setProperty("valueOf", fun);
(void)obj.toNumber();
QVERIFY(obj.property("callee").isFunction());
QVERIFY(obj.property("callee").strictlyEquals(fun));
}
}
QScriptValue QDeclarativeInclude::worker_include(QScriptContext *ctxt, QScriptEngine *engine)
{
if (ctxt->argumentCount() == 0)
return engine->undefinedValue();
QString urlString = ctxt->argument(0).toString();
QUrl url(ctxt->argument(0).toString());
if (url.isRelative()) {
QString contextUrl = QScriptDeclarativeClass::scopeChainValue(ctxt, -3).data().toString();
Q_ASSERT(!contextUrl.isEmpty());
url = QUrl(contextUrl).resolved(url);
urlString = url.toString();
}
QString localFile = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url);
QScriptValue func = ctxt->argument(1);
if (!func.isFunction())
func = QScriptValue();
QScriptValue result;
if (!localFile.isEmpty()) {
QFile f(localFile);
if (f.open(QIODevice::ReadOnly)) {
QByteArray data = f.readAll();
QString code = QString::fromUtf8(data);
QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(engine);
QScriptValue urlContext = engine->newObject();
urlContext.setData(QScriptValue(engine, urlString));
scriptContext->pushScope(urlContext);
QScriptValue scope = QScriptDeclarativeClass::scopeChainValue(ctxt, -4);
scriptContext->pushScope(scope);
scriptContext->setActivationObject(scope);
QDeclarativeScriptParser::extractPragmas(code);
engine->evaluate(code, urlString, 1);
engine->popContext();
if (engine->hasUncaughtException()) {
result = resultValue(engine, Exception);
result.setProperty(QLatin1String("exception"), engine->uncaughtException());
engine->clearExceptions();
} else {
result = resultValue(engine, Ok);
}
callback(engine, func, result);
} else {
result = resultValue(engine, NetworkError);
callback(engine, func, result);
}
}
return result;
}
void BotThread::registerStep(QScriptValue function, int frec)
{
if(function.isFunction())
{
m_steps.append(new BotStep(function,frec));
calcDelay();
}
}
int TarryTown::setTimeout(const QScriptValue &expression, int delay) {
if (expression.isString() || expression.isFunction()) {
int timerId = startTimer(delay);
p_timeoutHash.insert(timerId, expression);
return timerId;
}
return -1;
}
void QContext2DCanvas::addEventListener(const QString &type, const QScriptValue &listener,
bool useCapture)
{
Q_UNUSED(useCapture);
if (listener.isFunction()) {
QScriptValue self = m_env->toWrapper(this);
self.setProperty("on" + type, listener);
}
}
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));
}
//! [1]
int Environment::setInterval(const QScriptValue &expression, int delay)
{
if (expression.isString() || expression.isFunction()) {
int timerId = startTimer(delay);
m_intervalHash.insert(timerId, expression);
return timerId;
}
return -1;
}
void JavascriptInstance::GetObjectInformation(const QScriptValue &object, QSet<qint64> &ids, uint &valueCount, uint &objectCount, uint &nullCount, uint &numberCount,
uint &boolCount, uint &stringCount, uint &arrayCount, uint &funcCount, uint &qobjCount, uint &qobjMethodCount)
{
if (!ids.contains(object.objectId()))
ids << object.objectId();
QScriptValueIterator iter(object);
while(iter.hasNext())
{
iter.next();
QScriptValue v = iter.value();
if (ids.contains(v.objectId()))
continue;
ids << v.objectId();
valueCount++;
if (v.isNull())
nullCount++;
if (v.isNumber())
numberCount++;
else if (v.isBool())
boolCount++;
else if (v.isString())
stringCount++;
else if (v.isArray())
arrayCount++;
else if (v.isFunction())
funcCount++;
else if (v.isQObject())
qobjCount++;
if (v.isObject())
objectCount++;
if (v.isQMetaObject())
qobjMethodCount += v.toQMetaObject()->methodCount();
// Recurse
if ((v.isObject() || v.isArray()) && !v.isFunction() && !v.isString() && !v.isNumber() && !v.isBool() && !v.isQObject() && !v.isQMetaObject())
GetObjectInformation(v, ids, valueCount, objectCount, nullCount, numberCount, boolCount, stringCount, arrayCount, funcCount, qobjCount, qobjMethodCount);
}
}
static JSAgentWatchData fromScriptValue(const QString &expression,
const QScriptValue &value)
{
static const QString arrayStr = QCoreApplication::translate
("Debugger::JSAgentWatchData", "[Array of length %1]");
static const QString undefinedStr = QCoreApplication::translate
("Debugger::JSAgentWatchData", "<undefined>");
JSAgentWatchData data;
data.exp = expression.toUtf8();
data.name = data.exp;
data.hasChildren = false;
data.value = value.toString().toUtf8();
data.objectId = value.objectId();
if (value.isArray()) {
data.type = "Array";
data.value = arrayStr.arg(value.property(QLatin1String("length")).toString()).toUtf8();
data.hasChildren = true;
} else if (value.isBool()) {
data.type = "Bool";
// data.value = value.toBool() ? "true" : "false";
} else if (value.isDate()) {
data.type = "Date";
data.value = value.toDateTime().toString().toUtf8();
} else if (value.isError()) {
data.type = "Error";
} else if (value.isFunction()) {
data.type = "Function";
} else if (value.isUndefined()) {
data.type = undefinedStr.toUtf8();
} else if (value.isNumber()) {
data.type = "Number";
} else if (value.isRegExp()) {
data.type = "RegExp";
} else if (value.isString()) {
data.type = "String";
} else if (value.isVariant()) {
data.type = "Variant";
} else if (value.isQObject()) {
const QObject *obj = value.toQObject();
data.type = "Object";
data.value += '[';
data.value += obj->metaObject()->className();
data.value += ']';
data.hasChildren = true;
} else if (value.isObject()) {
data.type = "Object";
data.hasChildren = true;
data.value = "[Object]";
} else if (value.isNull()) {
data.type = "<null>";
} else {
data.type = "<unknown>";
}
return data;
}
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));
}
void Document::addEventListener(const QString &type, const QScriptValue &listener,
bool useCapture)
{
Q_UNUSED(useCapture);
if (listener.isFunction()) {
Environment *env = qobject_cast<Environment*>(parent());
QScriptValue self = env->toWrapper(this);
self.setProperty("on" + type, listener);
}
}
// If a callback is specified, the included files will be loaded asynchronously and the callback will be called
// when all of the files have finished loading.
// If no callback is specified, the included files will be loaded synchronously and will block execution until
// all of the files have finished loading.
void ScriptEngine::include(const QStringList& includeFiles, QScriptValue callback) {
if (_stoppingAllScripts) {
qCDebug(scriptengine) << "Script.include() while shutting down is ignored..."
<< "includeFiles:" << includeFiles << "parent script:" << getFilename();
return; // bail early
}
QList<QUrl> urls;
for (QString file : includeFiles) {
urls.append(resolvePath(file));
}
BatchLoader* loader = new BatchLoader(urls);
auto evaluateScripts = [=](const QMap<QUrl, QString>& data) {
for (QUrl url : urls) {
QString contents = data[url];
if (contents.isNull()) {
qCDebug(scriptengine) << "Error loading file: " << url << "line:" << __LINE__;
} else {
QScriptValue result = evaluate(contents, url.toString());
}
}
if (callback.isFunction()) {
QScriptValue(callback).call();
}
loader->deleteLater();
};
connect(loader, &BatchLoader::finished, this, evaluateScripts);
// If we are destroyed before the loader completes, make sure to clean it up
connect(this, &QObject::destroyed, loader, &QObject::deleteLater);
loader->start();
if (!callback.isFunction() && !loader->isFinished()) {
QEventLoop loop;
QObject::connect(loader, &BatchLoader::finished, &loop, &QEventLoop::quit);
loop.exec();
}
}
QString ScriptHandler::customToString(const DataInformation* data, const QScriptValue& func)
{
Q_ASSERT(func.isValid());
Q_ASSERT(func.isFunction());
Q_ASSERT(data->wasAbleToRead()); //this should never be called if EOF was reached
//it is effectively const, since nothing may be modified while mode is CustomToString
//const_cast is okay in this case
QScriptValue result = callFunction(func, const_cast<DataInformation*>(data), ScriptHandlerInfo::CustomToString);
if (result.isError())
data->logError() << "toStringFunc caused an error:" << result.toString();
return result.toString();
}
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;
}
void QDeclarativeValueTypeScriptClass::setProperty(Object *obj, const Identifier &,
const QScriptValue &value)
{
QDeclarativeValueTypeObject *o = static_cast<QDeclarativeValueTypeObject *>(obj);
QVariant v = QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value);
if (o->objectType == QDeclarativeValueTypeObject::Reference) {
QDeclarativeValueTypeReference *ref = static_cast<QDeclarativeValueTypeReference *>(obj);
ref->type->read(ref->object, ref->property);
QMetaProperty p = ref->type->metaObject()->property(m_lastIndex);
QDeclarativeBinding *newBinding = 0;
if (value.isFunction() && !value.isRegExp()) {
QDeclarativeContextData *ctxt = QDeclarativeEnginePrivate::get(engine)->getContext(context());
QDeclarativePropertyCache::Data cacheData;
cacheData.flags = QDeclarativePropertyCache::Data::IsWritable;
cacheData.propType = ref->object->metaObject()->property(ref->property).userType();
cacheData.coreIndex = ref->property;
QDeclarativePropertyCache::ValueTypeData valueTypeData;
valueTypeData.valueTypeCoreIdx = m_lastIndex;
valueTypeData.valueTypePropType = p.userType();
newBinding = new QDeclarativeBinding(value, ref->object, ctxt);
QScriptContextInfo ctxtInfo(context());
newBinding->setSourceLocation(ctxtInfo.fileName(), ctxtInfo.functionStartLineNumber());
QDeclarativeProperty prop = QDeclarativePropertyPrivate::restore(cacheData, valueTypeData, ref->object, ctxt);
newBinding->setTarget(prop);
if (newBinding->expression().contains(QLatin1String("this")))
newBinding->setEvaluateFlags(newBinding->evaluateFlags() | QDeclarativeBinding::RequiresThisObject);
}
QDeclarativeAbstractBinding *delBinding =
QDeclarativePropertyPrivate::setBinding(ref->object, ref->property, m_lastIndex, newBinding);
if (delBinding)
delBinding->destroy();
if (p.isEnumType() && (QMetaType::Type)v.type() == QMetaType::Double)
v = v.toInt();
p.write(ref->type, v);
ref->type->write(ref->object, ref->property, 0);
} else {
QDeclarativeValueTypeCopy *copy = static_cast<QDeclarativeValueTypeCopy *>(obj);
copy->type->setValue(copy->value);
QMetaProperty p = copy->type->metaObject()->property(m_lastIndex);
p.write(copy->type, v);
copy->value = copy->type->value();
}
}
void JavaScriptCommand::fillFromScriptValue(const QScriptValue *scriptValue, const CodeLocation &codeLocation)
{
AbstractCommand::fillFromScriptValue(scriptValue, codeLocation);
QScriptValue sourceCode = scriptValue->property(QLatin1String("sourceCode"));
if (sourceCode.isFunction())
m_sourceCode = QLatin1String("(") + sourceCode.toString() + QLatin1String(")()");
else
m_sourceCode = sourceCode.toString();
m_predefinedProperties << QLatin1String("className") << QLatin1String("sourceCode");
applyCommandProperties(scriptValue);
}
QScriptValue scriptSettingsRegister(QScriptContext *ctxt, QScriptEngine *e)
{
if (ctxt->argumentCount() != 1)
return ctxt->throwError("register() takes exactly one argument");
QScriptValue item = ctxt->argument(0);
Settings::Type itemType = static_cast<Settings::Type>(item.property("type").toInt32());
QString icon = item.property("icon").toString();
LocalizedString text = qscriptvalue_cast<LocalizedString>(item.property("text"));
AutoSettingsItem *settingsItem = new AutoSettingsItem(itemType, Icon(icon), text);
settingsItem->setConfig(QString(), QLatin1String("plugins/script/")
+ static_cast<ScriptEngine*>(e)->name());
QScriptValue onSaved = item.property("onSaved");
if (onSaved.isFunction()) {
ScriptSettingsConnector *helper = new ScriptSettingsConnector(e);
settingsItem->connect(SIGNAL(saved()), helper, SLOT(onSaved()));
qScriptConnect(helper, SIGNAL(saved()), item, onSaved);
}
QScriptValue entries = item.property("entries");
quint32 len = entries.property(QLatin1String("length")).toUInt32();
for (quint32 i = 0; i < len; ++i) {
QScriptValue entry = entries.property(i);
text = qscriptvalue_cast<LocalizedString>(entry.property("text"));
ObjectGenerator *gen = 0;
QString type = entry.property("type").toString();
if (type == QLatin1String("CheckBox"))
gen = new GeneralGenerator<QCheckBox>();
else if (type == QLatin1String("ComboBox"))
gen = new GeneralGenerator<AutoSettingsComboBox>();
else if (type == QLatin1String("LineEdit"))
gen = new GeneralGenerator<QLineEdit>();
else if (type == QLatin1String("TextEdit"))
gen = new GeneralGenerator<QTextEdit>();
else if (type == QLatin1String("PlainTextEdit"))
gen = new GeneralGenerator<QPlainTextEdit>();
else
continue;
AutoSettingsItem::Entry *entryItem = settingsItem->addEntry(text, gen);
QScriptValueIterator it(entry);
while (it.hasNext()) {
it.next();
if (it.name() == QLatin1String("type") || it.name() == QLatin1String("text"))
continue;
else if (it.name() == QLatin1String("name"))
entryItem->setName(it.value().toString());
else
entryItem->setProperty(it.name().toUtf8().constData(), it.value().toVariant());
}
}
Settings::registerItem(settingsItem);
return QScriptValue();
}
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 CanvasTimer::removeTimer(const QScriptValue &val)
{
if (!val.isFunction())
return;
for (int i = 0 ; i < activeTimers()->count() ; ++i) {
CanvasTimer *timer = activeTimers()->at(i);
if (timer->equals(val)) {
removeTimer(timer);
return;
}
}
}
QScriptValue Environment::eventHandler(QContext2DCanvas *canvas, const QString &type,
QScriptValue *who)
{
QString handlerName = "on" + type;
QScriptValue obj = toWrapper(canvas);
QScriptValue handler = obj.property(handlerName);
if (!handler.isValid()) {
obj = m_document;
handler = obj.property(handlerName);
}
if (who && handler.isFunction())
*who = obj;
return handler;
}
