bool qgsVariantLessThan( const QVariant& lhs, const QVariant& rhs ) { switch ( lhs.type() ) { case QVariant::Int: return lhs.toInt() < rhs.toInt(); case QVariant::UInt: return lhs.toUInt() < rhs.toUInt(); case QVariant::LongLong: return lhs.toLongLong() < rhs.toLongLong(); case QVariant::ULongLong: return lhs.toULongLong() < rhs.toULongLong(); case QVariant::Double: return lhs.toDouble() < rhs.toDouble(); case QVariant::Char: return lhs.toChar() < rhs.toChar(); case QVariant::Date: return lhs.toDate() < rhs.toDate(); case QVariant::Time: return lhs.toTime() < rhs.toTime(); case QVariant::DateTime: return lhs.toDateTime() < rhs.toDateTime(); default: return QString::localeAwareCompare( lhs.toString(), rhs.toString() ) < 0; } }
void KexiTimeTableEdit::setValueInInternalEditor(const QVariant &value) { if (value.isValid() && value.toTime().isValid()) m_lineedit->setText(m_formatter.toString(value.toTime())); else m_lineedit->setText(QString()); }
void KexiTimeTableEdit::handleCopyAction(const QVariant& value, const QVariant& visibleValue) { Q_UNUSED(visibleValue); if (!value.isNull() && value.toTime().isValid()) qApp->clipboard()->setText(m_formatter.toString(value.toTime())); else qApp->clipboard()->setText(QString()); }
bool ImageSortSettings::lessThan(const QVariant& left, const QVariant& right) const { if (left.type() != right.type()) { return false; } switch (left.type()) { case QVariant::Int: return compareByOrder(left.toInt(), right.toInt(), currentSortOrder); case QVariant::UInt: return compareByOrder(left.toUInt(), right.toUInt(), currentSortOrder); case QVariant::LongLong: return compareByOrder(left.toLongLong(), right.toLongLong(), currentSortOrder); case QVariant::ULongLong: return compareByOrder(left.toULongLong(), right.toULongLong(), currentSortOrder); case QVariant::Double: return compareByOrder(left.toDouble(), right.toDouble(), currentSortOrder); case QVariant::Date: return compareByOrder(left.toDate(), right.toDate(), currentSortOrder); case QVariant::DateTime: return compareByOrder(left.toDateTime(), right.toDateTime(), currentSortOrder); case QVariant::Time: return compareByOrder(left.toTime(), right.toTime(), currentSortOrder); case QVariant::Rect: case QVariant::RectF: { QRectF rectLeft = left.toRectF(); QRectF rectRight = right.toRectF(); int result; if ((result = compareByOrder(rectLeft.top(), rectRight.top(), currentSortOrder)) != 0) { return result < 0; } if ((result = compareByOrder(rectLeft.left(), rectRight.left(), currentSortOrder)) != 0) { return result < 0; } QSizeF sizeLeft = rectLeft.size(), sizeRight = rectRight.size(); if ((result = compareByOrder(sizeLeft.width()*sizeLeft.height(), sizeRight.width()*sizeRight.height(), currentSortOrder)) != 0) { return result < 0; } // FIXME: fall through?? If not, add "break" here } default: return naturalCompare(left.toString(), right.toString(), currentSortOrder, sortCaseSensitivity); } }
bool QgsAttributeTableFilterModel::lessThan( const QModelIndex &left, const QModelIndex &right ) const { if ( mSelectedOnTop ) { bool leftSelected = layer()->selectedFeaturesIds().contains( masterModel()->rowToId( left.row() ) ); bool rightSelected = layer()->selectedFeaturesIds().contains( masterModel()->rowToId( right.row() ) ); if ( leftSelected && !rightSelected ) { return sortOrder() == Qt::AscendingOrder; } else if ( rightSelected && !leftSelected ) { return sortOrder() == Qt::DescendingOrder; } } QVariant leftData = left.data( QgsAttributeTableModel::SortRole ); QVariant rightData = right.data( QgsAttributeTableModel::SortRole ); if ( leftData.isNull() ) return true; if ( rightData.isNull() ) return false; switch ( leftData.type() ) { case QVariant::Int: case QVariant::UInt: case QVariant::LongLong: case QVariant::ULongLong: return leftData.toLongLong() < rightData.toLongLong(); case QVariant::Double: return leftData.toDouble() < rightData.toDouble(); case QVariant::Date: return leftData.toDate() < rightData.toDate(); case QVariant::Time: return leftData.toTime() < rightData.toTime(); case QVariant::DateTime: return leftData.toDateTime() < rightData.toDateTime(); default: return leftData.toString().localeAwareCompare( rightData.toString() ) < 0; } }
// ============================================================================= bool TableViewModel::setData(const QModelIndex &index, const QVariant &value, int role) { int day = index.row() + 1; int column = index.column(); if( role == Qt::EditRole ) { try { switch(column) { case Col::START_TIME: mTimeTrackingModel->setStartTime( day, value.toTime(), true /* changeStartTimeOnly */); break; case Col::PAUSE_TIME: mTimeTrackingModel->setPause( day, value.toTime()); break; case Col::REQUIRED_TIME: mTimeTrackingModel->setRequiredWorkTime( day, value.toTime()); break; case Col::END_TIME: mTimeTrackingModel->setEndTime( day, value.toTime()); break; case Col::COMMENT: mTimeTrackingModel->setComment( day, value.toString()); break; } } catch (std::exception& e) { QMessageBox::warning(mParentWidget, tr("Problem accessing tracking time"), e.what()); } } else if(role == Qt::UserRole + USER_ROLE_FORCE_CHANGES) { switch(column) { case Col::START_TIME: mTimeTrackingModel->setStartTime( day, value.toTime(), false /* changeStartTimeOnly */); break; default: assert(false); } } return false; }
QString FillCellHelper::displayText( const QVariant& value ) const { QLocale locale; // in QStyledItemDelegate this is configurable, it comes from QWidget::locale()... QString text; switch (value.userType()) { case QMetaType::Float: case QVariant::Double: text = locale.toString(value.toReal()); break; case QVariant::Int: case QVariant::LongLong: text = locale.toString(value.toLongLong()); break; case QVariant::UInt: case QVariant::ULongLong: text = locale.toString(value.toULongLong()); break; case QVariant::Date: text = locale.toString(value.toDate(), QLocale::ShortFormat); break; case QVariant::Time: text = locale.toString(value.toTime(), QLocale::ShortFormat); break; case QVariant::DateTime: text = locale.toString(value.toDateTime().date(), QLocale::ShortFormat); text += QLatin1Char(' '); text += locale.toString(value.toDateTime().time(), QLocale::ShortFormat); break; default: text = value.toString(); break; } return text; }
QString SqliteDriver::formatValueLike(int t, const QVariant &v, const bool upper) { QString res("IS NULL"); switch (t) { case QVariant::Bool: { QString s(v.toString().left(1).upper()); if (s == QApplication::tr("Sí").left(1).upper()) res = "=1"; else if (s == QApplication::tr("No").left(1).upper()) res = "=0"; } break; case QVariant::Date: res = "LIKE '%%" + FLUtil::dateDMAtoAMD(v.toString()) + "'"; break; case QVariant::Time: { QTime t(v.toTime()); if (t.isValid() && !t.isNull()) res = "LIKE '" + t.toString(Qt::ISODate) + "%%'"; } break; default: if (upper) res = "LIKE '" + v.toString().upper() + "%%'"; else res = "LIKE '" + v.toString() + "%%'"; } return res; }
qreal ChartXYFunction::variantToAbsolute(const QVariant &variant) { qreal ret=0; switch(variant.type()) { case QVariant::Date: case QVariant::DateTime: if(variant.canConvert(QVariant::DateTime)) { QDateTime puppa=variant.toDateTime(); ret=(qreal)(variant.toDateTime().toMSecsSinceEpoch()); } break; case QVariant::Time: { QTime time=variant.toTime(); ret=(qreal)(time.msec()+(time.second()*1000)+(time.minute()*60000)+(time.hour())*3600000); break; } default: if(variant.canConvert(QVariant::Double)) { ret=(qreal)variant.toDouble(); } break; } return(ret); }
QVariant Nuria::RestfulHttpNode::serializeVariant (const QVariant &variant) { int type = variant.userType (); // Qt Types switch (type) { case QMetaType::QByteArray: case QMetaType::QString: return variant; case QMetaType::QDateTime: return variant.toDateTime ().toString (Qt::ISODate); case QMetaType::QDate: return variant.toDate ().toString (Qt::ISODate); case QMetaType::QTime: return variant.toTime ().toString (Qt::ISODate); } // POD types if ((type >= QMetaType::Bool && type <= QMetaType::Double) || (type >= QMetaType::Long && type <= QMetaType::Float)) { return variant; } // Lists and maps if (variant.canConvert< QVariantList > ()) { return deepConvertList (variant.toList ()); } else if (variant.canConvert< QVariantMap > ()) { return deepConvertMap (variant.toMap ()); } // Custom structures return serializeUserStructure (variant); }
TagValue TagValue::fromQVariant(const QVariant& variant) { TagValue result; const QVariant::Type type = variant.type(); switch(type) { default: assert(!"unknown type"); break; case QVariant::String: result = TagValue( variant.toString() ); break; case QVariant::Date: result = TagValue( variant.toDate() ); break; case QVariant::Time: result = TagValue( variant.toTime() ); break; } 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; }
void SqlQuery::bindValue(int pos, const QVariant& value) { int res = -1; Q_ASSERT(_stmt); if( _stmt ) { switch (value.type()) { case QVariant::Int: case QVariant::Bool: res = sqlite3_bind_int(_stmt, pos, value.toInt()); break; case QVariant::Double: res = sqlite3_bind_double(_stmt, pos, value.toDouble()); break; case QVariant::UInt: case QVariant::LongLong: res = sqlite3_bind_int64(_stmt, pos, value.toLongLong()); break; case QVariant::DateTime: { const QDateTime dateTime = value.toDateTime(); const QString str = dateTime.toString(QLatin1String("yyyy-MM-ddThh:mm:ss.zzz")); res = sqlite3_bind_text16(_stmt, pos, str.utf16(), str.size() * sizeof(ushort), SQLITE_TRANSIENT); break; } case QVariant::Time: { const QTime time = value.toTime(); const QString str = time.toString(QLatin1String("hh:mm:ss.zzz")); res = sqlite3_bind_text16(_stmt, pos, str.utf16(), str.size() * sizeof(ushort), SQLITE_TRANSIENT); break; } case QVariant::String: { if( !value.toString().isNull() ) { // lifetime of string == lifetime of its qvariant const QString *str = static_cast<const QString*>(value.constData()); res = sqlite3_bind_text16(_stmt, pos, str->utf16(), (str->size()) * sizeof(QChar), SQLITE_TRANSIENT); } else { res = sqlite3_bind_null(_stmt, pos); } break; } case QVariant::ByteArray: { auto ba = value.toByteArray(); res = sqlite3_bind_text(_stmt, pos, ba.constData(), ba.size(), SQLITE_TRANSIENT); break; } default: { QString str = value.toString(); // SQLITE_TRANSIENT makes sure that sqlite buffers the data res = sqlite3_bind_text16(_stmt, pos, str.utf16(), (str.size()) * sizeof(QChar), SQLITE_TRANSIENT); break; } } } if (res != SQLITE_OK) { qDebug() << Q_FUNC_INFO << "ERROR" << value << res; } Q_ASSERT( res == SQLITE_OK ); }
// Gibt die Uhrzeit des Programmstarts im Texteditor aus void MyWindow::printStart() { QVariant data = Start->data(); QTime time = data.toTime(); // String daraus machen QString msg( "(Demonstriert setData()) Programmstart: "); msg.append(time.toString("hh:mm:ss")); editor->setText(msg); }
QString KexiTextFormatter::toString(const QVariant& value, const QString& add, bool *lengthExceeded) const { //cases, in order of expected frequency if (!d->field || d->field->type() == KDbField::Text) { return toStringForTextType(value, add, d->field, lengthExceeded); } if (lengthExceeded) { *lengthExceeded = false; } if (d->field->isIntegerType()) { if (value.toInt() == 0) return add; //eat 0 } else if (d->field->isFPNumericType()) { //! @todo precision! //! @todo support 'g' format if (value.toDouble() == 0.0) return add.isEmpty() ? "0" : add; //eat 0 return KDb::formatNumberForVisibleDecimalPlaces( value.toDouble(), d->field->visibleDecimalPlaces()) + add; } switch (d->field->type()) { case KDbField::Boolean: { //! @todo temporary solution for booleans! const bool boolValue = value.isNull() ? QVariant(add).toBool() : value.toBool(); return boolValue ? "1" : "0"; } case KDbField::Date: return d->dateFormatter->toString( value.toString().isEmpty() ? QDate() : value.toDate()); case KDbField::Time: return d->timeFormatter->toString( value.toString().isEmpty() ? QTime(99, 0, 0) //hack to avoid converting null variant to valid QTime(0,0,0) : value.toTime()); case KDbField::DateTime: if (value.toString().isEmpty()) return add; return KexiDateTimeFormatter::toString( *d->dateFormatter, *d->timeFormatter, value.toDateTime()); case KDbField::BigInteger: if (value.toLongLong() == 0) return add; //eat 0 break; default: break; } //default: text return toStringForTextType(value, add, d->field, lengthExceeded); }
QString VariantDelegate::displayText(const QVariant &value) { switch (value.type()) { case QVariant::Bool: case QVariant::ByteArray: case QVariant::Char: case QVariant::Double: case QVariant::Int: case QVariant::LongLong: case QVariant::String: case QVariant::UInt: case QVariant::ULongLong: return value.toString(); case QVariant::Color: { QColor color = qvariant_cast<QColor>(value); return QString("(%1,%2,%3,%4)") .arg(color.red()).arg(color.green()) .arg(color.blue()).arg(color.alpha()); } case QVariant::Date: return value.toDate().toString(Qt::ISODate); case QVariant::DateTime: return value.toDateTime().toString(Qt::ISODate); case QVariant::Invalid: return "<Invalid>"; case QVariant::Point: { QPoint point = value.toPoint(); return QString("(%1,%2)").arg(point.x()).arg(point.y()); } case QVariant::Rect: { QRect rect = value.toRect(); return QString("(%1,%2,%3,%4)") .arg(rect.x()).arg(rect.y()) .arg(rect.width()).arg(rect.height()); } case QVariant::Size: { QSize size = value.toSize(); return QString("(%1,%2)").arg(size.width()).arg(size.height()); } case QVariant::StringList: return value.toStringList().join(','); case QVariant::Time: return value.toTime().toString(Qt::ISODate); default: break; } return QString("<%1>").arg(value.typeName()); }
static QString valueToSQLInternal(const KexiDB::Driver *driver, uint ftype, const QVariant& v) { if (v.isNull()) return "NULL"; switch (ftype) { case Field::Text: case Field::LongText: { QString s = v.toString(); return driver ? driver->escapeString(s) : KexiDB::escapeString(s); //QString("'")+s.replace( '"', "\\\"" ) + "'"; } case Field::Byte: case Field::ShortInteger: case Field::Integer: case Field::BigInteger: return v.toString(); case Field::Float: case Field::Double: { if (v.type() == QVariant::String) { //workaround for values stored as string that should be casted to floating-point QString s(v.toString()); return s.replace(',', '.'); } return v.toString(); } //TODO: here special encoding method needed case Field::Boolean: return QString::number(v.toInt() ? 1 : 0); //0 or 1 case Field::Time: return QLatin1Char('\'') + v.toTime().toString(Qt::ISODate) + QLatin1Char('\''); case Field::Date: return QLatin1Char('\'') + v.toDate().toString(Qt::ISODate) + QLatin1Char('\''); case Field::DateTime: return driver ? driver->dateTimeToSQL(v.toDateTime()) : KexiDB::dateTimeToSQL(v.toDateTime()); case Field::BLOB: { if (v.toByteArray().isEmpty()) return QString::fromLatin1("NULL"); if (v.type() == QVariant::String) { return driver ? driver->escapeBLOB(v.toString().toUtf8()) : KexiDB::escapeBLOB(v.toString().toUtf8(), KexiDB::BLOBEscape0xHex); } return driver ? driver->escapeBLOB(v.toByteArray()) : KexiDB::escapeBLOB(v.toByteArray(), KexiDB::BLOBEscape0xHex); } case Field::InvalidType: return "!INVALIDTYPE!"; default: KexiDBDbg << "Driver::valueToSQL(): UNKNOWN!"; return QString(); } return QString(); }
// ============================================================================= bool TableModelPreferences::setData(const QModelIndex & index, const QVariant & value, int role) { int row = index.row(); int col = index.column(); switch(role) { case Qt::EditRole: switch(col) { case 0: mTableModelAdapter->setWorkingDay(row, value.toBool()); break; case 1: mTableModelAdapter->setRequiredTime(row, value.toTime()); break; case 2: mTableModelAdapter->setPause(row, value.toTime()); break; } break; } return true; }
QString DurationStyledItemDelegate::displayText(const QVariant &value, const QLocale&) const { if (value.isNull()) return ""; QString s = ""; QTime t = value.toTime(); if (t.isValid()) { s = Utility::formatDuration(t); } return s; }
bool SessionModel::setData(const QModelIndex& index, const QVariant& value, int role) { if (!isBilled(index.row()) && role == Qt::EditRole) { Session session = m_data.at(index.row()); QDate date = session.date(); QTime start = session.start(); QTime stop = session.stop(); QString task = session.task(); switch (index.column()) { case 0: date = value.toDate(); break; case 1: start = value.toTime(); break; case 2: stop = value.toTime(); break; case 3: task = value.toString(); break; default: break; } if (edit(index.row(), Session(date, start, stop, task, false))) { return true; } else { return false; } } else if (index.column() == 9 && role == Qt::CheckStateRole) { setBilled(index.row(), value.toInt() == Qt::Checked); return true; } else { return QAbstractItemModel::setData(index, value, role); } }
int MultiSortFilterProxy::Compare(const QVariant& left, const QVariant& right) const { // Copied from the QSortFilterProxyModel::lessThan implementation, but returns // -1, 0 or 1 instead of true or false. switch (left.userType()) { case QVariant::Invalid: return (right.type() != QVariant::Invalid) ? -1 : 0; case QVariant::Int: return DoCompare(left.toInt(), right.toInt()); case QVariant::UInt: return DoCompare(left.toUInt(), right.toUInt()); case QVariant::LongLong: return DoCompare(left.toLongLong(), right.toLongLong()); case QVariant::ULongLong: return DoCompare(left.toULongLong(), right.toULongLong()); case QMetaType::Float: return DoCompare(left.toFloat(), right.toFloat()); case QVariant::Double: return DoCompare(left.toDouble(), right.toDouble()); case QVariant::Char: return DoCompare(left.toChar(), right.toChar()); case QVariant::Date: return DoCompare(left.toDate(), right.toDate()); case QVariant::Time: return DoCompare(left.toTime(), right.toTime()); case QVariant::DateTime: return DoCompare(left.toDateTime(), right.toDateTime()); case QVariant::String: default: if (isSortLocaleAware()) return left.toString().localeAwareCompare(right.toString()); else return left.toString().compare(right.toString(), sortCaseSensitivity()); } return 0; }
bool ResultsTree::GroupSortProxyModel::QVariantCompare::operator() (QVariant l, QVariant r) { // CODE COPIED FROM QSortFilterProxyModel::lessThan switch (l.userType()) { case QVariant::Invalid: return (r.type() != QVariant::Invalid); case QVariant::Int: return l.toInt() < r.toInt(); case QVariant::UInt: return l.toUInt() < r.toUInt(); case QVariant::LongLong: return l.toLongLong() < r.toLongLong(); case QVariant::ULongLong: return l.toULongLong() < r.toULongLong(); case QMetaType::Float: return l.toFloat() < r.toFloat(); case QVariant::Double: return l.toDouble() < r.toDouble(); case QVariant::Char: return l.toChar() < r.toChar(); case QVariant::Date: return l.toDate() < r.toDate(); case QVariant::Time: return l.toTime() < r.toTime(); case QVariant::DateTime: return l.toDateTime() < r.toDateTime(); case QVariant::String: default: //if (d->sort_localeaware) return l.toString().localeAwareCompare(r.toString()) < 0; /*else return l.toString().compare(r.toString(), d->sort_casesensitivity) < 0;*/ } return false; }
void TimeEdit::setDataValue(const QVariant &val) { qfLogFuncFrame() << val; QTime new_time = val.toTime(); if(checkSetDataValueFirstTime()) { setTime(new_time); } else { if(new_time != time()) { BlockerScope bs(m_blockTimeChanged); setTime(new_time); saveDataValue(); emit dataValueChanged(new_time); } } }
void KexiTimeTableEdit::setupContents(QPainter *p, bool focused, const QVariant& val, QString &txt, int &align, int &x, int &y_offset, int &w, int &h) { Q_UNUSED(p); Q_UNUSED(focused); Q_UNUSED(x); Q_UNUSED(w); Q_UNUSED(h); #ifdef Q_OS_WIN y_offset = -1; #else y_offset = 0; #endif if (!val.isNull() && val.canConvert(QVariant::Time)) txt = m_formatter.toString(val.toTime()); align |= Qt::AlignLeft; }
bool QValueFilter::matches(const QVariant & value, int type) const { Qt::CaseSensitivity s; Qt::MatchFlag mf; int t = type; if (t == -1){ t = value.type(); } switch(t) { case QVariant::Char: return value.toChar() == property("value").toChar(); case QVariant::Date: return value.toDate() == property("value").toDate(); case QVariant::DateTime: return value.toDateTime() == property("value").toDateTime(); case QVariant::Double: return value.toDouble() == property("value").toDouble(); case QVariant::Int: return value.toInt() == property("value").toInt(); case QVariant::LongLong: return value.toLongLong() == property("value").toLongLong(); case QVariant::String: s = static_cast<Qt::CaseSensitivity>(property("caseSensitivity", Qt::CaseInsensitive).toInt()); mf = static_cast<Qt::MatchFlag>(property("matchFlag", Qt::MatchStartsWith).toInt()); if (mf == Qt::MatchContains){ return value.toString().contains(property("value").toString(), s); } else if (mf == Qt::MatchEndsWith){ return QString::compare(value.toString().right(property("value").toString().length()), property("value").toString(), s) == 0; } return QString::compare(value.toString().left(property("value").toString().length()), property("value").toString(), s) == 0; case QVariant::Time: return value.toTime() == property("value").toTime(); case QVariant::UInt: return value.toUInt() == property("value").toUInt(); case QVariant::ULongLong: return value.toULongLong() == property("value").toULongLong(); default: return value == property("value"); } return false; }
QString SqliteDriver::formatValue(int t, const QVariant &v, const bool upper) { QString res; switch (FLFieldMetaData::flDecodeType(t)) { case QVariant::Bool: { QString s(v.toString().left(1).upper()); if (s == QApplication::tr("Sí").left(1).upper()) res = "0"; else if (s == QApplication::tr("No").left(1).upper()) res = "1"; else res = nullText(); } break; case QVariant::Date: res = "'" + FLUtil::dateDMAtoAMD(v.toString()) + "'"; break; case QVariant::Time: { QTime t(v.toTime()); if (t.isValid() && !t.isNull()) res = "'" + t.toString(Qt::ISODate) + "'"; else res = nullText(); } break; case QVariant::Int: case QVariant::UInt: case QVariant::Double: res += v.toString(); break; default: if (upper) res = "'" + v.toString().upper() + "'"; else res = "'" + v.toString() + "'"; } return res; }
TagValue TagValue::fromQVariant(const QVariant& variant) { TagValue result; const QVariant::Type type = variant.type(); switch(type) { default: assert(!"unknown type"); break; case QVariant::StringList: { std::deque<TagValue> list; QStringList stringList = variant.toStringList(); list.insert(list.end(), stringList.begin(), stringList.end()); result = TagValue(list); break; } case QVariant::String: result = TagValue( variant.toString() ); break; case QVariant::Date: result = TagValue( variant.toDate() ); break; case QVariant::Time: result = TagValue( variant.toTime() ); break; } return result; }
QVariant QSystemLocale::query(QueryType type, QVariant in) const { QSystemLocaleData *d = qSystemLocaleData(); if (type == LocaleChanged) { d->readEnvironment(); return QVariant(); } QReadLocker locker(&d->lock); const QLocale &lc_numeric = d->lc_numeric; const QLocale &lc_time = d->lc_time; const QLocale &lc_monetary = d->lc_monetary; const QLocale &lc_messages = d->lc_messages; switch (type) { case DecimalPoint: return lc_numeric.decimalPoint(); case GroupSeparator: return lc_numeric.groupSeparator(); case ZeroDigit: return lc_numeric.zeroDigit(); case NegativeSign: return lc_numeric.negativeSign(); case DateFormatLong: return lc_time.dateFormat(QLocale::LongFormat); case DateFormatShort: return lc_time.dateFormat(QLocale::ShortFormat); case TimeFormatLong: return lc_time.timeFormat(QLocale::LongFormat); case TimeFormatShort: return lc_time.timeFormat(QLocale::ShortFormat); case DayNameLong: return lc_time.dayName(in.toInt(), QLocale::LongFormat); case DayNameShort: return lc_time.dayName(in.toInt(), QLocale::ShortFormat); case MonthNameLong: return lc_time.monthName(in.toInt(), QLocale::LongFormat); case MonthNameShort: return lc_time.monthName(in.toInt(), QLocale::ShortFormat); case StandaloneMonthNameLong: return lc_time.standaloneMonthName(in.toInt(), QLocale::LongFormat); case StandaloneMonthNameShort: return lc_time.standaloneMonthName(in.toInt(), QLocale::ShortFormat); case DateToStringLong: return lc_time.toString(in.toDate(), QLocale::LongFormat); case DateToStringShort: return lc_time.toString(in.toDate(), QLocale::ShortFormat); case TimeToStringLong: return lc_time.toString(in.toTime(), QLocale::LongFormat); case TimeToStringShort: return lc_time.toString(in.toTime(), QLocale::ShortFormat); case DateTimeFormatLong: return lc_time.dateTimeFormat(QLocale::LongFormat); case DateTimeFormatShort: return lc_time.dateTimeFormat(QLocale::ShortFormat); case DateTimeToStringLong: return lc_time.toString(in.toDateTime(), QLocale::LongFormat); case DateTimeToStringShort: return lc_time.toString(in.toDateTime(), QLocale::ShortFormat); case PositiveSign: return lc_numeric.positiveSign(); case AMText: return lc_time.amText(); case PMText: return lc_time.pmText(); case FirstDayOfWeek: return lc_time.firstDayOfWeek(); case CurrencySymbol: return lc_monetary.currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt())); case CurrencyToString: { switch (in.type()) { case QVariant::Int: return lc_monetary.toCurrencyString(in.toInt()); case QVariant::UInt: return lc_monetary.toCurrencyString(in.toUInt()); case QVariant::Double: return lc_monetary.toCurrencyString(in.toDouble()); case QVariant::LongLong: return lc_monetary.toCurrencyString(in.toLongLong()); case QVariant::ULongLong: return lc_monetary.toCurrencyString(in.toULongLong()); default: break; } return QString(); } case MeasurementSystem: { const QString meas_locale = QString::fromLatin1(d->lc_measurement_var.constData(), d->lc_measurement_var.size()); if (meas_locale.compare(QLatin1String("Metric"), Qt::CaseInsensitive) == 0) return QLocale::MetricSystem; if (meas_locale.compare(QLatin1String("Other"), Qt::CaseInsensitive) == 0) return QLocale::MetricSystem; return QVariant((int)QLocale(meas_locale).measurementSystem()); } case UILanguages: { if (!d->uiLanguages.isEmpty()) return d->uiLanguages; QString languages = QString::fromLatin1(qgetenv("LANGUAGE")); QStringList lst; if (languages.isEmpty()) lst.append(QString::fromLatin1(d->lc_messages_var)); else lst = languages.split(QLatin1Char(':')); for (int i = 0; i < lst.size(); ++i) { const QString &name = lst.at(i); QString lang, script, cntry; if (qt_splitLocaleName(name, lang, script, cntry)) { if (!cntry.length()) d->uiLanguages.append(lang); else d->uiLanguages.append(lang % QLatin1Char('-') % cntry); } } return d->uiLanguages.isEmpty() ? QVariant() : QVariant(d->uiLanguages); } case StringToStandardQuotation: return lc_messages.quoteString(in.value<QStringRef>()); case StringToAlternateQuotation: return lc_messages.quoteString(in.value<QStringRef>(), QLocale::AlternateQuotation); case ListToSeparatedString: return lc_messages.createSeparatedList(in.toStringList()); case LocaleChanged: Q_ASSERT(false); default: break; } return QVariant(); }
static QString variantToTextValue(const QVariant &value, const QString &typeNs, const QString &type) { switch (value.userType()) { case QVariant::Char: // fall-through case QVariant::String: return value.toString(); case QVariant::Url: // xmlpatterns/data/qatomicvalue.cpp says to do this: return value.toUrl().toString(); case QVariant::ByteArray: { const QByteArray data = value.toByteArray(); if (typeNs == KDSoapNamespaceManager::xmlSchema1999() || typeNs == KDSoapNamespaceManager::xmlSchema2001()) { if (type == QLatin1String("hexBinary")) { const QByteArray hb = data.toHex(); return QString::fromLatin1(hb.constData(), hb.size()); } } // default to base64Binary, like variantToXMLType() does. const QByteArray b64 = value.toByteArray().toBase64(); return QString::fromLatin1(b64.constData(), b64.size()); } case QVariant::Int: // fall-through case QVariant::LongLong: // fall-through case QVariant::UInt: return QString::number(value.toLongLong()); case QVariant::ULongLong: return QString::number(value.toULongLong()); case QVariant::Bool: case QMetaType::Float: case QVariant::Double: return value.toString(); case QVariant::Time: { const QTime time = value.toTime(); if (time.msec()) { // include milli-seconds return time.toString(QLatin1String("hh:mm:ss.zzz")); } else { return time.toString(Qt::ISODate); } } case QVariant::Date: return value.toDate().toString(Qt::ISODate); case QVariant::DateTime: // http://www.w3.org/TR/xmlschema-2/#dateTime return KDDateTime(value.toDateTime()).toDateString(); case QVariant::Invalid: qDebug() << "ERROR: Got invalid QVariant in a KDSoapValue"; return QString(); default: if (value.canConvert<KDDateTime>()) { return value.value<KDDateTime>().toDateString(); } if (value.userType() == qMetaTypeId<float>()) { return QString::number(value.value<float>()); } qDebug() << QString::fromLatin1("QVariants of type %1 are not supported in " "KDSoap, see the documentation").arg(QLatin1String(value.typeName())); return value.toString(); } }
bool GCF::Message::encodeVariant(QDataStream& ds, const QVariant& value) { QString typeName; if( value.isValid() ) { typeName = QString(value.typeName()); if( typeName.isEmpty() ) return false; } else typeName = "Invalid"; if( value.type() >= QVariant::UserType ) return false; // Prepare the typename in-case of bool, char, int, double switch(value.type()) { case QVariant::Int: typeName = is32Bit() ? "qint32" : "qint64"; break; case QVariant::Char: typeName = "quint8"; break; case QVariant::UInt: typeName = is32Bit() ? "quint32" : "quint64"; break; default: break; } // Serialize value on to the byte array switch( value.type() ) { case QVariant::Invalid: ds << typeName; ds << qint32(0); break; case QVariant::Bool: ds << typeName; ds << value.toBool(); break; case QVariant::Char: ds << typeName; ds << value.toChar(); break; case QVariant::Color: ds << typeName; ds << value.value<QColor>(); break; case QVariant::Date: ds << typeName; ds << value.toDate(); break; case QVariant::DateTime: ds << typeName; ds << value.toDateTime(); break; case QVariant::Double: ds << typeName; ds << value.toDouble(); break; case QVariant::Int: ds << typeName; if( is32Bit() ) ds << (qint32)value.toInt(); else ds << (qint64)value.toInt(); break; case QVariant::Time: ds << typeName; ds << value.toTime(); break; case QVariant::UInt: ds << typeName; if( is32Bit() ) ds << (quint32)value.toUInt(); else ds << (quint64)value.toUInt(); break; case QVariant::String: ds << typeName; ds << value.toString(); break; case QVariant::Pixmap: ds << typeName; ds << value.value<QPixmap>(); break; case QVariant::ByteArray: ds << typeName; ds << value.toByteArray(); break; case QVariant::BitArray: ds << typeName; ds << value.toBitArray(); break; case QVariant::Image: ds << typeName; ds << value.value<QImage>(); break; case QVariant::Url: ds << typeName; ds << value.toUrl(); break; case QVariant::StringList: ds << typeName; ds << value.toStringList(); break; case QVariant::SizePolicy: ds << typeName; ds << value.value<QSizePolicy>(); break; case QVariant::SizeF: ds << typeName; ds << value.toSizeF(); break; case QVariant::Size: ds << typeName; ds << value.toSize(); break; case QVariant::RegExp: ds << typeName; ds << value.toRegExp(); break; case QVariant::RectF: ds << typeName; ds << value.toRectF(); break; case QVariant::Rect: ds << typeName; ds << value.toRect(); break; case QVariant::Polygon: ds << typeName; ds << value.value<QPolygon>(); break; case QVariant::PointF: ds << typeName; ds << value.toPointF(); break; case QVariant::Point: ds << typeName; ds << value.toPoint(); break; case QVariant::Matrix: ds << typeName; ds << value.value<QMatrix>(); break; case QVariant::LineF: ds << typeName; ds << value.toLineF(); break; case QVariant::Line: ds << typeName; ds << value.toLine(); break; case QVariant::Brush: ds << typeName; ds << value.value<QBrush>(); break; case QVariant::Bitmap: ds << typeName; ds << value.value<QBitmap>(); break; case QVariant::Transform: ds << typeName; ds << value.value<QTransform>(); break; default: // Other types will be supported shortly. // TODO: support user defined types. return false; } return true; }