void KCoreConfigSkeleton::ItemDateTime::setProperty(const QVariant & p)
{
mReference = p.toDateTime();
}
QVariant QSystemLocale::query(QueryType type, QVariant in) const
{
QBBSystemLocaleData *d = bbSysLocaleData();
QReadLocker locker(&d->lock);
const QLocale &lc_language = d->languageLocale();
const QLocale &lc_region = d->regionLocale();
switch (type) {
case DecimalPoint:
return lc_region.decimalPoint();
case GroupSeparator:
return lc_region.groupSeparator();
case NegativeSign:
return lc_region.negativeSign();
case PositiveSign:
return lc_region.positiveSign();
case DateFormatLong:
return lc_region.dateFormat(QLocale::LongFormat);
case DateFormatShort:
return lc_region.dateFormat(QLocale::ShortFormat);
case TimeFormatLong:
return d->timeFormat(QLocale::LongFormat);
case TimeFormatShort:
return d->timeFormat(QLocale::ShortFormat);
case DateTimeFormatLong:
return d->dateTimeFormat(QLocale::LongFormat);
case DateTimeFormatShort:
return d->dateTimeFormat(QLocale::ShortFormat);
case DayNameLong:
return lc_language.dayName(in.toInt(), QLocale::LongFormat);
case DayNameShort:
return lc_language.dayName(in.toInt(), QLocale::ShortFormat);
case MonthNameLong:
return lc_language.monthName(in.toInt(), QLocale::LongFormat);
case MonthNameShort:
return lc_language.monthName(in.toInt(), QLocale::ShortFormat);
case DateToStringLong:
return lc_region.toString(in.toDate(), QLocale::LongFormat);
case DateToStringShort:
return lc_region.toString(in.toDate(), QLocale::ShortFormat);
case TimeToStringLong:
return lc_region.toString(in.toTime(), QLocale::LongFormat);
case TimeToStringShort:
return lc_region.toString(in.toTime(), QLocale::ShortFormat);
case DateTimeToStringShort:
return lc_region.toString(in.toDateTime(), d->dateTimeFormat(QLocale::ShortFormat).toString());
case DateTimeToStringLong:
return lc_region.toString(in.toDateTime(), d->dateTimeFormat(QLocale::LongFormat).toString());
case MeasurementSystem:
return d->measurementSystem();
case ZeroDigit:
return lc_region.zeroDigit();
case CountryId:
return lc_region.country();
case LanguageId:
return lc_language.language();
case AMText:
return lc_language.amText();
case PMText:
return lc_language.pmText();
default:
break;
}
return QVariant();
}
void QDateTimeAxisPrivate::setMin(const QVariant &min)
{
Q_Q(QDateTimeAxis);
if (min.canConvert(QVariant::DateTime))
q->setMin(min.toDateTime());
}
void XMLRPC::marshall(QXmlStreamWriter *writer, const QVariant &value)
{
writer->writeStartElement("value");
switch( value.type() )
{
case QVariant::Int:
case QVariant::UInt:
case QVariant::LongLong:
case QVariant::ULongLong:
writer->writeTextElement("i4", value.toString());
break;
case QVariant::Double:
writer->writeTextElement("double", value.toString());
break;
case QVariant::Bool:
writer->writeTextElement("boolean", value.toBool() ? "1" : "0");
break;
case QVariant::Date:
writer->writeTextElement("dateTime.iso8601", value.toDate().toString( Qt::ISODate ) );
break;
case QVariant::DateTime:
writer->writeTextElement("dateTime.iso8601", value.toDateTime().toString( Qt::ISODate ) );
break;
case QVariant::Time:
writer->writeTextElement("dateTime.iso8601", value.toTime().toString( Qt::ISODate ) );
break;
case QVariant::StringList:
case QVariant::List:
{
writer->writeStartElement("array");
writer->writeStartElement("data");
foreach(const QVariant &item, value.toList())
marshall(writer, item);
writer->writeEndElement();
writer->writeEndElement();
break;
}
case QVariant::Map:
{
writer->writeStartElement("struct");
QMap<QString, QVariant> map = value.toMap();
QMap<QString, QVariant>::ConstIterator index = map.begin();
while( index != map.end() )
{
writer->writeStartElement("member");
writer->writeTextElement("name", index.key());
marshall( writer, *index );
writer->writeEndElement();
++index;
}
writer->writeEndElement();
break;
}
case QVariant::ByteArray:
{
writer->writeTextElement("base64", value.toByteArray().toBase64() );
break;
}
default:
{
if (value.isNull())
writer->writeEmptyElement("nil");
else if( value.canConvert(QVariant::String) )
{
writer->writeTextElement("string", value.toString() );
}
break;
}
}
writer->writeEndElement();
}
static QCFType<CFPropertyListRef> macValue(const QVariant &value)
{
CFPropertyListRef result = 0;
switch (value.type()) {
case QVariant::ByteArray:
{
QByteArray ba = value.toByteArray();
result = CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8 *>(ba.data()),
CFIndex(ba.size()));
}
break;
// should be same as below (look for LIST)
case QVariant::List:
case QVariant::StringList:
case QVariant::Polygon:
result = macList(value.toList());
break;
case QVariant::Map:
{
/*
QMap<QString, QVariant> is potentially a multimap,
whereas CFDictionary is a single-valued map. To allow
for multiple values with the same key, we store
multiple values in a CFArray. To avoid ambiguities,
we also wrap lists in a CFArray singleton.
*/
QMap<QString, QVariant> map = value.toMap();
QMap<QString, QVariant>::const_iterator i = map.constBegin();
int maxUniqueKeys = map.size();
int numUniqueKeys = 0;
QVarLengthArray<QCFType<CFPropertyListRef> > cfkeys(maxUniqueKeys);
QVarLengthArray<QCFType<CFPropertyListRef> > cfvalues(maxUniqueKeys);
while (i != map.constEnd()) {
const QString &key = i.key();
QList<QVariant> values;
do {
values << i.value();
++i;
} while (i != map.constEnd() && i.key() == key);
bool singleton = (values.count() == 1);
if (singleton) {
switch (values.first().type()) {
// should be same as above (look for LIST)
case QVariant::List:
case QVariant::StringList:
case QVariant::Polygon:
singleton = false;
default:
;
}
}
cfkeys[numUniqueKeys] = QCFString::toCFStringRef(key);
cfvalues[numUniqueKeys] = singleton ? macValue(values.first()) : macList(values);
++numUniqueKeys;
}
result = CFDictionaryCreate(kCFAllocatorDefault,
reinterpret_cast<const void **>(cfkeys.data()),
reinterpret_cast<const void **>(cfvalues.data()),
CFIndex(numUniqueKeys),
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
break;
case QVariant::DateTime:
{
/*
CFDate, unlike QDateTime, doesn't store timezone information.
*/
QDateTime dt = value.toDateTime();
if (dt.timeSpec() == Qt::LocalTime) {
QDateTime reference;
reference.setTime_t((uint)kCFAbsoluteTimeIntervalSince1970);
result = CFDateCreate(kCFAllocatorDefault, CFAbsoluteTime(reference.secsTo(dt)));
} else {
goto string_case;
}
}
break;
case QVariant::Bool:
result = value.toBool() ? kCFBooleanTrue : kCFBooleanFalse;
break;
case QVariant::Int:
case QVariant::UInt:
{
int n = value.toInt();
result = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &n);
}
break;
case QVariant::Double:
{
double n = value.toDouble();
result = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &n);
}
break;
case QVariant::LongLong:
case QVariant::ULongLong:
{
qint64 n = value.toLongLong();
result = CFNumberCreate(0, kCFNumberLongLongType, &n);
}
break;
case QVariant::String:
string_case:
default:
result = QCFString::toCFStringRef(QSettingsPrivate::variantToString(value));
}
return result;
}
int
MarkerRetracement::draw (QPainter *p, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRect &, void *m)
{
Marker *ret = (Marker *) m;
Entity *e = ret->settings();
QVariant *date = e->get(QString("date"));
if (! date)
return 0;
QVariant *date2 = e->get(QString("date2"));
if (! date2)
return 0;
QVariant *high = e->get(QString("high"));
if (! high)
return 0;
QVariant *low = e->get(QString("low"));
if (! low)
return 0;
QVariant *tset = e->get(QString("color"));
if (! tset)
return 0;
QColor color(tset->toString());
QVariant *extend = e->get(QString("extend"));
if (! extend)
return 0;
QVariant *l1 = e->get(QString("level1"));
if (! l1)
return 0;
QVariant *l2 = e->get(QString("level2"));
if (! l2)
return 0;
QVariant *l3 = e->get(QString("level3"));
if (! l3)
return 0;
QVariant *l4 = e->get(QString("level4"));
if (! l4)
return 0;
QVariant *l5 = e->get(QString("level5"));
if (! l5)
return 0;
QVariant *l6 = e->get(QString("level6"));
if (! l6)
return 0;
PlotDateScaleDraw *dsd = (PlotDateScaleDraw *) ret->plot()->axisScaleDraw(QwtPlot::xBottom);
int x = xMap.transform(dsd->dateToX(date->toDateTime()));
QDateTime dt = date2->toDateTime();
if (extend->toBool())
{
int s, e;
g_symbol->startEndRange(s, e);
Bar *bar = g_symbol->bar(e);
if (! bar)
return 0;
dt = bar->date();
}
int x2 = xMap.transform(dsd->dateToX(dt));
p->setPen(color);
ret->clearSelectionArea();
QList<double> lineList;
lineList.append(l1->toDouble());
lineList.append(l2->toDouble());
lineList.append(l3->toDouble());
lineList.append(l4->toDouble());
lineList.append(l5->toDouble());
lineList.append(l6->toDouble());
for (int loop = 0; loop < lineList.size(); loop++)
{
double td = lineList.at(loop);
if (td != 0)
{
double range = high->toDouble() - low->toDouble();
double r = 0;
if (td < 0)
r = low->toDouble() + (range * td);
else
{
if (td > 0)
r = low->toDouble() + (range * td);
else
{
if (td < 0)
r = high->toDouble();
else
r = low->toDouble();
}
}
int y = yMap.transform(r);
p->drawLine (x, y, x2, y);
p->drawText(x, y - 1, QString::number(td * 100) + "% - " + QString::number(r));
QPolygon array;
array.putPoints(0, 4, x, y - 4, x, y + 4, x2, y + 4, x2, y - 4);
ret->appendSelectionArea(QRegion(array));
}
}
// draw the low line
int y = yMap.transform(low->toDouble());
p->drawLine (x, y, x2, y);
Strip strip;
QString ts;
strip.strip(low->toDouble(), 4, ts);
p->drawText(x, y - 1, "0% - " + ts);
// store the selectable area the low line occupies
QPolygon array;
array.putPoints(0, 4, x, y - 4, x, y + 4, x2, y + 4, x2, y - 4);
ret->appendSelectionArea(QRegion(array));
// draw the high line
int y2 = yMap.transform(high->toDouble());
p->drawLine (x, y2, x2, y2);
strip.strip(high->toDouble(), 4, ts);
p->drawText(x, y2 - 1, "100% - " + ts);
// store the selectable area the high line occupies
array.clear();
array.putPoints(0, 4, x, y2 - 4, x, y2 + 4, x2, y2 + 4, x2, y2 - 4);
ret->appendSelectionArea(QRegion(array));
if (ret->selected())
{
int handleWidth = ret->handleWidth();
ret->clearGrabHandles();
//top left corner
ret->appendGrabHandle(QRegion(x, y2 - (handleWidth / 2),
handleWidth,
handleWidth,
QRegion::Rectangle));
p->fillRect(x,
y2 - (handleWidth / 2),
handleWidth,
handleWidth,
color);
//bottom right corner
ret->appendGrabHandle(QRegion(x2, y - (handleWidth / 2),
handleWidth,
handleWidth,
QRegion::Rectangle));
p->fillRect(x2,
y - (handleWidth / 2),
handleWidth,
handleWidth,
color);
}
return 1;
}
enum SetResponse issueLineToShipping::set(const ParameterList &pParams)
{
XDialog::set(pParams);
QVariant param;
bool valid;
param = pParams.value("transTS", &valid);
if (valid)
_transTS = param.toDateTime();
param = pParams.value("order_type", &valid);
if (valid)
{
_ordertype = param.toString();
if (_ordertype == "SO")
_orderNumberLit->setText(tr("Sales Order #:"));
else if (_ordertype == "TO")
_orderNumberLit->setText(tr("Transfer Order #:"));
}
param = pParams.value("order_id", &valid);
if (valid)
{
_itemid = param.toInt();
populate();
}
// TODO: deprecate by remoing from salesOrder and transferOrder windows
param = pParams.value("soitem_id", &valid);
if (valid)
{
_itemid = param.toInt();
_ordertype = "SO";
_orderNumberLit->setText(tr("Sales Order #:"));
populate();
}
// TODO: deprecate by remoing from salesOrder and transferOrder windows
param = pParams.value("toitem_id", &valid);
if (valid)
{
_itemid = param.toInt();
_ordertype = "TO";
_orderNumberLit->setText(tr("Transfer Order #:"));
populate();
}
if (pParams.inList("requireInventory"))
_requireInventory = true;
param = pParams.value("qty", &valid);
if (valid)
_qtyToIssue->setDouble(param.toDouble());
_snooze = pParams.inList("snooze");
if(pParams.inList("issue"))
sIssue();
return NoError;
}
bool PSV_Public::getLabels(QVariant &maxValue, QVariant &minValue, QPair<double, double> &range, QList<QPair<QVariant, QString> > &labelList)
{
if(maxValue.type() != minValue.type())
{
return false;
}
QVariant::Type type = maxValue.type();
switch(type)
{
case QVariant::Double:
case QVariant::Int:
case QVariant::UInt:
{
double max = maxValue.toDouble();
double min = minValue.toDouble();
int numTick = getNumTicks(max, min);
if(numTick <= 0)
{
return false;
}
adjustRange(max, min);
labelList.clear();
for(int i = 0; i <= numTick; ++i)
{
double value = min + 1.0 * (max - min) * i / numTick;
QString str = QObject::tr("%1").arg(value);
labelList.append(QPair<QVariant, QString>(value, str));
}
maxValue = max;
minValue = min;
range = QPair<double,double>(min,max);
return true;
}
break;
case QVariant::Date:
{
QDate maxDate = maxValue.toDate();
QDate minDate = minValue.toDate();
bool isOk = getDateLabels(maxDate, minDate, labelList);
maxValue = maxDate;
minValue = minDate;
range = QPair<double,double>(0.0, 1.0 * minDate.daysTo(maxDate));
return isOk;
}
break;
case QVariant::Time:
{
QTime maxTime = maxValue.toTime();
QTime minTime = minValue.toTime();
bool isOk = getTimeLabels(maxTime, minTime, labelList);
maxValue = maxTime;
minValue = minTime;
range = QPair<double,double>(0.0, 86400.0/*1.0 * minTime.secsTo(maxTime)*/);
return isOk;
}
break;
case QVariant::DateTime:
{
QDateTime maxTime = maxValue.toDateTime();
QDateTime minTime = minValue.toDateTime();
// PSV_Public::printMes(maxTime,"1maxTime");
// PSV_Public::printMes(minTime,"1minTime");
bool isOk = getDateTimeLabels(maxTime, minTime, labelList);
maxValue = maxTime;
minValue = minTime;
// PSV_Public::printMes(maxTime,"2maxTime");
// PSV_Public::printMes(minTime,"2minTime");
range = QPair<double,double>(PSV_BEGIN_DATETIME.secsTo(minValue.toDateTime()),PSV_BEGIN_DATETIME.secsTo(maxValue.toDateTime()));
return isOk;
}
break;
default:
break;
}
return false;
}
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();
}
}
void KConfigBase::writeEntry(const char *pKey, const QVariant &prop, bool bPersistent, bool bGlobal, bool bNLS)
{
switch(prop.type())
{
case QVariant::Invalid:
writeEntry(pKey, "", bPersistent, bGlobal, bNLS);
return;
case QVariant::String:
writeEntry(pKey, prop.toString(), bPersistent, bGlobal, bNLS);
return;
case QVariant::StringList:
writeEntry(pKey, prop.toStringList(), ',', bPersistent, bGlobal, bNLS);
return;
case QVariant::List:
{
QValueList< QVariant > list = prop.toList();
QValueList< QVariant >::ConstIterator it = list.begin();
QValueList< QVariant >::ConstIterator end = list.end();
QStringList strList;
for(; it != end; ++it)
strList.append((*it).toString());
writeEntry(pKey, strList, ',', bPersistent, bGlobal, bNLS);
return;
}
case QVariant::Font:
writeEntry(pKey, prop.toFont(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Point:
writeEntry(pKey, prop.toPoint(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Rect:
writeEntry(pKey, prop.toRect(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Size:
writeEntry(pKey, prop.toSize(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Color:
writeEntry(pKey, prop.toColor(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Int:
writeEntry(pKey, prop.toInt(), bPersistent, bGlobal, bNLS);
return;
case QVariant::UInt:
writeEntry(pKey, prop.toUInt(), bPersistent, bGlobal, bNLS);
return;
case QVariant::LongLong:
writeEntry(pKey, prop.toLongLong(), bPersistent, bGlobal, bNLS);
return;
case QVariant::ULongLong:
writeEntry(pKey, prop.toULongLong(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Bool:
writeEntry(pKey, prop.toBool(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Double:
writeEntry(pKey, prop.toDouble(), bPersistent, bGlobal, 'g', 6, bNLS);
return;
case QVariant::DateTime:
writeEntry(pKey, prop.toDateTime(), bPersistent, bGlobal, bNLS);
return;
case QVariant::Date:
writeEntry(pKey, QDateTime(prop.toDate()), bPersistent, bGlobal, bNLS);
return;
case QVariant::Pixmap:
case QVariant::Image:
case QVariant::Brush:
case QVariant::Palette:
case QVariant::ColorGroup:
case QVariant::Map:
case QVariant::IconSet:
case QVariant::CString:
case QVariant::PointArray:
case QVariant::Region:
case QVariant::Bitmap:
case QVariant::Cursor:
case QVariant::SizePolicy:
case QVariant::Time:
case QVariant::ByteArray:
case QVariant::BitArray:
case QVariant::KeySequence:
case QVariant::Pen:
break;
}
Q_ASSERT(0);
}
void PSV_Public::printMes(const QVariant &mes, const QString &frefix)
{
QString message;
int type = mes.type();
switch(type)
{
case QVariant::Bool :
message = mes.toBool() ? "true":"false";
break;
case QVariant::Color :
{
QColor color = mes.value<QColor>();
message = QObject::tr("colorname:%1,r=%2,g=%3,b=%4")
.arg(color.name())
.arg(color.red())
.arg(color.green())
.arg(color.blue());
}
break;
case QVariant::Date:
message = mes.toDate().toString("yyyy-MM-dd");
break;
case QVariant::DateTime:
message = mes.toDateTime().toString("yyyy-MM-dd hh:mm:ss");
break;
case QVariant::Double:
message = QString::number(mes.toDouble());
break;
case QVariant::UInt:
case QVariant::Int:
message = QString::number(mes.toInt());
break;
case QVariant::ULongLong:
case QVariant::LongLong:
message = QString::number(mes.toLongLong());
break;
case QVariant::Line:
{
QLine line = mes.toLine();
message = QObject::tr("Line x1=%1,y1=%2,x2=%3,y2=%4")
.arg(line.x1()).arg(line.y1()).arg(line.x2()).arg(line.y2());
}
break;
case QVariant::LineF:
{
QLineF lineF = mes.toLineF();
message = QObject::tr("LineF x1=%1,y1=%2,x2=%3,y2=%4")
.arg(lineF.x1()).arg(lineF.y1()).arg(lineF.x2()).arg(lineF.y2());
}
break;
case QVariant::Point:
{
QPoint point = mes.toPoint();
message = QObject::tr("point x=%1,y=%2")
.arg(point.x()).arg(point.y());
}
break;
case QVariant::PointF:
{
QPointF pointF = mes.toPointF();
message = QObject::tr("pointF x=%1,y=%2")
.arg(pointF.x()).arg(pointF.y());
}
break;
case QVariant::Rect:
{
QRect rect = mes.toRect();
message = QObject::tr("rect x=%1,y=%2,width=%3,height=%4")
.arg(rect.x()).arg(rect.y()).arg(rect.width()).arg(rect.height());
}
break;
case QVariant::RectF:
{
QRectF rectF = mes.toRect();
message = QObject::tr("rectF x=%1,y=%2,width=%3,height=%4")
.arg(rectF.x()).arg(rectF.y()).arg(rectF.width()).arg(rectF.height());
}
break;
default:
message = QObject::tr("type = %1,<%2>").arg(type).arg(mes.toString());
break;
}
QString outMes = QObject::tr("%1 %2").arg(frefix).arg(message);
qDebug()<<QObject::tr("PSV_LIB:<%1>%2").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss")).arg(outMes);
}
QDateTime HAudioBook::date() const
{
QVariant value;
getCdsProperty(HCdsProperties::dc_date, &value);
return value.toDateTime();
}
int
MarkerTLine::draw (QPainter *p, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRect &, void *m)
{
Marker *tline = (Marker *) m;
Entity *e = tline->settings();
QVariant *date = e->get(QString("date"));
if (! date)
return 0;
QVariant *date2 = e->get(QString("date2"));
if (! date2)
return 0;
QVariant *price = e->get(QString("price"));
if (! price)
return 0;
QVariant *price2 = e->get(QString("price2"));
if (! price2)
return 0;
QVariant *tset = e->get(QString("color"));
if (! tset)
return 0;
QColor color(tset->toString());
QVariant *extend = e->get(QString("extend"));
if (! extend)
return 0;
PlotDateScaleDraw *dsd = (PlotDateScaleDraw *) tline->plot()->axisScaleDraw(QwtPlot::xBottom);
int x = xMap.transform(dsd->dateToX(date->toDateTime()));
int x2 = xMap.transform(dsd->dateToX(date2->toDateTime()));
int y = yMap.transform(price->toDouble());
int y2 = yMap.transform(price2->toDouble());
p->setPen(color);
p->drawLine (x, y, x2, y2);
// save old values;
int tx2 = x2;
int ty2 = y2;
int tx = x;
int ty = y;
if (extend->toBool())
{
int ydiff = y - y2;
int xdiff = x2 - x;
if (xdiff > 0)
{
while (x2 < p->window().width())
{
x = x2;
y = y2;
x2 = x2 + xdiff;
y2 = y2 - ydiff;
p->drawLine (x, y, x2, y2);
}
}
}
// store the selectable area the line occupies
tline->clearSelectionArea();
QPolygon array;
array.putPoints(0, 4, tx, ty - 4, tx, ty + 4, x2, y2 + 4, x2, y2 - 4);
tline->appendSelectionArea(QRegion(array));
if (tline->selected())
{
int handleWidth = tline->handleWidth();
tline->clearGrabHandles();
tline->appendGrabHandle(QRegion(tx,
ty - (handleWidth / 2),
handleWidth,
handleWidth,
QRegion::Rectangle));
p->fillRect(tx,
ty - (handleWidth / 2),
handleWidth,
handleWidth,
color);
tline->appendGrabHandle(QRegion(tx2,
ty2 - (handleWidth / 2),
handleWidth,
handleWidth,
QRegion::Rectangle));
p->fillRect(tx2,
ty2 - (handleWidth / 2),
handleWidth,
handleWidth,
color);
}
return 1;
}
bool KCoreConfigSkeleton::ItemDateTime::isEqual(const QVariant &v) const
{
return mReference == v.toDateTime();
}
QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
{
QSystemLocalePrivate *d = systemLocalePrivate();
switch(type) {
case DecimalPoint:
return d->decimalPoint();
case GroupSeparator:
return d->groupSeparator();
case NegativeSign:
return d->negativeSign();
case PositiveSign:
return d->positiveSign();
case DateFormatLong:
return d->dateFormat(QLocale::LongFormat);
case DateFormatShort:
return d->dateFormat(QLocale::ShortFormat);
case TimeFormatLong:
return d->timeFormat(QLocale::LongFormat);
case TimeFormatShort:
return d->timeFormat(QLocale::ShortFormat);
case DateTimeFormatLong:
return d->dateTimeFormat(QLocale::LongFormat);
case DateTimeFormatShort:
return d->dateTimeFormat(QLocale::ShortFormat);
case DayNameLong:
return d->dayName(in.toInt(), QLocale::LongFormat);
case DayNameShort:
return d->dayName(in.toInt(), QLocale::ShortFormat);
case MonthNameLong:
case StandaloneMonthNameLong:
return d->monthName(in.toInt(), QLocale::LongFormat);
case MonthNameShort:
case StandaloneMonthNameShort:
return d->monthName(in.toInt(), QLocale::ShortFormat);
case DateToStringShort:
return d->toString(in.toDate(), QLocale::ShortFormat);
case DateToStringLong:
return d->toString(in.toDate(), QLocale::LongFormat);
case TimeToStringShort:
return d->toString(in.toTime(), QLocale::ShortFormat);
case TimeToStringLong:
return d->toString(in.toTime(), QLocale::LongFormat);
case DateTimeToStringShort:
return d->toString(in.toDateTime(), QLocale::ShortFormat);
case DateTimeToStringLong:
return d->toString(in.toDateTime(), QLocale::LongFormat);
case ZeroDigit:
return d->zeroDigit();
case LanguageId:
case ScriptId:
case CountryId: {
QString locale = QString::fromLatin1(getWinLocaleName());
QLocale::Language lang;
QLocale::Script script;
QLocale::Country cntry;
QLocalePrivate::getLangAndCountry(locale, lang, script, cntry);
if (type == LanguageId)
return lang;
if (type == ScriptId)
return script == QLocale::AnyScript ? fallbackUiLocale().script() : script;
if (cntry == QLocale::AnyCountry)
return fallbackUiLocale().country();
return cntry;
}
case MeasurementSystem:
return d->measurementSystem();
case AMText:
return d->amText();
case PMText:
return d->pmText();
case FirstDayOfWeek:
return d->firstDayOfWeek();
case CurrencySymbol:
return d->currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt()));
case CurrencyToString:
return d->toCurrencyString(in.value<QSystemLocale::CurrencyToStringArgument>());
case UILanguages:
return d->uiLanguages();
case LocaleChanged:
d->update();
break;
case NativeLanguageName:
return d->nativeLanguageName();
case NativeCountryName:
return d->nativeCountryName();
default:
break;
}
return QVariant();
}
QDomElement MaiaObject::toXml(QVariant arg) {
//dummy document
QDomDocument doc;
//value element, we need this in each case
QDomElement tagValue = doc.createElement("value");
/* qDebug("type: %d (%s)", arg.type(), arg.typeName()); */
switch(arg.type()) {
case QVariant::String: {
QDomElement tagString = doc.createElement("string");
QDomText textString = doc.createTextNode(arg.toString());
tagValue.appendChild(tagString);
tagString.appendChild(textString);
return tagValue;
} case QVariant::Int: {
QDomElement tagInt = doc.createElement("int");
QDomText textInt = doc.createTextNode(QString::number(arg.toInt()));
tagValue.appendChild(tagInt);
tagInt.appendChild(textInt);
return tagValue;
} case QVariant::Double: {
QDomElement tagDouble = doc.createElement("double");
QDomText textDouble = doc.createTextNode(QString::number(arg.toDouble()));
tagValue.appendChild(tagDouble);
tagDouble.appendChild(textDouble);
return tagValue;
} case QVariant::Bool: {
QString textValue = arg.toBool() ? "1" : "0";
QDomElement tag = doc.createElement("boolean");
QDomText text = doc.createTextNode(textValue);
tagValue.appendChild(tag);
tag.appendChild(text);
return tagValue;
} case QVariant::ByteArray: {
QString textValue = arg.toByteArray().toBase64();
QDomElement tag = doc.createElement("base64");
QDomText text = doc.createTextNode(textValue);
tagValue.appendChild(tag);
tag.appendChild(text);
return tagValue;
} case QVariant::DateTime: {
QString textValue = arg.toDateTime().toString("yyyyMMddThh:mm:ss");
QDomElement tag = doc.createElement("datetime.iso8601");
QDomText text = doc.createTextNode(textValue);
tagValue.appendChild(tag);
tag.appendChild(text);
return tagValue;
} case QVariant::List: {
QDomElement tagArray = doc.createElement("array");
QDomElement tagData = doc.createElement("data");
tagArray.appendChild(tagData);
tagValue.appendChild(tagArray);
const QList<QVariant> args = arg.toList();
for(int i = 0; i < args.size(); ++i) {
tagData.appendChild(toXml(args.at(i)));
}
return tagValue;
} case QVariant::Map: {
QDomElement tagStruct = doc.createElement("struct");
QDomElement member;
QDomElement name;
tagValue.appendChild(tagStruct);
QMap<QString, QVariant> map = arg.toMap();
QMapIterator<QString, QVariant> i(map);
while(i.hasNext()) {
i.next();
member = doc.createElement("member");
name = doc.createElement("name");
// (key) -> name -> member -> struct
tagStruct.appendChild(member);
member.appendChild(name);
name.appendChild(doc.createTextNode(i.key()));
// add variables by recursion
member.appendChild(toXml(i.value()));
}
return tagValue;
} default:
qDebug() << "Failed to marshal unknown variant type: " << arg.type() << endl;
}
return QDomElement(); //QString::null;
}
int
MarkerRetracement::info (PluginData *pd)
{
if (! pd->data)
return 0;
Marker *m = (Marker *) pd->data;
Entity *e = m->settings();
QVariant *date = e->get(QString("date"));
if (! date)
return 0;
QVariant *date2 = e->get(QString("date2"));
if (! date2)
return 0;
QVariant *high = e->get(QString("high"));
if (! high)
return 0;
QVariant *low = e->get(QString("low"));
if (! low)
return 0;
QVariant *l1 = e->get(QString("level1"));
if (! l1)
return 0;
QVariant *l2 = e->get(QString("level2"));
if (! l2)
return 0;
QVariant *l3 = e->get(QString("level3"));
if (! l3)
return 0;
QVariant *l4 = e->get(QString("level4"));
if (! l4)
return 0;
QVariant *l5 = e->get(QString("level5"));
if (! l5)
return 0;
QVariant *l6 = e->get(QString("level6"));
if (! l6)
return 0;
pd->info << tr("Retracement");
QDateTime dt = date->toDateTime();
pd->info << tr("Start Date") + "=" + dt.toString("yyyy-MM-dd");
pd->info << tr("Start Time") + "=" + dt.toString("HH:mm:ss");
dt = date2->toDateTime();
pd->info << tr("End Date") + "=" + dt.toString("yyyy-MM-dd");
pd->info << tr("End Time") + "=" + dt.toString("HH:mm:ss");
Strip strip;
QString ts;
strip.strip(high->toDouble(), 4, ts);
pd->info << tr("High") + "=" + ts;
strip.strip(low->toDouble(), 4, ts);
pd->info << tr("Low") + "=" + ts;
strip.strip(l1->toDouble(), 4, ts);
pd->info << tr("Level 1") + "=" + ts;
strip.strip(l2->toDouble(), 4, ts);
pd->info << tr("Level 2") + "=" + ts;
strip.strip(l3->toDouble(), 4, ts);
pd->info << tr("Level 3") + "=" + ts;
strip.strip(l4->toDouble(), 4, ts);
pd->info << tr("Level 4") + "=" + ts;
strip.strip(l5->toDouble(), 4, ts);
pd->info << tr("Level 5") + "=" + ts;
strip.strip(l6->toDouble(), 4, ts);
pd->info << tr("Level 6") + "=" + ts;
return 1;
}
QString QgsExpression::formatPreviewString( const QVariant &value, const bool htmlOutput )
{
static const int MAX_PREVIEW = 60;
const QString startToken = htmlOutput ? QStringLiteral( "<i><" ) : QStringLiteral( "<" );
const QString endToken = htmlOutput ? QStringLiteral( "></i>" ) : QStringLiteral( ">" );
if ( value.canConvert<QgsGeometry>() )
{
//result is a geometry
QgsGeometry geom = value.value<QgsGeometry>();
if ( geom.isNull() )
return startToken + tr( "empty geometry" ) + endToken;
else
return startToken + tr( "geometry: %1" ).arg( QgsWkbTypes::displayString( geom.constGet()->wkbType() ) )
+ endToken;
}
else if ( value.value< QgsWeakMapLayerPointer >().data() )
{
return startToken + tr( "map layer" ) + endToken;
}
else if ( !value.isValid() )
{
return htmlOutput ? tr( "<i>NULL</i>" ) : QString();
}
else if ( value.canConvert< QgsFeature >() )
{
//result is a feature
QgsFeature feat = value.value<QgsFeature>();
return startToken + tr( "feature: %1" ).arg( feat.id() ) + endToken;
}
else if ( value.canConvert< QgsInterval >() )
{
//result is a feature
QgsInterval interval = value.value<QgsInterval>();
return startToken + tr( "interval: %1 days" ).arg( interval.days() ) + endToken;
}
else if ( value.canConvert< QgsGradientColorRamp >() )
{
return startToken + tr( "gradient ramp" ) + endToken;
}
else if ( value.type() == QVariant::Date )
{
QDate dt = value.toDate();
return startToken + tr( "date: %1" ).arg( dt.toString( QStringLiteral( "yyyy-MM-dd" ) ) ) + endToken;
}
else if ( value.type() == QVariant::Time )
{
QTime tm = value.toTime();
return startToken + tr( "time: %1" ).arg( tm.toString( QStringLiteral( "hh:mm:ss" ) ) ) + endToken;
}
else if ( value.type() == QVariant::DateTime )
{
QDateTime dt = value.toDateTime();
return startToken + tr( "datetime: %1" ).arg( dt.toString( QStringLiteral( "yyyy-MM-dd hh:mm:ss" ) ) ) + endToken;
}
else if ( value.type() == QVariant::String )
{
const QString previewString = value.toString();
if ( previewString.length() > MAX_PREVIEW + 3 )
{
return tr( "'%1…'" ).arg( previewString.left( MAX_PREVIEW ) );
}
else
{
return '\'' + previewString + '\'';
}
}
else if ( value.type() == QVariant::Map )
{
QString mapStr = QStringLiteral( "{" );
const QVariantMap map = value.toMap();
QString separator;
for ( QVariantMap::const_iterator it = map.constBegin(); it != map.constEnd(); ++it )
{
mapStr.append( separator );
if ( separator.isEmpty() )
separator = QStringLiteral( "," );
mapStr.append( QStringLiteral( " '%1': %2" ).arg( it.key(), formatPreviewString( it.value(), htmlOutput ) ) );
if ( mapStr.length() > MAX_PREVIEW - 3 )
{
mapStr = tr( "%1…" ).arg( mapStr.left( MAX_PREVIEW - 2 ) );
break;
}
}
if ( !map.empty() )
mapStr += QStringLiteral( " " );
mapStr += QStringLiteral( "}" );
return mapStr;
}
else if ( value.type() == QVariant::List || value.type() == QVariant::StringList )
{
QString listStr = QStringLiteral( "[" );
const QVariantList list = value.toList();
QString separator;
for ( const QVariant &arrayValue : list )
{
listStr.append( separator );
if ( separator.isEmpty() )
separator = QStringLiteral( "," );
listStr.append( " " );
listStr.append( formatPreviewString( arrayValue, htmlOutput ) );
if ( listStr.length() > MAX_PREVIEW - 3 )
{
listStr = QString( tr( "%1…" ) ).arg( listStr.left( MAX_PREVIEW - 2 ) );
break;
}
}
if ( !list.empty() )
listStr += QStringLiteral( " " );
listStr += QStringLiteral( "]" );
return listStr;
}
else
{
return value.toString();
}
}
void UIPropertySetters::DefaultSetter(QWidget* editor, SettingsPropertyMapper::WidgetType editorType, SettingsPropertyMapper::PropertyType propertyType, QVariant propertyValue)
{
switch (editorType)
{
case SettingsPropertyMapper::CHECKBOX:
{
QCheckBox* pCheckBox = qobject_cast<QCheckBox*>(editor);
if (pCheckBox == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::BOOL)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pCheckBox->setChecked(propertyValue.toBool());
break;
}
case SettingsPropertyMapper::RADIOBUTTON:
{
QRadioButton* pRadioButton = qobject_cast<QRadioButton*>(editor);
if (pRadioButton == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::BOOL)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pRadioButton->setChecked(propertyValue.toBool());
break;
}
case SettingsPropertyMapper::CHECKABLE_GROUPBOX:
{
QGroupBox* pGroupBox = qobject_cast<QGroupBox*>(editor);
if (pGroupBox == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (!pGroupBox->isCheckable())
{
qCritical() << "Given QGroupBox is not checkable";
}
if (propertyType != SettingsPropertyMapper::BOOL)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pGroupBox->setChecked(propertyValue.toBool());
break;
}
case SettingsPropertyMapper::LINE_EDIT:
{
QLineEdit* pLineEdit = qobject_cast<QLineEdit*>(editor);
if (pLineEdit == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType == SettingsPropertyMapper::STRING || propertyType == SettingsPropertyMapper::INT)
{
pLineEdit->setText(propertyValue.toString());
}
else
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
}
break;
}
case SettingsPropertyMapper::TEXT_EDIT:
{
QTextEdit* pTextEdit = qobject_cast<QTextEdit*>(editor);
if (pTextEdit == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::STRING)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pTextEdit->setText(propertyValue.toString());
break;
}
case SettingsPropertyMapper::COMBOBOX:
{
QComboBox* pComboBox = qobject_cast<QComboBox*>(editor);
if (pComboBox == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::INT)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pComboBox->setCurrentIndex(propertyValue.toInt());
break;
}
case SettingsPropertyMapper::SPINBOX:
{
QSpinBox* pSpinBox = qobject_cast<QSpinBox*>(editor);
if (pSpinBox == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::INT)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pSpinBox->setValue(propertyValue.toInt());
break;
}
case SettingsPropertyMapper::DOUBLE_SPINBOX:
{
QDoubleSpinBox* pDoubleSpinBox = qobject_cast<QDoubleSpinBox*>(editor);
if (pDoubleSpinBox == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::DOUBLE)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pDoubleSpinBox->setValue(propertyValue.toDouble());
break;
}
case SettingsPropertyMapper::TIME_EDIT:
{
QTimeEdit* pTimeEdit = qobject_cast<QTimeEdit*>(editor);
if (pTimeEdit == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::TIME)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pTimeEdit->setTime(propertyValue.toTime());
break;
}
case SettingsPropertyMapper::DATETIME_EDIT:
{
QDateTimeEdit* pDateTimeEdit = qobject_cast<QDateTimeEdit*>(editor);
if (pDateTimeEdit == NULL)
{
qCritical() << "Invalid editor given";
return;
}
if (propertyType != SettingsPropertyMapper::DATETIME)
{
qCritical() << "Unable to set value with default setter for property using value" << propertyValue;
return;
}
pDateTimeEdit->setDateTime(propertyValue.toDateTime());
break;
}
default: break;
}
}
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 Timestamp::fromVariant(const QVariant v)
{
mT=v.toDateTime().toTime_t();
emit dataChanged();
return true;
}
void MVariant::tostring(QVariant params )
{
// qDebug()<<"\n"<<params.type()<<"\n"<<params;
switch ( params.type() ) {
case QVariant::Int:
case QVariant::UInt:
this->items << QString::number( params.toInt() );
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::String:
this->items <<params.toString();
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::Double:
this->items << QString::number( params.toDouble() );
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::DateTime:
this->items << params.toDateTime().toString();
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::Bool:
this->items << ( params.toBool() ? "true" : "false" );
this->ret<<this->items;
//this->items.clear();
break;
case QVariant::ByteArray:
{
QString data = params.toByteArray().toBase64();
if ( data.length() > 128 ) {
data = data.left(64)+"...";
}
this->items << data;
this->ret<<this->items;
// this->items.clear();
break;
}
case QVariant::StringList:
case QVariant::List:
{ //this->items.clear();
QListIterator<QVariant> it( params.toList() );
while( it.hasNext() ) {
//it.next();
this->tostring(it.next());
}
break;
}
case QVariant::Map:
{
//QStringList item;
QMapIterator<QString,QVariant> it( params.toMap());
while( it.hasNext() ) {
it.next();
//this->items.clear();
this->items<<it.key();
this->tostring(it.value());
//this->ret<<this->items;
this->items.clear();
}
break;
}
default:
break;
}
}
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;
}
}
QString QGalleryTrackerDateTimeColumn::toString(const QVariant &variant) const
{
return variant.toDateTime().toString(Qt::ISODate);
}
void evaluation()
{
QFETCH( QString, string );
QFETCH( bool, evalError );
QFETCH( QVariant, result );
QgsExpression exp( string );
QCOMPARE( exp.hasParserError(), false );
if ( exp.hasParserError() )
qDebug() << exp.parserErrorString();
QVariant res = exp.evaluate();
if ( exp.hasEvalError() )
qDebug() << exp.evalErrorString();
if ( res.type() != result.type() )
{
qDebug() << "got " << res.typeName() << " instead of " << result.typeName();
}
//qDebug() << res.type() << " " << result.type();
//qDebug() << "type " << res.typeName();
QCOMPARE( exp.hasEvalError(), evalError );
QCOMPARE( res.type(), result.type() );
switch ( res.type() )
{
case QVariant::Invalid:
break; // nothing more to check
case QVariant::Int:
QCOMPARE( res.toInt(), result.toInt() );
break;
case QVariant::Double:
QCOMPARE( res.toDouble(), result.toDouble() );
break;
case QVariant::String:
QCOMPARE( res.toString(), result.toString() );
break;
case QVariant::Date:
QCOMPARE( res.toDate(), result.toDate() );
break;
case QVariant::DateTime:
QCOMPARE( res.toDateTime(), result.toDateTime() );
break;
case QVariant::Time:
QCOMPARE( res.toTime(), result.toTime() );
break;
case QVariant::UserType:
{
if ( res.userType() == qMetaTypeId<QgsExpression::Interval>() )
{
QgsExpression::Interval inter = res.value<QgsExpression::Interval>();
QgsExpression::Interval gotinter = result.value<QgsExpression::Interval>();
QCOMPARE( inter.seconds(), gotinter.seconds() );
}
else
{
QFAIL( "unexpected user type" );
}
break;
}
default:
Q_ASSERT( false ); // should never happen
}
}
QWidget* MultiDelegate::createEditor( QWidget* parent,
const QStyleOptionViewItem& option,
const QModelIndex& index) const
{
const QAbstractItemModel* model = index.model();
QVariant value = model->data( index, Qt::EditRole);
switch (value.type()) {
case QMetaType::QTime:
{
QTimeEdit* editor = new QTimeEdit( parent);
editor->setMaximumWidth( editor->sizeHint().width());
//// Get value snapshot into editor
editor->setTime( value.toTime());
return editor;
}
case QMetaType::QDate:
{
QDateEdit* editor = new QDateEdit( parent);
setupCalenderWidget( editor);
editor->setMaximumWidth( editor->sizeHint().width());
//// Get value snapshot into editor
editor->setDate( value.toDate());
return editor;
}
case QMetaType::QDateTime:
{
QDateTimeEdit* editor = new QDateTimeEdit( parent);
setupCalenderWidget( editor);
editor->setMaximumWidth( editor->sizeHint().width());
editor->setDateTime( value.toDateTime());
return editor;
}
case QMetaType::QImage:
// Fall throu
case QMetaType::QPixmap:
// Fall throu
case QMetaType::QIcon:
{
PixmapViewer* editor = new PixmapViewer( parent);
connect( editor, SIGNAL(finished(int)), this, SLOT(closeEmittingEditor()));
return editor;
}
case QMetaType::QStringList:
{
QVariant varList = index.model()->data( index, ItemDataRole::EnumList);
if (varList.isNull()) break; // Not a enum-list, fall to std
QListWidget* editor = new QListWidget( parent);
foreach (const QString& bitItemText, varList.toStringList()) {
QListWidgetItem* bitItem = new QListWidgetItem( bitItemText, editor);
bitItem->setFlags(bitItem->flags() | Qt::ItemIsUserCheckable);
bitItem->setCheckState(Qt::Unchecked);
}
int width = editor->sizeHintForColumn(0) + 25;
int height = editor->sizeHintForRow(0) * editor->count() + 10;
editor->setMinimumWidth( width);
editor->setMaximumWidth( width);
editor->setMinimumHeight( height);
editor->setMaximumHeight( height);
//// Get value snapshot into editor
QStringList valList = value.toStringList();
int itemCount = editor->count();
for (int i = 0; i < itemCount; ++i) {
QListWidgetItem* bitItem = editor->item(i);
bool isActive = valList.contains( bitItem->text());
bitItem->setCheckState( isActive ? Qt::Checked : Qt::Unchecked);
}
return editor;
}
case QMetaType::QString:
{
QVariant varList = index.model()->data( index, ItemDataRole::EnumList);
if (varList.isNull()) break; // Not a enum-list, fall to std
QComboBox* editor = new QComboBox( parent);
editor->setSizeAdjustPolicy(QComboBox::AdjustToContents);
editor->addItems( varList.toStringList());
editor->setMaximumWidth( editor->minimumSizeHint().width());
//// Get value snapshot into editor
editor->setCurrentIndex( editor->findText( value.toString()));
return editor;
}
default:;
}
if (index.column() == 0) {
emit itemEditTrigged( index);
return 0; // No inline editor
}
QWidget* editor = QItemDelegate::createEditor( parent, option, index);
//// Get value snapshot into editor
QItemDelegate::setEditorData( editor, index);
return editor;
}
void IxValidator::validateDateFuture(const QVariant & v, QxInvalidValueX & lstInvalidValues) const
{
QDateTime dt = v.toDateTime();
if (! dt.isValid() || (dt < QDateTime::currentDateTime())) { lstInvalidValues.insert(this); }
}
QVariant QSystemLocale::query(QueryType type, QVariant in) const
{
QSystemLocaleData *d = qSystemLocaleData();
#if defined(Q_OS_QNX)
QBBLocaleData *bbd = qbbLocaleData();
#endif
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 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;
#if defined(Q_OS_QNX)
return bbd->ppsMeasurement;
#endif
return QVariant((int)QLocale(meas_locale).measurementSystem());
}
case UILanguages: {
static QString languages = QString::fromLatin1(qgetenv("LANGUAGE"));
if (!languages.isEmpty()) {
QStringList lst = languages.split(QLatin1Char(':'));
for (int i = 0; i < lst.size();) {
const QString &name = lst.at(i);
QString lang, script, cntry;
if (name.isEmpty() || !qt_splitLocaleName(name, lang, script, cntry))
lst.removeAt(i);
else
++i;
}
return lst;
}
if (!d->lc_messages_var.isEmpty()) {
QString lang, script, cntry;
if (qt_splitLocaleName(QString::fromLatin1(d->lc_messages_var.constData(), d->lc_messages_var.size()),
lang, script, cntry)) {
if (!cntry.length() && lang.length())
return QStringList(lang);
return QStringList(lang % QLatin1Char('-') % cntry);
}
}
return QVariant();
}
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.value<QStringList>());
case LocaleChanged:
d->updateLocale();
break;
default:
break;
}
return QVariant();
}
void QDateTimeAxisPrivate::setRange(const QVariant &min, const QVariant &max)
{
Q_Q(QDateTimeAxis);
if (min.canConvert(QVariant::DateTime) && max.canConvert(QVariant::DateTime))
q->setRange(min.toDateTime(), max.toDateTime());
}
QVariant TableModel::data(const QModelIndex &index, int role) const
{
QVariant ret;
if(!index.isValid())
return ret;
if(role == RawValueRole) {
ret = value(index.row(), index.column());
}
else if(role == ValueIsDirtyRole) {
ret = isDirty(index.row(), index.column());
}
else if(role == SortRole) {
int type = columnType(index.column());
if(type == QVariant::Bool)
ret = value(index.row(), index.column()).toBool();
else
ret = data(index, Qt::DisplayRole);
}
else if(role == Qt::DisplayRole) {
ColumnDefinition cd = m_columns.value(index.column());
if(cd.isNull()) {
return QString("!%1").arg(index.column());
}
if(data(index, ValueIsNullRole).toBool()) {
if(isNullReportedAsString())
return QStringLiteral("null");
return QVariant();
}
ret = data(index, Qt::EditRole);
int type = columnType(index.column());
if(type == QVariant::Invalid)
type = ret.type(); /// pokud jsou sloupce virtualni (sloupce se pocitaji, nemusi byt pro ne definovan typ)
if(type == QVariant::ByteArray) {
const static QString blob_string = "{blob %1%2}";
int size = ret.toByteArray().size();
if(size < 1024) ret = blob_string.arg(size).arg(" B");
else ret = blob_string.arg(size/1024).arg("kB");
}
else if(type == QVariant::Bool) {
/// display check
ret = QString();
}
QString format = cd.format();
if(format.isEmpty()) {
if(type == QVariant::Date) {
format = m_defaultDateFormat;
}
else if(type == QVariant::Time) {
format = m_defaultTimeFormat;
//qfInfo() << "format" << format;
}
else if(type == QVariant::DateTime) {
format = m_defaultDateTimeFormat;
//qfInfo() << "format" << format;
}
}
if(!format.isEmpty()) {
if(type == QVariant::Time) {
QTime t = ret.toTime();
ret = t.toString(format);
}
else if(type == QVariant::Date) {
QDate d = ret.toDate();
ret = d.toString(format);
}
else if(type == QVariant::DateTime) {
QDateTime dt = ret.toDateTime();
ret = dt.toString(format);
}
}
}
else if(role == Qt::EditRole) {
ret = data(index, RawValueRole);
ret = rawValueToEdit(index.column(), ret);
}
else if (role == ValueIsNullRole) {
ret = data(index, RawValueRole);
return ret.isNull() && ret.isValid();
}
else if (role == Qt::TextAlignmentRole) {
const ColumnDefinition cd = m_columns.value(index.column());
Qt::Alignment al = cd.alignment();
if(!!al)
ret = (int)al;
else {
if(!data(index, ValueIsNullRole).toBool()) {
ret = data(index, RawValueRole);
if(ret.type() > QVariant::Bool && ret.type() <= QVariant::Double)
ret = Qt::AlignRight;
else
ret = Qt::AlignLeft;
}
}
}
else if(role == Qt::TextColorRole) {
int type = columnType(index.column());
if(type == QVariant::ByteArray)
return QColor(Qt::blue);
if(data(index, ValueIsNullRole).toBool()) {
return QColor(Qt::blue);
}
ret = QVariant();
}
else if (role == Qt::BackgroundColorRole) {
/// delegate does it
}
else if (role == Qt::CheckStateRole) {
int type = columnType(index.column());
if(type == QVariant::Bool) {
//qfInfo() << "BOOL";
return (data(index, Qt::EditRole).toBool()? Qt::Checked: Qt::Unchecked);
}
return QVariant();
}
else if (role == Qt::ToolTipRole) {
QString s = data(index, Qt::DisplayRole).toString();
//s = "<pre>" + s + "</pre>"; /// kvuli chybe v Qt 4.6.3, kdy aplikace pada pokud je v textu za sebou 0x09 0x0A
s.replace("\t\n", "\n");
ret = s;
//ret = data(index, Qt::DisplayRole);
//qfInfo() << ret.toString();
}
return ret;
}
