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; }
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; } }
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; }
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); }
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); }
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); }
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 {}; } }
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; }
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; }
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; }
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(); }
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; }
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>(); }
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); } }
void TorcPlayer::SetProperty(PlayerProperty Property, QVariant Value) { switch (Property) { case Speed: m_speed = Value.toFloat(); break; default: break; } }
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) {
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(); }