/*
Format a variant value as a string representation of an unsigned integer.
This method was written to convert a QVariant of type ULongLong, but should cope with a variant of any type.
First convert the variant value to an unsigned long. It may or may not be a ulonglong type variant. If it is - good,
there will be no conversion problems.
Then format it as a string using the formatting information stored in this class.
*/
void QEStringFormatting::formatFromUnsignedInteger( const QVariant &value ) {
// Extract the value as an unsigned long using whatever conversion the QVariant uses.
//
// Note, this will not pick up if the QVariant type is not one of the types used to represent CA data.
// This is OK as it is not absolutely nessesary to do this sort of check at this point. Also the code is more robust as it will
// work if the range of QVariant types used expands.
// Note, this does not give us the freedom to specify what conversions should fail or succeed. For example, does QVariant::toULongLong()
// work if the value it holds is the string 1.000 and should it?
// If QVariant::toULongLong() does not do exactly what is required, a switch statement for each of the types used to hold CA data
// will need to be added and the conversions done manually or using QVariant::toULongLong() as required.
// Use QString conversions is variant is a string.
// (QVariant toLongLong can't convert strings like "2.000"!)
bool convertOk;
unsigned long ulValue;
if( value.type() == QVariant::String )
{
QString str = value.toString();
double dd = str.toDouble( &convertOk );
ulValue = dd;
}
// Use QVariant conversions otherwise
else
{
ulValue = value.toULongLong( &convertOk );
}
if( !convertOk )
{
formatFailure( QString( "Warning from QEStringFormatting::formatFromUnsignedInteger(). A variant could not be converted to an unsigned long." ) );
return;
}
// Generate the text
stream << ulValue;
// Add sperators if needs be
outStr = insertSeparators( outStr );
}
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;
}
LUA_INLINE void Lua::pushVariant(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_pushinteger(L, v.toInt());
break;
case QVariant::UInt:
lua_pushunsigned(L, v.toUInt());
break;
case QVariant::LongLong:
push(L, v.toLongLong());
break;
case QVariant::ULongLong:
push(L, v.toULongLong());
break;
case QVariant::Double:
lua_pushnumber(L, v.toDouble());
break;
case QVariant::Map:
pushMap(L, v.toMap());
break;
case QVariant::List:
pushList(L, v.toList());
break;
case QVariant::StringList:
pushList(L, v.toStringList());
break;
case QVariant::ByteArray:
push(L, v.toByteArray());
break;
default:
push(L, v.toString());
break;
}
}
bool SqlDataQuery::getDatabaseRevision(QSqlDatabase &connection,
DataRevision *revision) {
bool revisionOK = false;
quint64 numericRevision = 0L;
if (!m_revisionQuery.isEmpty()) {
QVariant resultRevision;
if (SqlQueryUtils().getSingleQueryValue(connection, m_revisionQuery,
m_bindValues, "", &resultRevision, &m_error)) {
// this code only supports numeric revisions; empty DataRevision returned otherwise.
numericRevision = resultRevision.toULongLong(&revisionOK);
} else {
qWarning() << "Failed to fetch the database revision.";
return false;
}
}
*revision =
revisionOK ?
DataRevision(new NumericRevision(numericRevision)) :
DataRevision();
return true;
}
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 TransferModel::setData( const QModelIndex& index, const QVariant& value, int role )
{
row=index.row();
column=index.column();
if(index.parent()!=QModelIndex() || row < 0 || row >= transfertItemList.count() || column < 0 || column >= COLUMN_COUNT)
return false;
transfertItem& item = transfertItemList[row];
if(role==Qt::UserRole)
{
item.id=value.toULongLong();
return true;
}
else if(role==Qt::DisplayRole)
{
switch(column)
{
case 0:
item.source=value.toString();
emit dataChanged(index,index);
return true;
break;
case 1:
item.size=value.toString();
emit dataChanged(index,index);
return true;
break;
case 2:
item.destination=value.toString();
emit dataChanged(index,index);
return true;
break;
default:
return false;
}
}
return false;
}
QColor VisualAttribute::value2color(const QVariant &var) const
{
if ( !_domain.isValid()){ // the range case
bool ok;
double d = var.toDouble(&ok);
if ( ok){
double f = (d - _actualRange.min())/_actualRange.distance();
int defColorSize = ColorRangeBase::defaultColorNames().size();
int index = std::max(0.0,std::min((double)defColorSize-1, f * (defColorSize)));
return ColorRangeBase::defaultColor(index);
}
}
double v;
if ( hasType(_domain->valueType(), itCONTINUOUSCOLOR)){
return ColorRangeBase::toColor(var.toULongLong(), ColorRangeBase::cmRGBA);
}else if ( hasType(_domain->ilwisType(), itNUMERICDOMAIN | itITEMDOMAIN)){
v = var.toDouble();
}else{
v = tovalue(var.toString());
}
return _representation->colors()->value2color(v, _actualRange, _stretchRange) ;
}
void IntegerWatchLineEdit::setModelData(const QVariant &v)
{
if (debug)
qDebug(">IntegerLineEdit::setModelData(%s, '%s'): base=%d, signed=%d, bigint=%d",
v.typeName(), qPrintable(v.toString()),
base(), isSigned(), isBigInt());
switch (v.type()) {
case QVariant::Int:
case QVariant::LongLong: {
const qint64 iv = v.toLongLong();
setSigned(true);
setText(QString::number(iv, base()));
}
break;
case QVariant::UInt:
case QVariant::ULongLong: {
const quint64 iv = v.toULongLong();
setSigned(false);
setText(QString::number(iv, base()));
}
break;
case QVariant::ByteArray:
setNumberText(QString::fromLatin1(v.toByteArray()));
break;
case QVariant::String:
setNumberText(v.toString());
break;
default:
qWarning("Invalid value (%s) passed to IntegerLineEdit::setModelData",
v.typeName());
setText(QString(QLatin1Char('0')));
break;
}
if (debug)
qDebug("<IntegerLineEdit::setModelData(): base=%d, signed=%d, bigint=%d",
base(), isSigned(), isBigInt());
}
static void AddWmdmItem(IWMDMMetaData* metadata, const wchar_t* name,
const QVariant& value) {
switch (value.type()) {
case QVariant::Int:
case QVariant::UInt: {
DWORD data = value.toUInt();
metadata->AddItem(WMDM_TYPE_DWORD, name, (BYTE*)&data, sizeof(data));
break;
}
case QVariant::String: {
ScopedWCharArray data(value.toString());
metadata->AddItem(WMDM_TYPE_STRING, name, (BYTE*)data.get(), data.bytes());
break;
}
case QVariant::ByteArray: {
QByteArray data = value.toByteArray();
metadata->AddItem(WMDM_TYPE_BINARY, name, (BYTE*)data.constData(), data.size());
break;
}
case QVariant::Bool: {
int data = value.toBool();
metadata->AddItem(WMDM_TYPE_BOOL, name, (BYTE*)&data, sizeof(data));
break;
}
case QVariant::LongLong:
case QVariant::ULongLong: {
quint64 data = value.toULongLong();
metadata->AddItem(WMDM_TYPE_QWORD, name, (BYTE*)&data, sizeof(data));
break;
}
default:
qLog(Warning) << "Type" << value.type() << "not handled";
Q_ASSERT(0);
break;
}
}
WId MInputContextConnection::winId()
{
#ifdef Q_WS_WIN
WId result = 0;
return result;
#else
QVariant winIdVariant = widgetState[WinId];
// after transfer by dbus type can change
switch (winIdVariant.type()) {
case QVariant::UInt:
if (sizeof(uint) >= sizeof(WId))
return winIdVariant.toUInt();
break;
case QVariant::ULongLong:
if (sizeof(qulonglong) >= sizeof(WId))
return winIdVariant.toULongLong();
break;
default:
if (winIdVariant.canConvert<WId>())
return winIdVariant.value<WId>();
}
return 0;
#endif
}
QString JSON::stringify(QVariant v){
if (v.isNull()){
return QLatin1String("null");
}
switch (v.type()) {
case QVariant::Bool:
return v.toBool()?QLatin1String("true"):QLatin1String("false");
break;
case QVariant::ULongLong:
case QVariant::UInt:
return QString::number(v.toULongLong());
break;
case QVariant::LongLong:
case QVariant::Int:
return QString::number(v.toLongLong());
break;
case QVariant::Double:
return QString::number(v.toDouble());
break;
case QVariant::Map:
{
QString r=QLatin1String("{");
QMap<QString, QVariant> map = v.toMap();
QMapIterator<QString, QVariant> i(map);
while (i.hasNext()){
i.next();
r+=QLatin1String("\"")+i.key()+ QLatin1String("\":") +stringify(i.value())+QLatin1String(",");
}
if(r.length()>1)
r.chop(1);
r+=QLatin1String("}");
return r;
}
break;
#if QT_VERSION >= 0x040500
case QVariant::Hash:
{
QString r=QLatin1String("{");
QHash<QString, QVariant> map = v.toHash();
QHashIterator<QString, QVariant> i(map);
while (i.hasNext()){
i.next();
r+=QLatin1String("\"")+i.key()+QLatin1String("\":")+stringify(i.value())+QLatin1String(",");
}
if(r.length()>1)
r.chop(1);
r+=QLatin1String("}");
return r;
}
break;
#endif
case QVariant::StringList:
{
QString r=QLatin1String("[");
QStringList l = v.toStringList();
foreach(QString i, l){
r+=QLatin1String("\"")+i+QLatin1String("\",");
}
if(r.length()>1)
r.chop(1);
r+=QLatin1String("]");
return r;
}
case QVariant::List:
{
QString r=QLatin1String("[");
QVariantList l = v.toList();
foreach(QVariant i, l){
r+=stringify(i)+QLatin1String(",");
}
if(r.length()>1)
r.chop(1);
r+=QLatin1String("]");
return r;
}
QT_BEGIN_NAMESPACE
static void copyArgument(void *to, int id, const QVariant &arg)
{
if (id == arg.userType()) {
switch (id) {
case QVariant::Bool:
*reinterpret_cast<bool *>(to) = arg.toBool();
return;
case QMetaType::UChar:
*reinterpret_cast<uchar *>(to) = arg.value<uchar>();
return;
case QMetaType::Short:
*reinterpret_cast<short *>(to) = arg.value<short>();
return;
case QMetaType::UShort:
*reinterpret_cast<ushort *>(to) = arg.value<ushort>();
return;
case QVariant::Int:
*reinterpret_cast<int *>(to) = arg.toInt();
return;
case QVariant::UInt:
*reinterpret_cast<uint *>(to) = arg.toUInt();
return;
case QVariant::LongLong:
*reinterpret_cast<qlonglong *>(to) = arg.toLongLong();
return;
case QVariant::ULongLong:
*reinterpret_cast<qulonglong *>(to) = arg.toULongLong();
return;
case QVariant::Double:
*reinterpret_cast<double *>(to) = arg.toDouble();
return;
case QVariant::String:
*reinterpret_cast<QString *>(to) = arg.toString();
return;
case QVariant::ByteArray:
*reinterpret_cast<QByteArray *>(to) = arg.toByteArray();
return;
case QVariant::StringList:
*reinterpret_cast<QStringList *>(to) = arg.toStringList();
return;
}
if (id == QDBusMetaTypeId::variant) {
*reinterpret_cast<QDBusVariant *>(to) = arg.value<QDBusVariant>();
return;
} else if (id == QDBusMetaTypeId::objectpath) {
*reinterpret_cast<QDBusObjectPath *>(to) = arg.value<QDBusObjectPath>();
return;
} else if (id == QDBusMetaTypeId::signature) {
*reinterpret_cast<QDBusSignature *>(to) = arg.value<QDBusSignature>();
return;
}
// those above are the only types possible
// the demarshaller code doesn't demarshall anything else
qFatal("Found a decoded basic type in a D-Bus reply that shouldn't be there");
}
// if we got here, it's either an un-dermarshalled type or a mismatch
if (arg.userType() != QDBusMetaTypeId::argument) {
// it's a mismatch
//qWarning?
return;
}
// is this type registered?
const char *userSignature = QDBusMetaType::typeToSignature(id);
if (!userSignature || !*userSignature) {
// type not registered
//qWarning?
return;
}
// is it the same signature?
QDBusArgument dbarg = arg.value<QDBusArgument>();
if (dbarg.currentSignature() != QLatin1String(userSignature)) {
// not the same signature, another mismatch
//qWarning?
return;
}
// we can demarshall
QDBusMetaType::demarshall(dbarg, id, to);
}
void print_ulonglong(QString const &name, QVariant const &value) {
qDebug() << "Got " << name << "=" << value.toULongLong() << "\n";
}
void QtCUrl::setOptions(Options& opt) {
Options defaults;
//defaults[CURLOPT_FAILONERROR] = true;
defaults[CURLOPT_ERRORBUFFER].setValue(_errorBuffer);
if(FileName.isEmpty())
{
defaults[CURLOPT_WRITEFUNCTION].setValue(&writer);
defaults[CURLOPT_WRITEDATA].setValue(&_buffer);
}else
{
File.setFileName(FileName);
defaults[CURLOPT_WRITEFUNCTION].setValue(&writer_file);
defaults[CURLOPT_WRITEDATA].setValue(&File);
}
defaults[CURLOPT_PROGRESSFUNCTION].setValue(&progress_callback);
defaults[CURLOPT_PROGRESSDATA].setValue(&AutoDelete);
defaults[CURLOPT_NOPROGRESS].setValue(0);
defaults[CURLOPT_SSL_VERIFYPEER].setValue(false);
defaults[CURLOPT_SSL_VERIFYHOST].setValue(false);
if(!Filter.isEmpty())
{
//defaults[CURLOPT_VERBOSE].setValue(1);
defaults[CURLOPT_HEADERFUNCTION].setValue(&writer2);
defaults[CURLOPT_WRITEHEADER].setValue(&_buffer_and_filter);
}
//defaults[CURLOPT_VERBOSE].setValue(1);
#ifdef QTCURL_DEBUG
curl_easy_setopt(_curl, CURLOPT_VERBOSE, 1);
curl_easy_setopt(_curl, CURLOPT_DEBUGFUNCTION, trace);
#endif
OptionsIterator i(defaults);
while (i.hasNext()) {
i.next();
if (! opt.contains(i.key())) {
opt[i.key()] = i.value();
}
}
if(opt.contains(CURLOPT_POSTFIELDSIZE))
{
int val = opt[CURLOPT_POSTFIELDSIZE].toInt();
curl_easy_setopt(_curl, CURLOPT_POSTFIELDSIZE, (long)val);
}
i = opt;
while (i.hasNext()) {
i.next();
QVariant value = i.value();
if(i.key() == CURLOPT_POSTFIELDSIZE)
{
continue;
}
switch (value.type()) {
case QVariant::Bool:
case QVariant::Int: {
int val = value.toInt();
curl_easy_setopt(_curl, i.key(), val);
break;
}
case QVariant::ByteArray: {
QByteArray ba = value.toByteArray();
curl_easy_setopt(_curl, i.key(), ba.constData());
break;
}
case QVariant::Url: {
QByteArray ba = value.toUrl().toEncoded();
curl_easy_setopt(_curl, i.key(), ba.constData());
break;
}
case QVariant::String: {
curl_easy_setopt(_curl, i.key(), value.toString().toUtf8().data());
break;
}
case QVariant::ULongLong: {
qulonglong val = value.toULongLong();
curl_easy_setopt(_curl, i.key(), (void*) val);
break;
}
case QVariant::StringList: {
struct curl_slist *slist = NULL;
foreach (const QString &tmp, value.toStringList()) {
slist = curl_slist_append(slist, tmp.toUtf8().data());
}
_slist.append(slist);
curl_easy_setopt(_curl, i.key(), slist);
break;
}
default:
const QString typeName = value.typeName();
if (typeName == "QtCUrl::WriterPtr") {
curl_easy_setopt(_curl, i.key(), value.value<WriterPtr>());
}else if (typeName == "QtCUrl::WriterFilePtr") {
curl_easy_setopt(_curl, i.key(), value.value<WriterFilePtr>());
}else if (typeName == "QtCUrl::HeaderPtr") {
curl_easy_setopt(_curl, i.key(), value.value<HeaderPtr>());
}else if (typeName == "QtCUrl::ProgressPtr") {
curl_easy_setopt(_curl, i.key(), value.value<ProgressPtr>());
}
else if (typeName == "std::string*") {
curl_easy_setopt(_curl, i.key(), value.value<std::string*>());
}
else if (typeName == "BufferAndFilter*") {
curl_easy_setopt(_curl, i.key(), value.value<BufferAndFilter*>());
}
else if (typeName == "char*") {
curl_easy_setopt(_curl, i.key(), value.value<char*>());
}
else if (typeName == "bool*") {
curl_easy_setopt(_curl, i.key(), value.value<bool*>());
}
else if (typeName == "QFile*") {
curl_easy_setopt(_curl, i.key(), value.value<QFile*>());
}
else {
//qDebug() << "[QtCUrl] Unsupported option type: " << typeName;
}
}
}
}
int lqtL_qvariant_value(lua_State *L) {
QVariant* self = static_cast<QVariant*>(lqtL_toudata(L, 1, "QVariant*"));
lqtL_selfcheck(L, self, "QVariant");
QVariant::Type type;
if (lua_isnoneornil(L, 2)) {
type = self->type();
} else {
type = (QVariant::Type)lqtL_toenum(L, 2, "QVariant.Type");
const char * currentType = self->typeName();
if (!self->canConvert(type) || !self->convert(type)) {
lua_pushnil(L);
lua_pushfstring(L, "cannot convert %s to %s", currentType, self->typeToName(type));
return 2;
}
}
switch (self->type()) {
case QVariant::Invalid: lua_pushnil(L); return 1;
/* basic types */
case QVariant::Bool: lua_pushboolean(L, self->toBool()); return 1;
case QVariant::Double: lua_pushnumber(L, self->toDouble()); return 1;
case QVariant::Int: lua_pushinteger(L, self->toInt()); return 1;
case QVariant::UInt: lua_pushinteger(L, self->toUInt()); return 1;
case QVariant::LongLong: lua_pushnumber(L, self->toLongLong()); return 1;
case QVariant::ULongLong: lua_pushnumber(L, self->toULongLong()); return 1;
case QVariant::ByteArray: {
const QByteArray &ba = self->toByteArray();
lua_pushlstring(L, ba.data(), ba.size());
return 1;
};
/* QtCore types */
case QVariant::BitArray: lqtL_passudata(L, new QBitArray(self->value<QBitArray>()), "QBitArray*"); return 1;
case QVariant::Char: lqtL_passudata(L, new QChar(self->value<QChar>()), "QChar*"); return 1;
case QVariant::Date: lqtL_passudata(L, new QDate(self->value<QDate>()), "QDate*"); return 1;
case QVariant::DateTime: lqtL_passudata(L, new QDateTime(self->value<QDateTime>()), "QDateTime*"); return 1;
case QVariant::KeySequence: lqtL_passudata(L, new QKeySequence(self->value<QKeySequence>()), "QKeySequence*"); return 1;
case QVariant::Line: lqtL_passudata(L, new QLine(self->value<QLine>()), "QLine*"); return 1;
case QVariant::LineF: lqtL_passudata(L, new QLineF(self->value<QLineF>()), "QLineF*"); return 1;
case QVariant::List: lqtL_passudata(L, new QList<QVariant>(self->toList()), "QList<QVariant>*"); return 1;
case QVariant::Locale: lqtL_passudata(L, new QLocale(self->value<QLocale>()), "QLocale*"); return 1;
case QVariant::Point: lqtL_passudata(L, new QPoint(self->value<QPoint>()), "QPoint*"); return 1;
case QVariant::PointF: lqtL_passudata(L, new QPointF(self->value<QPointF>()), "QPointF*"); return 1;
case QVariant::Rect: lqtL_passudata(L, new QRect(self->value<QRect>()), "QRect*"); return 1;
case QVariant::RectF: lqtL_passudata(L, new QRectF(self->value<QRectF>()), "QRectF*"); return 1;
case QVariant::RegExp: lqtL_passudata(L, new QRegExp(self->value<QRegExp>()), "QRegExp*"); return 1;
case QVariant::Size: lqtL_passudata(L, new QSize(self->value<QSize>()), "QSize*"); return 1;
case QVariant::SizeF: lqtL_passudata(L, new QSizeF(self->value<QSizeF>()), "QSizeF*"); return 1;
case QVariant::String: lqtL_passudata(L, new QString(self->value<QString>()), "QString*"); return 1;
case QVariant::StringList: lqtL_passudata(L, new QStringList(self->value<QStringList>()), "QStringList*"); return 1;
case QVariant::Time: lqtL_passudata(L, new QTime(self->value<QTime>()), "QTime*"); return 1;
case QVariant::Url: lqtL_passudata(L, new QUrl(self->value<QUrl>()), "QUrl*"); return 1;
#ifdef MODULE_qtgui
/* QtGui types */
case QVariant::Bitmap: lqtL_passudata(L, new QBitmap(self->value<QBitmap>()), "QBitmap*"); return 1;
case QVariant::Brush: lqtL_passudata(L, new QBrush(self->value<QBrush>()), "QBrush*"); return 1;
case QVariant::Color: lqtL_passudata(L, new QColor(self->value<QColor>()), "QColor*"); return 1;
case QVariant::Cursor: lqtL_passudata(L, new QCursor(self->value<QCursor>()), "QCursor*"); return 1;
case QVariant::Font: lqtL_passudata(L, new QFont(self->value<QFont>()), "QFont*"); return 1;
case QVariant::Icon: lqtL_passudata(L, new QIcon(self->value<QIcon>()), "QIcon*"); return 1;
case QVariant::Image: lqtL_passudata(L, new QImage(self->value<QImage>()), "QImage*"); return 1;
case QVariant::Matrix: lqtL_passudata(L, new QMatrix(self->value<QMatrix>()), "QMatrix*"); return 1;
case QVariant::Matrix4x4: lqtL_passudata(L, new QMatrix4x4(self->value<QMatrix4x4>()), "QMatrix4x4*"); return 1;
case QVariant::Palette: lqtL_passudata(L, new QPalette(self->value<QPalette>()), "QPalette*"); return 1;
case QVariant::Pen: lqtL_passudata(L, new QPen(self->value<QPen>()), "QPen*"); return 1;
case QVariant::Pixmap: lqtL_passudata(L, new QPixmap(self->value<QPixmap>()), "QPixmap*"); return 1;
case QVariant::Polygon: lqtL_passudata(L, new QPolygon(self->value<QPolygon>()), "QPolygon*"); return 1;
case QVariant::Quaternion: lqtL_passudata(L, new QQuaternion(self->value<QQuaternion>()), "QQuaternion*"); return 1;
case QVariant::Region: lqtL_passudata(L, new QRegion(self->value<QRegion>()), "QRegion*"); return 1;
case QVariant::SizePolicy: lqtL_passudata(L, new QSizePolicy(self->value<QSizePolicy>()), "QSizePolicy*"); return 1;
case QVariant::Transform: lqtL_passudata(L, new QTransform(self->value<QTransform>()), "QTransform*"); return 1;
case QVariant::TextFormat: lqtL_passudata(L, new QTextFormat(self->value<QTextFormat>()), "QTextFormat*"); return 1;
case QVariant::TextLength: lqtL_passudata(L, new QTextLength(self->value<QTextLength>()), "QTextLength*"); return 1;
case QVariant::Vector2D: lqtL_passudata(L, new QVector2D(self->value<QVector2D>()), "QVector2D*"); return 1;
case QVariant::Vector3D: lqtL_passudata(L, new QVector3D(self->value<QVector3D>()), "QVector3D*"); return 1;
case QVariant::Vector4D: lqtL_passudata(L, new QVector4D(self->value<QVector4D>()), "QVector4D*"); return 1;
#endif
}
return 0;
}
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();
}
Q_ULLONG fromQVariant<Q_ULLONG>(const QVariant & s)
{
return s.toULongLong();
};
bool ArpProtocol::setFieldData(int index, const QVariant &value,
FieldAttrib attrib)
{
bool isOk = false;
if (attrib != FieldValue)
goto _exit;
switch (index)
{
case arp_hwType:
{
uint hwType = value.toUInt(&isOk);
if (isOk)
data.set_hw_type(hwType);
break;
}
case arp_protoType:
{
uint protoType = value.toUInt(&isOk);
if (isOk)
data.set_proto_type(protoType);
break;
}
case arp_hwAddrLen:
{
uint hwAddrLen = value.toUInt(&isOk);
if (isOk)
data.set_hw_addr_len(hwAddrLen);
break;
}
case arp_protoAddrLen:
{
uint protoAddrLen = value.toUInt(&isOk);
if (isOk)
data.set_proto_addr_len(protoAddrLen);
break;
}
case arp_opCode:
{
uint opCode = value.toUInt(&isOk);
if (isOk)
data.set_op_code(opCode);
break;
}
case arp_senderHwAddr:
{
quint64 hwAddr = value.toULongLong(&isOk);
if (isOk)
data.set_sender_hw_addr(hwAddr);
break;
}
case arp_senderHwAddrMode:
{
uint mode = value.toUInt(&isOk);
if (isOk && data.HwAddrMode_IsValid(mode))
data.set_sender_hw_addr_mode((OstProto::Arp::HwAddrMode) mode);
else
isOk = false;
break;
}
case arp_senderHwAddrCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_sender_hw_addr_count(count);
break;
}
case arp_senderProtoAddr:
{
uint protoAddr = value.toUInt(&isOk);
if (isOk)
data.set_sender_proto_addr(protoAddr);
break;
}
case arp_senderProtoAddrMode:
{
uint mode = value.toUInt(&isOk);
if (isOk && data.ProtoAddrMode_IsValid(mode))
data.set_sender_proto_addr_mode(
(OstProto::Arp::ProtoAddrMode)mode);
else
isOk = false;
break;
}
case arp_senderProtoAddrCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_sender_proto_addr_count(count);
break;
}
case arp_senderProtoAddrMask:
{
uint mask = value.toUInt(&isOk);
if (isOk)
data.set_sender_proto_addr_mask(mask);
break;
}
case arp_targetHwAddr:
{
quint64 hwAddr = value.toULongLong(&isOk);
if (isOk)
data.set_target_hw_addr(hwAddr);
break;
}
case arp_targetHwAddrMode:
{
uint mode = value.toUInt(&isOk);
if (isOk && data.HwAddrMode_IsValid(mode))
data.set_target_hw_addr_mode((OstProto::Arp::HwAddrMode)mode);
else
isOk = false;
break;
}
case arp_targetHwAddrCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_target_hw_addr_count(count);
break;
}
case arp_targetProtoAddr:
{
uint protoAddr = value.toUInt(&isOk);
if (isOk)
data.set_target_proto_addr(protoAddr);
break;
}
case arp_targetProtoAddrMode:
{
uint mode = value.toUInt(&isOk);
if (isOk && data.ProtoAddrMode_IsValid(mode))
data.set_target_proto_addr_mode(
(OstProto::Arp::ProtoAddrMode)mode);
else
isOk = false;
break;
}
case arp_targetProtoAddrCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_target_proto_addr_count(count);
break;
}
case arp_targetProtoAddrMask:
{
uint mask = value.toUInt(&isOk);
if (isOk)
data.set_target_proto_addr_mask(mask);
break;
}
default:
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
index);
break;
}
_exit:
return isOk;
}
bool QDBusMarshaller::appendVariantInternal(const QVariant &arg)
{
int id = arg.userType();
if (id == QVariant::Invalid) {
qWarning("QDBusMarshaller: cannot add an invalid QVariant");
error(QLatin1String("Variant containing QVariant::Invalid passed in arguments"));
return false;
}
// intercept QDBusArgument parameters here
if (id == QDBusMetaTypeId::argument()) {
QDBusArgument dbusargument = qvariant_cast<QDBusArgument>(arg);
QDBusArgumentPrivate *d = QDBusArgumentPrivate::d(dbusargument);
if (!d->message)
return false; // can't append this one...
QDBusDemarshaller demarshaller(capabilities);
demarshaller.message = q_dbus_message_ref(d->message);
if (d->direction == Demarshalling) {
// it's demarshalling; just copy
demarshaller.iterator = static_cast<QDBusDemarshaller *>(d)->iterator;
} else {
// it's marshalling; start over
if (!q_dbus_message_iter_init(demarshaller.message, &demarshaller.iterator))
return false; // error!
}
return appendCrossMarshalling(&demarshaller);
}
const char *signature = QDBusMetaType::typeToSignature( QVariant::Type(id) );
if (!signature) {
qWarning("QDBusMarshaller: type `%s' (%d) is not registered with D-BUS. "
"Use qDBusRegisterMetaType to register it",
QMetaType::typeName(id), id);
error(QString::fromLatin1("Unregistered type %1 passed in arguments")
.arg(QLatin1String(QMetaType::typeName(id))));
return false;
}
switch (*signature) {
#ifdef __OPTIMIZE__
case DBUS_TYPE_BYTE:
case DBUS_TYPE_INT16:
case DBUS_TYPE_UINT16:
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
case DBUS_TYPE_INT64:
case DBUS_TYPE_UINT64:
case DBUS_TYPE_DOUBLE:
qIterAppend(&iterator, ba, *signature, arg.constData());
return true;
case DBUS_TYPE_BOOLEAN:
append( arg.toBool() );
return true;
#else
case DBUS_TYPE_BYTE:
append( qvariant_cast<uchar>(arg) );
return true;
case DBUS_TYPE_BOOLEAN:
append( arg.toBool() );
return true;
case DBUS_TYPE_INT16:
append( qvariant_cast<short>(arg) );
return true;
case DBUS_TYPE_UINT16:
append( qvariant_cast<ushort>(arg) );
return true;
case DBUS_TYPE_INT32:
append( static_cast<dbus_int32_t>(arg.toInt()) );
return true;
case DBUS_TYPE_UINT32:
append( static_cast<dbus_uint32_t>(arg.toUInt()) );
return true;
case DBUS_TYPE_INT64:
append( arg.toLongLong() );
return true;
case DBUS_TYPE_UINT64:
append( arg.toULongLong() );
return true;
case DBUS_TYPE_DOUBLE:
append( arg.toDouble() );
return true;
#endif
case DBUS_TYPE_STRING:
append( arg.toString() );
return true;
case DBUS_TYPE_OBJECT_PATH:
append( qvariant_cast<QDBusObjectPath>(arg) );
return true;
case DBUS_TYPE_SIGNATURE:
append( qvariant_cast<QDBusSignature>(arg) );
return true;
// compound types:
case DBUS_TYPE_VARIANT:
// nested QVariant
return append( qvariant_cast<QDBusVariant>(arg) );
case DBUS_TYPE_ARRAY:
// could be many things
// find out what kind of array it is
switch (arg.type()) {
case QVariant::StringList:
append( arg.toStringList() );
return true;
case QVariant::ByteArray:
append( arg.toByteArray() );
return true;
default:
;
}
Q_FALLTHROUGH();
case DBUS_TYPE_STRUCT:
case DBUS_STRUCT_BEGIN_CHAR:
return appendRegisteredType( arg );
case DBUS_TYPE_DICT_ENTRY:
case DBUS_DICT_ENTRY_BEGIN_CHAR:
qFatal("QDBusMarshaller::appendVariantInternal got a DICT_ENTRY!");
return false;
case DBUS_TYPE_UNIX_FD:
if (capabilities & QDBusConnection::UnixFileDescriptorPassing || ba) {
append(qvariant_cast<QDBusUnixFileDescriptor>(arg));
return true;
}
Q_FALLTHROUGH();
default:
qWarning("QDBusMarshaller::appendVariantInternal: Found unknown D-BUS type '%s'",
signature);
return false;
}
return true;
}
bool StpProtocol::setFieldData(int index, const QVariant &value,
FieldAttrib attrib)
{
bool isOk = false;
if (attrib != FieldValue)
return isOk;
switch (index)
{
case stp_protocol_id:
{
quint16 protoId = value.toUInt(&isOk);
if (isOk)
data_.set_protocol_id(protoId);
break;
}
case stp_version_id:
{
quint8 versionId = value.toUInt(&isOk);
if (isOk)
data_.set_protocol_version_id(versionId);
break;
}
case stp_bpdu_type:
{
quint8 bpdu = value.toUInt(&isOk);
if (isOk)
data_.set_bpdu_type(bpdu);
break;
}
case stp_flags:
{
quint8 flags = value.toUInt(&isOk);
if (isOk)
data_.set_flags(flags);
break;
}
case stp_root_id:
{
quint64 rootId = value.toULongLong(&isOk);
if (isOk)
data_.set_root_id(rootId);
break;
}
case stp_root_path_cost:
{
quint32 pathCost = value.toUInt(&isOk);
if (isOk)
data_.set_root_path_cost(pathCost);
break;
}
case stp_bridge_id:
{
quint64 bridgeId = value.toULongLong(&isOk);
if (isOk)
data_.set_bridge_id(bridgeId);
break;
}
case stp_port_id:
{
quint32 port_id = value.toUInt(&isOk);
if (isOk)
data_.set_port_id(port_id);
break;
}
case stp_message_age:
{
quint32 messageAge = value.toUInt(&isOk);
if (isOk)
data_.set_message_age(messageAge);
break;
}
case stp_max_age:
{
quint32 maxAge = value.toUInt(&isOk);
if (isOk)
data_.set_max_age(maxAge);
break;
}
case stp_hello_time:
{
quint32 helloTime = value.toUInt(&isOk);
if (isOk)
data_.set_hello_time(helloTime);
break;
}
case stp_forward_delay:
{
quint32 forwardDelay = value.toUInt(&isOk);
if (isOk)
data_.set_forward_delay(forwardDelay);
break;
}
default:
break;
}
return isOk;
}
// 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;
}
// Author & Date: Ehsan Azar 3 April 2012
// Purpose: Begin a new Xml group or navigate to it if it exists
// Inputs:
// nodeName - the node tag (it can be in the form of relative/path/to/node)
// node index (0-based) is enclosed (relative/path/to/node<2>/subnode)
// Note: nodeName tags are always created if they do not exist
// attribs - attribute name, attribute value pairs
// value - new node value, if non-empty
// Outputs:
// Returns true if nodeName is created
bool XmlFile::beginGroup(QString nodeName, const QMap<QString, QVariant> attribs, const QVariant & value)
{
bool bRet = false;
QDomElement set;
if (nodeName.isEmpty())
nodeName = firstChildKey();
if (nodeName.isEmpty())
nodeName = "XmlItem";
// Get the node path
QStringList nodepath = nodeName.split("/");
int level = nodepath.count();
m_levels.append(level);
for (int i = 0; i < level; ++i)
{
QString strTagName = nodepath[i];
// Extract index
int index = 0;
{
int idx = strTagName.indexOf("<");
if (idx >= 0)
{
index = strTagName.mid(idx + 1, strTagName.length() - idx - 2).toInt();
strTagName = strTagName.left(idx);
nodepath[i] = strTagName;
}
}
// Look if the element (with given index) exists then get it
QDomNode parent;
if (!m_nodes.isEmpty())
{
// Get the current node
parent = m_nodes.last();
} else {
parent = m_doc;
}
int count = 0;
for(QDomElement elem = parent.firstChildElement(strTagName); !elem.isNull(); elem = elem.nextSiblingElement(strTagName))
{
count++;
if (count == index + 1)
{
set = elem;
break;
}
}
// Create all new subnodes
for (int j = 0; j < (index + 1 - count); ++j)
{
bRet = true;
set = m_doc.createElement(strTagName);
parent.appendChild(set);
}
// Add all the parent nodes without attribute or value
if (i < level - 1)
m_nodes.append(set);
}
// Now add the node to the end of the list
m_nodes.append(set);
// if there is some text/value to set
if (value.isValid())
{
bool bTextLeaf = false;
QVariantList varlst;
switch (value.type())
{
case QVariant::StringList:
case QVariant::List:
varlst = value.toList();
if (AddList(varlst, nodepath.last()))
set.setAttribute("Type", "Array");
break;
default:
QString text;
if (value.type() == QVariant::UserType)
{
const XmlItem * item = static_cast<const XmlItem *>(value.data());
QVariant subval = item->XmlValue();
if (subval.type() == QVariant::UserType)
{
const XmlItem * subitem = static_cast<const XmlItem *>(subval.data());
QString strSubKey = subitem->XmlName();
QMap<QString, QVariant> attribs = subitem->XmlAttribs();
// Recursively add this item
beginGroup(strSubKey, attribs, subval);
endGroup();
}
else if (subval.type() == QVariant::List || subval.type() == QVariant::StringList)
{
varlst = subval.toList();
if (AddList(varlst, nodepath.last()))
set.setAttribute("Type", "Array");
} else {
text = subval.toString();
bTextLeaf = true;
}
} else {
text = value.toString();
bTextLeaf = true;
}
if (bTextLeaf)
{
// Remove all the children
while (set.hasChildNodes())
set.removeChild(set.lastChild());
// See if this is Xml fragment string
XmlFile xml;
if (!xml.setContent(text))
{
QDomNode frag = m_doc.importNode(xml.getFragment(), true);
set.appendChild(frag);
} else {
QDomText domText = m_doc.createTextNode(text);
set.appendChild(domText);
}
}
}
}
// Add all the additional attributes
QMap<QString, QVariant>::const_iterator iterator;
for (iterator = attribs.begin(); iterator != attribs.end(); ++iterator)
{
QString attrName = iterator.key();
QVariant attrValue = iterator.value();
switch (attrValue.type())
{
case QVariant::String:
set.setAttribute(attrName, attrValue.toString());
break;
case QVariant::Int:
set.setAttribute(attrName, attrValue.toInt());
break;
case QVariant::UInt:
set.setAttribute(attrName, attrValue.toUInt());
break;
case QVariant::LongLong:
set.setAttribute(attrName, attrValue.toLongLong());
break;
case QVariant::ULongLong:
set.setAttribute(attrName, attrValue.toULongLong());
break;
default:
// everything else is treated as double floating point
set.setAttribute(attrName, attrValue.toDouble());
break;
}
}
return bRet;
}
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;
}
AllPrimitiveTypes AbstractBitfieldDataInformation::fromVariant(const QVariant& variant, bool* ok) const
{
return AllPrimitiveTypes(variant.toULongLong(ok));
}
QString PostFilter::match(const QMap<QString, Token> &tokens, QString filter, bool invert)
{
// Invert the filter by prepending '-'
if (filter.startsWith('-'))
{
filter = filter.right(filter.length() - 1);
invert = !invert;
}
// Tokens
if (filter.startsWith('%') && filter.endsWith('%'))
{
QString key = filter.mid(1, filter.length() - 2);
bool cond = tokens.contains(key) && !isVariantEmpty(tokens[key].value());
if (cond && invert)
{ return QObject::tr("image has a \"%1\" token").arg(key); }
else if (!cond && !invert)
{ return QObject::tr("image does not have a \"%1\" token").arg(key); }
}
// Meta-tags
else if (filter.contains(":"))
{
QString type = filter.section(':', 0, 0).toLower();
filter = filter.section(':', 1).toLower();
if (!tokens.contains(type))
{
QStringList keys = tokens.keys();
return QObject::tr("unknown type \"%1\" (available types: \"%2\")").arg(type, keys.join("\", \""));
}
QVariant token = tokens[type].value();
if (token.type() == QVariant::Int || token.type() == QVariant::DateTime || token.type() == QVariant::ULongLong)
{
int input = 0;
if (token.type() == QVariant::Int)
{ input = token.toInt(); }
else if (token.type() == QVariant::DateTime)
{ input = token.toDateTime().toString("yyyyMMdd").toInt(); }
else if (token.type() == QVariant::ULongLong)
{ input = token.toULongLong(); }
bool cond;
if (token.type() == QVariant::DateTime)
{
if (filter.startsWith("..") || filter.startsWith("<="))
{ cond = input <= toDate(filter.right(filter.size()-2)); }
else if (filter.endsWith(".."))
{ cond = input >= toDate(filter.left(filter.size()-2)); }
else if (filter.startsWith(">="))
{ cond = input >= toDate(filter.right(filter.size()-2)); }
else if (filter.startsWith("<"))
{ cond = input < toDate(filter.right(filter.size()-1)); }
else if (filter.startsWith(">"))
{ cond = input > toDate(filter.right(filter.size()-1)); }
else if (filter.contains(".."))
{ cond = input >= toDate(filter.left(filter.indexOf(".."))) && input <= toDate(filter.right(filter.size()-filter.indexOf("..")-2)); }
else
{ cond = input == toDate(filter); }
}
else
{
if (filter.startsWith("..") || filter.startsWith("<="))
{ cond = input <= filter.rightRef(filter.size()-2).toInt(); }
else if (filter.endsWith(".."))
{ cond = input >= filter.leftRef(filter.size()-2).toInt(); }
else if (filter.startsWith(">="))
{ cond = input >= filter.rightRef(filter.size()-2).toInt(); }
else if (filter.startsWith("<"))
{ cond = input < filter.rightRef(filter.size()-1).toInt(); }
else if (filter.startsWith(">"))
{ cond = input > filter.rightRef(filter.size()-1).toInt(); }
else if (filter.contains(".."))
{ cond = input >= filter.leftRef(filter.indexOf("..")).toInt() && input <= filter.rightRef(filter.size()-filter.indexOf("..")-2).toInt(); }
else
{ cond = input == filter.toInt(); }
}
if (!cond && !invert)
{ return QObject::tr("image's %1 does not match").arg(type); }
if (cond && invert)
{ return QObject::tr("image's %1 match").arg(type); }
}
else
{
if (type == "rating")
{
QMap<QString, QString> assoc;
assoc["s"] = "safe";
assoc["q"] = "questionable";
assoc["e"] = "explicit";
if (assoc.contains(filter))
filter = assoc[filter];
bool cond = !filter.isEmpty() && token.toString().toLower().startsWith(filter.at(0));
if (!cond && !invert)
{ return QObject::tr("image is not \"%1\"").arg(filter); }
if (cond && invert)
{ return QObject::tr("image is \"%1\"").arg(filter); }
}
else if (type == "source")
{
QRegExp rx(filter + "*", Qt::CaseInsensitive, QRegExp::Wildcard);
bool cond = rx.exactMatch(token.toString());
if (!cond && !invert)
{ return QObject::tr("image's source does not starts with \"%1\"").arg(filter); }
if (cond && invert)
{ return QObject::tr("image's source starts with \"%1\"").arg(filter); }
}
else
{
QString input = token.toString();
bool cond = input == filter;
if (!cond && !invert)
{ return QObject::tr("image's %1 does not match").arg(type); }
if (cond && invert)
{ return QObject::tr("image's %1 match").arg(type); }
}
}
}
else if (!filter.isEmpty())
{
QStringList tags = tokens["allos"].value().toStringList();
// Check if any tag match the filter (case insensitive plain text with wildcards allowed)
bool cond = false;
for (const QString &tag : tags)
{
QRegExp reg(filter.trimmed(), Qt::CaseInsensitive, QRegExp::Wildcard);
if (reg.exactMatch(tag))
{
cond = true;
break;
}
}
if (!cond && !invert)
{ return QObject::tr("image does not contains \"%1\"").arg(filter); }
if (cond && invert)
{ return QObject::tr("image contains \"%1\"").arg(filter); }
}
return QString();
}
void toXmlRpcValue( const int spaces, const QVariant &child, QByteArray &b )
{
#ifdef DEBUG_XMLRPC
qDebug() << "toXmlRpcValue()";
#endif
switch ( child.type() )
{
case QVariant::LongLong:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><longlong>" + QString::number( child.toLongLong()) + "</longlong></value>" );
break;
case QVariant::ULongLong:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><ulonglong>" + QString::number( child.toULongLong()) + "</ulonglong></value>" );
break;
case QVariant::Int:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><int>" + QString::number( child.toInt()) + "</int></value>" );
break;
case QVariant::Bool:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( QString( "<value><boolean>") + (child.toBool() ? "1" : "0") + "</boolean></value>" );
break;
case QVariant::String:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><string>" + child.toString() + "</string></value>" );
break;
case QVariant::Double:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><double>" + QString::number( child.toDouble()) + "</double></value>" );
break;
case QVariant::Time:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><time.iso8601>" + child.toTime().toString( "HH:mm:ss") +
"</time.iso8601></value>" );
break;
case QVariant::Date:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><date.iso8601>" + child.toDate().toString( "yyyyMMdd") +
"</date.iso8601></value>" );
break;
case QVariant::DateTime:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><dateTime.iso8601>" + child.toDateTime().toString( "yyyyMMddTHH:mm:ss") +
"</dateTime.iso8601></value>" );
break;
case QVariant::ByteArray:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><base64>" + child.toByteArray().toBase64() + "</base64></value>" );
break;
case QVariant::List:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><array><data>" );
toXmlRpcArray( spaces + 2, child.toList(), b );
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "</data></array></value>" );
break;
case QVariant::Map:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "<value><struct>" );
toXmlRpcStruct( spaces + 2, child.toMap(), b );
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append( "</struct></value>" );
break;
case QVariant::Invalid:
#ifdef XMLRPC_WITHSPACES
b.append( '\n' );
b.append( QByteArray( spaces, ' ') );
#endif
b.append("<value><invalid/></value>");
break;
default:
qCritical() << "toXmlRpcValue(): unknown return xmlrpc type" << child.typeName() << endl << child;
qFatal( "programming error" );
}
}
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();
}
}
VALUE RubyType<QVariant>::toVALUE(const QVariant& v)
{
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE variant.toString=%1 variant.typeid=%2 variant.typeName=%3").arg(v.toString()).arg(v.type()).arg(v.typeName()) );
#endif
switch( v.type() ) {
case QVariant::Int:
return RubyType<int>::toVALUE(v.toInt());
case QVariant::UInt:
return RubyType<uint>::toVALUE(v.toUInt());
case QVariant::Double:
return RubyType<double>::toVALUE(v.toDouble());
case QVariant::ByteArray:
return RubyType<QByteArray>::toVALUE(v.toByteArray());
case QVariant::String:
return RubyType<QString>::toVALUE(v.toString());
case QVariant::Bool:
return RubyType<bool>::toVALUE(v.toBool());
case QVariant::StringList:
return RubyType<QStringList>::toVALUE(v.toStringList());
case QVariant::Map:
return RubyType<QVariantMap>::toVALUE(v.toMap());
case QVariant::List:
return RubyType<QVariantList>::toVALUE(v.toList());
case QVariant::LongLong:
return RubyType<qlonglong>::toVALUE(v.toLongLong());
case QVariant::ULongLong:
return RubyType<qlonglong>::toVALUE(v.toULongLong());
case QVariant::Size:
return RubyType<QSize>::toVALUE(v.toSize());
case QVariant::SizeF:
return RubyType<QSizeF>::toVALUE(v.toSizeF());
case QVariant::Point:
return RubyType<QPoint>::toVALUE(v.toPoint());
case QVariant::PointF:
return RubyType<QPointF>::toVALUE(v.toPointF());
case QVariant::Rect:
return RubyType<QRect>::toVALUE(v.toRect());
case QVariant::RectF:
return RubyType<QRectF>::toVALUE(v.toRectF());
case QVariant::Color:
return RubyType<QColor>::toVALUE( v.value<QColor>() );
case QVariant::Url:
return RubyType<QUrl>::toVALUE(v.toUrl());
case QVariant::Date:
return RubyType<QDate>::toVALUE( v.value<QDate>() );
case QVariant::Time:
return RubyType<QTime>::toVALUE( v.value<QTime>() );
case QVariant::DateTime:
return RubyType<QDateTime>::toVALUE( v.value<QDateTime>() );
case QVariant::Invalid: {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE variant=%1 is QVariant::Invalid. Returning Qnil.").arg(v.toString()) );
#endif
return Qnil;
} // fall through
case QVariant::UserType: {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE variant=%1 is QVariant::UserType. Trying to cast now.").arg(v.toString()) );
#endif
} // fall through
default: {
if( strcmp(v.typeName(),"float") == 0 ) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to double").arg(v.typeName()) );
#endif
return RubyType<double>::toVALUE(v.toDouble());
}
if( strcmp(v.typeName(),"Qross::VoidList") == 0 ) {
VoidList list = v.value<VoidList>();
Qross::MetaTypeHandler* handler = Qross::Manager::self().metaTypeHandler(list.typeName);
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to QList<%2> with %3 items, hasHandler=%4").arg(v.typeName()).arg(list.typeName.constData()).arg(list.count()).arg(handler ? "true" : "false") );
#endif
QVariantList l;
foreach(void* ptr, list) {
if( handler ) {
l << handler->callHandler(ptr);
}
else {
QVariant v;
v.setValue(ptr);
l << v;
}
}
return RubyType<QVariantList>::toVALUE(l);
}
if( qVariantCanConvert< Qross::Object::Ptr >(v) ) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toPyObject Casting '%1' to Qross::Object::Ptr").arg(v.typeName()) );
#endif
Qross::Object::Ptr obj = v.value< Qross::Object::Ptr >();
Qross::RubyObject* rbobj = dynamic_cast< Qross::RubyObject* >(obj.data());
if(! obj) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toPyObject To Qross::RubyObject* casted '%1' is NULL").arg(v.typeName()) );
#endif
return Qnil;
}
return rbobj->rbObject();
}
if( qVariantCanConvert< QWidget* >(v) ) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to QWidget").arg(v.typeName()) );
#endif
QWidget* widget = qvariant_cast< QWidget* >(v);
if(! widget) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrosswarning( QString("RubyType<QVariant>::toVALUE To QWidget casted '%1' is NULL").arg(v.typeName()) );
#endif
return Qnil;
}
return RubyExtension::toVALUE( new RubyExtension(widget), true /*owner*/ );
}
if( qVariantCanConvert< QObject* >(v) ) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrossdebug( QString("RubyType<QVariant>::toVALUE Casting '%1' to QObject*").arg(v.typeName()) );
#endif
QObject* obj = qvariant_cast< QObject* >(v);
if(! obj) {
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrosswarning( QString("RubyType<QVariant>::toVALUE To QObject casted '%1' is NULL").arg(v.typeName()) );
#endif
return Qnil;
}
return RubyExtension::toVALUE( new RubyExtension(obj), true /*owner*/ );
}
if( qVariantCanConvert< void* >(v) ) {
return Data_Wrap_Struct( rb_cObject, 0, 0, qvariant_cast<void*>(v));
}
//QObject* obj = (*reinterpret_cast< QObject*(*)>( variantargs[0]->toVoidStar() ));
//PyObject* qobjectptr = PyLong_FromVoidPtr( (void*) variantargs[0]->toVoidStar() );
#ifdef QROSS_RUBY_VARIANT_DEBUG
qrosswarning( QString("RubyType<QVariant>::toVALUE Not possible to convert the QVariant '%1' with type '%2' (%3) to a VALUE.").arg(v.toString()).arg(v.typeName()).arg(v.type()) );
#endif
//throw Py::TypeError( QString("Variant of type %1 can not be casted to a Ruby object.").arg(v.typeName()).toLatin1().constData() );
return 0;
}
}
void XmlPListSerializer::RenderValue(const QString &sName,
const QVariant &vValue,
bool needKey)
{
if ( vValue.canConvert<QObject*>())
{
const QObject *pObject = vValue.value<QObject*>();
SerializePListObjectProperties(sName, pObject, needKey);
return;
}
switch(vValue.type())
{
case QVariant::List:
{
RenderList(sName, vValue.toList());
break;
}
case QVariant::StringList:
{
RenderStringList(sName, vValue.toStringList());
break;
}
case QVariant::Map:
{
RenderMap(sName, vValue.toMap());
break;
}
case QVariant::DateTime:
{
if (vValue.toDateTime().isValid())
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("date", vValue.toDateTime()
.toUTC().toString("yyyy-MM-ddThh:mm:ssZ"));
}
break;
}
case QVariant::ByteArray:
{
if (!vValue.toByteArray().isNull())
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("data",
vValue.toByteArray().toBase64().data());
}
break;
}
case QVariant::Bool:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeEmptyElement(vValue.toBool() ?
"true" : "false");
break;
}
case QVariant::UInt:
case QVariant::ULongLong:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("integer",
QString::number(vValue.toULongLong()));
break;
}
case QVariant::Int:
case QVariant::LongLong:
case QVariant::Double:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("real",
QString("%1").arg(vValue.toDouble(), 0, 'f', 6));
break;
}
// anything else will be unrecognised, so wrap in a string
case QVariant::String:
default:
{
if (needKey)
m_pXmlWriter->writeTextElement("key", sName);
m_pXmlWriter->writeTextElement("string", vValue.toString());
break;
}
}
}
bool JSON_Model::setData(QModelIndex const& index, QVariant const& value, int role)
{
if (!index.isValid())
{
return false;
}
auto* ti = (Tree_Item*)index.internalPointer();
if (!ti || !ti->m_json)
{
return false;
}
bool modified = false;
auto* json = ti->m_json;
if (role == Qt::DisplayRole || role == Qt::EditRole)
{
if (index.column() == 1)
{
if (json->IsBool())
{
json->SetBool(value.toBool());
modified = true;
}
else if (json->IsInt())
{
json->SetInt(value.toInt());
modified = true;
}
else if (json->IsUint())
{
json->SetUint(value.toUInt());
modified = true;
}
else if (json->IsInt64())
{
json->SetInt64(value.toLongLong());
modified = true;
}
else if (json->IsUint64())
{
json->SetUint64(value.toULongLong());
modified = true;
}
else if (json->IsDouble() || json->IsNumber())
{
json->SetDouble(value.toDouble());
modified = true;
}
else if (json->IsString())
{
json->SetString(value.toString().toLatin1().data(), m_document->GetAllocator());
modified = true;
}
}
}
if (modified)
{
emit dataChanged(createIndex(index.row(), 0, index.internalPointer()), createIndex(index.row(), columnCount(), index.internalPointer()));
}
return modified;
}
