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;
}
}
QScriptValueImpl Variant::method_valueOf(QScriptContextPrivate *context, QScriptEnginePrivate *eng, QScriptClassInfo *classInfo)
{
if (Instance *instance = Instance::get(context->thisObject(), classInfo)) {
QVariant v = instance->value;
switch (v.type ()) {
case QVariant::Invalid:
return eng->undefinedValue();
case QVariant::String:
return (QScriptValueImpl(eng, v.toString()));
case QVariant::Int:
return (QScriptValueImpl(v.toInt()));
case QVariant::Bool:
return (QScriptValueImpl(v.toBool()));
case QVariant::Double:
return (QScriptValueImpl(v.toDouble())); // ### hmmm
case QVariant::Char:
return (QScriptValueImpl(v.toChar().unicode()));
case QVariant::UInt:
return (QScriptValueImpl(v.toUInt()));
default:
return context->thisObject();
} // switch
}
return context->thisObject();
}
void lua::push_qvariant(lua_State* const state, const QVariant& value)
{
switch (value.userType()) {
case QVariant::Invalid:
lua::push(state, lua::value::nil);
break;
case QVariant::Bool:
lua::push(state, value.toBool());
break;
case QVariant::Char:
lua::push(state, value.toChar());
break;
case QVariant::Int:
{
lua::push(state, value.toInt());
break;
}
case QVariant::Double:
case QVariant::UInt:
lua::push(state, value.toDouble());
break;
case QVariant::String:
lua::push(state, value.toString());
break;
case QVariant::Hash:
{
auto hash = value.toHash();
auto table = lua::push(state, lua::value::table);
for (auto i = hash.begin(); i != hash.end(); ++i) {
lua::table::set(table, i.key(), i.value());
}
break;
}
case QVariant::StringList:
{
auto list = value.toStringList();
auto table = lua::push(state, lua::value::table);
for (int i = 0; i < list.size(); ++i) {
lua::table::set(table, i + 1, list[i]);
}
break;
}
default:
{
auto converter = qvariant_push_handler.find(value.userType());
if (converter != qvariant_push_handler.end()) {
converter->second(state, value);
} else {
throw std::logic_error(std::string("No handler exists to push QVariant type: ") + value.typeName());
}
}
}
}
QString AsteriskManager::valueToString(QVariant value)
{
switch (value.type()) {
case QVariant::Char:
return value.toChar() == 1 ? "true" : "false";
default:
return value.toString();
}
}
uint qHash(const QVariant &var)
{
if (!var.isValid() || var.isNull())
return -1;
switch (var.type())
{
case QVariant::Int:
return qHash( var.toInt() );
case QVariant::UInt:
return qHash( var.toUInt() );
case QVariant::Bool:
return qHash( var.toUInt() );
case QVariant::Double:
return qHash( var.toUInt() );
case QVariant::LongLong:
return qHash( var.toLongLong() );
case QVariant::ULongLong:
return qHash( var.toULongLong() );
case QVariant::String:
return qHash( var.toString() );
case QVariant::Char:
return qHash( var.toChar() );
case QVariant::StringList:
return qHash( var.toString() );
case QVariant::ByteArray:
return qHash( var.toByteArray() );
case QVariant::Date:
case QVariant::Time:
case QVariant::DateTime:
case QVariant::Url:
case QVariant::Locale:
case QVariant::RegExp:
return qHash( var.toString() );
case QVariant::Map:
case QVariant::List:
case QVariant::BitArray:
case QVariant::Size:
case QVariant::SizeF:
case QVariant::Rect:
case QVariant::LineF:
case QVariant::Line:
case QVariant::RectF:
case QVariant::Point:
case QVariant::UserType:
case QVariant::Invalid:
default:
Q_ASSERT(false);
}
// could not generate a hash for the given variant
Q_ASSERT(false);
return 0;
}
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;
}
char AppSettings::getCsvSeparator (void)
{
QVariant var = m_Settings.value(SETTINGNAME_CSV_SEPARATOR);
if (var.canConvert(QVariant::Char))
{
char c = var.toChar().toAscii();
if (ExporterSinkCsv::isAllowedSeparator(c))
return c;
else
this->setCsvSeparator(ExporterSinkCsv::defaultSeparator());
}
return ExporterSinkCsv::defaultSeparator();
}
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;
}
Qt::Key QtUiTest::variantToKey(const QVariant &keyValue)
{
Qt::Key key = (Qt::Key)0;
switch(keyValue.type()) {
default:
key = (Qt::Key)keyValue.toInt();
break;
case QVariant::Char:
key = QtUiTest::asciiToKey(keyValue.toChar().toAscii());
break;
case QVariant::String:
if (keyValue.toString().length() == 1)
key = QtUiTest::asciiToKey(keyValue.toString()[0].toAscii());
break;
}
return key;
}
void MergeTool::chooseAction()
{
m_merging = (m_mergeType == NormalMerge);
if (m_merging)
return;
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Merge Conflict"));
msgBox.setIcon(QMessageBox::Question);
msgBox.setStandardButtons(QMessageBox::Abort);
msgBox.setText(tr("%1 merge conflict for \"%2\"\nLocal: %3\nRemote: %4")
.arg(mergeTypeName())
.arg(m_fileName)
.arg(stateName(m_localState, m_localInfo))
.arg(stateName(m_remoteState, m_remoteInfo))
);
switch (m_mergeType) {
case SubmoduleMerge:
case SymbolicLinkMerge:
addButton(&msgBox, tr("&Local"), 'l');
addButton(&msgBox, tr("&Remote"), 'r');
break;
case DeletedMerge:
if (m_localState == CreatedState || m_remoteState == CreatedState)
addButton(&msgBox, tr("&Created"), 'c');
else
addButton(&msgBox, tr("&Modified"), 'm');
addButton(&msgBox, tr("&Deleted"), 'd');
break;
default:
break;
}
msgBox.exec();
QByteArray ba;
QVariant key;
QAbstractButton *button = msgBox.clickedButton();
if (button)
key = button->property("key");
// either the message box was closed without clicking anything, or abort was clicked
if (!key.isValid())
key = QVariant(QLatin1Char('a')); // abort
ba.append(key.toChar().toLatin1());
ba.append('\n');
m_process->write(ba);
m_process->waitForBytesWritten();
}
QScriptValue ScriptToolbox::variantToScriptValue(QScriptEngine * engine, QVariant var)
{
if(var.isNull())
return engine->nullValue();
switch(var.type())
{
case QVariant::Invalid:
return engine->nullValue();
case QVariant::Bool:
return QScriptValue(engine, var.toBool());
case QVariant::Int:
return QScriptValue(engine, var.toInt());
case QVariant::UInt:
return QScriptValue(engine, var.toUInt());
case QVariant::Double:
return QScriptValue(engine, var.toDouble());
case QVariant::Char:
return QScriptValue(engine, var.toChar().unicode());
case QVariant::String:
return QScriptValue(engine, var.toString());
case QVariant::LongLong:
return QScriptValue(engine, qsreal(var.toLongLong()));
case QVariant::ULongLong:
return QScriptValue(engine, qsreal(var.toULongLong()));
case QVariant::Date:
case QVariant::Time:
case QVariant::DateTime:
return engine->newDate(var.toDateTime());
case QVariant::RegExp:
return engine->newRegExp(var.toRegExp());
/*
* Would be ideal to have these as well but I don't know if they are really necessary
case QVariant::StringList:
case QVariant::List:
case QVariant::Map:
*/
default:
return engine->newVariant(var);
}
// If we are not doing an explicity conversion just pass the variant back
// and see what happens
return engine->newVariant(var);
}
void AsteriskManager::insertNotEmpty(QVariantMap *headers, QString key, QVariant value)
{
bool isEmpty = false;
switch (value.type()) {
case QMetaType::Int:
isEmpty = value.toChar() == -1;
break;
case QMetaType::UInt:
isEmpty = value.toUInt() == 0;
break;
default:
isEmpty = value.isNull();
break;
}
if (!isEmpty)
headers->insert(key, value);
}
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;
}
static void _push(lua_State *L, const QVariant & v)
{
switch( v.type() )
{
case QVariant::Invalid:
lua_pushnil( L );
break;
case QVariant::Bool:
lua_pushboolean( L, v.toBool() );
break;
case QVariant::Int:
lua_pushnumber( L, v.toInt() );
break;
case QVariant::Double:
lua_pushnumber( L, v.toDouble() );
break;
case QVariant::LongLong:
lua_pushnumber( L, v.toLongLong() );
break;
case QVariant::ULongLong:
lua_pushnumber( L, (double)(quint32)v.toULongLong() );
break;
case QVariant::UInt:
lua_pushnumber( L, v.toUInt() );
break;
case QVariant::Char:
lua_pushnumber( L, v.toChar().unicode() );
break;
case QVariant::ByteArray:
lua_pushstring( L, v.toByteArray() );
break;
case QVariant::String:
lua_pushstring( L, v.toString().toLatin1() );
break;
default:
lua_pushnil( L );
break;
}
}
bool json_file_generate (QTextStream &res, const QVariant &val, int indent) {
switch (val.type()) {
case QVariant::Invalid: res << "null"; break;
case QVariant::Bool: res << (val.toBool() ? "true" : "false"); break;
case QVariant::Char: res << Json::quote(QString(val.toChar())).toUtf8(); break;
case QVariant::Double: res << QString::number(val.toDouble()).toLatin1(); break; //CHECKME: is '.' always '.'?
case QVariant::Int: res << QString::number(val.toInt()).toLatin1(); break;
case QVariant::String: res << Json::quote(val.toString()).toUtf8(); break;
case QVariant::UInt: res << QString::number(val.toUInt()).toLatin1(); break;
case QVariant::ULongLong: res << QString::number(val.toULongLong()).toLatin1(); break;
case QVariant::Map: {
//for (int c = indent; c > 0; c--) res << ' ';
res << "{";
indent++; bool comma = false;
QVariantMap m(val.toMap());
QVariantMap::const_iterator i;
for (i = m.constBegin(); i != m.constEnd(); ++i) {
if (comma) res << ",\n"; else { res << '\n'; comma = true; }
for (int c = indent; c > 0; c--) res << ' ';
res << Json::quote(i.key()).toUtf8();
res << ": ";
if (!json_file_generate(res, i.value(), indent)) return false;
}
indent--;
if (comma) {
res << '\n';
for (int c = indent; c > 0; c--) res << ' ';
}
res << '}';
indent--;
} break;
case QVariant::List: {
//for (int c = indent; c > 0; c--) res << ' ';
res << "[";
indent++; bool comma = false;
QVariantList m(val.toList());
foreach (const QVariant &v, m) {
if (comma) res << ",\n"; else { res << '\n'; comma = true; }
for (int c = indent; c > 0; c--) res << ' ';
if (!json_file_generate(res, v, indent)) return false;
}
indent--;
if (comma) {
res << '\n';
for (int c = indent; c > 0; c--) res << ' ';
}
res << ']';
indent--;
} break;
case QVariant::StringList: {
//for (int c = indent; c > 0; c--) res << ' ';
res << "[";
indent++; bool comma = false;
QStringList m(val.toStringList());
foreach (const QString &v, m) {
if (comma) res << ",\n"; else { res << '\n'; comma = true; }
for (int c = indent; c > 0; c--) res << ' ';
res << Json::quote(v).toUtf8();
}
indent--;
if (comma) {
res << '\n';
for (int c = indent; c > 0; c--) res << ' ';
}
res << ']';
indent--;
} break;
default: return false;
}
return true;
}
uint qHash( const QVariant &variant )
{
if ( !variant.isValid() || variant.isNull() )
return std::numeric_limits<uint>::max();
switch ( variant.type() )
{
case QVariant::Int:
return qHash( variant.toInt() );
case QVariant::UInt:
return qHash( variant.toUInt() );
case QVariant::Bool:
return qHash( variant.toBool() );
case QVariant::Double:
return qHash( variant.toDouble() );
case QVariant::LongLong:
return qHash( variant.toLongLong() );
case QVariant::ULongLong:
return qHash( variant.toULongLong() );
case QVariant::String:
return qHash( variant.toString() );
case QVariant::Char:
return qHash( variant.toChar() );
case QVariant::List:
#if QT_VERSION >= 0x050600
return qHash( variant.toList() );
#else
{
QVariantList list = variant.toList();
if ( list.isEmpty() )
return -1;
else
return qHash( list.at( 0 ) );
}
#endif
case QVariant::StringList:
#if QT_VERSION >= 0x050600
return qHash( variant.toStringList() );
#else
{
QStringList list = variant.toStringList();
if ( list.isEmpty() )
return -1;
else
return qHash( list.at( 0 ) );
}
#endif
case QVariant::ByteArray:
return qHash( variant.toByteArray() );
case QVariant::Date:
return qHash( variant.toDate() );
case QVariant::Time:
return qHash( variant.toTime() );
case QVariant::DateTime:
return qHash( variant.toDateTime() );
case QVariant::Url:
case QVariant::Locale:
case QVariant::RegExp:
return qHash( variant.toString() );
default:
break;
}
return std::numeric_limits<uint>::max();
}
bool ParamComboBox :: StoreParameterValue ()
{
QVariant v = pcb_combo_box_p -> currentData ();
bool success_flag = false;
switch (bpw_param_p -> pa_type)
{
case PT_LARGE_STRING:
case PT_STRING:
case PT_FILE_TO_READ:
case PT_FILE_TO_WRITE:
case PT_DIRECTORY:
case PT_KEYWORD:
{
QString s (v.toString ());
QByteArray ba = s.toLocal8Bit ();
const char *value_s = ba.constData ();
success_flag = SetParameterValue (bpw_param_p, value_s, true);
qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << value_s;
}
break;
case PT_CHAR:
{
QChar qc = v.toChar ();
char c = qc.toLatin1 ();
success_flag = SetParameterValue (bpw_param_p, &c, true);
qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << c;
}
break;
case PT_BOOLEAN:
{
bool b = v.toBool ();
success_flag = SetParameterValue (bpw_param_p, &b, true);
qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << b;
}
break;
case PT_SIGNED_INT:
case PT_UNSIGNED_INT:
{
bool conv_flag = false;
int i = v.toInt (&conv_flag);
if (conv_flag)
{
success_flag = SetParameterValue (bpw_param_p, &i, true);
qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << i;
}
}
break;
case PT_SIGNED_REAL:
case PT_UNSIGNED_REAL:
{
bool conv_flag = false;
double d = v.toDouble (&conv_flag);
if (conv_flag)
{
success_flag = SetParameterValue (bpw_param_p, &d, true);
qDebug () << "Setting " << bpw_param_p -> pa_name_s << " to " << d;
}
}
break;
default:
break;
}
return success_flag;
}
// Apply a simple variant type to a DOM property
static bool applySimpleProperty(const QVariant &v, bool translateString, DomProperty *dom_prop)
{
switch (v.type()) {
case QVariant::String: {
DomString *str = new DomString();
str->setText(v.toString());
if (!translateString)
str->setAttributeNotr(QStringLiteral("true"));
dom_prop->setElementString(str);
}
return true;
case QVariant::ByteArray:
dom_prop->setElementCstring(QString::fromUtf8(v.toByteArray()));
return true;
case QVariant::Int:
dom_prop->setElementNumber(v.toInt());
return true;
case QVariant::UInt:
dom_prop->setElementUInt(v.toUInt());
return true;
case QVariant::LongLong:
dom_prop->setElementLongLong(v.toLongLong());
return true;
case QVariant::ULongLong:
dom_prop->setElementULongLong(v.toULongLong());
return true;
case QVariant::Double:
dom_prop->setElementDouble(v.toDouble());
return true;
case QVariant::Bool:
dom_prop->setElementBool(v.toBool() ? QFormBuilderStrings::instance().trueValue : QFormBuilderStrings::instance().falseValue);
return true;
case QVariant::Char: {
DomChar *ch = new DomChar();
const QChar character = v.toChar();
ch->setElementUnicode(character.unicode());
dom_prop->setElementChar(ch);
}
return true;
case QVariant::Point: {
DomPoint *pt = new DomPoint();
const QPoint point = v.toPoint();
pt->setElementX(point.x());
pt->setElementY(point.y());
dom_prop->setElementPoint(pt);
}
return true;
case QVariant::PointF: {
DomPointF *ptf = new DomPointF();
const QPointF pointf = v.toPointF();
ptf->setElementX(pointf.x());
ptf->setElementY(pointf.y());
dom_prop->setElementPointF(ptf);
}
return true;
case QVariant::Color: {
DomColor *clr = new DomColor();
const QColor color = qvariant_cast<QColor>(v);
clr->setElementRed(color.red());
clr->setElementGreen(color.green());
clr->setElementBlue(color.blue());
const int alphaChannel = color.alpha();
if (alphaChannel != 255)
clr->setAttributeAlpha(alphaChannel);
dom_prop->setElementColor(clr);
}
return true;
case QVariant::Size: {
DomSize *sz = new DomSize();
const QSize size = v.toSize();
sz->setElementWidth(size.width());
sz->setElementHeight(size.height());
dom_prop->setElementSize(sz);
}
return true;
case QVariant::SizeF: {
DomSizeF *szf = new DomSizeF();
const QSizeF sizef = v.toSizeF();
szf->setElementWidth(sizef.width());
szf->setElementHeight(sizef.height());
dom_prop->setElementSizeF(szf);
}
return true;
case QVariant::Rect: {
DomRect *rc = new DomRect();
const QRect rect = v.toRect();
rc->setElementX(rect.x());
rc->setElementY(rect.y());
rc->setElementWidth(rect.width());
rc->setElementHeight(rect.height());
dom_prop->setElementRect(rc);
}
return true;
case QVariant::RectF: {
DomRectF *rcf = new DomRectF();
const QRectF rectf = v.toRectF();
rcf->setElementX(rectf.x());
rcf->setElementY(rectf.y());
rcf->setElementWidth(rectf.width());
rcf->setElementHeight(rectf.height());
dom_prop->setElementRectF(rcf);
}
return true;
case QVariant::Font: {
DomFont *fnt = new DomFont();
const QFont font = qvariant_cast<QFont>(v);
const uint mask = font.resolve();
if (mask & QFont::WeightResolved) {
fnt->setElementBold(font.bold());
fnt->setElementWeight(font.weight());
}
if (mask & QFont::FamilyResolved)
fnt->setElementFamily(font.family());
if (mask & QFont::StyleResolved)
fnt->setElementItalic(font.italic());
if (mask & QFont::SizeResolved)
fnt->setElementPointSize(font.pointSize());
if (mask & QFont::StrikeOutResolved)
fnt->setElementStrikeOut(font.strikeOut());
if (mask & QFont::UnderlineResolved)
fnt->setElementUnderline(font.underline());
if (mask & QFont::KerningResolved)
fnt->setElementKerning(font.kerning());
if (mask & QFont::StyleStrategyResolved) {
const QMetaEnum styleStrategy_enum = metaEnum<QAbstractFormBuilderGadget>("styleStrategy");
fnt->setElementStyleStrategy(QLatin1String(styleStrategy_enum.valueToKey(font.styleStrategy())));
}
dom_prop->setElementFont(fnt);
}
return true;
#ifndef QT_NO_CURSOR
case QVariant::Cursor: {
const QMetaEnum cursorShape_enum = metaEnum<QAbstractFormBuilderGadget>("cursorShape");
dom_prop->setElementCursorShape(QLatin1String(cursorShape_enum.valueToKey(qvariant_cast<QCursor>(v).shape())));
}
return true;
#endif
case QVariant::KeySequence: {
DomString *s = new DomString();
s->setText(qvariant_cast<QKeySequence>(v).toString(QKeySequence::PortableText));
dom_prop->setElementString(s);
}
return true;
case QVariant::Locale: {
DomLocale *dom = new DomLocale();
const QLocale locale = qvariant_cast<QLocale>(v);
const QMetaEnum language_enum = metaEnum<QAbstractFormBuilderGadget>("language");
const QMetaEnum country_enum = metaEnum<QAbstractFormBuilderGadget>("country");
dom->setAttributeLanguage(QLatin1String(language_enum.valueToKey(locale.language())));
dom->setAttributeCountry(QLatin1String(country_enum.valueToKey(locale.country())));
dom_prop->setElementLocale(dom);
}
return true;
case QVariant::SizePolicy: {
DomSizePolicy *dom = new DomSizePolicy();
const QSizePolicy sizePolicy = qvariant_cast<QSizePolicy>(v);
dom->setElementHorStretch(sizePolicy.horizontalStretch());
dom->setElementVerStretch(sizePolicy.verticalStretch());
const QMetaEnum sizeType_enum = metaEnum<QAbstractFormBuilderGadget>("sizeType");
dom->setAttributeHSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.horizontalPolicy())));
dom->setAttributeVSizeType(QLatin1String(sizeType_enum.valueToKey(sizePolicy.verticalPolicy())));
dom_prop->setElementSizePolicy(dom);
}
return true;
case QVariant::Date: {
DomDate *dom = new DomDate();
const QDate date = qvariant_cast<QDate>(v);
dom->setElementYear(date.year());
dom->setElementMonth(date.month());
dom->setElementDay(date.day());
dom_prop->setElementDate(dom);
}
return true;
case QVariant::Time: {
DomTime *dom = new DomTime();
const QTime time = qvariant_cast<QTime>(v);
dom->setElementHour(time.hour());
dom->setElementMinute(time.minute());
dom->setElementSecond(time.second());
dom_prop->setElementTime(dom);
}
return true;
case QVariant::DateTime: {
DomDateTime *dom = new DomDateTime();
const QDateTime dateTime = qvariant_cast<QDateTime>(v);
dom->setElementHour(dateTime.time().hour());
dom->setElementMinute(dateTime.time().minute());
dom->setElementSecond(dateTime.time().second());
dom->setElementYear(dateTime.date().year());
dom->setElementMonth(dateTime.date().month());
dom->setElementDay(dateTime.date().day());
dom_prop->setElementDateTime(dom);
}
return true;
case QVariant::Url: {
DomUrl *dom = new DomUrl();
const QUrl url = v.toUrl();
DomString *str = new DomString();
str->setText(url.toString());
dom->setElementString(str);
dom_prop->setElementUrl(dom);
}
return true;
case QVariant::StringList: {
DomStringList *sl = new DomStringList;
sl->setElementString(qvariant_cast<QStringList>(v));
dom_prop->setElementStringList(sl);
}
return true;
default:
break;
}
return false;
}
/*
Generate a string given a value, using formatting defined within this class.
*/
QString QEStringFormatting::formatString( const QVariant& value ) const
{
QEStringFormatting* self = (QEStringFormatting*) this; // this works as modified members are just used as temp. variables.
QString result;
if( value.type() != QVariant::List ){
// "Simple" scalar
result = self->formatElementString( value );
} else {
// Array variable
const QVariantList valueArray = value.toList();
const int number = valueArray.count ();
switch( arrayAction ) {
case APPEND:
// Interpret each element in the array as an unsigned integer and append
// string representations of each element from the array with a space in
// between each.
for( int j = 0; j < number; j++ ){
QVariant element = valueArray.value (j);
QString elementString;
elementString = self->formatElementString( element );
if( j > 0 )result.append ( " " );
result.append( elementString );
}
break;
case ASCII:
// Interpret each element from the array as a character in a string.
// Translate all non printing characters to '?' except for trailing
// zeros (ignore them)
for( int j = 0; j < number; j++ ){
QVariant element = valueArray.value( j );
bool okay;
int c = element.toInt( &okay );
if( !okay || (c == 0) ) break; // Not an int or got a zero - end of string.
// Ignore carriage returns.
// Note this will cause problems when implementing on Commodore 8-bit machines,
// Acorn BBC, ZX Spectrum, and TRS-80 as they don't use a line feed.
if( c == '\r' )
{
}
// Translate all non printing characters (except for space and line feed) to a '?'
else if( (c!= '\n') && (c < ' ' || c > '~') )
{
result.append( "?" );
}
// Use everything else as is.
else
{
result.append( element.toChar() );
}
}
break;
case INDEX:
// Interpret the element selected by setArrayIndex().
if( arrayIndex < (unsigned int)(number) )
{
QVariant element = valueArray.value ((int) arrayIndex);
result = self->formatElementString( element );
}
break;
default:
self->formatFailure( QString ( "Invalid arrayAction: %d" ).arg ( (int) arrayAction ));
result = "---";
break;
}
}
// Add units if required, if there are any present, and if the text is not an error message
int eguLen = dbEgu.length(); // ??? Why cant this be in the 'if' statement? If it is it never adds an egu
if( addUnits && eguLen && (format != FORMAT_TIME) )
{
result.append( " " ).append( dbEgu );
}
return result;
}
/**
* @brief is a help function that returns the hex representation of a value
* @param value that is given
* @return hex representation of the value given
*/
QString TextPanelItemDelegate::toText(QVariant value) const
{
return qPrintable(value.toChar());
}
bool qgsVariantLessThan( const QVariant& lhs, const QVariant& rhs )
{
// invalid < NULL < any value
if ( !lhs.isValid() )
return rhs.isValid();
else if ( lhs.isNull() )
return rhs.isValid() && !rhs.isNull();
else if ( !rhs.isValid() || rhs.isNull() )
return false;
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();
case QVariant::Bool:
return lhs.toBool() < rhs.toBool();
case QVariant::List:
{
const QList<QVariant> &lhsl = lhs.toList();
const QList<QVariant> &rhsl = rhs.toList();
int i, n = qMin( lhsl.size(), rhsl.size() );
for ( i = 0; i < n && lhsl[i].type() == rhsl[i].type() && lhsl[i].isNull() == rhsl[i].isNull() && lhsl[i] == rhsl[i]; i++ )
;
if ( i == n )
return lhsl.size() < rhsl.size();
else
return qgsVariantLessThan( lhsl[i], rhsl[i] );
}
case QVariant::StringList:
{
const QStringList &lhsl = lhs.toStringList();
const QStringList &rhsl = rhs.toStringList();
int i, n = qMin( lhsl.size(), rhsl.size() );
for ( i = 0; i < n && lhsl[i] == rhsl[i]; i++ )
;
if ( i == n )
return lhsl.size() < rhsl.size();
else
return lhsl[i] < rhsl[i];
}
default:
return QString::localeAwareCompare( lhs.toString(), rhs.toString() ) < 0;
}
}
/*! \internal
Stringifies \a variant.
*/
void JsonWriter::stringify(const QVariant &variant, int depth)
{
if (variant.type() == QVariant::List || variant.type() == QVariant::StringList) {
m_result += QLatin1Char('[');
QVariantList list = variant.toList();
for (int i = 0; i < list.count(); i++) {
if (i != 0) {
m_result += QLatin1Char(',');
if (m_autoFormatting)
m_result += QLatin1Char(' ');
}
stringify(list[i], depth+1);
}
m_result += QLatin1Char(']');
} else if (variant.type() == QVariant::Map) {
QString indent = m_autoFormattingIndent.repeated(depth);
QVariantMap map = variant.toMap();
if (m_autoFormatting && depth != 0) {
m_result += QLatin1Char('\n');
m_result += indent;
m_result += QLatin1String("{\n");
} else {
m_result += QLatin1Char('{');
}
for (QVariantMap::const_iterator it = map.constBegin(); it != map.constEnd(); ++it) {
if (it != map.constBegin()) {
m_result += QLatin1Char(',');
if (m_autoFormatting)
m_result += QLatin1Char('\n');
}
if (m_autoFormatting)
m_result += indent + QLatin1Char(' ');
m_result += QLatin1Char('\"') + escape(it.key()) + QLatin1String("\":");
stringify(it.value(), depth+1);
}
if (m_autoFormatting) {
m_result += QLatin1Char('\n');
m_result += indent;
}
m_result += QLatin1Char('}');
} else if (variant.type() == QVariant::String || variant.type() == QVariant::ByteArray) {
m_result += QLatin1Char('\"') + escape(variant) + QLatin1Char('\"');
} else if (variant.type() == QVariant::Double || (int)variant.type() == (int)QMetaType::Float) {
double d = variant.toDouble();
if (qIsFinite(d))
m_result += QString::number(variant.toDouble(), 'g', 15);
else
m_result += QLatin1String("null");
} else if (variant.type() == QVariant::Bool) {
m_result += variant.toBool() ? QLatin1String("true") : QLatin1String("false");
} else if (variant.type() == QVariant::Invalid) {
m_result += QLatin1String("null");
} else if (variant.type() == QVariant::ULongLong) {
m_result += QString::number(variant.toULongLong());
} else if (variant.type() == QVariant::LongLong) {
m_result += QString::number(variant.toLongLong());
} else if (variant.type() == QVariant::Int) {
m_result += QString::number(variant.toInt());
} else if (variant.type() == QVariant::UInt) {
m_result += QString::number(variant.toUInt());
} else if (variant.type() == QVariant::Char) {
QChar c = variant.toChar();
if (c.unicode() > 127)
m_result += QLatin1String("\"\\u") + QString::number(c.unicode(), 16).rightJustified(4, QLatin1Char('0')) + QLatin1Char('\"');
else
m_result += QLatin1Char('\"') + c + QLatin1Char('\"');
} else if (variant.canConvert<qlonglong>()) {
m_result += QString::number(variant.toLongLong());
} else if (variant.canConvert<QString>()) {
m_result += QLatin1Char('\"') + escape(variant) + QLatin1Char('\"');
} else {
if (!m_errorString.isEmpty())
m_errorString.append(QLatin1Char('\n'));
QString msg = QString::fromLatin1("Unsupported type %1 (id: %2)").arg(QString::fromUtf8(variant.typeName())).arg(variant.userType());
m_errorString.append(msg);
qWarning() << "JsonWriter::stringify - " << msg;
m_result += QLatin1String("null");
}
}
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;
}
void JSON::gen(QByteArray &res, const QVariant &val)
{
switch (val.type()) {
case QVariant::Invalid: res += QLatin1String("null"); break;
case QVariant::Bool: res += (val.toBool() ? QLatin1String("true") : QLatin1String("false")); break;
case QVariant::Char: res += quote(QString(val.toChar())).toUtf8(); break;
case QVariant::Double: res += QByteArray::number(val.toDouble()); break; //CHECKME: is '.' always '.'?
case QVariant::Int: res += QByteArray::number(val.toInt()); break;
case QVariant::LongLong: res += QByteArray::number(val.toLongLong()); break;
case QVariant::UInt: res += QByteArray::number(val.toUInt()); break;
case QVariant::ULongLong: res += QByteArray::number(val.toULongLong()); break;
case QVariant::String: res += quote(val.toString()).toUtf8(); break;
case QVariant::ByteArray: res += quote(val.toByteArray()); break;
case QVariant::Map: {
res += '{';
bool comma = false;
QVariantMap m(val.toMap());
QMapIterator<QString, QVariant> i(m);
while (i.hasNext()) {
i.next();
if (comma)
res += ',';
else
comma = true;
res += quote(i.key()).toUtf8();
res += ':';
gen(res, i.value());
}
res += '}';
}
break;
case QVariant::Hash: {
res += '{';
bool comma = false;
QVariantHash m(val.toHash());
QHashIterator<QString, QVariant> i(m);
while (i.hasNext()) {
i.next();
if (comma)
res += ',';
else
comma = true;
res += quote(i.key()).toUtf8();
res += ':';
gen(res, i.value());
}
res += '}';
}
break;
case QVariant::List: {
res += '[';
bool comma = false;
QVariantList m(val.toList());
foreach (const QVariant &v, m) {
if (comma)
res += ',';
else
comma = true;
gen(res, v);
}
res += ']';
}
break;
case QVariant::StringList: {
res += '[';
bool comma = false;
QStringList m(val.toStringList());
foreach (const QString &v, m) {
if (comma)
res += ',';
else
comma = true;
res += quote(v).toUtf8();
}
res += ']';
}
break;
default:
if (val.canConvert(QVariant::String))
gen(res, val.toString());
else
res += QLatin1String("null");
}
}
