Example #1
0
void HumanListModel::setData(const long id, const QVariant &value, int role)
{
    switch (role)
    {
    case Human::ProfessionRole:
    {
        Human * item = (Human *)find( id );
        item->setProfession(value.toString());
        break;
    }
    case Human::MoraleRole:
    {
        Human * item = (Human *)find( id );
        item->setMorale(value.toFloat());
        break;
    }
    case Human::FatigueRole:
    {
        Human * item = (Human *)find( id );
        item->setFatigue(value.toFloat());
        break;
    }
    case Human::HungerRole:
    {
        Human * item = (Human *)find( id );
        item->setHunger(value.toFloat());
        break;
    }
    default:
        qWarning() << "HumanListModel::setData does not understand what role" << role << "is.";
        break;
    }
}
void RenderingItem::setValue(QVariant new_value)
{
    if(value == new_value)
        return;
    value = new_value;
    if(!GUI)
        return;
    if(QString(GUI->metaObject()->className()) == "QSlider")
    {
        QSlider *slider = (QSlider*)GUI;
        if(slider->maximum() == 10) // int
            slider->setValue(new_value.toInt());
        else
            slider->setValue(new_value.toFloat()*5.0);
    }
    if(QString(GUI->metaObject()->className()) == "QColorToolButton")
    {
        ((QColorToolButton*)GUI)->setColor(new_value.toInt());
    }
    if(QString(GUI->metaObject()->className()) == "QDoubleSpinBox")
    {
        ((QDoubleSpinBox*)GUI)->setValue(new_value.toFloat());
    }
    if(QString(GUI->metaObject()->className()) == "QSpinBox")
    {
        ((QSpinBox*)GUI)->setValue(new_value.toInt());

    }
    if(QString(GUI->metaObject()->className()) == "QComboBox")
    {
        ((QComboBox*)GUI)->setCurrentIndex(new_value.toInt());
    }
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
bool SGLogNormalTableModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
  // qDebug() << "SGLogNormalTableModel::setData " << value.toString() << "\n";
  if (!index.isValid() || role != Qt::EditRole || index.row() < 0 || index.row() >= m_BinNumbers.count() || index.column() < 0 || index.column()
      >= m_ColumnCount)
  {
    return false;
  }
  bool ok;
  qint32 row = index.row();
  qint32 col = index.column();
  switch(col)
  {
    case BinNumber:
      m_BinNumbers[row] = value.toFloat(&ok);
      break;
    case Average:
      m_Average[row] = value.toFloat(&ok);
      break;
    case StdDev:
      m_StdDev[row] = value.toFloat(&ok);
      break;
    case LineColor:
      m_Colors[row] = value.toString();
      break;
    default:
      Q_ASSERT(false);

  }

  emit
  dataChanged(index, index);
  return true;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
bool SGBetaTableModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
  // std::cout << "SGBetaTableModel::setData " << value.toString().toStdString() << std::endl;
  if (!index.isValid() || role != Qt::EditRole || index.row() < 0 || index.row() >= m_BinNumbers.count() || index.column() < 0 || index.column()
      >= m_ColumnCount)
  {
    return false;
  }
  bool ok;
  qint32 row = index.row();
  qint32 col = index.column();
  switch(col)
  {
    case BinNumber:
      m_BinNumbers[row] = value.toFloat(&ok);
      break;
    case Alpha:
      m_Alpha[row] = value.toFloat(&ok);
      break;
    case Beta:
      m_Beta[row] = value.toFloat(&ok);
      break;
    case LineColor:
      m_Colors[row] = value.toString();
      break;
    default:
      Q_ASSERT(false);

  }

  emit
  dataChanged(index, index);
  return true;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
bool SGMDFTableModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
  // qDebug() << "SGMDFTableModel::setData " << value.toString() << "\n";
  if (!index.isValid() || role != Qt::EditRole || index.row() < 0 || index.row() >= m_Angles.count() || index.column() < 0 || index.column()
      >= m_ColumnCount)
  {
    return false;
  }
  bool ok;
  qint32 row = index.row();
  qint32 col = index.column();
  switch(col)
  {
    case Angle:
      m_Angles[row] = value.toFloat(&ok);
      break;
    case Axis:
      m_Axis[row] = value.toString();
      break;
    case Weight:
      m_Weights[row] = value.toFloat(&ok);
      break;

    default:
      Q_ASSERT(false);

  }

  emit dataChanged(index, index);
  return true;
}
Example #6
0
bool
APETagHelper::setTags( const Meta::FieldHash &changes )
{
    bool modified = TagHelper::setTags( changes );

    foreach( const qint64 key, changes.keys() )
    {
        QVariant value = changes.value( key );
        TagLib::String field = fieldName( key );

        if( !field.isNull() && !field.isEmpty() )
        {
            if( key == Meta::valRating )
                m_tag->addValue( field, Qt4QStringToTString( QString::number( value.toFloat() / 10.0 ) ) );
            else if( key == Meta::valScore )
                m_tag->addValue( field, Qt4QStringToTString( QString::number( value.toFloat() / 100.0 ) ) );
            else
                m_tag->addValue( field, Qt4QStringToTString( value.toString() ) );

            modified = true;
        }
        else if( key == Meta::valUniqueId )
        {
            QPair < UIDType, QString > uidPair = splitUID( value.toString() );
            if( uidPair.first == UIDInvalid )
                continue;

            m_tag->addValue( uidFieldName( uidPair.first ), Qt4QStringToTString( uidPair.second ) );
            modified = true;
        }
    }

    return modified;
}
glm::quat EntityActionInterface::extractQuatArgument(QString objectName, QVariantMap arguments,
                                                     QString argumentName, bool& ok, bool required) {
    if (!arguments.contains(argumentName)) {
        if (required) {
            qDebug() << objectName << "requires argument:" << argumentName;
        }
        ok = false;
        return glm::quat();
    }

    QVariant resultV = arguments[argumentName];
    if (resultV.type() != (QVariant::Type) QMetaType::QVariantMap) {
        qDebug() << objectName << "argument" << argumentName << "must be a map, not" << resultV.typeName();
        ok = false;
        return glm::quat();
    }

    QVariantMap resultVM = resultV.toMap();
    if (!resultVM.contains("x") || !resultVM.contains("y") || !resultVM.contains("z") || !resultVM.contains("w")) {
        qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, z, and w";
        ok = false;
        return glm::quat();
    }

    QVariant xV = resultVM["x"];
    QVariant yV = resultVM["y"];
    QVariant zV = resultVM["z"];
    QVariant wV = resultVM["w"];

    bool xOk = true;
    bool yOk = true;
    bool zOk = true;
    bool wOk = true;
    float x = xV.toFloat(&xOk);
    float y = yV.toFloat(&yOk);
    float z = zV.toFloat(&zOk);
    float w = wV.toFloat(&wOk);
    if (!xOk || !yOk || !zOk || !wOk) {
        qDebug() << objectName << "argument" << argumentName
                 << "must be a map with keys: x, y, z, and w of type float.";
        ok = false;
        return glm::quat();
    }

    if (x != x || y != y || z != z || w != w) {
        // at least one of the components is NaN!
        ok = false;
        return glm::quat();
    }

    return glm::normalize(glm::quat(w, x, y, z));
}
/*!
 * Set an argument with the given index to the given value.
 *
 * @param index
 * @param value
 */
void Similarity::Input::set(int index, const QVariant& value)
{
   EDEBUG_FUNC(this,index,&value);

   switch (index)
   {
   case ClusteringType:
      _base->_clusMethod = static_cast<ClusteringMethod>(CLUSTERING_NAMES.indexOf(value.toString()));
      break;
   case CorrelationType:
      _base->_corrMethod = static_cast<CorrelationMethod>(CORRELATION_NAMES.indexOf(value.toString()));
      _base->_corrName = value.toString();
      break;
   case MinExpression:
      _base->_minExpression = value.toFloat();
      break;
   case MinSamples:
      _base->_minSamples = value.toInt();
      break;
   case MinClusters:
      _base->_minClusters = value.toInt();
      break;
   case MaxClusters:
      _base->_maxClusters = value.toInt();
      break;
   case CriterionType:
      _base->_criterion = static_cast<Pairwise::Criterion>(CRITERION_NAMES.indexOf(value.toString()));
      break;
   case RemovePreOutliers:
      _base->_removePreOutliers = value.toBool();
      break;
   case RemovePostOutliers:
      _base->_removePostOutliers = value.toBool();
      break;
   case MinCorrelation:
      _base->_minCorrelation = value.toFloat();
      break;
   case MaxCorrelation:
      _base->_maxCorrelation = value.toFloat();
      break;
   case WorkBlockSize:
      _base->_workBlockSize = value.toInt();
      break;
   case GlobalWorkSize:
      _base->_globalWorkSize = value.toInt();
      break;
   case LocalWorkSize:
      _base->_localWorkSize = value.toInt();
      break;
   }
}
Example #9
0
void MRecord::setField(int field, QVariant value)
{
    switch (field) {
    case MFieldGlobal::BRAKE:
        Brake=value.toFloat();
        break;
    case MFieldGlobal::FUELCONSUMTION:
        FuelConsumtion=value.toFloat();
        break;
    case MFieldGlobal::GAS:
        Gas=value.toFloat();
        break;
    case MFieldGlobal::LATITUDE:
        Latitude=value.toDouble();
        break;
    case MFieldGlobal::LIMITSPEED:
        LimitSpeed=value.toFloat();
        break;
    case MFieldGlobal::LONGITUDE:
        Longitude=value.toDouble();
        break;
    case MFieldGlobal::MAXENCODE:
        MaxEncode=value.toFloat();
        break;
    case MFieldGlobal::ONOFF:
        ONOFF=value.toInt();
        break;
    case MFieldGlobal::ROTASPEED:
        RotaSpeed=value.toFloat();
        break;
    case MFieldGlobal::SPEED:
        Speed=value.toFloat();
        break;
    case MFieldGlobal::STEERANGLE:
        SteerAngel=value.toFloat();
        break;
    case MFieldGlobal::VALUE1:
        Value1=value.toFloat();
        break;
    case MFieldGlobal::VALUE2:
        Value2=value.toFloat();
        break;
    case MFieldGlobal::VALUE3:
        Value3=value.toInt();
        break;
    default:
        qDebug()<<"Value invalid in MRecord::setField!";
        break;
    }
}
glm::vec3 EntityActionInterface::extractVec3Argument(QString objectName, QVariantMap arguments,
                                                     QString argumentName, bool& ok, bool required) {
    if (!arguments.contains(argumentName)) {
        if (required) {
            qDebug() << objectName << "requires argument:" << argumentName;
        }
        ok = false;
        return glm::vec3(0.0f);
    }

    QVariant resultV = arguments[argumentName];
    if (resultV.type() != (QVariant::Type) QMetaType::QVariantMap) {
        qDebug() << objectName << "argument" << argumentName << "must be a map";
        ok = false;
        return glm::vec3(0.0f);
    }

    QVariantMap resultVM = resultV.toMap();
    if (!resultVM.contains("x") || !resultVM.contains("y") || !resultVM.contains("z")) {
        qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, z";
        ok = false;
        return glm::vec3(0.0f);
    }

    QVariant xV = resultVM["x"];
    QVariant yV = resultVM["y"];
    QVariant zV = resultVM["z"];

    bool xOk = true;
    bool yOk = true;
    bool zOk = true;
    float x = xV.toFloat(&xOk);
    float y = yV.toFloat(&yOk);
    float z = zV.toFloat(&zOk);
    if (!xOk || !yOk || !zOk) {
        qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, and z of type float.";
        ok = false;
        return glm::vec3(0.0f);
    }

    if (x != x || y != y || z != z) {
        // at least one of the values is NaN
        ok = false;
        return glm::vec3(0.0f);
    }

    return glm::vec3(x, y, z);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
bool ComparisonSelectionTableModel::setData(const QModelIndex & index, const QVariant & value, int role)
{
  // std::cout << "ComparisonSelectionTableModel::setData " << value.toString().toStdString() << std::endl;
  if (!index.isValid() || role != Qt::EditRole || index.row() < 0 || index.row() >= m_FieldNames.count() || index.column() < 0 || index.column()
      >= m_ColumnCount)
  {
    return false;
  }
  bool ok;
  qint32 row = index.row();
  qint32 col = index.column();
  switch(col)
  {
    case FieldName:
      m_FieldNames[row] = value.toString();
      break;
    case FieldValue:
      m_FieldValues[row] = value.toFloat(&ok);
      break;
    case FieldOperator:
      m_FieldOperators[row] =  value.toString();
      break;
//    case FieldPhaseValue:
//      m_FieldPhaseValues[row] =  value.toInt(&ok);
//      break;
    default:
      Q_ASSERT(false);

  }

  emit
  dataChanged(index, index);
  return true;
}
Example #12
0
        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
        {
            ESXRecordT record2 = record.get();

            switch (record2.mValue.getType())
            {
                case ESM::VT_String:

                    record2.mValue.setString (data.toString().toUtf8().constData());
                    break;

                case ESM::VT_Int:
                case ESM::VT_Short:
                case ESM::VT_Long:

                    record2.mValue.setInteger (data.toInt());
                    break;

                case ESM::VT_Float:

                    record2.mValue.setFloat (data.toFloat());
                    break;

                default: break;
            }

            record.setModified (record2);
        }
Example #13
0
glm::vec4 vec4FromVariant(const QVariant& object, bool& valid) {
    glm::vec4 v;
    valid = false;
    if (!object.isValid() || object.isNull()) {
        return v;
    } else if (object.canConvert<float>()) {
        v = glm::vec4(object.toFloat());
        valid = true;
    } else if (object.canConvert<QVector4D>()) {
        auto qvec4 = qvariant_cast<QVector4D>(object);
        v.x = qvec4.x();
        v.y = qvec4.y();
        v.z = qvec4.z();
        v.w = qvec4.w();
        valid = true;
    } else {
        auto map = object.toMap();
        auto x = map["x"];
        auto y = map["y"];
        auto z = map["z"];
        auto w = map["w"];
        if (x.canConvert<float>() && y.canConvert<float>() && z.canConvert<float>() && w.canConvert<float>()) {
            v.x = x.toFloat();
            v.y = y.toFloat();
            v.z = z.toFloat();
            v.w = w.toFloat();
            valid = true;
        }
    }
    return v;
}
void Transcoder::SetElementProperties(const QString& name, GObject* object) {
  QSettings s;
  s.beginGroup("Transcoder/" + name);

  guint properties_count = 0;
  GParamSpec** properties = g_object_class_list_properties(
        G_OBJECT_GET_CLASS(object), &properties_count);

  for (int i=0 ; i<properties_count ; ++i) {
    GParamSpec* property = properties[i];

    const QVariant value = s.value(property->name);
    if (value.isNull())
      continue;

    LogLine(QString("Setting %1 property: %2 = %3").arg(name, property->name, value.toString()));

    switch (property->value_type) {
      case G_TYPE_DOUBLE:  g_object_set(object, property->name, value.toDouble(), NULL); break;
      case G_TYPE_FLOAT:   g_object_set(object, property->name, value.toFloat(), NULL);  break;
      case G_TYPE_BOOLEAN: g_object_set(object, property->name, value.toInt(), NULL);    break;
      case G_TYPE_INT:
      default:             g_object_set(object, property->name, value.toInt(), NULL);    break;
    }
  }

  g_free(properties);
}
Example #15
0
void CSMWorld::ContainerRefIdAdapter::setData (const RefIdColumn *column, RefIdData& data, int index,
    const QVariant& value) const
{
    Record<ESM::Container>& record = static_cast<Record<ESM::Container>&> (
        data.getRecord (RefIdData::LocalIndex (index, UniversalId::Type_Container)));

    ESM::Container container = record.get();

    if (column==mWeight)
        container.mWeight = value.toFloat();
    else if (column==mOrganic)
    {
        if (value.toInt())
            container.mFlags |= ESM::Container::Organic;
        else
            container.mFlags &= ~ESM::Container::Organic;
    }
    else if (column==mRespawn)
    {
        if (value.toInt())
            container.mFlags |= ESM::Container::Respawn;
        else
            container.mFlags &= ~ESM::Container::Respawn;
    }
    else
    {
        NameRefIdAdapter<ESM::Container>::setData (column, data, index, value);

        return;
    }

    record.setModified(container);
}
Example #16
0
QString apiVariantToString(const QVariant &variant)
{
    if (variant.userType() == QVariant::Double) {
        return QString::number(variant.toFloat());
    }
    if (variant.userType() == QVariant::ByteArray) {
        if (variant.toByteArray().size() < 1024) {
            int bytes = variant.toByteArray().size();
            return QObject::tr("[binary data, size = %1 bytes]").arg(bytes);
        } else {
            float kb = variant.toByteArray().size()/1024.;
            return QObject::tr("[binary data, size = %1 kb]").arg(kb);
        }
    }

    if (variant.userType() < QVariant::UserType) {
        return variant.toString();
    }

    if (variant.canConvert<ApiPointer>()) {
        return variant.value<ApiPointer>().toString();
    }
    if (variant.canConvert<ApiBitmask>()) {
        return variant.value<ApiBitmask>().toString();
    }
    if (variant.canConvert<ApiStruct>()) {
        return variant.value<ApiStruct>().toString();
    }
    if (variant.canConvert<ApiArray>()) {
        return variant.value<ApiArray>().toString();
    }

    return QString();
}
inline optional<float> toNumber(const QVariant& value) {
    if (value.type() == QVariant::Double) {
        return value.toFloat();
    } else {
        return {};
    }
}
Example #18
0
Factory::Params Factory::getParametersFromXML(const QDomNodeList & l) {
    Params result;
    for (int i = 0; i < l.length(); i++) {
        QDomElement e = l.at(i).toElement();
        if ( e.tagName() != "parameter" )
            continue;

        QString parameterName = e.attribute("parameter_name");
        QString parameterType = e.attribute("parameter_type");
        QVariant parameterValue = e.attribute("parameter_value");
        ParameterValue * pv = 0;

        if ( parameterType == "integer" )
            pv = new ParameterInt(parameterValue.toInt());
        else if ( parameterType == "real" )
            pv = new ParameterReal(parameterValue.toFloat());
        else if ( parameterType == "string" ) {
            QString stringValue = parameterValue.toString();
            std::string conversedString = stringValue.toStdString();
            pv = new ParameterString(conversedString);
        }

        result.insert(parameterName, pv);
    }

    return result;
}
Example #19
0
glm::vec2 vec2FromVariant(const QVariant &object, bool& isValid) {
    isValid = false;
    glm::vec2 result;
    if (object.canConvert<float>()) {
        result = glm::vec2(object.toFloat());
    } else if (object.canConvert<QVector2D>()) {
        auto qvec2 = qvariant_cast<QVector2D>(object);
        result.x = qvec2.x();
        result.y = qvec2.y();
    } else {
        auto map = object.toMap();
        auto x = map["x"];
        if (!x.isValid()) {
            x = map["width"];
        }
        auto y = map["y"];
        if (!y.isValid()) {
            y = map["height"];
        }
        if (x.isValid() && y.isValid()) {
            result.x = x.toFloat(&isValid);
            if (isValid) {
                result.y = y.toFloat(&isValid);
            }
        }
    }
    return result;
}
Example #20
0
QString QItemDelegatePrivate::valueToText(const QVariant &value, const QStyleOptionViewItemV4 &option)
{
    QString text;
    switch (value.userType()) {
        case QMetaType::Float:
            text = option.locale.toString(value.toFloat(), 'g');
            break;
        case QVariant::Double:
            text = option.locale.toString(value.toDouble(), 'g', DBL_DIG);
            break;
        case QVariant::Int:
        case QVariant::LongLong:
            text = option.locale.toString(value.toLongLong());
            break;
        case QVariant::UInt:
        case QVariant::ULongLong:
            text = option.locale.toString(value.toULongLong());
            break;
        case QVariant::Date:
            text = option.locale.toString(value.toDate(), QLocale::ShortFormat);
            break;
        case QVariant::Time:
            text = option.locale.toString(value.toTime(), QLocale::ShortFormat);
            break;
        case QVariant::DateTime:
            text = option.locale.toString(value.toDateTime().date(), QLocale::ShortFormat);
            text += QLatin1Char(' ');
            text += option.locale.toString(value.toDateTime().time(), QLocale::ShortFormat);
            break;
        default:
            text = replaceNewLine(value.toString());
            break;
    }
    return text;
}
Example #21
0
QScriptValue variantToScriptValue(QVariant& qValue, QScriptEngine& scriptEngine) {
    switch(qValue.type()) {
        case QVariant::Bool:
            return qValue.toBool();
            break;
        case QVariant::Int:
            return qValue.toInt();
            break;
        case QVariant::Double:
            return qValue.toDouble();
            break;
        case QVariant::String:
        case QVariant::Url:
            return scriptEngine.newVariant(qValue);
            break;
        case QVariant::Map: {
            QVariantMap childMap = qValue.toMap();
            return variantMapToScriptValue(childMap, scriptEngine);
            break;
        }
        case QVariant::List: {
            QVariantList childList = qValue.toList();
            return variantListToScriptValue(childList, scriptEngine);
            break;
        }
        default:
            if (qValue.canConvert<float>()) {
                return qValue.toFloat();
            }
            qCDebug(shared) << "unhandled QScript type" << qValue.type();
            break;
    }

    return QScriptValue();
}
Example #22
0
Item AtomicValue::toXDM(const QVariant &value)
{
    Q_ASSERT_X(value.isValid(), Q_FUNC_INFO,
               "QVariants sent to Patternist must be valid.");

    switch(value.userType())
    {
        case QVariant::Char:
        /* Fallthrough. A single codepoint is a string in XQuery. */
        case QVariant::String:
            return AtomicString::fromValue(value.toString());
        case QVariant::Url:
        {
            /* QUrl doesn't follow the spec properly, so we
             * have to let it be an xs:string. Calling QVariant::toString()
             * on a QVariant that contains a QUrl returns, surprisingly,
             * an empty string. */
            return AtomicString::fromValue(value.toUrl().toString());
        }
        case QVariant::ByteArray:
            return HexBinary::fromValue(value.toByteArray());
        case QVariant::Int:
        /* Fallthrough. */
        case QVariant::LongLong:
        /* Fallthrough. */
        case QVariant::UInt:
            return Integer::fromValue(value.toLongLong());
        case QVariant::ULongLong:
            return DerivedInteger<TypeUnsignedLong>::fromValueUnchecked(value.toULongLong());
        case QVariant::Bool:
            return Boolean::fromValue(value.toBool());
        case QVariant::Time:
            return SchemaTime::fromDateTime(value.toDateTime());
        case QVariant::Date:
            return Date::fromDateTime(QDateTime(value.toDate(), QTime(), Qt::UTC));
        case QVariant::DateTime:
            return DateTime::fromDateTime(value.toDateTime());
        case QMetaType::Float:
            return Item(Double::fromValue(value.toFloat()));
        case QVariant::Double:
            return Item(Double::fromValue(value.toDouble()));
        default:
        {
            if (value.userType() == qMetaTypeId<float>())
            {
                return Item(Float::fromValue(value.value<float>()));
            }
            else {
                Q_ASSERT_X(false,
                           Q_FUNC_INFO,
                           qPrintable(QString::fromLatin1(
                               "QVariants of type %1 are not supported in "
                               "Patternist, see the documentation")
                                  .arg(QLatin1String(value.typeName()))));
                return AtomicValue::Ptr();
            }
        }
    }
}
	std::vector<Point3<float>> BodyConvexHullShapeWidget::getPoints() const
	{
		std::vector<Point3<float>> points;
		for(int row=0; row< pointsTableModel->rowCount(); ++row)
		{
			QModelIndex indexX = pointsTableModel->index(row, 0);
			QModelIndex indexY = pointsTableModel->index(row, 1);
			QModelIndex indexZ = pointsTableModel->index(row, 2);

			QVariant valueX = pointsTableModel->data(indexX);
			QVariant valueY = pointsTableModel->data(indexY);
			QVariant valueZ = pointsTableModel->data(indexZ);

			points.push_back(Point3<float>(valueX.toFloat(), valueY.toFloat(), valueZ.toFloat()));
		}

		return points;
	}
bool Matrix::setData(const QModelIndex& index, const QVariant& value, int role)
{
	if (role == Qt::EditRole) {
		matrix[index.row()][index.column()] = value.toFloat();
		emit dataChanged(index,index);
		return true;
	} else
		return false;
}
Example #25
0
bool QtnPropertyFloatBase::fromVariantImpl(const QVariant& var)
{
    bool ok = false;
    ValueType value = var.toFloat(&ok);
    if (!ok)
        return false;

    return setValue(value);
}
void FeatureLayerDrawer::setAttribute(const QString &attrName, const QVariant &value)
{
    LayerDrawer::setAttribute(attrName, value);

    if ( attrName == "linewidth")
        _lineWidth = value.toFloat();
    if ( attrName == "boundarywidth")
        _boundarywidth = value.toFloat();
    if ( attrName == "polygonboundaries")
        _showBoundaries = value.toBool();
    if ( attrName == "polygonareas")
        _showAreas = value.toBool();
    if ( attrName == "areatransparency")
        _areaTransparency = value.toFloat();
    if ( attrName == "boundarycolor")
        _boundaryColor = value.value<QColor>();
    if ( attrName == "linecolor")
        _lineColor = value.value<QColor>();
}
Example #27
0
void CSMWorld::WeaponRefIdAdapter::setData (const RefIdColumn *column, RefIdData& data, int index,
    const QVariant& value) const
{
    Record<ESM::Weapon>& record = static_cast<Record<ESM::Weapon>&> (
        data.getRecord (RefIdData::LocalIndex (index, UniversalId::Type_Weapon)));

    if (column==mColumns.mType)
        record.get().mData.mType = value.toInt();
    else if (column==mColumns.mHealth)
        record.get().mData.mHealth = value.toInt();
    else if (column==mColumns.mSpeed)
        record.get().mData.mSpeed = value.toFloat();
    else if (column==mColumns.mReach)
        record.get().mData.mReach = value.toFloat();
    else if (column==mColumns.mChop[0])
        record.get().mData.mChop[0] = value.toInt();
    else if (column==mColumns.mChop[1])
        record.get().mData.mChop[1] = value.toInt();
    else if (column==mColumns.mSlash[0])
        record.get().mData.mSlash[0] = value.toInt();
    else if (column==mColumns.mSlash[1])
        record.get().mData.mSlash[1] = value.toInt();
    else if (column==mColumns.mThrust[0])
        record.get().mData.mThrust[0] = value.toInt();
    else if (column==mColumns.mThrust[1])
        record.get().mData.mThrust[1] = value.toInt();
    else
    {
        std::map<const RefIdColumn *, unsigned int>::const_iterator iter =
            mColumns.mFlags.find (column);

        if (iter!=mColumns.mFlags.end())
        {
            if (value.toInt()!=0)
                record.get().mData.mFlags |= iter->second;
            else
                record.get().mData.mFlags &= ~iter->second;
        }
        else
            EnchantableRefIdAdapter<ESM::Weapon>::setData (column, data, index, value);
    }
}
Example #28
0
void TorcPlayer::SetProperty(PlayerProperty Property, QVariant Value)
{
    switch (Property)
    {
        case Speed:
            m_speed = Value.toFloat();
            break;
        default:
            break;
    }
}
Example #29
0
static void
writeValue(trace::Writer &writer, const QVariant &var, unsigned &id)
{
    int arrayType   = QMetaType::type("ApiArray");
    int bitmaskType = QMetaType::type("ApiBitmask");
    int structType  = QMetaType::type("ApiStruct");
    int pointerType = QMetaType::type("ApiPointer");
    int enumType    = QMetaType::type("ApiEnum");
    int type = var.userType();

    switch(type) {
    case QVariant::Bool:
        writer.writeBool(var.toBool());
        break;
    case QVariant::ByteArray: {
        QByteArray ba = var.toByteArray();
        writer.writeBlob((const void*)ba.constData(), ba.size());
    }
        break;
    case QVariant::Double:
        writer.writeDouble(var.toDouble());
        break;
    case QMetaType::Float:
        writer.writeFloat(var.toFloat());
        break;
    case QVariant::Int:
        writer.writeSInt(var.toInt());
        break;
    case QVariant::LongLong:
        writer.writeSInt(var.toLongLong());
        break;
    case QVariant::String: {
        QString str = var.toString();
        writer.writeString(str.toLocal8Bit().constData(), str.length());
    }
        break;
    case QVariant::UInt:
        writer.writeUInt(var.toInt());
        break;
    case QVariant::ULongLong:
        writer.writeUInt(var.toLongLong());
        break;
    default:
        if (type == arrayType) {
            ApiArray array = var.value<ApiArray>();
            QVector<QVariant> vals = array.values();
            writer.beginArray(vals.count());
            foreach(QVariant el, vals) {
                writer.beginElement();
                writeValue(writer, el, ++id);
                writer.endElement();
            }
            writer.endArray();
        } else if (type == bitmaskType) {
Example #30
0
void QPngHandler::setOption(ImageOption option, const QVariant &value)
{
    if (option == Gamma)
        d->gamma = value.toFloat();
    else if (option == Quality)
        d->quality = value.toInt();
    else if (option == Description)
        d->description = value.toString();
    else if (option == ScaledSize)
        d->scaledSize = value.toSize();
}