QString ActionInstance::evaluateTextString(bool &ok, const QString &toEvaluate, int &position)
{
ok = true;
int startIndex = position;
QString result;
while(position < toEvaluate.length())
{
if(toEvaluate[position] == QChar('$'))
{
//find a variable name
if(VariableRegExp.indexIn(toEvaluate, position) != -1)
{
QString foundVariableName = VariableRegExp.cap(1);
QScriptValue foundVariable = d->scriptEngine->globalObject().property(foundVariableName);
position += foundVariableName.length();
if(!foundVariable.isValid())
{
ok = false;
emit executionException(ActionException::InvalidParameterException, tr("Undefined variable \"%1\"").arg(foundVariableName));
return QString();
}
QString stringEvaluationResult;
if(foundVariable.isNull())
stringEvaluationResult = "[Null]";
else if(foundVariable.isUndefined())
stringEvaluationResult = "[Undefined]";
else if(foundVariable.isArray())
{
while((position + 1 < toEvaluate.length()) && toEvaluate[position + 1] == QChar('['))
{
position += 2;
QString indexArray = evaluateTextString(ok, toEvaluate, position);
if((position < toEvaluate.length()) && toEvaluate[position] == QChar(']'))
{
QScriptString internalIndexArray = d->scriptEngine->toStringHandle(indexArray);
bool flag = true;
int numIndex = internalIndexArray.toArrayIndex(&flag);
if(flag) //numIndex is valid
foundVariable = foundVariable.property(numIndex);
else //use internalIndexArray
foundVariable = foundVariable.property(internalIndexArray);
}
else
{
//syntax error
ok = false;
emit executionException(ActionException::InvalidParameterException, tr("Invalid parameter. Unable to evaluate string"));
return QString();
}
//COMPATIBILITY: we break the while loop if foundVariable is no more of Array type
if(!foundVariable.isArray())
break;
}
//end of while, no more '['
if(foundVariable.isArray())
stringEvaluationResult = evaluateVariableArray(ok, foundVariable);
else
stringEvaluationResult = foundVariable.toString();
}
else if(foundVariable.isVariant())
{
QVariant variantEvaluationResult = foundVariable.toVariant();
switch(variantEvaluationResult.type())
{
case QVariant::StringList:
stringEvaluationResult = variantEvaluationResult.toStringList().join("\n");
break;
case QVariant::ByteArray:
stringEvaluationResult = "[Raw data]";
break;
default:
stringEvaluationResult = foundVariable.toString();
break;
}
}
else
stringEvaluationResult = foundVariable.toString();
result.append(stringEvaluationResult);
}
}
else if (toEvaluate[position] == QChar(']'))
{
if(startIndex == 0)
//in top level evaluation isolated character ']' is accepted (for compatibility reason), now prefer "\]"
//i.e without matching '['
result.append(toEvaluate[position]);
else
//on other levels, the parsing is stopped at this point
return result;
}
else if(toEvaluate[position] == QChar('\\'))
{
if(startIndex == 0)
{
//for ascendant compatibility reason
//in top level evaluation '\' is not only an escape character,
//but can also be a standard character in some cases
if((position + 1) < toEvaluate.length())
{
position++;
if(toEvaluate[position] == QChar('$') || toEvaluate[position] == QChar('[') || toEvaluate[position] == QChar(']') || toEvaluate[position] == QChar('\\'))
result.append(toEvaluate[position]);
else
{
position--;
result.append(toEvaluate[position]);
}
}
else
result.append(toEvaluate[position]);
}
else
{
position++;
if( position < toEvaluate.length() )
result.append(toEvaluate[position]);
}
}
else
result.append(toEvaluate[position]);
position++;
}
return result;
}
QScriptValue REcmaHelper::toScriptValue(QScriptEngine* engine, REntity* cppValue) {
QScriptValue v;
v = tryCast<RAttributeEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RAttributeDefinitionEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RArcEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RBlockReferenceEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RCircleEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimAlignedEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimAngularEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimDiametricEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimOrdinateEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimRadialEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimRotatedEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<REllipseEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RHatchEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RImageEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RLeaderEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RLineEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RPointEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RPolylineEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RSolidEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RSplineEntity>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RTextEntity>(engine, cppValue);
if (v.isValid()) return v;
return qScriptValueFromValue(engine, cppValue);
}
void Circle3DOverlay::setProperties(const QScriptValue &properties) {
Planar3DOverlay::setProperties(properties);
QScriptValue startAt = properties.property("startAt");
if (startAt.isValid()) {
setStartAt(startAt.toVariant().toFloat());
}
QScriptValue endAt = properties.property("endAt");
if (endAt.isValid()) {
setEndAt(endAt.toVariant().toFloat());
}
QScriptValue outerRadius = properties.property("outerRadius");
if (outerRadius.isValid()) {
setOuterRadius(outerRadius.toVariant().toFloat());
}
QScriptValue innerRadius = properties.property("innerRadius");
if (innerRadius.isValid()) {
setInnerRadius(innerRadius.toVariant().toFloat());
}
QScriptValue hasTickMarks = properties.property("hasTickMarks");
if (hasTickMarks.isValid()) {
setHasTickMarks(hasTickMarks.toVariant().toBool());
}
QScriptValue majorTickMarksAngle = properties.property("majorTickMarksAngle");
if (majorTickMarksAngle.isValid()) {
setMajorTickMarksAngle(majorTickMarksAngle.toVariant().toFloat());
}
QScriptValue minorTickMarksAngle = properties.property("minorTickMarksAngle");
if (minorTickMarksAngle.isValid()) {
setMinorTickMarksAngle(minorTickMarksAngle.toVariant().toFloat());
}
QScriptValue majorTickMarksLength = properties.property("majorTickMarksLength");
if (majorTickMarksLength.isValid()) {
setMajorTickMarksLength(majorTickMarksLength.toVariant().toFloat());
}
QScriptValue minorTickMarksLength = properties.property("minorTickMarksLength");
if (minorTickMarksLength.isValid()) {
setMinorTickMarksLength(minorTickMarksLength.toVariant().toFloat());
}
QScriptValue majorTickMarksColor = properties.property("majorTickMarksColor");
if (majorTickMarksColor.isValid()) {
QScriptValue red = majorTickMarksColor.property("red");
QScriptValue green = majorTickMarksColor.property("green");
QScriptValue blue = majorTickMarksColor.property("blue");
if (red.isValid() && green.isValid() && blue.isValid()) {
_majorTickMarksColor.red = red.toVariant().toInt();
_majorTickMarksColor.green = green.toVariant().toInt();
_majorTickMarksColor.blue = blue.toVariant().toInt();
}
}
QScriptValue minorTickMarksColor = properties.property("minorTickMarksColor");
if (minorTickMarksColor.isValid()) {
QScriptValue red = minorTickMarksColor.property("red");
QScriptValue green = minorTickMarksColor.property("green");
QScriptValue blue = minorTickMarksColor.property("blue");
if (red.isValid() && green.isValid() && blue.isValid()) {
_minorTickMarksColor.red = red.toVariant().toInt();
_minorTickMarksColor.green = green.toVariant().toInt();
_minorTickMarksColor.blue = blue.toVariant().toInt();
}
}
}
void Base3DOverlay::setProperties(const QScriptValue& properties) {
Overlay::setProperties(properties);
QScriptValue drawInFront = properties.property("drawInFront");
if (drawInFront.isValid()) {
bool value = drawInFront.toVariant().toBool();
setDrawInFront(value);
}
QScriptValue position = properties.property("position");
// if "position" property was not there, check to see if they included aliases: start, point, p1
if (!position.isValid()) {
position = properties.property("start");
if (!position.isValid()) {
position = properties.property("p1");
if (!position.isValid()) {
position = properties.property("point");
}
}
}
if (position.isValid()) {
QScriptValue x = position.property("x");
QScriptValue y = position.property("y");
QScriptValue z = position.property("z");
if (x.isValid() && y.isValid() && z.isValid()) {
glm::vec3 newPosition;
newPosition.x = x.toVariant().toFloat();
newPosition.y = y.toVariant().toFloat();
newPosition.z = z.toVariant().toFloat();
setPosition(newPosition);
}
}
if (properties.property("lineWidth").isValid()) {
setLineWidth(properties.property("lineWidth").toVariant().toFloat());
}
QScriptValue rotation = properties.property("rotation");
if (rotation.isValid()) {
glm::quat newRotation;
// size, scale, dimensions is special, it might just be a single scalar, or it might be a vector, check that here
QScriptValue x = rotation.property("x");
QScriptValue y = rotation.property("y");
QScriptValue z = rotation.property("z");
QScriptValue w = rotation.property("w");
if (x.isValid() && y.isValid() && z.isValid() && w.isValid()) {
newRotation.x = x.toVariant().toFloat();
newRotation.y = y.toVariant().toFloat();
newRotation.z = z.toVariant().toFloat();
newRotation.w = w.toVariant().toFloat();
setRotation(newRotation);
}
}
if (properties.property("isSolid").isValid()) {
setIsSolid(properties.property("isSolid").toVariant().toBool());
}
if (properties.property("isFilled").isValid()) {
setIsSolid(properties.property("isSolid").toVariant().toBool());
}
if (properties.property("isWire").isValid()) {
setIsSolid(!properties.property("isWire").toVariant().toBool());
}
if (properties.property("solid").isValid()) {
setIsSolid(properties.property("solid").toVariant().toBool());
}
if (properties.property("filled").isValid()) {
setIsSolid(properties.property("filled").toVariant().toBool());
}
if (properties.property("wire").isValid()) {
setIsSolid(!properties.property("wire").toVariant().toBool());
}
if (properties.property("isDashedLine").isValid()) {
setIsDashedLine(properties.property("isDashedLine").toVariant().toBool());
}
if (properties.property("dashed").isValid()) {
setIsDashedLine(properties.property("dashed").toVariant().toBool());
}
if (properties.property("ignoreRayIntersection").isValid()) {
setIgnoreRayIntersection(properties.property("ignoreRayIntersection").toVariant().toBool());
}
}
void REcmaLineData::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RLineData*) 0)));
protoCreated = true;
}
// primary base class REntityData:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<REntityData*>());
if (dpt.isValid()) {
proto->setPrototype(dpt);
}
/*
REcmaLine::initEcma(engine, proto);
*/
QScriptValue fun;
// toString:
REcmaHelper::registerFunction(&engine, proto, toString, "toString");
// copy:
REcmaHelper::registerFunction(&engine, proto, copy, "copy");
// destroy:
REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
// conversion for base class REntityData
REcmaHelper::registerFunction(&engine, proto, getREntityData, "getREntityData");
// 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, getLine, "getLine");
REcmaHelper::registerFunction(&engine, proto, getHull, "getHull");
REcmaHelper::registerFunction(&engine, proto, getStartPoint, "getStartPoint");
REcmaHelper::registerFunction(&engine, proto, getEndPoint, "getEndPoint");
REcmaHelper::registerFunction(&engine, proto, getAngle, "getAngle");
REcmaHelper::registerFunction(&engine, proto, getDirection1, "getDirection1");
REcmaHelper::registerFunction(&engine, proto, getDirection2, "getDirection2");
REcmaHelper::registerFunction(&engine, proto, reverse, "reverse");
REcmaHelper::registerFunction(&engine, proto, getTrimEnd, "getTrimEnd");
REcmaHelper::registerFunction(&engine, proto, trimStartPoint, "trimStartPoint");
REcmaHelper::registerFunction(&engine, proto, trimEndPoint, "trimEndPoint");
REcmaHelper::registerFunction(&engine, proto, getSideOfPoint, "getSideOfPoint");
REcmaHelper::registerFunction(&engine, proto, getReferencePoints, "getReferencePoints");
REcmaHelper::registerFunction(&engine, proto, moveReferencePoint, "moveReferencePoint");
REcmaHelper::registerFunction(&engine, proto, castToShape, "castToShape");
REcmaHelper::registerFunction(&engine, proto, getShapes, "getShapes");
engine.setDefaultPrototype(
qMetaTypeId<RLineData*>(), *proto);
engine.setDefaultPrototype(qMetaTypeId<
RLineData
> (), *proto);
QScriptValue ctor = engine.newFunction(create, *proto, 2);
// static methods:
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RLineData",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
QScriptValue searchReplaceFunction(QScriptContext *context, QScriptEngine *engine, bool replace){
QEditor *editor = qobject_cast<QEditor*>(context->thisObject().toQObject());
//read arguments
SCRIPT_REQUIRE(editor, "invalid object");
SCRIPT_REQUIRE(!replace || context->argumentCount()>=2, "at least two arguments are required");
SCRIPT_REQUIRE(context->argumentCount()>=1, "at least one argument is required");
SCRIPT_REQUIRE(context->argumentCount()<=4, "too many arguments");
SCRIPT_REQUIRE(context->argument(0).isString()||context->argument(0).isRegExp(), "first argument must be a string or regexp");
QDocumentSearch::Options flags = QDocumentSearch::Silent;
bool global = false, caseInsensitive = false;
QString searchFor;
if (context->argument(0).isRegExp()) {
flags |= QDocumentSearch::RegExp;
QRegExp r = context->argument(0).toRegExp();
searchFor = r.pattern();
caseInsensitive = r.caseSensitivity() == Qt::CaseInsensitive;
Q_ASSERT(caseInsensitive == context->argument(0).property("ignoreCase").toBool()); //check assumption about javascript core
global = context->argument(0).property("global").toBool();
} else searchFor = context->argument(0).toString();
QScriptValue handler;
QDocumentCursor scope = editor->document()->cursor(0,0,editor->document()->lineCount(),0);
int handlerCount = 0;
for (int i=1; i<context->argumentCount();i++)
if (context->argument(i).isString() || context->argument(i).isFunction()) handlerCount++;
SCRIPT_REQUIRE(handlerCount <= (replace?2:1), "too many string or function arguments");
for (int i=1; i<context->argumentCount();i++) {
QScriptValue a = context->argument(i);
if (a.isFunction()) {
SCRIPT_REQUIRE(!handler.isValid(), "Multiple callbacks");
handler = a;
} else if (a.isString()) {
if (!replace || handlerCount > 1) {
QString s = a.toString().toLower();
global = s.contains("g");
caseInsensitive = s.contains("i");
if (s.contains("w")) flags |= QDocumentSearch::WholeWords;
} else {
SCRIPT_REQUIRE(!handler.isValid(), "Multiple callbacks");
handler = a;
}
handlerCount--;
} else if (a.isNumber()) flags |= QDocumentSearch::Options((int)a.toNumber());
else if (a.isObject()) scope = cursorFromValue(a);
else SCRIPT_REQUIRE(false, "Invalid argument");
}
SCRIPT_REQUIRE(handler.isValid() || !replace, "No callback given");
if (!caseInsensitive) flags |= QDocumentSearch::CaseSensitive;
//search/replace
QDocumentSearch search(editor, searchFor, flags);
search.setScope(scope);
if (replace && handler.isString()) {
search.setReplaceText(handler.toString());
search.setOption(QDocumentSearch::Replace,true);
return search.next(false, global, false, false);
}
if (!handler.isValid())
return search.next(false,global,true,false);
int count=0;
while (search.next(false, false, true, false) && search.cursor().isValid()) {
count++;
QDocumentCursor temp = search.cursor();
QScriptValue cb = handler.call(QScriptValue(), QScriptValueList() << engine->newQObject(&temp));
if (replace && cb.isValid()){
QDocumentCursor tmp = search.cursor();
tmp.replaceSelectedText(cb.toString());
search.setCursor(tmp.selectionEnd());
}
if (!global) break;
}
return count;
}
// includes for base ecma wrapper classes
void REcmaThread::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RThread*) 0)));
protoCreated = true;
}
// primary base class QThread:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<QThread*>());
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 QThread
REcmaHelper::registerFunction(&engine, proto, getQThread, "getQThread");
// 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, start, "start");
engine.setDefaultPrototype(
qMetaTypeId<RThread*>(), *proto);
qScriptRegisterMetaType<
RThread*>(
&engine, toScriptValue, fromScriptValue, *proto);
QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, yieldCurrentThread, "yieldCurrentThread");
REcmaHelper::registerFunction(&engine, &ctor, currentThreadAddress, "currentThreadAddress");
REcmaHelper::registerFunction(&engine, &ctor, currentThreadName, "currentThreadName");
REcmaHelper::registerFunction(&engine, &ctor, currentThread, "currentThread");
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RThread",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
/*!
Applies the given \a command to the given \a backend.
*/
QScriptDebuggerResponse QScriptDebuggerCommandExecutor::execute(
QScriptDebuggerBackend *backend,
const QScriptDebuggerCommand &command)
{
QScriptDebuggerResponse response;
switch (command.type()) {
case QScriptDebuggerCommand::None:
break;
case QScriptDebuggerCommand::Interrupt:
backend->interruptEvaluation();
break;
case QScriptDebuggerCommand::Continue:
if (backend->engine()->isEvaluating()) {
backend->continueEvalution();
response.setAsync(true);
}
break;
case QScriptDebuggerCommand::StepInto: {
QVariant attr = command.attribute(QScriptDebuggerCommand::StepCount);
int count = attr.isValid() ? attr.toInt() : 1;
backend->stepInto(count);
response.setAsync(true);
}
break;
case QScriptDebuggerCommand::StepOver: {
QVariant attr = command.attribute(QScriptDebuggerCommand::StepCount);
int count = attr.isValid() ? attr.toInt() : 1;
backend->stepOver(count);
response.setAsync(true);
}
break;
case QScriptDebuggerCommand::StepOut:
backend->stepOut();
response.setAsync(true);
break;
case QScriptDebuggerCommand::RunToLocation:
backend->runToLocation(command.fileName(), command.lineNumber());
response.setAsync(true);
break;
case QScriptDebuggerCommand::RunToLocationByID:
backend->runToLocation(command.scriptId(), command.lineNumber());
response.setAsync(true);
break;
case QScriptDebuggerCommand::ForceReturn: {
int contextIndex = command.contextIndex();
QScriptDebuggerValue value = command.scriptValue();
QScriptEngine *engine = backend->engine();
QScriptValue realValue = value.toScriptValue(engine);
backend->returnToCaller(contextIndex, realValue);
response.setAsync(true);
}
break;
case QScriptDebuggerCommand::Resume:
backend->resume();
response.setAsync(true);
break;
case QScriptDebuggerCommand::SetBreakpoint: {
QScriptBreakpointData data = command.breakpointData();
if (!data.isValid())
data = QScriptBreakpointData(command.fileName(), command.lineNumber());
int id = backend->setBreakpoint(data);
response.setResult(id);
}
break;
case QScriptDebuggerCommand::DeleteBreakpoint: {
int id = command.breakpointId();
if (!backend->deleteBreakpoint(id))
response.setError(QScriptDebuggerResponse::InvalidBreakpointID);
}
break;
case QScriptDebuggerCommand::DeleteAllBreakpoints:
backend->deleteAllBreakpoints();
break;
case QScriptDebuggerCommand::GetBreakpoints: {
QScriptBreakpointMap bps = backend->breakpoints();
if (!bps.isEmpty())
response.setResult(bps);
}
break;
case QScriptDebuggerCommand::GetBreakpointData: {
int id = command.breakpointId();
QScriptBreakpointData data = backend->breakpointData(id);
if (data.isValid())
response.setResult(data);
else
response.setError(QScriptDebuggerResponse::InvalidBreakpointID);
}
break;
case QScriptDebuggerCommand::SetBreakpointData: {
int id = command.breakpointId();
QScriptBreakpointData data = command.breakpointData();
if (!backend->setBreakpointData(id, data))
response.setError(QScriptDebuggerResponse::InvalidBreakpointID);
}
break;
case QScriptDebuggerCommand::GetScripts: {
QScriptScriptMap scripts = backend->scripts();
if (!scripts.isEmpty())
response.setResult(scripts);
}
break;
case QScriptDebuggerCommand::GetScriptData: {
qint64 id = command.scriptId();
QScriptScriptData data = backend->scriptData(id);
if (data.isValid())
response.setResult(data);
else
response.setError(QScriptDebuggerResponse::InvalidScriptID);
}
break;
case QScriptDebuggerCommand::ScriptsCheckpoint:
backend->scriptsCheckpoint();
response.setResult(QVariant::fromValue(backend->scriptsDelta()));
break;
case QScriptDebuggerCommand::GetScriptsDelta:
response.setResult(QVariant::fromValue(backend->scriptsDelta()));
break;
case QScriptDebuggerCommand::ResolveScript:
response.setResult(backend->resolveScript(command.fileName()));
break;
case QScriptDebuggerCommand::GetBacktrace:
response.setResult(backend->backtrace());
break;
case QScriptDebuggerCommand::GetContextCount:
response.setResult(backend->contextCount());
break;
case QScriptDebuggerCommand::GetContextState: {
QScriptContext *ctx = backend->context(command.contextIndex());
if (ctx)
response.setResult(static_cast<int>(ctx->state()));
else
response.setError(QScriptDebuggerResponse::InvalidContextIndex);
}
break;
case QScriptDebuggerCommand::GetContextID: {
int idx = command.contextIndex();
if ((idx >= 0) && (idx < backend->contextCount()))
response.setResult(backend->contextIds()[idx]);
else
response.setError(QScriptDebuggerResponse::InvalidContextIndex);
}
break;
case QScriptDebuggerCommand::GetContextInfo: {
QScriptContext *ctx = backend->context(command.contextIndex());
if (ctx)
response.setResult(QScriptContextInfo(ctx));
else
response.setError(QScriptDebuggerResponse::InvalidContextIndex);
}
break;
case QScriptDebuggerCommand::GetThisObject: {
QScriptContext *ctx = backend->context(command.contextIndex());
if (ctx)
response.setResult(ctx->thisObject());
else
response.setError(QScriptDebuggerResponse::InvalidContextIndex);
}
break;
case QScriptDebuggerCommand::GetActivationObject: {
QScriptContext *ctx = backend->context(command.contextIndex());
if (ctx)
response.setResult(ctx->activationObject());
else
response.setError(QScriptDebuggerResponse::InvalidContextIndex);
}
break;
case QScriptDebuggerCommand::GetScopeChain: {
QScriptContext *ctx = backend->context(command.contextIndex());
if (ctx) {
QScriptDebuggerValueList dest;
QScriptValueList src = ctx->scopeChain();
for (int i = 0; i < src.size(); ++i)
dest.append(src.at(i));
response.setResult(dest);
} else {
response.setError(QScriptDebuggerResponse::InvalidContextIndex);
}
}
break;
case QScriptDebuggerCommand::ContextsCheckpoint: {
response.setResult(QVariant::fromValue(backend->contextsCheckpoint()));
}
break;
case QScriptDebuggerCommand::GetPropertyExpressionValue: {
QScriptContext *ctx = backend->context(command.contextIndex());
int lineNumber = command.lineNumber();
QVariant attr = command.attribute(QScriptDebuggerCommand::UserAttribute);
QStringList path = attr.toStringList();
if (!ctx || path.isEmpty())
break;
QScriptContextInfo ctxInfo(ctx);
if (ctx->callee().isValid()
&& ((lineNumber < ctxInfo.functionStartLineNumber())
|| (lineNumber > ctxInfo.functionEndLineNumber()))) {
break;
}
QScriptValueList objects;
int pathIndex = 0;
if (path.at(0) == QLatin1String("this")) {
objects.append(ctx->thisObject());
++pathIndex;
} else {
objects << ctx->scopeChain();
}
for (int i = 0; i < objects.size(); ++i) {
QScriptValue val = objects.at(i);
for (int j = pathIndex; val.isValid() && (j < path.size()); ++j) {
val = val.property(path.at(j));
}
if (val.isValid()) {
bool hadException = (ctx->state() == QScriptContext::ExceptionState);
QString str = val.toString();
if (!hadException && backend->engine()->hasUncaughtException())
backend->engine()->clearExceptions();
response.setResult(str);
break;
}
}
}
break;
case QScriptDebuggerCommand::GetCompletions: {
QScriptContext *ctx = backend->context(command.contextIndex());
QVariant attr = command.attribute(QScriptDebuggerCommand::UserAttribute);
QStringList path = attr.toStringList();
if (!ctx || path.isEmpty())
break;
QScriptValueList objects;
QString prefix = path.last();
QSet<QString> matches;
if (path.size() > 1) {
const QString &topLevelIdent = path.at(0);
QScriptValue obj;
if (topLevelIdent == QLatin1String("this")) {
obj = ctx->thisObject();
} else {
QScriptValueList scopeChain;
scopeChain = ctx->scopeChain();
for (int i = 0; i < scopeChain.size(); ++i) {
QScriptValue oo = scopeChain.at(i).property(topLevelIdent);
if (oo.isObject()) {
obj = oo;
break;
}
}
}
for (int i = 1; obj.isObject() && (i < path.size()-1); ++i)
obj = obj.property(path.at(i));
if (obj.isValid())
objects.append(obj);
} else {
objects << ctx->scopeChain();
QStringList keywords;
keywords.append(QString::fromLatin1("this"));
keywords.append(QString::fromLatin1("true"));
keywords.append(QString::fromLatin1("false"));
keywords.append(QString::fromLatin1("null"));
for (int i = 0; i < keywords.size(); ++i) {
const QString &kwd = keywords.at(i);
if (isPrefixOf(prefix, kwd))
matches.insert(kwd);
}
}
for (int i = 0; i < objects.size(); ++i) {
QScriptValue obj = objects.at(i);
while (obj.isObject()) {
QScriptValueIterator it(obj);
while (it.hasNext()) {
it.next();
QString propertyName = it.name();
if (isPrefixOf(prefix, propertyName))
matches.insert(propertyName);
}
obj = obj.prototype();
}
}
QStringList matchesList = matches.toList();
qStableSort(matchesList);
response.setResult(matchesList);
}
break;
case QScriptDebuggerCommand::NewScriptObjectSnapshot: {
int id = backend->newScriptObjectSnapshot();
response.setResult(id);
}
break;
case QScriptDebuggerCommand::ScriptObjectSnapshotCapture: {
int id = command.snapshotId();
QScriptObjectSnapshot *snap = backend->scriptObjectSnapshot(id);
Q_ASSERT(snap != 0);
QScriptDebuggerValue object = command.scriptValue();
Q_ASSERT(object.type() == QScriptDebuggerValue::ObjectValue);
QScriptEngine *engine = backend->engine();
QScriptValue realObject = object.toScriptValue(engine);
Q_ASSERT(realObject.isObject());
QScriptObjectSnapshot::Delta delta = snap->capture(realObject);
QScriptDebuggerObjectSnapshotDelta result;
result.removedProperties = delta.removedProperties;
bool didIgnoreExceptions = backend->ignoreExceptions();
backend->setIgnoreExceptions(true);
for (int i = 0; i < delta.changedProperties.size(); ++i) {
const QScriptValueProperty &src = delta.changedProperties.at(i);
bool hadException = engine->hasUncaughtException();
QString str = src.value().toString();
if (!hadException && engine->hasUncaughtException())
engine->clearExceptions();
QScriptDebuggerValueProperty dest(src.name(), src.value(), str, src.flags());
result.changedProperties.append(dest);
}
for (int j = 0; j < delta.addedProperties.size(); ++j) {
const QScriptValueProperty &src = delta.addedProperties.at(j);
bool hadException = engine->hasUncaughtException();
QString str = src.value().toString();
if (!hadException && engine->hasUncaughtException())
engine->clearExceptions();
QScriptDebuggerValueProperty dest(src.name(), src.value(), str, src.flags());
result.addedProperties.append(dest);
}
backend->setIgnoreExceptions(didIgnoreExceptions);
response.setResult(QVariant::fromValue(result));
}
break;
case QScriptDebuggerCommand::DeleteScriptObjectSnapshot: {
int id = command.snapshotId();
backend->deleteScriptObjectSnapshot(id);
}
break;
case QScriptDebuggerCommand::NewScriptValueIterator: {
QScriptDebuggerValue object = command.scriptValue();
Q_ASSERT(object.type() == QScriptDebuggerValue::ObjectValue);
QScriptEngine *engine = backend->engine();
QScriptValue realObject = object.toScriptValue(engine);
Q_ASSERT(realObject.isObject());
int id = backend->newScriptValueIterator(realObject);
response.setResult(id);
}
break;
case QScriptDebuggerCommand::GetPropertiesByIterator: {
int id = command.iteratorId();
int count = 1000;
QScriptValueIterator *it = backend->scriptValueIterator(id);
Q_ASSERT(it != 0);
QScriptDebuggerValuePropertyList props;
for (int i = 0; (i < count) && it->hasNext(); ++i) {
it->next();
QString name = it->name();
QScriptValue value = it->value();
QString valueAsString = value.toString();
QScriptValue::PropertyFlags flags = it->flags();
QScriptDebuggerValueProperty prp(name, value, valueAsString, flags);
props.append(prp);
}
response.setResult(props);
}
break;
case QScriptDebuggerCommand::DeleteScriptValueIterator: {
int id = command.iteratorId();
backend->deleteScriptValueIterator(id);
}
break;
case QScriptDebuggerCommand::Evaluate: {
int contextIndex = command.contextIndex();
QString program = command.program();
QString fileName = command.fileName();
int lineNumber = command.lineNumber();
backend->evaluate(contextIndex, program, fileName, lineNumber);
response.setAsync(true);
}
break;
case QScriptDebuggerCommand::ScriptValueToString: {
QScriptDebuggerValue value = command.scriptValue();
QScriptEngine *engine = backend->engine();
QScriptValue realValue = value.toScriptValue(engine);
response.setResult(realValue.toString());
}
break;
case QScriptDebuggerCommand::SetScriptValueProperty: {
QScriptDebuggerValue object = command.scriptValue();
QScriptEngine *engine = backend->engine();
QScriptValue realObject = object.toScriptValue(engine);
QScriptDebuggerValue value = command.subordinateScriptValue();
QScriptValue realValue = value.toScriptValue(engine);
QString name = command.name();
realObject.setProperty(name, realValue);
}
break;
case QScriptDebuggerCommand::ClearExceptions:
backend->engine()->clearExceptions();
break;
case QScriptDebuggerCommand::UserCommand:
case QScriptDebuggerCommand::MaxUserCommand:
break;
}
return response;
}
void REcmaOrthoGrid::init(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(ROrthoGrid*) 0)));
protoCreated = true;
}
// primary base class RGrid:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RGrid*>());
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 RGrid
REcmaHelper::registerFunction(&engine, proto, getRGrid, "getRGrid");
// 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, clearCache, "clearCache");
REcmaHelper::registerFunction(&engine, proto, snapToGrid, "snapToGrid");
REcmaHelper::registerFunction(&engine, proto, update, "update");
REcmaHelper::registerFunction(&engine, proto, paint, "paint");
REcmaHelper::registerFunction(&engine, proto, paintMetaGrid, "paintMetaGrid");
REcmaHelper::registerFunction(&engine, proto, paintGridLines, "paintGridLines");
REcmaHelper::registerFunction(&engine, proto, paintGridPoints, "paintGridPoints");
REcmaHelper::registerFunction(&engine, proto, paintCursor, "paintCursor");
REcmaHelper::registerFunction(&engine, proto, paintRuler, "paintRuler");
REcmaHelper::registerFunction(&engine, proto, getInfoText, "getInfoText");
REcmaHelper::registerFunction(&engine, proto, getIdealSpacing, "getIdealSpacing");
REcmaHelper::registerFunction(&engine, proto, isIsometric, "isIsometric");
REcmaHelper::registerFunction(&engine, proto, setIsometric, "setIsometric");
REcmaHelper::registerFunction(&engine, proto, getProjection, "getProjection");
REcmaHelper::registerFunction(&engine, proto, setProjection, "setProjection");
engine.setDefaultPrototype(
qMetaTypeId<ROrthoGrid*>(), *proto);
QScriptValue ctor = engine.newFunction(create, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, getIdealGridSpacing, "getIdealGridSpacing");
REcmaHelper::registerFunction(&engine, &ctor, isFractionalFormat, "isFractionalFormat");
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("ROrthoGrid",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void KeyEvent::fromScriptValue(const QScriptValue& object, KeyEvent& event) {
event.isValid = false; // assume the worst
event.isMeta = object.property("isMeta").toVariant().toBool();
event.isControl = object.property("isControl").toVariant().toBool();
event.isAlt = object.property("isAlt").toVariant().toBool();
event.isKeypad = object.property("isKeypad").toVariant().toBool();
event.isAutoRepeat = object.property("isAutoRepeat").toVariant().toBool();
QScriptValue key = object.property("key");
if (key.isValid()) {
event.key = key.toVariant().toInt();
event.text = QString(QChar(event.key));
event.isValid = true;
} else {
QScriptValue text = object.property("text");
if (text.isValid()) {
event.text = object.property("text").toVariant().toString();
// if the text is a special command, then map it here...
// TODO: come up with more elegant solution here, a map? is there a Qt function that gives nice names for keys?
if (event.text.toUpper() == "F1") {
event.key = Qt::Key_F1;
} else if (event.text.toUpper() == "F2") {
event.key = Qt::Key_F2;
} else if (event.text.toUpper() == "F3") {
event.key = Qt::Key_F3;
} else if (event.text.toUpper() == "F4") {
event.key = Qt::Key_F4;
} else if (event.text.toUpper() == "F5") {
event.key = Qt::Key_F5;
} else if (event.text.toUpper() == "F6") {
event.key = Qt::Key_F6;
} else if (event.text.toUpper() == "F7") {
event.key = Qt::Key_F7;
} else if (event.text.toUpper() == "F8") {
event.key = Qt::Key_F8;
} else if (event.text.toUpper() == "F9") {
event.key = Qt::Key_F9;
} else if (event.text.toUpper() == "F10") {
event.key = Qt::Key_F10;
} else if (event.text.toUpper() == "F11") {
event.key = Qt::Key_F11;
} else if (event.text.toUpper() == "F12") {
event.key = Qt::Key_F12;
} else if (event.text.toUpper() == "UP") {
event.key = Qt::Key_Up;
event.isKeypad = true;
} else if (event.text.toUpper() == "DOWN") {
event.key = Qt::Key_Down;
event.isKeypad = true;
} else if (event.text.toUpper() == "LEFT") {
event.key = Qt::Key_Left;
event.isKeypad = true;
} else if (event.text.toUpper() == "RIGHT") {
event.key = Qt::Key_Right;
event.isKeypad = true;
} else if (event.text.toUpper() == "SPACE") {
event.key = Qt::Key_Space;
} else if (event.text.toUpper() == "ESC") {
event.key = Qt::Key_Escape;
} else if (event.text.toUpper() == "TAB") {
event.key = Qt::Key_Tab;
} else if (event.text.toUpper() == "DELETE") {
event.key = Qt::Key_Delete;
} else if (event.text.toUpper() == "BACKSPACE") {
event.key = Qt::Key_Backspace;
} else if (event.text.toUpper() == "SHIFT") {
event.key = Qt::Key_Shift;
} else if (event.text.toUpper() == "ALT") {
event.key = Qt::Key_Alt;
} else if (event.text.toUpper() == "CONTROL") {
event.key = Qt::Key_Control;
} else if (event.text.toUpper() == "META") {
event.key = Qt::Key_Meta;
} else if (event.text.toUpper() == "PAGE DOWN") {
event.key = Qt::Key_PageDown;
} else if (event.text.toUpper() == "PAGE UP") {
event.key = Qt::Key_PageUp;
} else if (event.text.toUpper() == "HOME") {
event.key = Qt::Key_Home;
} else if (event.text.toUpper() == "END") {
event.key = Qt::Key_End;
} else if (event.text.toUpper() == "HELP") {
event.key = Qt::Key_Help;
} else if (event.text.toUpper() == "CAPS LOCK") {
event.key = Qt::Key_CapsLock;
} else {
// Key values do not distinguish between uppercase and lowercase
// and use the uppercase key value.
event.key = event.text.toUpper().at(0).unicode();
}
event.isValid = true;
}
}
QScriptValue isShifted = object.property("isShifted");
if (isShifted.isValid()) {
event.isShifted = isShifted.toVariant().toBool();
} else {
// if no isShifted was included, get it from the text
QChar character = event.text.at(0);
if (character.isLetter() && character.isUpper()) {
event.isShifted = true;
} else {
// if it's a symbol, then attempt to detect shifted-ness
if (QString("~!@#$%^&*()_+{}|:\"<>?").contains(character)) {
event.isShifted = true;
}
}
}
const bool wantDebug = false;
if (wantDebug) {
qCDebug(scriptengine) << "event.key=" << event.key
<< " event.text=" << event.text
<< " event.isShifted=" << event.isShifted
<< " event.isControl=" << event.isControl
<< " event.isMeta=" << event.isMeta
<< " event.isAlt=" << event.isAlt
<< " event.isKeypad=" << event.isKeypad
<< " event.isAutoRepeat=" << event.isAutoRepeat;
}
}
void QDeclarativeObjectScriptClass::setProperty(QObject *obj,
const Identifier &name,
const QScriptValue &value,
QScriptContext *context,
QDeclarativeContextData *evalContext)
{
Q_UNUSED(name);
Q_ASSERT(obj);
Q_ASSERT(lastData);
Q_ASSERT(context);
if (!lastData->isValid()) {
QString error = QLatin1String("Cannot assign to non-existent property \"") +
toString(name) + QLatin1Char('\"');
context->throwError(error);
return;
}
if (!(lastData->flags & QDeclarativePropertyCache::Data::IsWritable) &&
!(lastData->flags & QDeclarativePropertyCache::Data::IsQList)) {
QString error = QLatin1String("Cannot assign to read-only property \"") +
toString(name) + QLatin1Char('\"');
context->throwError(error);
return;
}
QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(engine);
if (!evalContext) {
// Global object, QScriptContext activation object, QDeclarativeContext object
QScriptValue scopeNode = scopeChainValue(context, -3);
if (scopeNode.isValid()) {
Q_ASSERT(scriptClass(scopeNode) == enginePriv->contextClass);
evalContext = enginePriv->contextClass->contextFromValue(scopeNode);
}
}
QDeclarativeBinding *newBinding = 0;
if (value.isFunction() && !value.isRegExp()) {
QScriptContextInfo ctxtInfo(context);
QDeclarativePropertyCache::ValueTypeData valueTypeData;
newBinding = new QDeclarativeBinding(value, obj, evalContext);
newBinding->setSourceLocation(ctxtInfo.fileName(), ctxtInfo.functionStartLineNumber());
newBinding->setTarget(QDeclarativePropertyPrivate::restore(*lastData, valueTypeData, obj, evalContext));
if (newBinding->expression().contains(QLatin1String("this")))
newBinding->setEvaluateFlags(newBinding->evaluateFlags() | QDeclarativeBinding::RequiresThisObject);
}
QDeclarativeAbstractBinding *delBinding =
QDeclarativePropertyPrivate::setBinding(obj, lastData->coreIndex, -1, newBinding);
if (delBinding)
delBinding->destroy();
if (value.isNull() && lastData->flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {
QObject *o = 0;
int status = -1;
int flags = 0;
void *argv[] = { &o, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty, lastData->coreIndex, argv);
} else if (value.isUndefined() && lastData->flags & QDeclarativePropertyCache::Data::IsResettable) {
void *a[] = { 0 };
QMetaObject::metacall(obj, QMetaObject::ResetProperty, lastData->coreIndex, a);
} else if (value.isUndefined() && lastData->propType == qMetaTypeId<QVariant>()) {
QDeclarativePropertyPrivate::write(obj, *lastData, QVariant(), evalContext);
} else if (value.isUndefined()) {
QString error = QLatin1String("Cannot assign [undefined] to ") +
QLatin1String(QMetaType::typeName(lastData->propType));
context->throwError(error);
} else if (value.isFunction() && !value.isRegExp()) {
// this is handled by the binding creation above
} else {
//### expand optimization for other known types
if (lastData->propType == QMetaType::Int && value.isNumber()) {
int rawValue = qRound(value.toNumber());
int status = -1;
int flags = 0;
void *a[] = { (void *)&rawValue, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty,
lastData->coreIndex, a);
return;
} else if (lastData->propType == QMetaType::QReal && value.isNumber()) {
qreal rawValue = qreal(value.toNumber());
int status = -1;
int flags = 0;
void *a[] = { (void *)&rawValue, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty,
lastData->coreIndex, a);
return;
} else if (lastData->propType == QMetaType::QString && value.isString()) {
const QString &rawValue = value.toString();
int status = -1;
int flags = 0;
void *a[] = { (void *)&rawValue, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty,
lastData->coreIndex, a);
return;
}
QVariant v;
if (lastData->flags & QDeclarativePropertyCache::Data::IsQList)
v = enginePriv->scriptValueToVariant(value, qMetaTypeId<QList<QObject *> >());
else
v = enginePriv->scriptValueToVariant(value, lastData->propType);
if (!QDeclarativePropertyPrivate::write(obj, *lastData, v, evalContext)) {
const char *valueType = 0;
if (v.userType() == QVariant::Invalid) valueType = "null";
else valueType = QMetaType::typeName(v.userType());
QString error = QLatin1String("Cannot assign ") +
QLatin1String(valueType) +
QLatin1String(" to ") +
QLatin1String(QMetaType::typeName(lastData->propType));
context->throwError(error);
}
}
}
QString QFormScriptRunner::QFormScriptRunnerPrivate::engineError(QScriptEngine &scriptEngine) {
QScriptValue error = scriptEngine.evaluate(QLatin1String("Error"));
if (error.isValid())
return error.toString();
return QCoreApplication::tr("Unknown error");
}
void REcmaNavigationAction::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RNavigationAction*) 0)));
protoCreated = true;
}
// primary base class RActionAdapter:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RActionAdapter*>());
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 RActionAdapter
REcmaHelper::registerFunction(&engine, proto, getRActionAdapter, "getRActionAdapter");
// conversion for base class RAction
REcmaHelper::registerFunction(&engine, proto, getRAction, "getRAction");
// 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, mousePressEvent, "mousePressEvent");
REcmaHelper::registerFunction(&engine, proto, mouseReleaseEvent, "mouseReleaseEvent");
REcmaHelper::registerFunction(&engine, proto, mouseMoveEvent, "mouseMoveEvent");
engine.setDefaultPrototype(
qMetaTypeId<RNavigationAction*>(), *proto);
QScriptValue ctor = engine.newFunction(create, *proto, 2);
// static methods:
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RNavigationAction",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
QScriptValue REcmaHelper::toScriptValue(QScriptEngine* engine, QSharedPointer<REntityData>& cppValue) {
QScriptValue v;
v = tryCast<RAttributeData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RAttributeDefinitionData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RArcData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RBlockReferenceData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RCircleData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimAlignedData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimAngularData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimDiametricData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimOrdinateData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimRadialData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RDimRotatedData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<REllipseData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RHatchData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RImageData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RLeaderData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RLineData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RPointData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RPolylineData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RSolidData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RSplineData>(engine, cppValue);
if (v.isValid()) return v;
v = tryCast<RTextData>(engine, cppValue);
if (v.isValid()) return v;
return qScriptValueFromValue(engine, cppValue);
}
void REcmaCircleEntity::init(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RCircleEntity*) 0)));
protoCreated = true;
}
// primary base class REntity:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<REntity*>());
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 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, clone, "clone");
REcmaHelper::registerFunction(&engine, proto, getType, "getType");
REcmaHelper::registerFunction(&engine, proto, setProperty, "setProperty");
REcmaHelper::registerFunction(&engine, proto, getProperty, "getProperty");
REcmaHelper::registerFunction(&engine, proto, exportEntity, "exportEntity");
REcmaHelper::registerFunction(&engine, proto, getData, "getData");
REcmaHelper::registerFunction(&engine, proto, getCenter, "getCenter");
REcmaHelper::registerFunction(&engine, proto, getRadius, "getRadius");
REcmaHelper::registerFunction(&engine, proto, setRadius, "setRadius");
REcmaHelper::registerFunction(&engine, proto, getLength, "getLength");
engine.setDefaultPrototype(
qMetaTypeId<RCircleEntity*>(), *proto);
QScriptValue ctor = engine.newFunction(create, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, init, "init");
REcmaHelper::registerFunction(&engine, &ctor, getStaticPropertyTypeIds, "getStaticPropertyTypeIds");
// static properties:
ctor.setProperty("PropertyCustom",
qScriptValueFromValue(&engine, RCircleEntity::PropertyCustom),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyHandle",
qScriptValueFromValue(&engine, RCircleEntity::PropertyHandle),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyType",
qScriptValueFromValue(&engine, RCircleEntity::PropertyType),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyBlock",
qScriptValueFromValue(&engine, RCircleEntity::PropertyBlock),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLayer",
qScriptValueFromValue(&engine, RCircleEntity::PropertyLayer),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLinetype",
qScriptValueFromValue(&engine, RCircleEntity::PropertyLinetype),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLineweight",
qScriptValueFromValue(&engine, RCircleEntity::PropertyLineweight),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyColor",
qScriptValueFromValue(&engine, RCircleEntity::PropertyColor),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDrawOrder",
qScriptValueFromValue(&engine, RCircleEntity::PropertyDrawOrder),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterX",
qScriptValueFromValue(&engine, RCircleEntity::PropertyCenterX),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterY",
qScriptValueFromValue(&engine, RCircleEntity::PropertyCenterY),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterZ",
qScriptValueFromValue(&engine, RCircleEntity::PropertyCenterZ),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyRadius",
qScriptValueFromValue(&engine, RCircleEntity::PropertyRadius),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDiameter",
qScriptValueFromValue(&engine, RCircleEntity::PropertyDiameter),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCircumference",
qScriptValueFromValue(&engine, RCircleEntity::PropertyCircumference),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyArea",
qScriptValueFromValue(&engine, RCircleEntity::PropertyArea),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RCircleEntity",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void REcmaImportListenerAdapter::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RImportListenerAdapter*) 0)));
protoCreated = true;
}
// primary base class QObject:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<QObject*>());
if (dpt.isValid()) {
proto->setPrototype(dpt);
}
/*
REcmaImportListener::initEcma(engine, proto);
*/
QScriptValue fun;
// toString:
REcmaHelper::registerFunction(&engine, proto, toString, "toString");
// destroy:
REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
// conversion for base class QObject
REcmaHelper::registerFunction(&engine, proto, getQObject, "getQObject");
// conversion for base class RImportListener
REcmaHelper::registerFunction(&engine, proto, getRImportListener, "getRImportListener");
// get class name
REcmaHelper::registerFunction(&engine, proto, getClassName, "getClassName");
// conversion to all base classes (multiple inheritance):
REcmaHelper::registerFunction(&engine, proto, getBaseClasses, "getBaseClasses");
// properties of secondary base class RImportListener:
// methods of secondary base class RImportListener:
// properties:
// methods:
REcmaHelper::registerFunction(&engine, proto, preImportEvent, "preImportEvent");
REcmaHelper::registerFunction(&engine, proto, postImportEvent, "postImportEvent");
engine.setDefaultPrototype(
qMetaTypeId<RImportListenerAdapter*>(), *proto);
qScriptRegisterMetaType<
RImportListenerAdapter*>(
&engine, toScriptValue, fromScriptValue, *proto);
QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
// static methods:
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RImportListenerAdapter",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void tst_QScriptValueGenerated::isValid_test(const char*, const QScriptValue& value)
{
QFETCH(bool, expected);
QCOMPARE(value.isValid(), expected);
QCOMPARE(value.isValid(), expected);
}
QScriptValue DefaultScriptClass::property(const QScriptValue& object, const QScriptString& name, uint id)
{
Q_ASSERT(mHandlerInfo->mode() != ScriptHandlerInfo::None);
DataInformation* data = toDataInformation(object);
if (!data)
{
mHandlerInfo->logger()->error() << "could not cast data from" << object.data().toString();
return engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Attempting to access an invalid object"));
}
if (name == s_valid)
{
return data->validationSuccessful();
}
else if (name == s_wasAbleToRead)
{
return data->wasAbleToRead();
}
else if (name == s_parent)
{
Q_CHECK_PTR(data->parent());
//parent() cannot be null
if (data->parent()->isTopLevel())
return engine()->nullValue();
return data->parent()->asDataInformation()->toScriptValue(engine(), mHandlerInfo);
}
else if (name == s_datatype)
{
return data->typeName();
}
else if (name == s_updateFunc)
{
return data->updateFunc();
}
else if (name == s_validationFunc)
{
return data->validationFunc();
}
else if (name == s_validationError)
{
return data->validationError();
}
else if (name == s_byteOrder)
{
return ParserUtils::byteOrderToString(data->byteOrder());
}
else if (name == s_name)
{
return data->name();
}
else if (name == s_customTypeName)
{
return data->typeName();
}
else if (name == s_asStringFunc)
{
return data->toStringFunction();
}
QScriptValue other = additionalProperty(data, name, id);
if (other.isValid())
return other;
else
{
data->logError() << "could not find property with name" << name.toString();
return engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Cannot read property ") + name.toString());
}
}
void REcmaSnapAuto::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RSnapAuto*) 0)));
protoCreated = true;
}
// primary base class RSnap:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RSnap*>());
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 RSnap
REcmaHelper::registerFunction(&engine, proto, getRSnap, "getRSnap");
// 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, snap, "snap");
engine.setDefaultPrototype(
qMetaTypeId<RSnapAuto*>(), *proto);
QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, init, "init");
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RSnapAuto",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void DefaultScriptClass::setProperty(QScriptValue& object, const QScriptString& name, uint id, const QScriptValue& value)
{
const ScriptHandlerInfo::Mode mode = mHandlerInfo->mode();
Q_ASSERT(mode != ScriptHandlerInfo::None);
DataInformation* data = toDataInformation(object);
if (!data)
{
mHandlerInfo->logger()->error() << "could not cast data from" << object.data().toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Attempting to access an invalid object"));
return;
}
if (mode == ScriptHandlerInfo::Validating)
{
//only way write access is allowed is when validating: valid and validationError
if (data->hasBeenValidated())
data->logError() << "Cannot modify this object, it has already been validated!";
else if (name == s_valid)
data->mValidationSuccessful = value.toBool();
else if (name == s_validationError)
data->setValidationError(value.toString());
else
data->logError() << "Cannot write to property" << name.toString() << "while validating!";
return;
}
if (mode != ScriptHandlerInfo::Updating)
{
data->logError() << "Writing to property" << name.toString() << "is only allowed when updating.";
return;
}
Q_ASSERT(mode == ScriptHandlerInfo::Updating);
if (name == s_byteOrder)
{
data->setByteOrder(ParserUtils::byteOrderFromString(value.toString(),
LoggerWithContext(data->logger(), data->fullObjectPath())));
}
else if (name == s_datatype)
{
//change the type of the underlying object
setDataType(value, data);
}
else if (name == s_updateFunc)
{
data->setUpdateFunc(value);
}
else if (name == s_validationFunc)
{
data->setValidationFunc(value);
}
else if (name == s_name)
{
data->setName(value.toString());
}
else if (name == s_customTypeName)
{
if (!value.isValid() || value.isNull() || value.isUndefined())
data->setCustomTypeName(QString()); //unset
else
data->setCustomTypeName(value.toString());
}
else if (name == s_asStringFunc)
{
data->setToStringFunction(value);
}
else
{
bool setAdditional = setAdditionalProperty(data, name, id, value);
if (setAdditional)
return;
else
{
data->logError() << "could not set property with name" << name.toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Cannot write property ") + name.toString());
}
}
}
/*
Documented in qdeclarativeengine.cpp
*/
QScriptValue QDeclarativeInclude::include(QScriptContext *ctxt, QScriptEngine *engine)
{
if (ctxt->argumentCount() == 0)
return engine->undefinedValue();
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
QUrl contextUrl = ep->contextClass->urlFromValue(QScriptDeclarativeClass::scopeChainValue(ctxt, -3));
if (contextUrl.isEmpty())
return ctxt->throwError(QLatin1String("Qt.include(): Can only be called from JavaScript files"));
QString urlString = ctxt->argument(0).toString();
QUrl url(urlString);
if (url.isRelative()) {
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()) {
QDeclarativeInclude *i =
new QDeclarativeInclude(url, QDeclarativeEnginePrivate::getEngine(engine), ctxt);
if (func.isValid())
i->setCallback(func);
result = i->result();
} else {
QFile f(localFile);
if (f.open(QIODevice::ReadOnly)) {
QByteArray data = f.readAll();
QString code = QString::fromUtf8(data);
QDeclarativeContextData *context =
ep->contextClass->contextFromValue(QScriptDeclarativeClass::scopeChainValue(ctxt, -3));
QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(engine);
scriptContext->pushScope(ep->contextClass->newUrlContext(context, 0, urlString));
scriptContext->pushScope(ep->globalClass->staticGlobalObject());
QScriptValue scope = QScriptDeclarativeClass::scopeChainValue(ctxt, -5);
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;
}
vector<Document::Sketch> Document::_readNative(QTextStream &stream)
{
QString contents = stream.readAll();
QScriptValue all;
QScriptEngine engine;
all = engine.evaluate(contents); //parse the JSON
vector<Sketch> out;
if(!all.isArray())
return out;
QScriptValueIterator it(all);
while (it.hasNext()) {
it.next();
QScriptValue curSketch = it.value();
Sketch cur;
//read the points
QScriptValue pts = curSketch.property("pts");
if(!pts.isValid() || !pts.isArray() || pts.property("length").toInt32() % 2 != 0)
return out;
int numPts = pts.property("length").toInt32() / 2;
Cornu::VectorC<Vector2d> readPts;
QScriptValueIterator it2(pts);
for(int i = 0; i < numPts; ++i)
{
it2.next();
double x = it2.value().toNumber();
it2.next();
double y = it2.value().toNumber();
readPts.push_back(Vector2d(x, y));
}
cur.pts = new Cornu::Polyline(readPts);
//read the parameters
QScriptValueIterator it3(curSketch);
while(it3.hasNext())
{
it3.next();
if(!it3.value().isNumber())
continue;
QByteArray nameArray = it3.name().toAscii();
std::string name(nameArray.constData(), nameArray.length());
double value = it3.value().toNumber();
//check parameters
const vector<Cornu::Parameters::Parameter> ¶ms = Cornu::Parameters::parameters();
for(int i = 0; i < (int)params.size(); ++i)
{
if(params[i].typeName == name)
{
cur.params.set(params[i].type, value);
break;
}
}
//check algorithms
for(int i = 0; i < Cornu::NUM_ALGORITHM_STAGES; ++i)
{
if(name == Cornu::AlgorithmBase::get((Cornu::AlgorithmStage)i, 0)->stageName())
{
cur.params.setAlgorithm(i, (int)value);
break;
}
}
}
QScriptValue oversketch = curSketch.property("oversketch");
if(oversketch.isValid() && oversketch.isNumber())
cur.oversketch = oversketch.toInt32();
if(cur.oversketch < 0 || cur.oversketch >= (int)out.size()) //check that the index is valid
cur.oversketch = -1;
cur.name = _getNextSketchName();
out.push_back(cur);
}
return out;
}
void REcmaDimLinearEntity::initEcma(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(createEcma, *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("PropertyProtected",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyProtected),
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("PropertyLinetypeScale",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyLinetypeScale),
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("PropertyDisplayedColor",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyDisplayedColor),
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("PropertyMeasuredValue",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyMeasuredValue),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLinearFactor",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyLinearFactor),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDimScale",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyDimScale),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyAutoTextPos",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyAutoTextPos),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyFontName",
qScriptValueFromValue(&engine, RDimLinearEntity::PropertyFontName),
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 REcmaView::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RView*) 0)));
protoCreated = true;
}
// primary base class RObject:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RObject*>());
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 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, clone, "clone");
REcmaHelper::registerFunction(&engine, proto, getName, "getName");
REcmaHelper::registerFunction(&engine, proto, setName, "setName");
REcmaHelper::registerFunction(&engine, proto, getCenterPoint, "getCenterPoint");
REcmaHelper::registerFunction(&engine, proto, setCenterPoint, "setCenterPoint");
REcmaHelper::registerFunction(&engine, proto, getWidth, "getWidth");
REcmaHelper::registerFunction(&engine, proto, setWidth, "setWidth");
REcmaHelper::registerFunction(&engine, proto, getHeight, "getHeight");
REcmaHelper::registerFunction(&engine, proto, setHeight, "setHeight");
REcmaHelper::registerFunction(&engine, proto, getBox, "getBox");
REcmaHelper::registerFunction(&engine, proto, getProperty, "getProperty");
REcmaHelper::registerFunction(&engine, proto, setProperty, "setProperty");
REcmaHelper::registerFunction(&engine, proto, isSelectedForPropertyEditing, "isSelectedForPropertyEditing");
engine.setDefaultPrototype(
qMetaTypeId<RView*>(), *proto);
QScriptValue ctor = engine.newFunction(create, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, init, "init");
// static properties:
ctor.setProperty("PropertyName",
qScriptValueFromValue(&engine, RView::PropertyName),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterPoint",
qScriptValueFromValue(&engine, RView::PropertyCenterPoint),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyWidth",
qScriptValueFromValue(&engine, RView::PropertyWidth),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyHeight",
qScriptValueFromValue(&engine, RView::PropertyHeight),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RView",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void REcmaDimRadialData::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RDimRadialData*) 0)));
protoCreated = true;
}
// primary base class RDimensionData:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RDimensionData*>());
if (dpt.isValid()) {
proto->setPrototype(dpt);
}
/*
*/
QScriptValue fun;
// toString:
REcmaHelper::registerFunction(&engine, proto, toString, "toString");
// copy:
REcmaHelper::registerFunction(&engine, proto, copy, "copy");
// destroy:
REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
// conversion for base class RDimensionData
REcmaHelper::registerFunction(&engine, proto, getRDimensionData, "getRDimensionData");
// conversion for base class REntityData
REcmaHelper::registerFunction(&engine, proto, getREntityData, "getREntityData");
// 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, isValid, "isValid");
REcmaHelper::registerFunction(&engine, proto, setCenter, "setCenter");
REcmaHelper::registerFunction(&engine, proto, getCenter, "getCenter");
REcmaHelper::registerFunction(&engine, proto, setChordPoint, "setChordPoint");
REcmaHelper::registerFunction(&engine, proto, getChordPoint, "getChordPoint");
REcmaHelper::registerFunction(&engine, proto, getReferencePoints, "getReferencePoints");
REcmaHelper::registerFunction(&engine, proto, moveReferencePoint, "moveReferencePoint");
REcmaHelper::registerFunction(&engine, proto, move, "move");
REcmaHelper::registerFunction(&engine, proto, rotate, "rotate");
REcmaHelper::registerFunction(&engine, proto, scale, "scale");
REcmaHelper::registerFunction(&engine, proto, mirror, "mirror");
REcmaHelper::registerFunction(&engine, proto, getShapes, "getShapes");
REcmaHelper::registerFunction(&engine, proto, getMeasuredValue, "getMeasuredValue");
REcmaHelper::registerFunction(&engine, proto, getAutoLabel, "getAutoLabel");
engine.setDefaultPrototype(
qMetaTypeId<RDimRadialData*>(), *proto);
engine.setDefaultPrototype(qMetaTypeId<
RDimRadialData
> (), *proto);
QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
// static methods:
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RDimRadialData",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
void Color::fromScriptValue(const QScriptValue &object)
{
// red component
QScriptValue value = object.property("r");
if ((!value.isValid()) || (value.isUndefined()))
{
// property is not valid or Undefined. set to 0, not the default NaN
m_r = 0;
}
else
{
// convert to unsigned integer
quint32 r = value.toUInt32();
if (r > MAX_COLOR_VALUE)
{
// clip value
m_r = MAX_COLOR_VALUE;
}
else
{
m_r = r;
}
}
// green component
value = object.property("g");
if ((!value.isValid()) || (value.isUndefined()))
{
// property is not valid or Undefined. set to 0, not the default NaN
m_g = 0;
}
else
{
// convert to unsigned integer
quint32 g = value.toUInt32();
if (g > MAX_COLOR_VALUE)
{
// clip value
m_g = MAX_COLOR_VALUE;
}
else
{
m_g = g;
}
}
// blue component
value = object.property("b");
if ((!value.isValid()) || (value.isUndefined()))
{
// property is Undefined. set to 0, not the default NaN
m_b = 0;
}
else
{
// convert to unsigned integer
quint32 b = value.toUInt32();
if (b > MAX_COLOR_VALUE)
{
// clip value
m_b = MAX_COLOR_VALUE;
}
else
{
m_b = b;
}
}
}
