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;
}
