QScriptValue ScriptEngine::filesForDirectory (const QString &dir_)
{
QString dir = dir_;
QDir directory(dir);
if(!directory.exists()) {
return myengine.undefinedValue();
}
QStringList files = directory.entryList(QDir::Files);
QScriptValue ret = myengine.newArray(files.count());
for (int i = 0; i < files.size(); i++) {
ret.setProperty(i, files[i]);
}
return ret;
}
QScriptValue qtscript_create_QStateMachine_SignalEvent_class(QScriptEngine *engine)
{
engine->setDefaultPrototype(qMetaTypeId<QStateMachine::SignalEvent*>(), QScriptValue());
QScriptValue proto = engine->newVariant(qVariantFromValue((QStateMachine::SignalEvent*)0));
proto.setPrototype(engine->defaultPrototype(qMetaTypeId<QEvent*>()));
for (int i = 0; i < 4; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QStateMachine_SignalEvent_prototype_call, qtscript_QStateMachine_SignalEvent_function_lengths[i+1]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
proto.setProperty(QString::fromLatin1(qtscript_QStateMachine_SignalEvent_function_names[i+1]),
fun, QScriptValue::SkipInEnumeration);
}
engine->setDefaultPrototype(qMetaTypeId<QStateMachine::SignalEvent*>(), proto);
QScriptValue ctor = engine->newFunction(qtscript_QStateMachine_SignalEvent_static_call, proto, qtscript_QStateMachine_SignalEvent_function_lengths[0]);
ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
return ctor;
}
QScriptValue EnumScriptClass::additionalProperty(const DataInformation* data, const QScriptString& name, uint id)
{
if (name == s_values)
{
const EnumDataInformation* pData = data->asEnum();
QScriptValue ret = engine()->newObject();
QMapIterator<AllPrimitiveTypes, QString> it(pData-> enumValues()->values());
while(it.hasNext()) {
it.next();
ret.setProperty(it.value(), QString::number(it.key().value<quint64>())); //should always work
}
return ret;
}
else if (name == s_type)
{
return data->typeName();
}
return PrimitiveScriptClass::additionalProperty(data, name, id);
}
QScriptValue qtscript_create_QWhatsThis_class(QScriptEngine *engine)
{
engine->setDefaultPrototype(qMetaTypeId<QWhatsThis*>(), QScriptValue());
QScriptValue proto = engine->newVariant(qVariantFromValue((QWhatsThis*)0));
engine->setDefaultPrototype(qMetaTypeId<QWhatsThis*>(), proto);
QScriptValue ctor = engine->newFunction(qtscript_QWhatsThis_static_call, proto, qtscript_QWhatsThis_function_lengths[0]);
ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
for (int i = 0; i < 6; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QWhatsThis_static_call,
qtscript_QWhatsThis_function_lengths[i+1]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i+1)));
ctor.setProperty(QString::fromLatin1(qtscript_QWhatsThis_function_names[i+1]),
fun, QScriptValue::SkipInEnumeration);
}
return ctor;
}
//! [78]
QScriptValue getSet(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue obj = ctx->thisObject();
QScriptValue data = obj.data();
if (!data.isValid()) {
data = eng->newObject();
obj.setData(data);
}
QScriptValue result;
if (ctx->argumentCount() == 1) {
QString str = ctx->argument(0).toString();
str.replace("Roberta", "Ken");
result = str;
data.setProperty("x", result);
} else {
result = data.property("x");
}
return result;
}
QScriptValue qtscript_create_QGraphicsRectItem_class(QScriptEngine *engine)
{
engine->setDefaultPrototype(qMetaTypeId<QGraphicsRectItem*>(), QScriptValue());
QScriptValue proto = engine->newVariant(qVariantFromValue((QGraphicsRectItem*)0));
proto.setPrototype(engine->defaultPrototype(qMetaTypeId<QAbstractGraphicsShapeItem*>()));
for (int i = 0; i < 3; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QGraphicsRectItem_prototype_call, qtscript_QGraphicsRectItem_function_lengths[i+1]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
proto.setProperty(QString::fromLatin1(qtscript_QGraphicsRectItem_function_names[i+1]),
fun, QScriptValue::SkipInEnumeration);
}
engine->setDefaultPrototype(qMetaTypeId<QGraphicsRectItem*>(), proto);
QScriptValue ctor = engine->newFunction(qtscript_QGraphicsRectItem_static_call, proto, qtscript_QGraphicsRectItem_function_lengths[0]);
ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
return ctor;
}
QScriptValue qtscript_create_QXmlReader_class(QScriptEngine *engine)
{
static const int function_lengths[] = {
0
// static
// prototype
, 0
, 0
, 0
, 0
, 0
, 2
, 1
, 1
, 0
, 1
, 2
, 1
, 1
, 1
, 1
, 1
, 2
, 1
, 2
, 0
};
engine->setDefaultPrototype(qMetaTypeId<QXmlReader*>(), QScriptValue());
QScriptValue proto = engine->newVariant(qVariantFromValue((QXmlReader*)0));
for (int i = 0; i < 20; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QXmlReader_prototype_call, function_lengths[i+1]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
proto.setProperty(QString::fromLatin1(qtscript_QXmlReader_function_names[i+1]),
fun, QScriptValue::SkipInEnumeration);
}
engine->setDefaultPrototype(qMetaTypeId<QXmlReader*>(), proto);
QScriptValue ctor = engine->newFunction(qtscript_QXmlReader_static_call, proto, function_lengths[0]);
ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
return ctor;
}
static QScriptValue argumentsObjectInNative_test1(QScriptContext *ctx, QScriptEngine *eng)
{
#define VERIFY(statement) \
do {\
if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
return QString::fromLatin1("Failed " #statement);\
} while (0)
QScriptValue obj = ctx->argumentsObject();
VERIFY(obj.isObject());
VERIFY(obj.property(0).toUInt32() == 123);
VERIFY(obj.property(1).toString() == QString::fromLatin1("456"));
obj.setProperty(0, "abc");
VERIFY(eng->evaluate("arguments[0]").toString() == QString::fromLatin1("abc") );
return QString::fromLatin1("success");
#undef VERIFY
}
QScriptValue AdditionalDataRequest::toScriptValue( QScriptEngine *engine ) const
{
QScriptValue value = engine->newObject();
value.setProperty( QLatin1String("stop"), m_stop );
value.setProperty( QLatin1String("city"), m_city );
value.setProperty( QLatin1String("dataType"),
m_sourceName.startsWith(QLatin1String("Arrivals"), Qt::CaseInsensitive)
? parseModeName(ParseForArrivals) : parseModeName(ParseForDepartures));
value.setProperty( QLatin1String("transportLine"), m_transportLine );
value.setProperty( QLatin1String("target"), m_target );
value.setProperty( QLatin1String("dateTime"), engine->newDate(m_dateTime) );
value.setProperty( QLatin1String("routeDataUrl"), m_routeDataUrl );
return value;
}
static QScriptValue toBattleChoice(QScriptEngine *e, const BattleChoice& info) {
QScriptValue v = e->newObject();
v.setProperty("type", bchoices.count() > info.type ? bchoices[info.type] : "unknown");
v.setProperty("slot", int(info.slot()));
if (info.attackingChoice()) {
v.setProperty("attackSlot", int(info.attackSlot()));
v.setProperty("target", int(info.target()));
} else if (info.switchChoice()) {
v.setProperty("pokeSlot", int(info.pokeSlot()));
} else if (info.rearrangeChoice()) {
QScriptValue v2 = e->newArray();
for (int i = 0; i < 6; i++) {
v2.setProperty(i, int(info.choice.rearrange.pokeIndexes[i]));
}
v.setProperty("neworder", v2);
} else if (info.itemChoice()) {
v.setProperty("item", info.item());
v.setProperty("target", info.itemTarget());
v.setProperty("attack", info.itemAttack());
}
return v;
}
QScriptValue PHISRequestObj::initObject( QScriptEngine *engine, const QString &mod )
{
QScriptValue request=PHISScriptObj::initObject( engine, mod );
QScriptValue arr=engine->newArray();
QStringList values, keys;
QString value, key, props=QStringLiteral( "properties" );
int i=0, l;
QScriptValue sv=engine->newObject();
QScriptValue subarr;
request.setProperty( QStringLiteral( "post" ), sv );
keys=PHIS_IF()->postKeys();
foreach( key, keys ) {
values=PHIS_IF()->postValues( key );
subarr=engine->newArray();
l=0;
foreach ( value, values ) subarr.setProperty( l++, value );
sv.setProperty( key, subarr );
arr.setProperty( i++, key );
}
static QScriptValue js_enumGroup(QScriptContext *context, QScriptEngine *engine)
{
int groupId = context->argument(0).toInt32();
QList<DROID *> matches;
DROID_GROUP *psGroup = grpFind(groupId);
DROID *psCurr;
SCRIPT_ASSERT(context, psGroup, "Invalid group index %d", groupId);
for (psCurr = psGroup->psList; psCurr != NULL; psCurr = psCurr->psGrpNext)
{
matches.push_back(psCurr);
}
QScriptValue result = engine->newArray(matches.size());
for (int i = 0; i < matches.size(); i++)
{
DROID *psDroid = matches.at(i);
result.setProperty(i, convDroid(psDroid, engine));
}
return result;
}
QScriptValue qtscript_create_QProgressDialog_class(QScriptEngine *engine)
{
engine->setDefaultPrototype(qMetaTypeId<QProgressDialog*>(), QScriptValue());
QScriptValue proto = engine->newVariant(qVariantFromValue((QProgressDialog*)0));
proto.setPrototype(engine->defaultPrototype(qMetaTypeId<QDialog*>()));
for (int i = 0; i < 5; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QProgressDialog_prototype_call, qtscript_QProgressDialog_function_lengths[i+1]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
proto.setProperty(QString::fromLatin1(qtscript_QProgressDialog_function_names[i+1]),
fun, QScriptValue::SkipInEnumeration);
}
qScriptRegisterMetaType<QProgressDialog*>(engine, qtscript_QProgressDialog_toScriptValue,
qtscript_QProgressDialog_fromScriptValue, proto);
QScriptValue ctor = engine->newFunction(qtscript_QProgressDialog_static_call, proto, qtscript_QProgressDialog_function_lengths[0]);
ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
return ctor;
}
void setupCLineEdit(QScriptEngine *engine)
{
QScriptValue widget = engine->newObject();
widget.setProperty("AllCustomers", QScriptValue(engine, CLineEdit::AllCustomers), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ActiveCustomers", QScriptValue(engine, CLineEdit::ActiveCustomers), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("AllProspects", QScriptValue(engine, CLineEdit::AllProspects), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ActiveProspects", QScriptValue(engine, CLineEdit::ActiveProspects), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("AllCustomersAndProspects", QScriptValue(engine, CLineEdit::AllCustomersAndProspects), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ActiveCustomersAndProspects",QScriptValue(engine, CLineEdit::ActiveCustomersAndProspects),QScriptValue::ReadOnly | QScriptValue::Undeletable);
engine->globalObject().setProperty("CLineEdit", widget, QScriptValue::ReadOnly | QScriptValue::Undeletable);
qScriptRegisterMetaType(engine, CLineEditTypesToScriptValue, CLineEditTypesFromScriptValue);
}
QScriptValue ScriptEngine::dirsForDirectory (const QString &dir_)
{
QString dir = dir_;
QDir directory(dir);
if(!directory.exists()) {
return myengine.undefinedValue();
}
QStringList dirs = directory.entryList(QDir::Dirs);
QScriptValue ret = myengine.newArray(dirs.size());
for (int i = 0; i < dirs.size(); i++) {
if (dirs[i] != "." && dirs[i] != "..") {
ret.setProperty(i, dirs[i]);
}
}
return ret;
}
NResponse & NTcpServerSocketMusicServices::getArtist(const NClientSession & session,
NResponse & response)
{
bool ok;
QString search = session.url().queryItemValue("search");
QStringList searches = search.split("+", QString::SkipEmptyParts);
searches = NConvert_n::fromUTF8PercentEncoding(searches);
int start = session.url().queryItemValue("start").toInt();
int limit = session.url().queryItemValue("limit").toInt(&ok);
if (!ok)
limit = 25;
QString dir = session.url().queryItemValue("dir");
int year = session.url().queryItemValue("year").toInt(&ok);
if (!ok)
year = -1;
QString genre;
if(session.url().hasQueryItem("genre"))// Cos of NULL test
{
genre = session.url().queryItemValue("genre");
if (genre.isNull())
genre = "";
genre = NConvert_n::fromUTF8PercentEncoding(genre);
}
const NTcpServerAuthSession authSession = getAuthServices().getSession(session.sessionId());
logMessage(session.socket()->peerAddress().toString(),
QString("%1 is looking for artist: \"%2\"; start: %3; limit: %4, dir:\"%5\"").
arg(authSession.login()).arg(NConvert_n::fromUTF8PercentEncoding(search)).arg(start).arg(limit).arg(dir));
int totalCount = NMDB.getArtistListCount(searches, year, genre);
QScriptEngine se;
QScriptValue svRoot = se.newObject();
QScriptValue svData = se.newArray(totalCount);
svRoot.setProperty(RSP_DATA, svData);
bool succeed = NMDB.getArtistList(se, svData, totalCount, searches, start, limit, dir, year, genre);
setJsonRootReponse(svRoot, totalCount, succeed);
response.setData(NJson::serializeToQByteArray(svRoot));
return response;
}
void ScriptEngine::setObservedProperty(QScriptValue &object, const QString &name,
const QScriptValue &value, ScriptPropertyObserver *observer)
{
if (!observer) {
object.setProperty(name, value);
return;
}
QScriptValue data = newArray();
data.setProperty(0, object);
data.setProperty(1, name);
data.setProperty(2, value);
QScriptValue getterFunc = newFunction(js_observedGet, observer);
getterFunc.setProperty(QLatin1String("qbsdata"), data);
object.setProperty(name, getterFunc, QScriptValue::PropertyGetter);
}
QScriptDeclarativeClass::Value MetaCallArgument::toValue(QDeclarativeEngine *e)
{
QScriptEngine *engine = QDeclarativeEnginePrivate::getScriptEngine(e);
if (type == qMetaTypeId<QScriptValue>()) {
return QScriptDeclarativeClass::Value(engine, *((QScriptValue *)&data));
} else if (type == QMetaType::Int) {
return QScriptDeclarativeClass::Value(engine, *((int *)&data));
} else if (type == QMetaType::UInt) {
return QScriptDeclarativeClass::Value(engine, *((uint *)&data));
} else if (type == QMetaType::Bool) {
return QScriptDeclarativeClass::Value(engine, *((bool *)&data));
} else if (type == QMetaType::Double) {
return QScriptDeclarativeClass::Value(engine, *((double *)&data));
} else if (type == QMetaType::Float) {
return QScriptDeclarativeClass::Value(engine, *((float *)&data));
} else if (type == QMetaType::QString) {
return QScriptDeclarativeClass::Value(engine, *((QString *)&data));
} else if (type == QMetaType::QObjectStar) {
QObject *object = *((QObject **)&data);
QDeclarativeData::get(object, true)->setImplicitDestructible();
QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
return QScriptDeclarativeClass::Value(engine, priv->objectClass->newQObject(object));
} else if (type == qMetaTypeId<QList<QObject *> >()) {
QList<QObject *> &list = *(QList<QObject *>*)&data;
QScriptValue rv = engine->newArray(list.count());
QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(e);
for (int ii = 0; ii < list.count(); ++ii) {
QObject *object = list.at(ii);
QDeclarativeData::get(object, true)->setImplicitDestructible();
rv.setProperty(ii, priv->objectClass->newQObject(object));
}
return QScriptDeclarativeClass::Value(engine, rv);
} else if (type == -1 || type == qMetaTypeId<QVariant>()) {
return QScriptDeclarativeClass::Value(engine, QDeclarativeEnginePrivate::get(e)->scriptValueFromVariant(*((QVariant *)&data)));
} else {
return QScriptDeclarativeClass::Value();
}
}
QScriptValue OverlayPanel::getProperty(const QString &property) {
if (property == "anchorPosition") {
return vec3toScriptValue(_scriptEngine, getAnchorPosition());
}
if (property == "anchorPositionBinding") {
return propertyBindingToScriptValue(_scriptEngine,
PropertyBinding(_anchorPositionBindMyAvatar ?
"MyAvatar" : "",
_anchorPositionBindEntity));
}
if (property == "anchorRotation") {
return quatToScriptValue(_scriptEngine, getAnchorRotation());
}
if (property == "anchorRotationBinding") {
return propertyBindingToScriptValue(_scriptEngine,
PropertyBinding(_anchorRotationBindMyAvatar ?
"MyAvatar" : "",
_anchorRotationBindEntity));
}
if (property == "anchorScale") {
return vec3toScriptValue(_scriptEngine, getAnchorScale());
}
if (property == "visible") {
return getVisible();
}
if (property == "children") {
QScriptValue array = _scriptEngine->newArray(_children.length());
for (int i = 0; i < _children.length(); i++) {
array.setProperty(i, _children[i]);
}
return array;
}
QScriptValue value = Billboardable::getProperty(_scriptEngine, property);
if (value.isValid()) {
return value;
}
return PanelAttachable::getProperty(_scriptEngine, property);
}
QScriptValue register_LCG_prototype(QScriptEngine *engine)
{
QScriptValue proto = engine->newObject();
proto.setProperty("Seed", engine->newFunction(LCG_Seed_u32_u32_u32_u32, 4), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("Int", engine->newFunction(LCG_Int_selector, 0), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("MaxInt", engine->newFunction(LCG_MaxInt_const, 0), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("IntFast", engine->newFunction(LCG_IntFast, 0), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("Int", engine->newFunction(LCG_Int_selector, 2), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("Float", engine->newFunction(LCG_Float_selector, 0), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("Float", engine->newFunction(LCG_Float_selector, 2), QScriptValue::Undeletable | QScriptValue::ReadOnly);
proto.setProperty("metaTypeId", engine->toScriptValue<qint32>((qint32)qMetaTypeId<LCG>()));
engine->setDefaultPrototype(qMetaTypeId<LCG>(), proto);
engine->setDefaultPrototype(qMetaTypeId<LCG*>(), proto);
qScriptRegisterMetaType(engine, ToScriptValue_LCG, FromScriptValue_LCG, proto);
QScriptValue ctor = engine->newFunction(LCG_ctor, proto, 4);
engine->globalObject().setProperty("LCG", ctor, QScriptValue::Undeletable | QScriptValue::ReadOnly);
return ctor;
}
NResponse & NTcpServerSocketUserServices::getUser(const NClientSession & session, NResponse & response)
{
bool ok;
int start = session.url().queryItemValue("start").toInt();
if (!ok)
start = 0;
int limit = session.url().queryItemValue("limit").toInt(&ok);
if (!ok)
limit = 25;
QString dir = session.url().queryItemValue("dir");
QString sort = session.url().queryItemValue("sort");
QString search = session.url().queryItemValue("search");
QStringList searches = search.split("+", QString::SkipEmptyParts);
searches = NConvert_n::fromUTF8PercentEncoding(searches);
const NTcpServerAuthSession authSession = getAuthServices().getSession(session.sessionId());
logMessage(session.socket()->peerAddress().toString(),
QString("%1 is looking for users: \"%2\"; start: %3; limit: %4, sort:\"%5\", dir:\"%6\"").
arg(authSession.login()). // 1
arg(NConvert_n::fromUTF8PercentEncoding(search)).// 2
arg(start).// 3
arg(limit).// 4
arg(sort).// 5
arg(dir));// 6
int totalCount = NDB.getUserListCount(searches);
QScriptEngine se;
QScriptValue svRoot = se.newObject();
QScriptValue svData = se.newArray(totalCount);
svRoot.setProperty(RSP_DATA, svData);
bool succeed = NDB.getUserList(se, svData, searches, start, limit, sort, dir);
setJsonRootReponse(svRoot, totalCount, succeed);
response.setData(NJson::serializeToQByteArray(svRoot));
return response;
}
static QScriptValue js_enumStruct(QScriptContext *context, QScriptEngine *engine)
{
QList<STRUCTURE *> matches;
int player = -1, looking = -1;
QString statsName;
switch (context->argumentCount())
{
default:
case 3:
looking = context->argument(2).toInt32(); // fall-through
case 2:
statsName = context->argument(1).toString(); // fall-through
case 1:
player = context->argument(0).toInt32();
break;
case 0:
player = engine->globalObject().property("me").toInt32();
}
SCRIPT_ASSERT(context, player < MAX_PLAYERS && player >= 0, "Target player index out of range: %d", player);
SCRIPT_ASSERT(context, looking < MAX_PLAYERS && looking >= -1, "Looking player index out of range: %d", looking);
for (STRUCTURE *psStruct = apsStructLists[player]; psStruct; psStruct = psStruct->psNext)
{
if ((looking == -1 || psStruct->visible[looking])
&& (statsName.isEmpty() || statsName.compare(psStruct->pStructureType->pName) == 0))
{
matches.push_back(psStruct);
}
}
QScriptValue result = engine->newArray(matches.size());
for (int i = 0; i < matches.size(); i++)
{
STRUCTURE *psStruct = matches.at(i);
result.setProperty(i, convStructure(psStruct, engine));
}
return result;
}
static QScriptValue js_enumDroid(QScriptContext *context, QScriptEngine *engine)
{
QList<DROID *> matches;
int player = -1, looking = -1;
DROID_TYPE droidType = DROID_ANY;
switch (context->argumentCount())
{
default:
case 3:
looking = context->argument(2).toInt32(); // fall-through
case 2:
droidType = (DROID_TYPE)context->argument(1).toInt32(); // fall-through
case 1:
player = context->argument(0).toInt32();
break;
case 0:
player = engine->globalObject().property("me").toInt32();
}
SCRIPT_ASSERT(context, player < MAX_PLAYERS && player >= 0, "Target player index out of range: %d", player);
SCRIPT_ASSERT(context, looking < MAX_PLAYERS && looking >= -1, "Looking player index out of range: %d", looking);
for (DROID *psDroid = apsDroidLists[player]; psDroid; psDroid = psDroid->psNext)
{
if ((looking == -1 || psDroid->visible[looking]) && (droidType == DROID_ANY || droidType == psDroid->droidType))
{
matches.push_back(psDroid);
}
}
QScriptValue result = engine->newArray(matches.size());
for (int i = 0; i < matches.size(); i++)
{
DROID *psDroid = matches.at(i);
result.setProperty(i, convDroid(psDroid, engine));
}
return result;
}
QScriptValue TextOverlay::getProperty(const QString& property) {
if (property == "font") {
QScriptValue font = _scriptEngine->newObject();
font.setProperty("size", _fontSize);
return font;
}
if (property == "text") {
return _text;
}
if (property == "backgroundColor") {
return xColorToScriptValue(_scriptEngine, _backgroundColor);
}
if (property == "backgroundAlpha") {
return _backgroundAlpha;
}
if (property == "leftMargin") {
return _leftMargin;
}
if (property == "topMargin") {
return _topMargin;
}
return Overlay2D::getProperty(property);
}
NResponse & NTcpServerSocketCfgServices::getAvailableLevelList(NResponse & response)
{
QScriptEngine se;
QScriptValue svRoot = se.newObject();
QStringList levels = NTcpServerAuthSession::toStringLevel(AUTH_LEVEL_ADMIN, " ").split(" ");
svRoot.setProperty(RSP_SUCCESS , QScriptValue(levels.count() > 0));
svRoot.setProperty(RSP_MSG, QScriptValue(levels.count() > 0 ? RSP_MSG_LOADED : RSP_MSG_NO_RESULTS));
svRoot.setProperty(RSP_COUNT, QScriptValue(levels.count()));
QScriptValue svData = se.newArray(levels.count());
svRoot.setProperty(RSP_DATA, svData);
for(int i = 0; i < levels.count(); i++)
{
QScriptValue svLevel = se.newObject();
svData.setProperty(i, svLevel);
svLevel.setProperty("id", NTcpServerAuthSession::toIntLevel(levels.at(i)));
svLevel.setProperty("level", levels.at(i));
}
response.setData(NJson::serializeToQByteArray(svRoot));
return response;
}
static QScriptValue setupDBusInterface(QScriptEngine *engine, QDBusAbstractInterface *iface)
{
QScriptValue v = engine->newQObject(iface);
if (!qobject_cast<QDBusConnectionInterface *>(iface)) {
const QMetaObject *mo = iface->metaObject();
for (int i = 0; i < mo->methodCount(); ++i) {
const QMetaMethod method = mo->method(i);
const QByteArray signature = method.methodSignature();
//qDebug() << "signature" << signature;
int parenIndex = signature.indexOf('(');
if (parenIndex == -1)
continue;
const QByteArray name = signature.left(parenIndex);
if (name.isEmpty())
continue;
// don't try to override properties
if (mo->indexOfProperty(name) != -1)
continue;
QScriptValue callWrapper = engine->newFunction(do_dbus_call);
const QString nameString = QString::fromLatin1(name);
callWrapper.setProperty(QLatin1String("functionName"), QScriptValue(engine, nameString));
v.setProperty(nameString, callWrapper);
}
}
v.setProperty(QLatin1String("service"), QScriptValue(engine, iface->service()), QScriptValue::ReadOnly);
v.setProperty(QLatin1String("path"), QScriptValue(engine, iface->path()), QScriptValue::ReadOnly);
v.setProperty(QLatin1String("interface"), QScriptValue(engine, iface->interface()), QScriptValue::ReadOnly);
v.setProperty(QLatin1String("isValid"), QScriptValue(engine, iface->isValid()), QScriptValue::ReadOnly);
v.setProperty(QLatin1String("connection"), engine->newQObject(new QScriptDBusConnection(iface->connection(), engine)), QScriptValue::ReadOnly);
return v;
}
QScriptDBusInterfaceConstructor::QScriptDBusInterfaceConstructor(QScriptEngine *engine, QScriptValue extensionObject)
{
QScriptValue ctorValue = engine->newQObject(this);
QScriptValue klass = engine->newQMetaObject(metaObject(), ctorValue);
extensionObject.setProperty(QLatin1String("QDBusInterface"), klass);
}
void setupComments(QScriptEngine *engine)
{
QScriptValue widget = engine->newObject();
widget.setProperty("Uninitialized", QScriptValue(engine, Comments::Uninitialized), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Address", QScriptValue(engine, Comments::Address), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("BBOMHead", QScriptValue(engine, Comments::BBOMHead), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("BBOMItem", QScriptValue(engine, Comments::BBOMItem), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("BOMHead", QScriptValue(engine, Comments::BOMHead), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("BOMItem", QScriptValue(engine, Comments::BOMItem), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("BOOHead", QScriptValue(engine, Comments::BOOHead), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("BOOItem", QScriptValue(engine, Comments::BOOItem), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("CRMAccount", QScriptValue(engine, Comments::CRMAccount), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Contact", QScriptValue(engine, Comments::Contact), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Customer", QScriptValue(engine, Comments::Customer), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Employee", QScriptValue(engine, Comments::Employee), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Incident", QScriptValue(engine, Comments::Incident), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Item", QScriptValue(engine, Comments::Item), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ItemSite", QScriptValue(engine, Comments::ItemSite), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ItemSource", QScriptValue(engine, Comments::ItemSource), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Location", QScriptValue(engine, Comments::Location), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("LotSerial", QScriptValue(engine, Comments::LotSerial), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Opportunity", QScriptValue(engine, Comments::Opportunity), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Project", QScriptValue(engine, Comments::Project), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("PurchaseOrder", QScriptValue(engine, Comments::PurchaseOrder), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("PurchaseOrderItem",QScriptValue(engine, Comments::PurchaseOrderItem),QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ReturnAuth", QScriptValue(engine, Comments::ReturnAuth), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("ReturnAuthItem", QScriptValue(engine, Comments::ReturnAuthItem), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Quote", QScriptValue(engine, Comments::Quote), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("QuoteItem", QScriptValue(engine, Comments::QuoteItem), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("SalesOrder", QScriptValue(engine, Comments::SalesOrder), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("SalesOrderItem", QScriptValue(engine, Comments::SalesOrderItem), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("TransferOrder", QScriptValue(engine, Comments::TransferOrder), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("TransferOrderItem",QScriptValue(engine, Comments::TransferOrderItem),QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Vendor", QScriptValue(engine, Comments::Vendor), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("Warehouse", QScriptValue(engine, Comments::Warehouse), QScriptValue::ReadOnly | QScriptValue::Undeletable);
widget.setProperty("WorkOrder", QScriptValue(engine, Comments::WorkOrder), QScriptValue::ReadOnly | QScriptValue::Undeletable);
engine->globalObject().setProperty("Comments", widget, QScriptValue::ReadOnly | QScriptValue::Undeletable);
}
void REcmaDimLinearEntity::init(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RDimLinearEntity*) 0)));
protoCreated = true;
}
// primary base class RDimensionEntity:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RDimensionEntity*>());
if (dpt.isValid()) {
proto->setPrototype(dpt);
}
/*
*/
QScriptValue fun;
// toString:
REcmaHelper::registerFunction(&engine, proto, toString, "toString");
// destroy:
REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
// conversion for base class RDimensionEntity
REcmaHelper::registerFunction(&engine, proto, getRDimensionEntity, "getRDimensionEntity");
// conversion for base class REntity
REcmaHelper::registerFunction(&engine, proto, getREntity, "getREntity");
// conversion for base class RObject
REcmaHelper::registerFunction(&engine, proto, getRObject, "getRObject");
// get class name
REcmaHelper::registerFunction(&engine, proto, getClassName, "getClassName");
// conversion to all base classes (multiple inheritance):
REcmaHelper::registerFunction(&engine, proto, getBaseClasses, "getBaseClasses");
// properties:
// methods:
REcmaHelper::registerFunction(&engine, proto, setProperty, "setProperty");
REcmaHelper::registerFunction(&engine, proto, getProperty, "getProperty");
REcmaHelper::registerFunction(&engine, proto, getData, "getData");
REcmaHelper::registerFunction(&engine, proto, setExtensionPoint1, "setExtensionPoint1");
REcmaHelper::registerFunction(&engine, proto, getExtensionPoint1, "getExtensionPoint1");
REcmaHelper::registerFunction(&engine, proto, setExtensionPoint2, "setExtensionPoint2");
REcmaHelper::registerFunction(&engine, proto, getExtensionPoint2, "getExtensionPoint2");
engine.setDefaultPrototype(
qMetaTypeId<RDimLinearEntity*>(), *proto);
QScriptValue ctor = engine.newFunction(create, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, init, "init");
// static properties:
ctor.setProperty("PropertyCustom",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyCustom),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyHandle",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyHandle),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyType",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyType),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyBlock",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyBlock),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLayer",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyLayer),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLinetype",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyLinetype),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLineweight",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyLineweight),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyColor",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyColor),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDrawOrder",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyDrawOrder),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMiddleOfTextX",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyMiddleOfTextX),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMiddleOfTextY",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyMiddleOfTextY),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMiddleOfTextZ",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyMiddleOfTextZ),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyText",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyText),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyUpperTolerance",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyUpperTolerance),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLowerTolerance",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyLowerTolerance),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDimensionLinePosX",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyDimensionLinePosX),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDimensionLinePosY",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyDimensionLinePosY),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDimensionLinePosZ",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyDimensionLinePosZ),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyExtensionPoint1X",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyExtensionPoint1X),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyExtensionPoint1Y",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyExtensionPoint1Y),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyExtensionPoint1Z",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyExtensionPoint1Z),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyExtensionPoint2X",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyExtensionPoint2X),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyExtensionPoint2Y",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyExtensionPoint2Y),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyExtensionPoint2Z",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyExtensionPoint2Z),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RDimLinearEntity",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void setupQEventProto(QScriptEngine *engine)
{
QScriptValue proto = engine->newQObject(new QEventProto(engine));
engine->setDefaultPrototype(qMetaTypeId<QEvent*>(), proto);
QScriptValue constructor = engine->newFunction(constructQEvent, proto);
engine->globalObject().setProperty("QEvent", constructor);
constructor.setProperty("None", QScriptValue(engine, QEvent::None), ENUMPROPFLAGS);
constructor.setProperty("ActionAdded", QScriptValue(engine, QEvent::ActionAdded), ENUMPROPFLAGS);
constructor.setProperty("ActionChanged", QScriptValue(engine, QEvent::ActionChanged), ENUMPROPFLAGS);
constructor.setProperty("ActivationChange", QScriptValue(engine, QEvent::ActivationChange), ENUMPROPFLAGS);
constructor.setProperty("ApplicationActivate", QScriptValue(engine, QEvent::ApplicationActivate), ENUMPROPFLAGS);
constructor.setProperty("ApplicationActivated", QScriptValue(engine, QEvent::ApplicationActivated), ENUMPROPFLAGS);
constructor.setProperty("ApplicationDeactivate", QScriptValue(engine, QEvent::ApplicationDeactivate), ENUMPROPFLAGS);
constructor.setProperty("ApplicationFontChange", QScriptValue(engine, QEvent::ApplicationFontChange), ENUMPROPFLAGS);
constructor.setProperty("ApplicationLayoutDirectionChange", QScriptValue(engine, QEvent::ApplicationLayoutDirectionChange), ENUMPROPFLAGS);
constructor.setProperty("ApplicationPaletteChange", QScriptValue(engine, QEvent::ApplicationPaletteChange), ENUMPROPFLAGS);
constructor.setProperty("ApplicationStateChange", QScriptValue(engine, QEvent::ApplicationStateChange), ENUMPROPFLAGS);
constructor.setProperty("ApplicationWindowIconChange", QScriptValue(engine, QEvent::ApplicationWindowIconChange), ENUMPROPFLAGS);
constructor.setProperty("ChildAdded", QScriptValue(engine, QEvent::ChildAdded), ENUMPROPFLAGS);
constructor.setProperty("ChildPolished", QScriptValue(engine, QEvent::ChildPolished), ENUMPROPFLAGS);
constructor.setProperty("ChildRemoved", QScriptValue(engine, QEvent::ChildRemoved), ENUMPROPFLAGS);
constructor.setProperty("Clipboard", QScriptValue(engine, QEvent::Clipboard), ENUMPROPFLAGS);
constructor.setProperty("Close", QScriptValue(engine, QEvent::Close), ENUMPROPFLAGS);
constructor.setProperty("CloseSoftwareInputPanel", QScriptValue(engine, QEvent::CloseSoftwareInputPanel), ENUMPROPFLAGS);
constructor.setProperty("ContentsRectChange", QScriptValue(engine, QEvent::ContentsRectChange), ENUMPROPFLAGS);
constructor.setProperty("ContextMenu", QScriptValue(engine, QEvent::ContextMenu), ENUMPROPFLAGS);
constructor.setProperty("CursorChange", QScriptValue(engine, QEvent::CursorChange), ENUMPROPFLAGS);
constructor.setProperty("DeferredDelete", QScriptValue(engine, QEvent::DeferredDelete), ENUMPROPFLAGS);
constructor.setProperty("DragEnter", QScriptValue(engine, QEvent::DragEnter), ENUMPROPFLAGS);
constructor.setProperty("DragLeave", QScriptValue(engine, QEvent::DragLeave), ENUMPROPFLAGS);
constructor.setProperty("DragMove", QScriptValue(engine, QEvent::DragMove), ENUMPROPFLAGS);
constructor.setProperty("Drop", QScriptValue(engine, QEvent::Drop), ENUMPROPFLAGS);
constructor.setProperty("DynamicPropertyChange", QScriptValue(engine, QEvent::DynamicPropertyChange), ENUMPROPFLAGS);
constructor.setProperty("EnabledChange", QScriptValue(engine, QEvent::EnabledChange), ENUMPROPFLAGS);
constructor.setProperty("Enter", QScriptValue(engine, QEvent::Enter), ENUMPROPFLAGS);
#ifdef QT_KEYPAD_NAVIGATION
constructor.setProperty("EnterEditFocus", QScriptValue(engine, QEvent::EnterEditFocus), ENUMPROPFLAGS);
#endif
constructor.setProperty("EnterWhatsThisMode", QScriptValue(engine, QEvent::EnterWhatsThisMode), ENUMPROPFLAGS);
constructor.setProperty("Expose", QScriptValue(engine, QEvent::Expose), ENUMPROPFLAGS);
constructor.setProperty("FileOpen", QScriptValue(engine, QEvent::FileOpen), ENUMPROPFLAGS);
constructor.setProperty("FocusIn", QScriptValue(engine, QEvent::FocusIn), ENUMPROPFLAGS);
constructor.setProperty("FocusOut", QScriptValue(engine, QEvent::FocusOut), ENUMPROPFLAGS);
constructor.setProperty("FocusAboutToChange", QScriptValue(engine, QEvent::FocusAboutToChange), ENUMPROPFLAGS);
constructor.setProperty("FontChange", QScriptValue(engine, QEvent::FontChange), ENUMPROPFLAGS);
constructor.setProperty("Gesture", QScriptValue(engine, QEvent::Gesture), ENUMPROPFLAGS);
constructor.setProperty("GestureOverride", QScriptValue(engine, QEvent::GestureOverride), ENUMPROPFLAGS);
constructor.setProperty("GrabKeyboard", QScriptValue(engine, QEvent::GrabKeyboard), ENUMPROPFLAGS);
constructor.setProperty("GrabMouse", QScriptValue(engine, QEvent::GrabMouse), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneContextMenu", QScriptValue(engine, QEvent::GraphicsSceneContextMenu), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneDragEnter", QScriptValue(engine, QEvent::GraphicsSceneDragEnter), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneDragLeave", QScriptValue(engine, QEvent::GraphicsSceneDragLeave), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneDragMove", QScriptValue(engine, QEvent::GraphicsSceneDragMove), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneDrop", QScriptValue(engine, QEvent::GraphicsSceneDrop), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneHelp", QScriptValue(engine, QEvent::GraphicsSceneHelp), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneHoverEnter", QScriptValue(engine, QEvent::GraphicsSceneHoverEnter), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneHoverLeave", QScriptValue(engine, QEvent::GraphicsSceneHoverLeave), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneHoverMove", QScriptValue(engine, QEvent::GraphicsSceneHoverMove), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneMouseDoubleClick", QScriptValue(engine, QEvent::GraphicsSceneMouseDoubleClick), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneMouseMove", QScriptValue(engine, QEvent::GraphicsSceneMouseMove), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneMousePress", QScriptValue(engine, QEvent::GraphicsSceneMousePress), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneMouseRelease", QScriptValue(engine, QEvent::GraphicsSceneMouseRelease), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneMove", QScriptValue(engine, QEvent::GraphicsSceneMove), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneResize", QScriptValue(engine, QEvent::GraphicsSceneResize), ENUMPROPFLAGS);
constructor.setProperty("GraphicsSceneWheel", QScriptValue(engine, QEvent::GraphicsSceneWheel), ENUMPROPFLAGS);
constructor.setProperty("Hide", QScriptValue(engine, QEvent::Hide), ENUMPROPFLAGS);
constructor.setProperty("HideToParent", QScriptValue(engine, QEvent::HideToParent), ENUMPROPFLAGS);
constructor.setProperty("HoverEnter", QScriptValue(engine, QEvent::HoverEnter), ENUMPROPFLAGS);
constructor.setProperty("HoverLeave", QScriptValue(engine, QEvent::HoverLeave), ENUMPROPFLAGS);
constructor.setProperty("HoverMove", QScriptValue(engine, QEvent::HoverMove), ENUMPROPFLAGS);
constructor.setProperty("IconDrag", QScriptValue(engine, QEvent::IconDrag), ENUMPROPFLAGS);
constructor.setProperty("IconTextChange", QScriptValue(engine, QEvent::IconTextChange), ENUMPROPFLAGS);
constructor.setProperty("InputMethod", QScriptValue(engine, QEvent::InputMethod), ENUMPROPFLAGS);
constructor.setProperty("InputMethodQuery", QScriptValue(engine, QEvent::InputMethodQuery), ENUMPROPFLAGS);
constructor.setProperty("KeyboardLayoutChange", QScriptValue(engine, QEvent::KeyboardLayoutChange), ENUMPROPFLAGS);
constructor.setProperty("KeyPress", QScriptValue(engine, QEvent::KeyPress), ENUMPROPFLAGS);
constructor.setProperty("KeyRelease", QScriptValue(engine, QEvent::KeyRelease), ENUMPROPFLAGS);
constructor.setProperty("LanguageChange", QScriptValue(engine, QEvent::LanguageChange), ENUMPROPFLAGS);
constructor.setProperty("LayoutDirectionChange", QScriptValue(engine, QEvent::LayoutDirectionChange), ENUMPROPFLAGS);
constructor.setProperty("LayoutRequest", QScriptValue(engine, QEvent::LayoutRequest), ENUMPROPFLAGS);
constructor.setProperty("Leave", QScriptValue(engine, QEvent::Leave), ENUMPROPFLAGS);
#ifdef QT_KEYPAD_NAVIGATION
constructor.setProperty("LeaveEditFocus", QScriptValue(engine, QEvent::LeaveEditFocus), ENUMPROPFLAGS);
#endif
constructor.setProperty("LeaveWhatsThisMode", QScriptValue(engine, QEvent::LeaveWhatsThisMode), ENUMPROPFLAGS);
constructor.setProperty("LocaleChange", QScriptValue(engine, QEvent::LocaleChange), ENUMPROPFLAGS);
constructor.setProperty("NonClientAreaMouseButtonDblClick", QScriptValue(engine, QEvent::NonClientAreaMouseButtonDblClick), ENUMPROPFLAGS);
constructor.setProperty("NonClientAreaMouseButtonPress", QScriptValue(engine, QEvent::NonClientAreaMouseButtonPress), ENUMPROPFLAGS);
constructor.setProperty("NonClientAreaMouseButtonRelease", QScriptValue(engine, QEvent::NonClientAreaMouseButtonRelease), ENUMPROPFLAGS);
constructor.setProperty("NonClientAreaMouseMove", QScriptValue(engine, QEvent::NonClientAreaMouseMove), ENUMPROPFLAGS);
constructor.setProperty("MacSizeChange", QScriptValue(engine, QEvent::MacSizeChange), ENUMPROPFLAGS);
constructor.setProperty("MetaCall", QScriptValue(engine, QEvent::MetaCall), ENUMPROPFLAGS);
constructor.setProperty("ModifiedChange", QScriptValue(engine, QEvent::ModifiedChange), ENUMPROPFLAGS);
constructor.setProperty("MouseButtonDblClick", QScriptValue(engine, QEvent::MouseButtonDblClick), ENUMPROPFLAGS);
constructor.setProperty("MouseButtonPress", QScriptValue(engine, QEvent::MouseButtonPress), ENUMPROPFLAGS);
constructor.setProperty("MouseButtonRelease", QScriptValue(engine, QEvent::MouseButtonRelease), ENUMPROPFLAGS);
constructor.setProperty("MouseMove", QScriptValue(engine, QEvent::MouseMove), ENUMPROPFLAGS);
constructor.setProperty("MouseTrackingChange", QScriptValue(engine, QEvent::MouseTrackingChange), ENUMPROPFLAGS);
constructor.setProperty("Move", QScriptValue(engine, QEvent::Move), ENUMPROPFLAGS);
constructor.setProperty("NativeGesture", QScriptValue(engine, QEvent::NativeGesture), ENUMPROPFLAGS);
constructor.setProperty("OrientationChange", QScriptValue(engine, QEvent::OrientationChange), ENUMPROPFLAGS);
constructor.setProperty("Paint", QScriptValue(engine, QEvent::Paint), ENUMPROPFLAGS);
constructor.setProperty("PaletteChange", QScriptValue(engine, QEvent::PaletteChange), ENUMPROPFLAGS);
constructor.setProperty("ParentAboutToChange", QScriptValue(engine, QEvent::ParentAboutToChange), ENUMPROPFLAGS);
constructor.setProperty("ParentChange", QScriptValue(engine, QEvent::ParentChange), ENUMPROPFLAGS);
constructor.setProperty("PlatformPanel", QScriptValue(engine, QEvent::PlatformPanel), ENUMPROPFLAGS);
constructor.setProperty("PlatformSurface", QScriptValue(engine, QEvent::PlatformSurface), ENUMPROPFLAGS);
constructor.setProperty("Polish", QScriptValue(engine, QEvent::Polish), ENUMPROPFLAGS);
constructor.setProperty("PolishRequest", QScriptValue(engine, QEvent::PolishRequest), ENUMPROPFLAGS);
constructor.setProperty("QueryWhatsThis", QScriptValue(engine, QEvent::QueryWhatsThis), ENUMPROPFLAGS);
constructor.setProperty("ReadOnlyChange", QScriptValue(engine, QEvent::ReadOnlyChange), ENUMPROPFLAGS);
constructor.setProperty("RequestSoftwareInputPanel", QScriptValue(engine, QEvent::RequestSoftwareInputPanel), ENUMPROPFLAGS);
constructor.setProperty("Resize", QScriptValue(engine, QEvent::Resize), ENUMPROPFLAGS);
constructor.setProperty("ScrollPrepare", QScriptValue(engine, QEvent::ScrollPrepare), ENUMPROPFLAGS);
constructor.setProperty("Scroll", QScriptValue(engine, QEvent::Scroll), ENUMPROPFLAGS);
constructor.setProperty("Shortcut", QScriptValue(engine, QEvent::Shortcut), ENUMPROPFLAGS);
constructor.setProperty("ShortcutOverride", QScriptValue(engine, QEvent::ShortcutOverride), ENUMPROPFLAGS);
constructor.setProperty("Show", QScriptValue(engine, QEvent::Show), ENUMPROPFLAGS);
constructor.setProperty("ShowToParent", QScriptValue(engine, QEvent::ShowToParent), ENUMPROPFLAGS);
constructor.setProperty("SockAct", QScriptValue(engine, QEvent::SockAct), ENUMPROPFLAGS);
constructor.setProperty("StateMachineSignal", QScriptValue(engine, QEvent::StateMachineSignal), ENUMPROPFLAGS);
constructor.setProperty("StateMachineWrapped", QScriptValue(engine, QEvent::StateMachineWrapped), ENUMPROPFLAGS);
constructor.setProperty("StatusTip", QScriptValue(engine, QEvent::StatusTip), ENUMPROPFLAGS);
constructor.setProperty("StyleChange", QScriptValue(engine, QEvent::StyleChange), ENUMPROPFLAGS);
constructor.setProperty("TabletMove", QScriptValue(engine, QEvent::TabletMove), ENUMPROPFLAGS);
constructor.setProperty("TabletPress", QScriptValue(engine, QEvent::TabletPress), ENUMPROPFLAGS);
constructor.setProperty("TabletRelease", QScriptValue(engine, QEvent::TabletRelease), ENUMPROPFLAGS);
constructor.setProperty("TabletEnterProximity", QScriptValue(engine, QEvent::TabletEnterProximity), ENUMPROPFLAGS);
constructor.setProperty("TabletLeaveProximity", QScriptValue(engine, QEvent::TabletLeaveProximity), ENUMPROPFLAGS);
#if QT_VERSION >= 0x050900
constructor.setProperty("TabletTrackingChange", QScriptValue(engine, QEvent::TabletTrackingChange), ENUMPROPFLAGS);
#endif
constructor.setProperty("ThreadChange", QScriptValue(engine, QEvent::ThreadChange), ENUMPROPFLAGS);
constructor.setProperty("Timer", QScriptValue(engine, QEvent::Timer), ENUMPROPFLAGS);
constructor.setProperty("ToolBarChange", QScriptValue(engine, QEvent::ToolBarChange), ENUMPROPFLAGS);
constructor.setProperty("ToolTip", QScriptValue(engine, QEvent::ToolTip), ENUMPROPFLAGS);
constructor.setProperty("ToolTipChange", QScriptValue(engine, QEvent::ToolTipChange), ENUMPROPFLAGS);
constructor.setProperty("TouchBegin", QScriptValue(engine, QEvent::TouchBegin), ENUMPROPFLAGS);
constructor.setProperty("TouchCancel", QScriptValue(engine, QEvent::TouchCancel), ENUMPROPFLAGS);
constructor.setProperty("TouchEnd", QScriptValue(engine, QEvent::TouchEnd), ENUMPROPFLAGS);
constructor.setProperty("TouchUpdate", QScriptValue(engine, QEvent::TouchUpdate), ENUMPROPFLAGS);
constructor.setProperty("UngrabKeyboard", QScriptValue(engine, QEvent::UngrabKeyboard), ENUMPROPFLAGS);
constructor.setProperty("UngrabMouse", QScriptValue(engine, QEvent::UngrabMouse), ENUMPROPFLAGS);
constructor.setProperty("UpdateLater", QScriptValue(engine, QEvent::UpdateLater), ENUMPROPFLAGS);
constructor.setProperty("UpdateRequest", QScriptValue(engine, QEvent::UpdateRequest), ENUMPROPFLAGS);
constructor.setProperty("WhatsThis", QScriptValue(engine, QEvent::WhatsThis), ENUMPROPFLAGS);
constructor.setProperty("WhatsThisClicked", QScriptValue(engine, QEvent::WhatsThisClicked), ENUMPROPFLAGS);
constructor.setProperty("Wheel", QScriptValue(engine, QEvent::Wheel), ENUMPROPFLAGS);
constructor.setProperty("WinEventAct", QScriptValue(engine, QEvent::WinEventAct), ENUMPROPFLAGS);
constructor.setProperty("WindowActivate", QScriptValue(engine, QEvent::WindowActivate), ENUMPROPFLAGS);
constructor.setProperty("WindowBlocked", QScriptValue(engine, QEvent::WindowBlocked), ENUMPROPFLAGS);
constructor.setProperty("WindowDeactivate", QScriptValue(engine, QEvent::WindowDeactivate), ENUMPROPFLAGS);
constructor.setProperty("WindowIconChange", QScriptValue(engine, QEvent::WindowIconChange), ENUMPROPFLAGS);
constructor.setProperty("WindowStateChange", QScriptValue(engine, QEvent::WindowStateChange), ENUMPROPFLAGS);
constructor.setProperty("WindowTitleChange", QScriptValue(engine, QEvent::WindowTitleChange), ENUMPROPFLAGS);
constructor.setProperty("WindowUnblocked", QScriptValue(engine, QEvent::WindowUnblocked), ENUMPROPFLAGS);
constructor.setProperty("WinIdChange", QScriptValue(engine, QEvent::WinIdChange), ENUMPROPFLAGS);
constructor.setProperty("ZOrderChange", QScriptValue(engine, QEvent::ZOrderChange), ENUMPROPFLAGS);
constructor.setProperty("User", QScriptValue(engine, QEvent::User), ENUMPROPFLAGS);
constructor.setProperty("MaxUser", QScriptValue(engine, QEvent::MaxUser), ENUMPROPFLAGS);
}
