static void qtscript_QDomImplementation_InvalidDataPolicy_fromScriptValue(const QScriptValue &value, QDomImplementation::InvalidDataPolicy &out)
{
    out = qvariant_cast<QDomImplementation::InvalidDataPolicy>(value.toVariant());
}
static void qtscript_QFormLayout_ItemRole_fromScriptValue(const QScriptValue &value, QFormLayout::ItemRole &out)
{
    out = qvariant_cast<QFormLayout::ItemRole>(value.toVariant());
}
static void qtscript_QFormLayout_RowWrapPolicy_fromScriptValue(const QScriptValue &value, QFormLayout::RowWrapPolicy &out)
{
    out = qvariant_cast<QFormLayout::RowWrapPolicy>(value.toVariant());
}
static void qtscript_QTextFormat_FormatType_fromScriptValue(const QScriptValue &value, QTextFormat::FormatType &out)
{
    out = qvariant_cast<QTextFormat::FormatType>(value.toVariant());
}
static void qtscript_QTextFormat_PageBreakFlag_fromScriptValue(const QScriptValue &value, QTextFormat::PageBreakFlag &out)
{
    out = qvariant_cast<QTextFormat::PageBreakFlag>(value.toVariant());
}
static void qtscript_QTimeLine_CurveShape_fromScriptValue(const QScriptValue &value, QTimeLine::CurveShape &out)
{
    out = qvariant_cast<QTimeLine::CurveShape>(value.toVariant());
}
Beispiel #7
0
static void qtscript_QXmlQuery_QueryLanguage_fromScriptValue(const QScriptValue &value, QXmlQuery::QueryLanguage &out)
{
    out = qvariant_cast<QXmlQuery::QueryLanguage>(value.toVariant());
}
static void qtscript_QStyleOptionGraphicsItem_StyleOptionVersion_fromScriptValue(const QScriptValue &value, QStyleOptionGraphicsItem::StyleOptionVersion &out)
{
    out = qvariant_cast<QStyleOptionGraphicsItem::StyleOptionVersion>(value.toVariant());
}
static void qtscript_QProcess_ProcessState_fromScriptValue(const QScriptValue &value, QProcess::ProcessState &out)
{
    out = qvariant_cast<QProcess::ProcessState>(value.toVariant());
}
Beispiel #10
0
void Plugin::setSetting(const QString& name, const QScriptValue& value) {
	mv::Settings settings;
	settings.beginGroup("plugins/" + plugin_->id());
	settings.setValue(name, value.toVariant());
}
Beispiel #11
0
      void REcmaSnap::fromScriptValueEnumStatus(const QScriptValue& value, RSnap::Status& out)
 
     {
         out = qvariant_cast<RSnap::Status>(value.toVariant());
     }
Beispiel #12
0
void QSqlDatabasePtrfromScriptValue(const QScriptValue &obj, QSqlDatabase* &item)
{
  item = obj.toVariant().value<QSqlDatabase*>();
}
/*!
    Returns the match score for converting \a actual to be of type \a conversionType.  A
    zero score means "perfect match" whereas a higher score is worse.

    The conversion table is copied out of the QtScript callQtMethod() function.
*/
int QDeclarativeObjectMethodScriptClass::matchScore(const QScriptValue &actual, int conversionType,
                                                    const QByteArray &conversionTypeName)
{
    if (actual.isNumber()) {
        switch (conversionType) {
        case QMetaType::Double:
            return 0;
        case QMetaType::Float:
            return 1;
        case QMetaType::LongLong:
        case QMetaType::ULongLong:
            return 2;
        case QMetaType::Long:
        case QMetaType::ULong:
            return 3;
        case QMetaType::Int:
        case QMetaType::UInt:
            return 4;
        case QMetaType::Short:
        case QMetaType::UShort:
            return 5;
            break;
        case QMetaType::Char:
        case QMetaType::UChar:
            return 6;
        default:
            return 10;
        }
    } else if (actual.isString()) {
        switch (conversionType) {
        case QMetaType::QString:
            return 0;
        default:
            return 10;
        }
    } else if (actual.isBoolean()) {
        switch (conversionType) {
        case QMetaType::Bool:
            return 0;
        default:
            return 10;
        }
    } else if (actual.isDate()) {
        switch (conversionType) {
        case QMetaType::QDateTime:
            return 0;
        case QMetaType::QDate:
            return 1;
        case QMetaType::QTime:
            return 2;
        default:
            return 10;
        }
    } else if (actual.isRegExp()) {
        switch (conversionType) {
        case QMetaType::QRegExp:
            return 0;
        default:
            return 10;
        }
    } else if (actual.isVariant()) {
        if (conversionType == qMetaTypeId<QVariant>())
            return 0;
        else if (actual.toVariant().userType() == conversionType)
            return 0;
        else
            return 10;
    } else if (actual.isArray()) {
        switch (conversionType) {
        case QMetaType::QStringList:
        case QMetaType::QVariantList:
            return 5;
        default:
            return 10;
        }
    } else if (actual.isQObject()) {
        switch (conversionType) {
        case QMetaType::QObjectStar:
            return 0;
        default:
            return 10;
        }
    } else if (actual.isNull()) {
        switch (conversionType) {
        case QMetaType::VoidStar:
        case QMetaType::QObjectStar:
            return 0;
        default:
            if (!conversionTypeName.endsWith('*'))
                return 10;
            else
                return 0;
        }
    } else {
        return 10;
    }
}
static void qtscript_QWebElement_StyleResolveStrategy_fromScriptValue(const QScriptValue &value, QWebElement::StyleResolveStrategy &out)
{
    out = qvariant_cast<QWebElement::StyleResolveStrategy>(value.toVariant());
}
Beispiel #15
0
    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;
	}
static void qtscript_QProcess_ExitStatus_fromScriptValue(const QScriptValue &value, QProcess::ExitStatus &out)
{
    out = qvariant_cast<QProcess::ExitStatus>(value.toVariant());
}
static void qtscript_QTimeLine_Direction_fromScriptValue(const QScriptValue &value, QTimeLine::Direction &out)
{
    out = qvariant_cast<QTimeLine::Direction>(value.toVariant());
}
Beispiel #18
0
static void qtscript_QDate_MonthNameType_fromScriptValue(const QScriptValue &value, QDate::MonthNameType &out)
{
    out = qvariant_cast<QDate::MonthNameType>(value.toVariant());
}
static void qtscript_QTimeLine_State_fromScriptValue(const QScriptValue &value, QTimeLine::State &out)
{
    out = qvariant_cast<QTimeLine::State>(value.toVariant());
}
Beispiel #20
0
QScriptValue constructQSslKey(QScriptContext *context,
                                    QScriptEngine  *engine)
{
  QSslKey *obj = 0;
  QString key;
  QSsl::KeyAlgorithm algorithm;
  QSsl::EncodingFormat encoding;
  QSsl::KeyType type;
  QByteArray passPhrase;

  if (context->argumentCount() == 1) { // Handle `const QSslKey & other`.
    QSslKey paramKey = qscriptvalue_cast<QSslKey>(context->argument(0));
    obj = new QSslKey(paramKey);
  } else if (context->argumentCount() >= 2) {
    QScriptValue arg = context->argument(0);
    // TODO: How to check is this is a QByteArray or QIODevice*???
    key = arg.toString();
    algorithm = static_cast<QSsl::KeyAlgorithm>(context->argument(1).toInt32());

    if (key.length() > 0) { // Handle `const QByteArray & encoded`.
      QByteArray encoded = arg.toVariant().toByteArray();
      if (context->argumentCount() == 2) {
        obj = new QSslKey(encoded, algorithm);
      } else if (context->argumentCount() == 3) {
        encoding = static_cast<QSsl::EncodingFormat>(context->argument(2).toInt32());
        obj = new QSslKey(encoded, algorithm, encoding);
      } else if (context->argumentCount() == 4) {
        encoding = static_cast<QSsl::EncodingFormat>(context->argument(2).toInt32());
        type = static_cast<QSsl::KeyType>(context->argument(3).toInt32());
        obj = new QSslKey(encoded, algorithm, encoding, type);
      } else if (context->argumentCount() == 5) {
        encoding = static_cast<QSsl::EncodingFormat>(context->argument(2).toInt32());
        type = static_cast<QSsl::KeyType>(context->argument(3).toInt32());
        passPhrase = context->argument(4).toVariant().toByteArray();
        obj = new QSslKey(encoded, algorithm, encoding, type, passPhrase);
      }
    }
    // TODO: Something is wrong with how we expose QIODevice
    /*
    else { // Handle `QIODevice * device`.
      QIODevice *device = qscriptvalue_cast<QIODevice*>(arg);
      if (context->argumentCount() == 2) {
        obj = new QSslKey(device, algorithm);
      } else if (context->argumentCount() == 3) {
        encoding = static_cast<QSsl::EncodingFormat>(context->argument(2).toInt32());
        obj = new QSslKey(device, algorithm, encoding);
      } else if (context->argumentCount() == 4) {
        encoding = static_cast<QSsl::EncodingFormat>(context->argument(2).toInt32());
        type = static_cast<QSsl::KeyType>(context->argument(3).toInt32());
        obj = new QSslKey(device, algorithm, encoding, type);
      } else if (context->argumentCount() == 5) {
        encoding = static_cast<QSsl::EncodingFormat>(context->argument(2).toInt32());
        type = static_cast<QSsl::KeyType>(context->argument(3).toInt32());
        passPhrase = context->argument(4).toVariant().toByteArray();
        obj = new QSslKey(device, algorithm, encoding, type, passPhrase);
      }
    }
    */
  } else {
    context->throwError(QScriptContext::UnknownError,
                        "No SSL Key provided to QSslKey");
  }

  return engine->toScriptValue(obj);
}
static void qtscript_QTextFormat_Property_fromScriptValue(const QScriptValue &value, QTextFormat::Property &out)
{
    out = qvariant_cast<QTextFormat::Property>(value.toVariant());
}
static void qtscript_QHeaderView_ResizeMode_fromScriptValue(const QScriptValue &value, QHeaderView::ResizeMode &out)
{
    out = qvariant_cast<QHeaderView::ResizeMode>(value.toVariant());
}
static void qtscript_QTextFormat_ObjectTypes_fromScriptValue(const QScriptValue &value, QTextFormat::ObjectTypes &out)
{
    out = qvariant_cast<QTextFormat::ObjectTypes>(value.toVariant());
}
Beispiel #24
0
static void qtscript_QComboBox_SizeAdjustPolicy_fromScriptValue(const QScriptValue &value, QComboBox::SizeAdjustPolicy &out)
{
    out = qvariant_cast<QComboBox::SizeAdjustPolicy>(value.toVariant());
}
static void qtscript_QAbstractPrintDialog_PrintDialogOption_fromScriptValue(const QScriptValue &value, QAbstractPrintDialog::PrintDialogOption &out)
{
    out = qvariant_cast<QAbstractPrintDialog::PrintDialogOption>(value.toVariant());
}
Beispiel #26
0
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();
        }
    }
}
static void qtscript_QFormLayout_FieldGrowthPolicy_fromScriptValue(const QScriptValue &value, QFormLayout::FieldGrowthPolicy &out)
{
    out = qvariant_cast<QFormLayout::FieldGrowthPolicy>(value.toVariant());
}
static void qtscript_QStyleOptionProgressBar_StyleOptionVersion_fromScriptValue(const QScriptValue &value, QStyleOptionProgressBar::StyleOptionVersion &out)
{
    out = qvariant_cast<QStyleOptionProgressBar::StyleOptionVersion>(value.toVariant());
}
Beispiel #29
0
static void qtscript_QGLShader_ShaderTypeBit_fromScriptValue(const QScriptValue &value, QGLShader::ShaderTypeBit &out)
{
    out = qvariant_cast<QGLShader::ShaderTypeBit>(value.toVariant());
}
static void qtscript_QReadWriteLock_RecursionMode_fromScriptValue(const QScriptValue &value, QReadWriteLock::RecursionMode &out)
{
    out = qvariant_cast<QReadWriteLock::RecursionMode>(value.toVariant());
}