/*
Generate a string given a value, using formatting defined within this class.
*/
QString QEStringFormatting::formatString( const QVariant& value ) const
{
QEStringFormatting* self = (QEStringFormatting*) this; // this works as modified members are just used as temp. variables.
QString result;
if( value.type() != QVariant::List ){
// "Simple" scalar
result = self->formatElementString( value );
} else {
// Array variable
const QVariantList valueArray = value.toList();
const int number = valueArray.count ();
switch( arrayAction ) {
case APPEND:
// Interpret each element in the array as an unsigned integer and append
// string representations of each element from the array with a space in
// between each.
for( int j = 0; j < number; j++ ){
QVariant element = valueArray.value (j);
QString elementString;
elementString = self->formatElementString( element );
if( j > 0 )result.append ( " " );
result.append( elementString );
}
break;
case ASCII:
// Interpret each element from the array as a character in a string.
// Translate all non printing characters to '?' except for trailing
// zeros (ignore them)
for( int j = 0; j < number; j++ ){
QVariant element = valueArray.value( j );
bool okay;
int c = element.toInt( &okay );
if( !okay || (c == 0) ) break; // Not an int or got a zero - end of string.
// Ignore carriage returns.
// Note this will cause problems when implementing on Commodore 8-bit machines,
// Acorn BBC, ZX Spectrum, and TRS-80 as they don't use a line feed.
if( c == '\r' )
{
}
// Translate all non printing characters (except for space and line feed) to a '?'
else if( (c!= '\n') && (c < ' ' || c > '~') )
{
result.append( "?" );
}
// Use everything else as is.
else
{
result.append( element.toChar() );
}
}
break;
case INDEX:
// Interpret the element selected by setArrayIndex().
if( arrayIndex < (unsigned int)(number) )
{
QVariant element = valueArray.value ((int) arrayIndex);
result = self->formatElementString( element );
}
break;
default:
self->formatFailure( QString ( "Invalid arrayAction: %d" ).arg ( (int) arrayAction ));
result = "---";
break;
}
}
// Add units if required, if there are any present, and if the text is not an error message
int eguLen = dbEgu.length(); // ??? Why cant this be in the 'if' statement? If it is it never adds an egu
if( addUnits && eguLen && (format != FORMAT_TIME) )
{
result.append( " " ).append( dbEgu );
}
return result;
}
void TestDeltaT::testDeltaTByEspenakMeeus()
{
// test data from http://eclipse.gsfc.nasa.gov/SEcat5/deltat.html#tab1
QVariantList data;
data << -500 << 17190 << 430;
data << -400 << 15530 << 390;
data << -300 << 14080 << 360;
data << -200 << 12790 << 330;
data << -100 << 11640 << 290;
data << 0 << 10580 << 260;
data << 100 << 9600 << 240;
data << 200 << 8640 << 210;
data << 300 << 7680 << 180;
data << 400 << 6700 << 160;
data << 500 << 5710 << 140;
data << 600 << 4740 << 120;
data << 700 << 3810 << 100;
data << 800 << 2960 << 80;
data << 900 << 2200 << 70;
data << 1000 << 1570 << 55;
data << 1100 << 1090 << 40;
data << 1200 << 740 << 30;
data << 1300 << 490 << 20;
data << 1400 << 320 << 20;
data << 1500 << 200 << 20;
data << 1600 << 120 << 20;
data << 1700 << 9 << 5;
data << 1750 << 13 << 2;
data << 1800 << 14 << 1;
data << 1850 << 7 << 1;
data << 1900 << -3 << 1;
data << 1950 << 29 << 0.1;
data << 1955 << 31.1 << 0.1;
data << 1960 << 33.2 << 0.1;
data << 1965 << 35.7 << 0.1;
data << 1970 << 40.2 << 0.1;
data << 1975 << 45.5 << 0.1;
data << 1980 << 50.5 << 0.1;
data << 1985 << 54.3 << 0.1;
data << 1990 << 56.9 << 0.1;
data << 1995 << 60.8 << 0.1;
data << 2000 << 63.8 << 0.1;
data << 2005 << 64.7 << 0.1;
while(data.count() >= 3)
{
int year = data.takeFirst().toInt();
int yout, mout, dout;
double JD;
double expectedResult = data.takeFirst().toDouble();
double acceptableError = data.takeFirst().toDouble();
StelUtils::getJDFromDate(&JD, year, 1, 1, 0, 0, 0);
double result = StelUtils::getDeltaTByEspenakMeeus(JD);
double actualError = qAbs(qAbs(expectedResult) - qAbs(result));
StelUtils::getDateFromJulianDay(JD, &yout, &mout, &dout);
QVERIFY2(actualError <= acceptableError, QString("date=%2 year=%3 result=%4 expected=%5 error=%6 acceptable=%7")
.arg(QString("%1-%2-%3 00:00:00").arg(yout).arg(mout).arg(dout))
.arg(year)
.arg(result)
.arg(expectedResult)
.arg(actualError)
.arg(acceptableError)
.toUtf8());
}
}
void ApplicationUI::setupLevel(const QVariantMap &levelData)
{
if (m_map) {
delete m_map;
}
if (m_robot) {
delete m_robot;
}
while (!m_functions.empty()) {
Function *f = m_functions[0];
m_functions.removeFirst();
delete f;
}
while (!m_stack.empty()) {
FunctionRunner *f = m_stack.pop();
delete f;
}
m_mapArea = m_gamePage->findChild<Container*>("mapArea");
if (!m_mapArea) {
qDebug("Failed to find map area");
return;
}
m_mapArea->removeAll();
int width = levelData["width"].toInt();
int height = levelData["height"].toInt();
int startX = levelData["startX"].toInt();
int startY = levelData["startY"].toInt();
QString direction = levelData["startDir"].toString();
int endX = levelData["endX"].toInt();
int endY = levelData["endY"].toInt();
QVariantList mapData = levelData["data"].toList();
int moves = levelData["totalMoves"].toInt();
setTutorial(levelData["tutorial"].toInt()); // will return 0 if no tutorial field
int functionCount = 3;
if (levelData.contains("numFunctions"))
functionCount = levelData["numFunctions"].toInt();
if (functionCount < 0) functionCount = 0;
if (functionCount > 3) functionCount = 3; // FIXME: Hide function buttons if not allowed.
QVariantList functionLimits = levelData["functionLimit"].toList();
for (int i=0; i<functionCount; i++) {
Function *f;
if (i < functionLimits.count())
f = new Function(functionLimits[i].toInt());
else
f = new Function();
m_functions.append(f);
qDebug("Function %d limited to %d\n", i, f->count());
}
setFunctionCount(functionCount);
qDebug("Function count: %d\n", functionCount);
if (width < 0 || width > MAX_WIDTH || height < 0 || height > MAX_HEIGHT || width * height != mapData.count()) {
qDebug("Bad level data: %dx%d with %d elements\n", width, height, mapData.count());
return;
}
int *data = new int[width*height];
for (int i=0; i<width*height; i++) {
data[i] = mapData[i].toInt();
}
m_map = new Map(height, width, endX, endY, data, m_mapArea, this);
Label *movesLabel = m_gamePage->findChild<Label*>("movesLeft");
m_robot = new Robot(m_map, moves, movesLabel, startX, startY, endX, endY, Robot::getDirection(direction), this);
m_functionHeader = static_cast<Container *>(m_gamePage->findChild<Container*>("functionHeader"));
m_functionActions.clear();
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction1")));
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction2")));
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction3")));
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction4")));
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction5")));
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction6")));
m_functionActions.append(static_cast<Container *>(m_gamePage->findChild<Container*>("functionAction7")));
qDebug("Function header: %p\n", m_functionHeader);
qDebug("Function actions size: %d\n", m_functionActions.count());
QObject::connect(m_robot, SIGNAL(moved(int,int)), this, SLOT(robotMoved(int,int)));
}
bool GmpProtocol::setFieldData(int index, const QVariant &value,
FieldAttrib attrib)
{
bool isOk = false;
if (attrib != FieldValue)
goto _exit;
switch (index)
{
case kType:
{
uint type = value.toUInt(&isOk);
if (isOk)
data.set_type(type);
break;
}
case kRsvdMrtCode:
{
uint val = value.toUInt(&isOk);
if (isOk)
data.set_rsvd_code(val);
break;
}
case kChecksum:
{
uint csum = value.toUInt(&isOk);
if (isOk)
data.set_checksum(csum);
break;
}
case kMldMrt:
{
uint mrt = value.toUInt(&isOk);
if (isOk)
data.set_max_response_time(mrt);
break;
}
case kGroupAddress:
// XXX: Handled by subclass
isOk = false;
break;
case kRsvd1:
isOk = false;
break;
case kSFlag:
{
bool flag = value.toBool();
data.set_s_flag(flag);
isOk = true;
break;
}
case kQrv:
{
uint qrv = value.toUInt(&isOk);
if (isOk)
data.set_qrv(qrv);
break;
}
case kQqic:
{
uint qqi = value.toUInt(&isOk);
if (isOk)
data.set_qqi(qqi);
break;
}
case kSourceCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_source_count(count);
break;
}
case kSources:
// XXX: Handled by subclass
isOk = false;
break;
case kRsvd2:
isOk = false;
break;
case kGroupRecordCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_group_record_count(count);
break;
}
case kGroupRecords:
{
QVariantList list = value.toList();
data.clear_group_records();
for (int i = 0; i < list.count(); i++)
{
QVariantMap grpRec = list.at(i).toMap();
OstProto::Gmp::GroupRecord *rec = data.add_group_records();
rec->set_type(OstProto::Gmp::GroupRecord::RecordType(
grpRec["groupRecordType"].toInt()));
// NOTE: rec->group_address => subclass responsibility
rec->set_is_override_source_count(
grpRec["overrideGroupRecordSourceCount"].toBool());
rec->set_source_count(grpRec["groupRecordSourceCount"].toUInt());
// NOTE: rec->sources => subclass responsibility
rec->set_is_override_aux_data_length(
grpRec["overrideAuxDataLength"].toBool());
rec->set_aux_data_length(grpRec["auxDataLength"].toUInt());
QByteArray ba = grpRec["auxData"].toByteArray();
// pad to word boundary
if (ba.size() % 4)
ba.append(QByteArray(4 - (ba.size() % 4), char(0)));
rec->set_aux_data(std::string(ba.constData(), ba.size()));
}
break;
}
// Meta Fields
case kIsOverrideChecksum:
{
bool ovr = value.toBool();
data.set_is_override_checksum(ovr);
isOk = true;
break;
}
case kGroupMode:
{
uint mode = value.toUInt(&isOk);
if (isOk && data.GroupMode_IsValid(mode))
data.set_group_mode((OstProto::Gmp::GroupMode)mode);
break;
}
case kGroupCount:
{
uint count = value.toUInt(&isOk);
if (isOk)
data.set_group_count(count);
break;
}
case kGroupPrefix:
{
uint prefix = value.toUInt(&isOk);
if (isOk)
data.set_group_prefix(prefix);
break;
}
case kIsOverrideSourceCount:
{
bool ovr = value.toBool();
data.set_is_override_source_count(ovr);
isOk = true;
break;
}
case kIsOverrideGroupRecordCount:
{
bool ovr = value.toBool();
data.set_is_override_group_record_count(ovr);
isOk = true;
break;
}
default:
qFatal("%s: unimplemented case %d in switch", __PRETTY_FUNCTION__,
index);
break;
}
_exit:
return isOk;
}
int main(int argc, char **argv)
{
enum ExitCode
{
/**
* We start from 2, because QApplicationArgumentParser
* uses 1.
*/
QueryFailure = 2,
StdOutFailure
};
const QCoreApplication app(argc, argv);
QCoreApplication::setApplicationName(QLatin1String("xmlpatterns"));
QXmlNamePool namePool;
PatternistApplicationParser parser(argc, argv, namePool);
parser.setApplicationDescription(QLatin1String("A tool for running XQuery queries."));
parser.setApplicationVersion(QLatin1String("0.1"));
QApplicationArgument param(QLatin1String("param"),
QXmlPatternistCLI::tr("Binds an external variable. The value is directly available using the variable reference: $name."),
qMetaTypeId<Parameter>());
param.setMaximumOccurrence(-1);
parser.addArgument(param);
const QApplicationArgument noformat(QLatin1String("no-format"),
QXmlPatternistCLI::tr("By default output is formatted for readability. When specified, strict serialization is performed."));
parser.addArgument(noformat);
const QApplicationArgument isURI(QLatin1String("is-uri"),
QXmlPatternistCLI::tr("If specified, all filenames on the command line are interpreted as URIs instead of a local filenames."));
parser.addArgument(isURI);
const QApplicationArgument initialTemplateName(QLatin1String("initial-template"),
QXmlPatternistCLI::tr("The name of the initial template to call as a Clark Name."),
QVariant::String);
parser.addArgument(initialTemplateName);
/* The temporary object is required to compile with g++ 3.3. */
QApplicationArgument queryURI = QApplicationArgument(QLatin1String("query/stylesheet"),
QXmlPatternistCLI::tr("A local filename pointing to the query to run. If the name ends with .xsl it's assumed "
"to be an XSL-T stylesheet. If it ends with .xq, it's assumed to be an XQuery query. (In "
"other cases it's also assumed to be an XQuery query, but that interpretation may "
"change in a future release of Qt.)"),
QVariant::String);
queryURI.setMinimumOccurrence(1);
queryURI.setNameless(true);
parser.addArgument(queryURI);
QApplicationArgument focus = QApplicationArgument(QLatin1String("focus"),
QXmlPatternistCLI::tr("The document to use as focus. Mandatory "
"in case a stylesheet is used. This option is "
"also affected by the is-uris option."),
QVariant::String);
focus.setMinimumOccurrence(0);
focus.setNameless(true);
parser.addArgument(focus);
QApplicationArgument output(QLatin1String("output"),
QXmlPatternistCLI::tr("A local file to which the output should be written. "
"The file is overwritten, or if not exist, created. "
"If absent, stdout is used."),
qMetaTypeId<QIODevice *>());
parser.addArgument(output);
if(!parser.parse())
return parser.exitCode();
/* Get the query URI. */
const QUrl effectiveURI(finalizeURI(parser, isURI, queryURI));
QXmlQuery::QueryLanguage lang;
if(effectiveURI.toString().endsWith(QLatin1String(".xsl")))
lang = QXmlQuery::XSLT20;
else
lang = QXmlQuery::XQuery10;
if(lang == QXmlQuery::XQuery10 && parser.has(initialTemplateName))
{
parser.message(QXmlPatternistCLI::tr("An initial template name cannot be specified when running an XQuery."));
return QApplicationArgumentParser::ParseError;
}
QXmlQuery query(lang, namePool);
query.setInitialTemplateName(qvariant_cast<QXmlName>(parser.value(initialTemplateName)));
/* Bind external variables. */
{
const QVariantList parameters(parser.values(param));
const int len = parameters.count();
/* For tracking duplicates. */
QSet<QString> usedParameters;
for(int i = 0; i < len; ++i)
{
const Parameter p(qvariant_cast<Parameter>(parameters.at(i)));
if(usedParameters.contains(p.first))
{
parser.message(QXmlPatternistCLI::tr("Each parameter must be unique, %1 is specified at least twice.").arg(p.first));
return QApplicationArgumentParser::ParseError;
}
else
{
usedParameters.insert(p.first);
query.bindVariable(p.first, QXmlItem(p.second));
}
}
}
if(parser.has(focus))
{
if(!query.setFocus(finalizeURI(parser, isURI, focus)))
return QueryFailure;
}
else if(lang == QXmlQuery::XSLT20 && !parser.has(initialTemplateName))
{
parser.message(QXmlPatternistCLI::tr("When a stylesheet is used, a "
"document must be specified as a focus, or an "
"initial template name must be specified, or both."));
return QApplicationArgumentParser::ParseError;
}
query.setQuery(effectiveURI);
const QPatternist::AutoPtr<QIODevice> outDevice(qvariant_cast<QIODevice *>(parser.value(output)));
Q_ASSERT(outDevice);
Q_ASSERT(outDevice->isWritable());
if(query.isValid())
{
typedef QPatternist::AutoPtr<QAbstractXmlReceiver> RecPtr;
RecPtr receiver;
if(parser.has(noformat))
receiver = RecPtr(new QXmlSerializer(query, outDevice.data()));
else
receiver = RecPtr(new QXmlFormatter(query, outDevice.data()));
const bool success = query.evaluateTo(receiver.data());
if(success)
return parser.exitCode();
else
return QueryFailure;
}
else
return QueryFailure;
}
bool IgmpProtocol::setFieldData(int index, const QVariant &value,
FieldAttrib attrib)
{
bool isOk = false;
if (attrib != FieldValue)
goto _exit;
switch (index)
{
case kRsvdMrtCode:
{
uint mrt = value.toUInt(&isOk);
if (isOk)
data.set_max_response_time(mrt);
break;
}
case kGroupAddress:
{
QHostAddress addr(value.toString());
quint32 ip = addr.toIPv4Address();
isOk = (addr.protocol() == QAbstractSocket::IPv4Protocol);
if (isOk)
data.mutable_group_address()->set_v4(ip);
break;
}
case kSources:
{
QStringList list = value.toStringList();
data.clear_sources();
foreach(QString str, list)
{
quint32 ip = QHostAddress(str).toIPv4Address();
data.add_sources()->set_v4(ip);
}
break;
}
case kGroupRecords:
{
GmpProtocol::setFieldData(index, value, attrib);
QVariantList list = value.toList();
for (int i = 0; i < list.count(); i++)
{
QVariantMap grpRec = list.at(i).toMap();
OstProto::Gmp::GroupRecord *rec = data.mutable_group_records(i);
rec->mutable_group_address()->set_v4(QHostAddress(
grpRec["groupRecordAddress"].toString())
.toIPv4Address());
QStringList srcList = grpRec["groupRecordSourceList"]
.toStringList();
rec->clear_sources();
foreach (QString src, srcList)
{
rec->add_sources()->set_v4(
QHostAddress(src).toIPv4Address());
}
}
break;
}
QVariantList RZQLua::call(std::string const &function_name, QVariantList const &args)
{
auto const &L = m_lua;
lua_getglobal(L, function_name.c_str());
assert(lua_isfunction(L, -1));
if (args.size() != 0)
{
for(auto const &arg : args)
{
auto type = arg.type();
switch (type)
{
case QVariant::Type::String:
lua_pushstring(L, arg.toString().toStdString().c_str());
break;
case QVariant::Type::Int:
lua_pushinteger(L, arg.toInt());
break;
case QVariant::Type::Bool:
lua_pushboolean(L, arg.toInt());
break;
case QVariant::Type::Double:
lua_pushnumber(L, arg.toDouble());
break;
default:
LOG_WARNING("unhandled argument type: " << arg.typeName());
assert(false);
break;
}
}
}
auto top = lua_gettop(L) - args.count();
lua_pcall(L, args.size(), LUA_MULTRET, 0);
auto num_rv = lua_gettop(L) - top + 1;
QVariantList rv;
for (int i = num_rv - 1; i >= 0; --i)
{
int idx = -1 - i;
auto type = lua_type(L, idx);
switch (type)
{
case LUA_TNUMBER:
rv.append(lua_tonumber(L, idx));
break;
case LUA_TBOOLEAN:
rv.append(lua_toboolean(L, idx));
break;
case LUA_TSTRING:
rv.append(lua_tostring(L, idx));
break;
default:
LOG_WARNING("unhandled return type: " << lua_typename(L, idx));
assert(false);
break;
}
}
lua_pop(L, num_rv);
return rv;
}
void ArrayDataModel::append(const QVariantList &values)
{
beginInsertRows(QModelIndex(),0, values.count());
mDatas.prepend(values);
endInsertRows();
}
void myOperationCustom::setParameters(QVariantList parameters) {
REQUIRE(parameters.count() != 0);
//m_Parameter = parameters.at(0).toDouble();
}
Client::DataList Client::getData(const string& query) {
QJsonDocument root;
QString temp = QString::fromStdString(query);
QByteArray bytearray = query.c_str();
QString query_string = QString::fromUtf8(bytearray.data(), bytearray.size());
qDebug() << "query_string: " << query_string;
QString uri = getQueryString(query_string);
qDebug() << "uri: " << uri;
get(uri, root);
DataList result;
QVariantMap variant = root.toVariant().toMap();
// Iterate through the weather data
for (const QVariant &i : variant["businesses"].toList()) {
QVariantMap item = i.toMap();
QString name = removeTestInfo(item["name"].toString());
qDebug() << "name: " << name;
QString business_url = item["business_url"].toString();
qDebug() << "business_url: " << business_url;
QString s_photo_url = item["s_photo_url"].toString();
qDebug() << "s_photo_url: " << s_photo_url;
QString photo_url = item["photo_url"].toString();
qDebug() << "photo_url: " << photo_url;
QString rating_s_img_url = item["rating_s_img_url"].toString();
qDebug() << "rating_s_img_url: " << rating_s_img_url;
QString address = item["address"].toString();
qDebug() << "address: " << address;
QString telephone = item["telephone"].toString();
qDebug() << "telephone: " << telephone;
QVariantList deals = item["deals"].toList();
QString summary;
if ( deals.count() > 0 ) {
QVariantMap temp = deals.first().toMap();
summary = temp["description"].toString();
}
qDebug() << "summary: " << summary;
// Add a result to the weather list
result.emplace_back(
Data { name.toStdString(), business_url.toStdString(), s_photo_url.toStdString(),
photo_url.toStdString(), rating_s_img_url.toStdString(),
address.toStdString(), telephone.toStdString(), summary.toStdString() });
}
return result;
}
int main(int argc, char **argv)
{
enum ExitCode
{
/**
* We start from 2, because QApplicationArgumentParser
* uses 1.
*/
QueryFailure = 2,
StdOutFailure
};
const QCoreApplication app(argc, argv);
QCoreApplication::setApplicationName(QLatin1String("xmlpatterns"));
PatternistApplicationParser parser(argc, argv);
parser.setApplicationDescription(QLatin1String("A tool for running XQuery queries."));
parser.setApplicationVersion(QLatin1String("0.1"));
/* Is there a better way to do this? Probably not, but if the class becomes public, we probably
* want a helper function that wraps this hack. */
const int parameterType = qVariantFromValue(Parameter()).userType();
const int outputType = qVariantFromValue(static_cast<QIODevice *>(0)).userType();
QApplicationArgument param(QLatin1String("param"),
QXmlPatternistCLI::tr("Binds an external variable. The value is directly available using the variable reference: $name."),
parameterType);
param.setMaximumOccurrence(-1);
parser.addArgument(param);
const QApplicationArgument noformat(QLatin1String("no-format"),
QXmlPatternistCLI::tr("By default output is formatted for readability. When specified, strict serialization is performed."));
parser.addArgument(noformat);
const QApplicationArgument isURI(QLatin1String("is-uri"),
QXmlPatternistCLI::tr("If specified, the filename is interpreted as a URI instead of a local filename."));
parser.addArgument(isURI);
/* The temporary object is required to compile with g++ 3.3. */
QApplicationArgument queryURI = QApplicationArgument(QString(), /* Nameless. */
QXmlPatternistCLI::tr("A local filename pointing to the query to run. "
"If the name ends with .xq it's assumed "
"to be an XQuery query. (In other cases too, but "
"that interpretation may change in a future release of Qt.)"),
QVariant::String);
queryURI.setMinimumOccurrence(1);
parser.addArgument(queryURI);
QApplicationArgument output(QLatin1String("output"),
QXmlPatternistCLI::tr("A local file to which the output should be written. The file is overwritten, or if not exist, created. If absent, stdout is used."),
outputType);
parser.addArgument(output);
if(!parser.parse())
return parser.exitCode();
QXmlQuery query;
/* Bind external variables. */
{
const QVariantList parameters(parser.values(param));
const int len = parameters.count();
for(int i = 0; i < len; ++i)
{
const Parameter p(qVariantValue<Parameter>(parameters.at(i)));
query.bindVariable(p.first, QXmlItem(p.second));
}
}
/* The final preparations and execute the query. */
QPatternist::ColoringMessageHandler messageHandler;
query.setMessageHandler(&messageHandler);
/* Get the query URI. */
QUrl userURI;
{
const QString stringURI(parser.value(queryURI).toString());
if(parser.has(isURI))
userURI = QUrl::fromEncoded(stringURI.toLatin1());
else
userURI = QUrl::fromLocalFile(stringURI);
}
const QUrl effectiveURI(QUrl::fromLocalFile(QDir::current().absolutePath() + QLatin1Char('/')).resolved(userURI));
Q_ASSERT_X(userURI.isValid(), Q_FUNC_INFO,
"QApplicationArgumentParser should promise us this.");
query.setQuery(effectiveURI);
QIODevice *const outDevice = qVariantValue<QIODevice *>(parser.value(output));
Q_ASSERT(outDevice);
Q_ASSERT(outDevice->isWritable());
if(query.isValid())
{
QAbstractXmlReceiver *receiver = 0;
if(parser.has(noformat))
receiver = new QXmlSerializer(query, outDevice);
else
receiver = new QXmlFormatter(query, outDevice);
const bool success = query.evaluateTo(receiver);
delete outDevice;
delete receiver;
if(success)
return parser.exitCode();
else
return QueryFailure;
}
else
{
delete outDevice;
return QueryFailure;
}
}
/*
taken from http://delta.affinix.com/2006/08/14/invokemethodwithvariants/
thanks to Justin Karneges once again :)
*/
bool MaiaXmlRpcServerConnection::invokeMethodWithVariants( QObject *obj,
const QByteArray &method,
const QVariantList &args,
QVariant *ret,
Qt::ConnectionType type )
{
// QMetaObject::invokeMethod() has a 10 argument maximum
if( args.count() > 10 ) {
return false;
}
QList<QByteArray> argTypes;
for( int n = 0; n < args.count(); ++n ) {
argTypes += args[n].typeName();
}
// get return type
int metatype = 0;
QByteArray retTypeName = getReturnType(obj->metaObject(), method, argTypes);
if( !retTypeName.isEmpty() && retTypeName != "QVariant" ) {
metatype = QMetaType::type(retTypeName.data());
if( metatype == 0 ) {
// lookup failed
return false;
}
}
QGenericArgument arg[10];
for( int n = 0; n < args.count(); ++n ) {
arg[n] = QGenericArgument(args[n].typeName(), args[n].constData());
}
QGenericReturnArgument retarg;
QVariant retval;
if( metatype != 0 && retTypeName != "void" ) {
retval = QVariant(metatype, (const void *)0);
retarg = QGenericReturnArgument(retval.typeName(), retval.data());
}
else {
/* QVariant */
retarg = QGenericReturnArgument("QVariant", &retval);
}
if( retTypeName.isEmpty() || retTypeName == "void" ) {
/* void */
if( !QMetaObject::invokeMethod(obj, method.data(), type,
arg[0], arg[1], arg[2], arg[3], arg[4],
arg[5], arg[6], arg[7], arg[8], arg[9]) ) {
return false;
}
}
else {
if( !QMetaObject::invokeMethod(obj, method.data(), type, retarg,
arg[0], arg[1], arg[2], arg[3], arg[4],
arg[5], arg[6], arg[7], arg[8], arg[9]) ) {
return false;
}
}
if( retval.isValid() && ret ) {
*ret = retval;
}
return true;
} // bool invokeMethodWithVariants( QObject *obj, const QByteArray &method, const QVariantList &args, QVariant *ret, Qt::ConnectionType type )
void ReverseGeoLookupThread::run() {
if (geo_lookup_data.isEmpty())
return;
QNetworkRequest request;
QNetworkAccessManager *rgl = new QNetworkAccessManager();
QEventLoop loop;
QString mapquestURL("http://open.mapquestapi.com/nominatim/v1/reverse.php?format=json&accept-language=%1&lat=%2&lon=%3");
QString geonamesURL("http://api.geonames.org/findNearbyPlaceNameJSON?language=%1&lat=%2&lng=%3&radius=50&username=dirkhh");
QString geonamesOceanURL("http://api.geonames.org/oceanJSON?language=%1&lat=%2&lng=%3&radius=50&username=dirkhh");
QString divelogsURL("https://www.divelogs.de/mapsearch_divespotnames.php?lat=%1&lng=%2&radius=50");
QTimer timer;
request.setRawHeader("Accept", "text/json");
request.setRawHeader("User-Agent", getUserAgent().toUtf8());
connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
Q_FOREACH (const GeoLookupInfo& info, geo_lookup_data ) {
struct dive_site *ds = info.uuid ? get_dive_site_by_uuid(info.uuid) : &displayed_dive_site;
// first check the findNearbyPlaces API from geonames - that should give us country, state, city
request.setUrl(geonamesURL.arg(uiLanguage(NULL)).arg(info.lat.udeg / 1000000.0).arg(info.lon.udeg / 1000000.0));
QNetworkReply *reply = rgl->get(request);
timer.setSingleShot(true);
connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
timer.start(5000); // 5 secs. timeout
loop.exec();
if(timer.isActive()) {
timer.stop();
if(reply->error() > 0) {
report_error("got error accessing geonames.org: %s", qPrintable(reply->errorString()));
goto clear_reply;
}
int v = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (v < 200 || v >= 300)
goto clear_reply;
QByteArray fullReply = reply->readAll();
QJsonParseError errorObject;
QJsonDocument jsonDoc = QJsonDocument::fromJson(fullReply, &errorObject);
if (errorObject.error != QJsonParseError::NoError) {
report_error("error parsing geonames.org response: %s", qPrintable(errorObject.errorString()));
goto clear_reply;
}
QJsonObject obj = jsonDoc.object();
QVariant geoNamesObject = obj.value("geonames").toVariant();
QVariantList geoNames = geoNamesObject.toList();
if (geoNames.count() > 0) {
QVariantMap firstData = geoNames.at(0).toMap();
int ri = 0, l3 = -1, lt = -1;
if (ds->taxonomy.category == NULL) {
ds->taxonomy.category = alloc_taxonomy();
} else {
// clear out the data (except for the ocean data)
int ocean;
if ((ocean = taxonomy_index_for_category(&ds->taxonomy, TC_OCEAN)) > 0) {
ds->taxonomy.category[0] = ds->taxonomy.category[ocean];
ds->taxonomy.nr = 1;
} else {
// ocean is -1 if there is no such entry, and we didn't copy above
// if ocean is 0, so the following gets us the correct count
ds->taxonomy.nr = ocean + 1;
}
}
// get all the data - OCEAN is special, so start at COUNTRY
for (int j = TC_COUNTRY; j < TC_NR_CATEGORIES; j++) {
if (firstData[taxonomy_api_names[j]].isValid()) {
ds->taxonomy.category[ri].category = j;
ds->taxonomy.category[ri].origin = taxonomy::GEOCODED;
free((void*)ds->taxonomy.category[ri].value);
ds->taxonomy.category[ri].value = copy_string(qPrintable(firstData[taxonomy_api_names[j]].toString()));
ri++;
}
}
ds->taxonomy.nr = ri;
l3 = taxonomy_index_for_category(&ds->taxonomy, TC_ADMIN_L3);
lt = taxonomy_index_for_category(&ds->taxonomy, TC_LOCALNAME);
if (l3 == -1 && lt != -1) {
// basically this means we did get a local name (what we call town), but just like most places
// we didn't get an adminName_3 - which in some regions is the actual city that town belongs to,
// then we copy the town into the city
ds->taxonomy.category[ri].value = copy_string(ds->taxonomy.category[lt].value);
ds->taxonomy.category[ri].origin = taxonomy::COPIED;
ds->taxonomy.category[ri].category = TC_ADMIN_L3;
ds->taxonomy.nr++;
}
mark_divelist_changed(true);
} else {
report_error("geonames.org did not provide reverse lookup information");
qDebug() << "no reverse geo lookup; geonames returned\n" << fullReply;
}
} else {
report_error("timeout accessing geonames.org");
disconnect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
reply->abort();
}
// next check the oceans API to figure out the body of water
request.setUrl(geonamesOceanURL.arg(uiLanguage(NULL)).arg(info.lat.udeg / 1000000.0).arg(info.lon.udeg / 1000000.0));
reply = rgl->get(request);
connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
timer.start(5000); // 5 secs. timeout
loop.exec();
if(timer.isActive()) {
timer.stop();
if(reply->error() > 0) {
report_error("got error accessing oceans API of geonames.org: %s", qPrintable(reply->errorString()));
goto clear_reply;
}
int v = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
if (v < 200 || v >= 300)
goto clear_reply;
QByteArray fullReply = reply->readAll();
QJsonParseError errorObject;
QJsonDocument jsonDoc = QJsonDocument::fromJson(fullReply, &errorObject);
if (errorObject.error != QJsonParseError::NoError) {
report_error("error parsing geonames.org response: %s", qPrintable(errorObject.errorString()));
goto clear_reply;
}
QJsonObject obj = jsonDoc.object();
QVariant oceanObject = obj.value("ocean").toVariant();
QVariantMap oceanName = oceanObject.toMap();
if (oceanName["name"].isValid()) {
int idx;
if (ds->taxonomy.category == NULL)
ds->taxonomy.category = alloc_taxonomy();
idx = taxonomy_index_for_category(&ds->taxonomy, TC_OCEAN);
if (idx == -1)
idx = ds->taxonomy.nr;
if (idx < TC_NR_CATEGORIES) {
ds->taxonomy.category[idx].category = TC_OCEAN;
ds->taxonomy.category[idx].origin = taxonomy::GEOCODED;
ds->taxonomy.category[idx].value = copy_string(qPrintable(oceanName["name"].toString()));
if (idx == ds->taxonomy.nr)
ds->taxonomy.nr++;
}
mark_divelist_changed(true);
}
} else {
report_error("timeout accessing geonames.org");
disconnect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
reply->abort();
}
clear_reply:
reply->deleteLater();
}
rgl->deleteLater();
}
void Core::writeOra(const QString& oraPath, const QSize& canvasSize, const QVariantList layerList) {
QZipWriter zipWriter(oraPath);
zipWriter.setCompressionPolicy(QZipWriter::AutoCompress);
QByteArray xmlByteArray;
// mimetype file
xmlByteArray.append("image/openraster");
zipWriter.addFile("mimetype", xmlByteArray);
// stack.xml file
QXmlStreamWriter stream(&xmlByteArray);
stream.setAutoFormatting(true);
stream.writeStartDocument();
stream.writeStartElement("image");
stream.writeAttribute("w", QString::number(canvasSize.width()));
stream.writeAttribute("h",QString::number(canvasSize.height()));
stream.writeStartElement("stack");
QByteArray ba;
QBuffer buffer(&ba);
for (int i = 0; i < layerList.count(); i++) {
QMap<QString, QVariant> map = layerList.at(i).toMap();
QString name = map.value("name").toString();
QString isVisible = map.value("isVisible").toString();
QString isLock = map.value("isLock").toString();
QString isSelected = map.value("isSelected").toString();
buffer.open(QIODevice::WriteOnly);
QObject* obj = qvariant_cast<QObject*>(map.value("canvasItem"));
CanvasItem* canvasItem = qobject_cast<CanvasItem*>(obj);
QPixmap* pixmap = canvasItem->pixmap();
pixmap->save(&buffer, "PNG");
buffer.close();
QString src = "data/" + name + ".png";
zipWriter.addFile(src, ba);
// layer
stream.writeStartElement("layer");
stream.writeAttribute("name", name);
stream.writeAttribute("composite-op", "svg:src-over");
stream.writeAttribute("visibility", isVisible == "true" ? "visible" : "hidden");
stream.writeAttribute("edit-locked", isLock);
stream.writeAttribute("selected", isSelected);
stream.writeAttribute("src", src);
stream.writeAttribute("x", "0");
stream.writeAttribute("y", "0");
stream.writeAttribute("opacity", "1.0");
stream.writeEndElement(); // layer
}
stream.writeEndElement(); // stack
stream.writeEndElement(); // image
stream.writeEndDocument(); // document
zipWriter.addFile("stack.xml", xmlByteArray);
zipWriter.close();
}
bool ODataListModel::hasChildren(const QVariantList& indexPath) {
// we aren't multilevel so we are only concerned with the root having children
return indexPath.count() == 0 && !mDataList.isEmpty();
}
ApiTraceState::ApiTraceState(const QVariantMap &parsedJson)
{
m_parameters = parsedJson[QLatin1String("parameters")].toMap();
QVariantMap attachedShaders =
parsedJson[QLatin1String("shaders")].toMap();
QVariantMap::const_iterator itr;
for (itr = attachedShaders.constBegin(); itr != attachedShaders.constEnd();
++itr) {
QString type = itr.key();
QString source = itr.value().toString();
m_shaderSources[type] = source;
}
QVariantList textureUnits =
parsedJson[QLatin1String("textures")].toList();
for (int i = 0; i < textureUnits.count(); ++i) {
QVariantMap unit = textureUnits[i].toMap();
for (itr = unit.constBegin(); itr != unit.constEnd(); ++itr) {
QVariantMap target = itr.value().toMap();
if (target.count()) {
QVariantList levels = target[QLatin1String("levels")].toList();
for (int j = 0; j < levels.count(); ++j) {
QVariantMap level = levels[j].toMap();
QVariantMap image = level[QLatin1String("image")].toMap();
QSize size(image[QLatin1String("__width__")].toInt(),
image[QLatin1String("__height__")].toInt());
QString cls = image[QLatin1String("__class__")].toString();
QString type = image[QLatin1String("__type__")].toString();
bool normalized =
image[QLatin1String("__normalized__")].toBool();
int numChannels =
image[QLatin1String("__channels__")].toInt();
Q_ASSERT(type == QLatin1String("uint8"));
Q_ASSERT(normalized == true);
QByteArray dataArray =
image[QLatin1String("__data__")].toByteArray();
ApiTexture tex;
tex.setSize(size);
tex.setNumChannels(numChannels);
tex.setLevel(j);
tex.setUnit(i);
tex.setTarget(itr.key());
tex.contentsFromBase64(dataArray);
m_textures.append(tex);
}
}
}
}
QVariantMap fbos =
parsedJson[QLatin1String("framebuffer")].toMap();
for (itr = fbos.constBegin(); itr != fbos.constEnd(); ++itr) {
QVariantMap buffer = itr.value().toMap();
QSize size(buffer[QLatin1String("__width__")].toInt(),
buffer[QLatin1String("__height__")].toInt());
QString cls = buffer[QLatin1String("__class__")].toString();
QString type = buffer[QLatin1String("__type__")].toString();
bool normalized = buffer[QLatin1String("__normalized__")].toBool();
int numChannels = buffer[QLatin1String("__channels__")].toInt();
Q_ASSERT(type == QLatin1String("uint8"));
Q_ASSERT(normalized == true);
QByteArray dataArray =
buffer[QLatin1String("__data__")].toByteArray();
ApiFramebuffer fbo;
fbo.setSize(size);
fbo.setNumChannels(numChannels);
fbo.setType(itr.key());
fbo.contentsFromBase64(dataArray);
m_framebuffers.append(fbo);
}
}
void TestLogging::actionLog()
{
QVariantList actionParams;
QVariantMap param1;
param1.insert("name", "mockActionParam1");
param1.insert("value", 7);
actionParams.append(param1);
QVariantMap param2;
param2.insert("name", "mockActionParam2");
param2.insert("value", true);
actionParams.append(param2);
QVariantMap params;
params.insert("actionTypeId", mockActionIdWithParams);
params.insert("deviceId", m_mockDeviceId);
params.insert("params", actionParams);
// enable notifications
QCOMPARE(enableNotifications(), true);
QSignalSpy clientSpy(m_mockTcpServer, SIGNAL(outgoingData(QUuid,QByteArray)));
// EXECUTE with params
QVariant response = injectAndWait("Actions.ExecuteAction", params);
verifyDeviceError(response);
// Lets wait 3for the notification
clientSpy.wait(200);
QVariant notification = checkNotification(clientSpy, "Logging.LogEntryAdded");
QVERIFY(!notification.isNull());
QVariantMap logEntry = notification.toMap().value("params").toMap().value("logEntry").toMap();
// Make sure the notification contains all the stuff we expect
QCOMPARE(logEntry.value("typeId").toString(), mockActionIdWithParams.toString());
QCOMPARE(logEntry.value("deviceId").toString(), m_mockDeviceId.toString());
QCOMPARE(logEntry.value("eventType").toString(), JsonTypes::loggingEventTypeToString(Logging::LoggingEventTypeTrigger));
QCOMPARE(logEntry.value("source").toString(), JsonTypes::loggingSourceToString(Logging::LoggingSourceActions));
QCOMPARE(logEntry.value("loggingLevel").toString(), JsonTypes::loggingLevelToString(Logging::LoggingLevelInfo));
// EXECUTE without params
params.clear(); clientSpy.clear();
params.insert("actionTypeId", mockActionIdNoParams);
params.insert("deviceId", m_mockDeviceId);
response = injectAndWait("Actions.ExecuteAction", params);
verifyDeviceError(response);
clientSpy.wait(200);
notification = checkNotification(clientSpy, "Logging.LogEntryAdded");
QVERIFY(!notification.isNull());
// get this logentry with filter
params.clear();
params.insert("deviceIds", QVariantList() << m_mockDeviceId);
params.insert("loggingSources", QVariantList() << JsonTypes::loggingSourceToString(Logging::LoggingSourceActions));
params.insert("eventTypes", QVariantList() << JsonTypes::loggingEventTypeToString(Logging::LoggingEventTypeTrigger));
params.insert("values", QVariantList() << "7, true");
response = injectAndWait("Logging.GetLogEntries", params);
verifyLoggingError(response);
QVariantList logEntries = response.toMap().value("params").toMap().value("logEntries").toList();
QCOMPARE(logEntries.count(), 1);
// EXECUTE broken action
params.clear(); clientSpy.clear();
params.insert("actionTypeId", mockActionIdFailing);
params.insert("deviceId", m_mockDeviceId);
response = injectAndWait("Actions.ExecuteAction", params);
verifyDeviceError(response, DeviceManager::DeviceErrorSetupFailed);
clientSpy.wait(200);
notification = checkNotification(clientSpy, "Logging.LogEntryAdded");
QVERIFY(!notification.isNull());
logEntry = notification.toMap().value("params").toMap().value("logEntry").toMap();
// Make sure the notification contains all the stuff we expect
QCOMPARE(logEntry.value("typeId").toString(), mockActionIdFailing.toString());
QCOMPARE(logEntry.value("deviceId").toString(), m_mockDeviceId.toString());
QCOMPARE(logEntry.value("eventType").toString(), JsonTypes::loggingEventTypeToString(Logging::LoggingEventTypeTrigger));
QCOMPARE(logEntry.value("source").toString(), JsonTypes::loggingSourceToString(Logging::LoggingSourceActions));
QCOMPARE(logEntry.value("loggingLevel").toString(), JsonTypes::loggingLevelToString(Logging::LoggingLevelAlert));
QCOMPARE(logEntry.value("errorCode").toString(), JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorSetupFailed));
// get this logentry with filter
params.clear();
params.insert("deviceIds", QVariantList() << m_mockDeviceId);
params.insert("loggingSources", QVariantList() << JsonTypes::loggingSourceToString(Logging::LoggingSourceActions));
params.insert("eventTypes", QVariantList() << JsonTypes::loggingEventTypeToString(Logging::LoggingEventTypeTrigger));
params.insert("values", QVariantList() << "7, true");
response = injectAndWait("Logging.GetLogEntries", params);
verifyLoggingError(response);
logEntries = response.toMap().value("params").toMap().value("logEntries").toList();
QCOMPARE(logEntries.count(), 1);
// check different filters
params.clear();
params.insert("deviceIds", QVariantList() << m_mockDeviceId);
params.insert("loggingSources", QVariantList() << JsonTypes::loggingSourceToString(Logging::LoggingSourceActions));
params.insert("eventTypes", QVariantList() << JsonTypes::loggingEventTypeToString(Logging::LoggingEventTypeTrigger));
params.insert("typeIds", QVariantList() << mockActionIdNoParams);
response = injectAndWait("Logging.GetLogEntries", params);
verifyLoggingError(response);
logEntries = response.toMap().value("params").toMap().value("logEntries").toList();
QCOMPARE(logEntries.count(), 1);
params.clear();
params.insert("deviceIds", QVariantList() << m_mockDeviceId);
params.insert("loggingSources", QVariantList() << JsonTypes::loggingSourceToString(Logging::LoggingSourceActions));
params.insert("eventTypes", QVariantList() << JsonTypes::loggingEventTypeToString(Logging::LoggingEventTypeTrigger));
params.insert("typeIds", QVariantList() << mockActionIdNoParams << mockActionIdWithParams << mockActionIdFailing);
response = injectAndWait("Logging.GetLogEntries", params);
verifyLoggingError(response);
logEntries = response.toMap().value("params").toMap().value("logEntries").toList();
QVERIFY(logEntries.count() == 3);
// disable notifications
QCOMPARE(disableNotifications(), true);
}
QString QJson::encodeData(const QVariant &data, EncodeOptions options, QString *errorMessage,
int indentation, QString currentLinePrefix)
{
QString indentedLinePrefix = options.testFlag(Compact) ?
QString::fromLatin1("") :
(currentLinePrefix + QString::fromLatin1(" ").repeated(indentation));
QString optionalNewLine = options.testFlag(Compact) ?
QString::fromLatin1("") :
(QString::fromLatin1("\n") + currentLinePrefix);
QString optionalIndentedNewLine = options.testFlag(Compact) ?
QString::fromLatin1("") :
(QString::fromLatin1("\n") + indentedLinePrefix);
QString encoded;
switch (data.type())
{
case(QVariant::Bool) :
encoded += QString::fromLatin1(data.toBool() ? "true" : "false");
break;
case(QVariant::Int) :
case(QVariant::UInt) :
case(QVariant::LongLong) :
case(QVariant::ULongLong) :
Q_ASSERT(data.canConvert(QVariant::String));
encoded = data.toString();
break;
case(QVariant::Double) :
encoded = QString::number(data.toDouble(), 'g', 16);
if (!encoded.contains(QString::fromLatin1(".")) && !encoded.contains(QString::fromLatin1("e")))
encoded += ".0";
break;
case(QVariant::String) :
encoded = encodeString(data.toString());
break;
case(QVariant::ByteArray) :
encoded = encodeByteArray(data.toByteArray());
break;
case(QVariant::List) :
{
encoded = QString::fromLatin1("[") + optionalIndentedNewLine;
QVariantList list = data.toList();
for (int i = 0; i < list.count(); ++i)
{
if (i) encoded += QString::fromLatin1(",") + optionalIndentedNewLine;
encoded += encodeData(list.at(i), options, errorMessage, indentation, indentedLinePrefix);
if (errorMessage && !errorMessage->isNull())
return QString();
}
encoded += optionalNewLine + QString::fromLatin1("]");
}
break;
case(QVariant::StringList) :
{
encoded = QString::fromLatin1("[") + optionalIndentedNewLine;
QStringList list = data.toStringList();
for (int i = 0; i < list.count(); ++i)
{
if (i) encoded += QString::fromLatin1(",") + optionalIndentedNewLine;
encoded += encodeData(list.at(i), options, errorMessage, indentation, indentedLinePrefix);
if (errorMessage && !errorMessage->isNull())
return QString();
}
encoded += optionalNewLine + QString::fromLatin1("]");
}
break;
case(QVariant::Map) :
{
encoded = QString::fromLatin1("{") + optionalIndentedNewLine;
QVariantMap map = data.toMap();
QVariantMap::iterator i;
bool first = true;
for (i = map.begin(); i != map.end(); ++i)
{
if (!first)
encoded += QString::fromLatin1(",") + optionalIndentedNewLine;
first = false;
encoded += encodeString(i.key());
encoded += options.testFlag(Compact) ? QString::fromLatin1(":") : QString::fromLatin1(" : ");
encoded += encodeData(i.value(), options, errorMessage, indentation, indentedLinePrefix);
if (errorMessage && !errorMessage->isNull())
return QString();
}
encoded += optionalNewLine + QString::fromLatin1("}");
}
break;
case(QVariant::Hash) :
{
encoded = QString::fromLatin1("{") + optionalIndentedNewLine;
QVariantHash hash = data.toHash();
QVariantHash::iterator i;
bool first = true;
for (i = hash.begin(); i != hash.end(); ++i)
{
if (!first)
encoded += QString::fromLatin1(",") + optionalIndentedNewLine;
first = false;
encoded += encodeString(i.key());
encoded += options.testFlag(Compact) ? QString::fromLatin1(":") : QString::fromLatin1(" : ");
encoded += encodeData(i.value(), options, errorMessage, indentation, indentedLinePrefix);
if (errorMessage && !errorMessage->isNull())
return QString();
}
encoded += optionalNewLine + QString::fromLatin1("}");
}
break;
case(QVariant::Invalid) :
encoded = QString::fromLatin1("null");
break;
default:
if (!options.testFlag(EncodeUnknownTypesAsNull))
{
if (errorMessage)
*errorMessage = QString::fromLatin1("Can't encode this type of data to JSON: %1")
.arg(data.typeName());
return QString();
}
encoded = QString::fromLatin1("null");
break;
}
return encoded;
}
int main(int argc, char **argv)
{
KAboutData aboutData( "networkmanagement_configshell", "libknetworkmanager", ki18n("Network Management"),
0,
ki18n("Create network connections standalone"),
KAboutData::License_GPL,
ki18n("(c) 2008 Will Stephenson") );
aboutData.addAuthor(ki18n("Will Stephenson"), KLocalizedString(), "*****@*****.**");
KCmdLineArgs::init(argc, argv, &aboutData);
KCmdLineOptions options;
options.add("connection <connection-id>", ki18n("Connection ID to edit"));
options.add("hiddennetwork <ssid>", ki18n("Connect to a hidden wireless network"));
options.add("type <type>", ki18n("Connection type to create, must be one of '802-3-ethernet', '802-11-wireless', 'pppoe', 'vpn', 'cellular', 'bluetooth'"));
options.add("specific-args <args>", ki18n("Space-separated connection type-specific arguments, may be either 'gsm' or 'cdma' for cellular connections,\n'openvpn' or 'vpnc' for vpn connections,\ninterface and AP identifiers for wireless connections,\nbluetooth mac address and service ('dun' or 'nap') for bluetooth connections.\n\nYou can also pass the serial device (i.e. 'rfcomm0') instead of service for dun bluetooth connections,\nin that case this program will block waiting for that device to be registered in ModemManager."));
options.add("+mode", ki18n("Operation mode, may be either 'create' or 'edit'"), "create");
KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
KUniqueApplication app;
const KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
if (args->count() < 1)
{
args->usage();
return -1;
}
ConnectionEditor editor(0);
QString specifics = args->getOption("specific-args");
QString ssid;
QVariantList specificArgs;
foreach (const QString& arg, specifics.split( ' ' )) {
specificArgs << QVariant(arg);
}
kDebug(KDE_DEFAULT_DEBUG_AREA) << specificArgs;
kDebug(KDE_DEFAULT_DEBUG_AREA) << args;
QTextStream qout(stdout, QIODevice::WriteOnly);
if (args->arg(0) == QLatin1String("create")) {
if (args->isSet("type")) {
const QString type = args->getOption("type");
Knm::Connection *con = 0;
if (type == QLatin1String("cellular")) {
MobileConnectionWizard *mobileConnectionWizard = new MobileConnectionWizard();
if (mobileConnectionWizard->exec() == QDialog::Accepted &&
mobileConnectionWizard->getError() == MobileProviders::Success) {
con = editor.createConnection(true, mobileConnectionWizard->type(), mobileConnectionWizard->args(), false);
}
delete mobileConnectionWizard;
}
/* To create a bluetooth DUN connection:
* networkmanagement_configshell create --type bluetooth --specific-args "00:11:22:33:44:55 dun"
* or
* networkmanagement_configshell create --type bluetooth --specific-args "00:11:22:33:44:55 rfcomm0"
*
* in the latter case networkmanagement_configshell will block waiting for the device rfcomm0 to be
* registered in ModemManager.
*/
else if (type == QLatin1String("bluetooth")) {
if (specificArgs.count() == 2) {
new Bluetooth(specificArgs[0].toString(), specificArgs[1].toString());
return app.exec();
} else {
qout << i18n("Expected two specific args, found %1: %2", specificArgs.count(), specifics) << "\n";
return -1;
}
} else {
con = editor.createConnection(true, Knm::Connection::typeFromString(type), specificArgs);
}
if (!con) {
kDebug(KDE_DEFAULT_DEBUG_AREA) << Knm::Connection::typeFromString(type) << "type connection cannot be created.";
return -1;
}
/* TODO: test if connection already exists and in case affirmative do not add it. */
ManageConnection::saveConnection(con);
return app.exec();
} else {
args->usage();
return -1;
}
} else {
if (args->isSet("connection")) {
QString connectionId = args->getOption("connection");
kDebug(KDE_DEFAULT_DEBUG_AREA) << "Editing connections is not yet implemented";
return 0;
// do edit
} else {
args->usage();
return -1;
}
}
return 0;
}
void ut_redeyereduction::testRedEyeForMultipleCircularAreas()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.red-eye-reduction");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.red-eye-reduction"));
QVariantList centerPoints;
for (int i = 100; i < 110; i++)
centerPoints << QPoint(i, i);
QVERIFY(filter->supportsOption(QuillImageFilter::Center));
QVERIFY(filter->setOption(QuillImageFilter::Center, QVariant(centerPoints)));
QVariantList list0 = filter->option(QuillImageFilter::SelectionArea).value<QVariantList>();
QVERIFY(list0.count() == 0); // No radius set yet
QVERIFY(filter->supportsOption(QuillImageFilter::Radius));
QVariantList radii;
for (int r = 1; r < 101; r++)
radii << QVariant(r);
QVERIFY(filter->setOption(QuillImageFilter::Radius, QVariant(radii)));
QVariantList outRadii = filter->option(QuillImageFilter::Radius).value<QVariantList>();
for (int i = 0; i < radii.count(); i++) {
bool bOK = true;
QCOMPARE(outRadii[i].toInt(), radii[i].toInt(&bOK));
QVERIFY(bOK);
}
QVariantList outCenter = filter->option(QuillImageFilter::Center).value<QVariantList>();
for (int i = 0; i < centerPoints.count(); i++) {
QCOMPARE(outCenter[i].toPoint(), centerPoints[i].toPoint());
}
QVERIFY(filter->supportsOption(QuillImageFilter::SelectionArea));
QVariantList polygonList = filter->option(QuillImageFilter::SelectionArea).value<QVariantList>();
QCOMPARE( polygonList.count(), ( radii.count() < centerPoints.count() ? radii.count() : centerPoints.count() ) );
for (int i = 0; i < polygonList.count(); i++)
{
QPolygon polygon = polygonList[i].value<QPolygon>();
float pi = 3.14159265;
float margin = 1;
for (int phi = 0; phi < 360; phi += 10)
{
float x = radii[i].toInt() * cos( 2.0 * pi * phi / 360.0);
if (fabs(x) > margin)
x = (x>0 ? 1 : -1) * floor(fabs(x) - margin);
else
x = 0;
float y = radii[i].toInt() * sin( 2.0 * pi * phi / 360.0);
if (fabs(y) > margin)
y = (y>0 ? 1 : -1) * floor(fabs(y) - margin);
else
y = 0;
QPoint pt(x, y);
pt += centerPoints[i].toPoint();
QVERIFY(polygon.containsPoint(pt, Qt::WindingFill));
}
for (int phi = 0; phi < 360; phi += 10)
{
float x = radii[i].toInt() * cos( 2.0 * pi * phi / 360.0);
x = (x>0 ? 1 : -1) * ceil(fabs(x) + margin);
float y = radii[i].toInt() * sin( 2.0 * pi * phi / 360.0);
y = (y>0 ? 1 : -1) * ceil(fabs(y) + margin);
QPoint pt(x, y);
pt += centerPoints[i].toPoint();
QVERIFY(polygon.containsPoint(pt, Qt::WindingFill) == false);
}
}
delete filter;
}
QDocumentServerMessage QCategoryStoreServer::invokeMethod( const QDocumentServerMessage &message )
{
const QByteArray signature = message.signature();
const QVariantList arguments = message.arguments();
if( signature == "addCategory(QString,QString,QString,QString,bool)" )
{
QVariantList arguments = message.arguments();
Q_ASSERT( arguments.count() == 5 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->addCategory(
qvariant_cast< QString >( arguments[ 0 ] ),
qvariant_cast< QString >( arguments[ 1 ] ),
qvariant_cast< QString >( arguments[ 2 ] ),
qvariant_cast< QString >( arguments[ 3 ] ),
qvariant_cast< bool >( arguments[ 4 ] ) ) ) );
}
else if( signature == "categoryExists(QString)" )
{
Q_ASSERT( arguments.count() == 1 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->categoryExists(
qvariant_cast< QString >( arguments[ 0 ] ) ) ) );
}
else if( signature == "categoryFromId(QString)" )
{
Q_ASSERT( arguments.count() == 1 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->categoryFromId(
qvariant_cast< QString >( arguments[ 0 ] ) ) ) );
}
else if( signature == "scopeCategories(QString)" )
{
Q_ASSERT( arguments.count() == 1 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->scopeCategories(
qvariant_cast< QString >( arguments[ 0 ] ) ) ) );
}
else if( signature == "removeCategory(QString)" )
{
Q_ASSERT( arguments.count() == 1 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->removeCategory(
qvariant_cast< QString >( arguments[ 0 ] ) ) ) );
}
else if( signature == "setCategoryScope(QString,QString)" )
{
Q_ASSERT( arguments.count() == 2 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->setCategoryScope(
qvariant_cast< QString >( arguments[ 0 ] ),
qvariant_cast< QString >( arguments[ 1 ] ) ) ) );
}
else if( signature == "setCategoryIcon(QString,QString)" )
{
Q_ASSERT( arguments.count() == 2 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->setCategoryIcon(
qvariant_cast< QString >( arguments[ 0 ] ),
qvariant_cast< QString >( arguments[ 1 ] ) ) ) );
}
else if ( signature == "setCategoryRingTone(QString,QString)" )
{
Q_ASSERT( arguments.count() == 2 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->setCategoryRingTone(
qvariant_cast< QString >( arguments[ 0 ] ),
qvariant_cast< QString >( arguments[ 1 ] ) ) ) );
}
else if( signature == "setCategoryLabel(QString,QString)" )
{
Q_ASSERT( arguments.count() == 2 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->setCategoryLabel(
qvariant_cast< QString >( arguments[ 0 ] ),
qvariant_cast< QString >( arguments[ 1 ] ) ) ) );
}
else if( signature == "setSystemCategory(QString)" )
{
Q_ASSERT( arguments.count() == 1 );
return message.createReply( QVariant::fromValue( QCategoryStore::instance()->setSystemCategory(
qvariant_cast< QString >( arguments[ 0 ] ) ) ) );
}
else
{
qWarning() << "Tried to invoke unknown message";
Q_ASSERT( false );
return message.createError( "Unknown method" );
}
}
MainWindow::MainWindow():
m_canClose(false)
{
// Initialize pseudo-random numbers generator
srand(time(NULL));
// Create default UI
m_ui = new Ui::MainWindow();
m_ui->setupUi(this);
// Create menus
createMenus();
// Create label for displaying playlist length
m_playlistLengthLabel = new QLabel(this);
m_ui->statusBar->addPermanentWidget(m_playlistLengthLabel, 0);
m_playlistLengthLabel->setText(tr("%n track(s)", "", 0).append(QLatin1String(" (00:00)")));
// Set playlist browser columns widths and visibility
const QVariantList playlistColumnsStates = Settings::instance()->playlistColumnsStates();
const QVariantList playlistColumnsWidths = Settings::instance()->playlistColumnsWidths();
QMenu *menu = ActionManager::instance()->menu(QStringLiteral("PlaylistVisibleColumns"));
for (int i = 0; i < playlistColumnsStates.count() - 1; i++) {
if (playlistColumnsStates.at(i).toBool()) {
m_ui->playlistView->showColumn(i);
m_ui->playlistView->setColumnWidth(i, playlistColumnsWidths.at(i).toInt());
menu->actions().at(i)->setChecked(true);
} else {
m_ui->playlistView->hideColumn(i);
menu->actions().at(i)->setChecked(false);
}
}
// Restore main window geometry
restoreGeometry(Settings::instance()->windowGeometry());
restoreState(Settings::instance()->windowState());
m_ui->viewsSplitter->restoreState(Settings::instance()->windowSplitterState());
// Enable or disable collections
if (Settings::instance()->collectionsEnabled()) {
setupCollections();
if (Settings::instance()->collectionsAutoRebuild()) {
TaskManager::instance()->rebuildCollections();
}
} else {
m_ui->viewsTab->setTabEnabled(0, false);
}
// Create seek slider and volume slider
m_ui->seekSlider->setMediaObject(Player::instance()->mediaObject());
m_ui->volumeSlider->setAudioOutput(Player::instance()->audioOutput());
// Load last playlist
if (Settings::instance()->sessionRestore()) {
const QString playlistFile = Settings::configDir() + QLatin1String("/last.m3u");
Player::instance()->playlist()->loadPlaylist(playlistFile);
Player::instance()->setRandomMode(Settings::instance()->playerRandomMode());
Player::instance()->setRepeatMode(static_cast<Player::RepeatMode>(Settings::instance()->playerRepeatMode()));
}
// At the very end bind all signals and slots
bindSignals();
// Bind global shortcuts
bindShortcuts();
// The playlist can be populated before the MainWindow is constructed
onPlaylistLengthChanged(Player::instance()->playlist()->totalLength(),
Player::instance()->playlist()->rowCount());
}
PublishFormat PublishFormat::fromVariant(Type type, const QVariant &in, bool *ok, QString *errorMessage)
{
QString pn;
if(type == HttpResponse)
pn = "'http-response'";
else if(type == HttpStream)
pn = "'http-stream'";
else // WebSocketMessage
pn = "'ws-message'";
if(!isKeyedObject(in))
{
setError(ok, errorMessage, QString("%1 is not an object").arg(pn));
return PublishFormat();
}
PublishFormat out(type);
bool ok_;
if(type == HttpResponse)
{
if(keyedObjectContains(in, "code"))
{
QVariant vcode = keyedObjectGetValue(in, "code");
if(!vcode.canConvert(QVariant::Int))
{
setError(ok, errorMessage, QString("%1 contains 'code' with wrong type").arg(pn));
return PublishFormat();
}
out.code = vcode.toInt();
if(out.code < 0 || out.code > 999)
{
setError(ok, errorMessage, QString("%1 contains 'code' with invalid value").arg(pn));
return PublishFormat();
}
}
else
out.code = 200;
QString reasonStr = getString(in, pn, "reason", false, &ok_, errorMessage);
if(!ok_)
{
if(ok)
*ok = false;
return PublishFormat();
}
if(!reasonStr.isEmpty())
out.reason = reasonStr.toUtf8();
else
out.reason = StatusReasons::getReason(out.code);
if(keyedObjectContains(in, "headers"))
{
QVariant vheaders = keyedObjectGetValue(in, "headers");
if(vheaders.type() == QVariant::List)
{
foreach(const QVariant &vheader, vheaders.toList())
{
if(vheader.type() != QVariant::List)
{
setError(ok, errorMessage, "headers contains element with wrong type");
return PublishFormat();
}
QVariantList lheader = vheader.toList();
if(lheader.count() != 2)
{
setError(ok, errorMessage, "headers contains list with wrong number of elements");
return PublishFormat();
}
QString name = getString(lheader[0], &ok_);
if(!ok_)
{
setError(ok, errorMessage, "header contains name element with wrong type");
return PublishFormat();
}
QString val = getString(lheader[1], &ok_);
if(!ok_)
{
setError(ok, errorMessage, "header contains value element with wrong type");
return PublishFormat();
}
out.headers += HttpHeader(name.toUtf8(), val.toUtf8());
}
}
else if(isKeyedObject(vheaders))
void CertificateDialog::updateValue()
{
const QSslCertificate certificate(m_certificates.value(m_ui->chainItemView->currentIndex().data(Qt::UserRole).toInt()));
const CertificateField field(static_cast<CertificateField>(m_ui->detailsItemView->currentIndex().data(Qt::UserRole).toInt()));
m_ui->valueTextEdit->clear();
switch (field)
{
case ValidityField:
case PublicKeyField:
case ExtensionsField:
case DigestField:
break;
case VersionField:
m_ui->valueTextEdit->setPlainText(QString(certificate.version()));
break;
case SerialNumberField:
m_ui->valueTextEdit->setPlainText(formatHex(QString(certificate.serialNumber()), QLatin1Char(':')));
break;
case SignatureAlgorithmField:
m_ui->valueTextEdit->setPlainText(QRegularExpression(QLatin1String("Signature Algorithm:(.+)")).match(certificate.toText()).captured(1).trimmed());
break;
case IssuerField:
{
const QList<QByteArray> attributes(certificate.issuerInfoAttributes());
for (int i = 0; i < attributes.count(); ++i)
{
m_ui->valueTextEdit->appendPlainText(QStringLiteral("%1 = %2").arg(QString(attributes.at(i))).arg(certificate.issuerInfo(attributes.at(i)).join(QLatin1String(", "))));
}
}
break;
case ValidityNotBeforeField:
m_ui->valueTextEdit->setPlainText(certificate.effectiveDate().toString(QLatin1String("yyyy-MM-dd hh:mm:ss t")));
break;
case ValidityNotAfterField:
m_ui->valueTextEdit->setPlainText(certificate.expiryDate().toString(QLatin1String("yyyy-MM-dd hh:mm:ss t")));
break;
case SubjectField:
{
const QList<QByteArray> attributes(certificate.subjectInfoAttributes());
for (int i = 0; i < attributes.count(); ++i)
{
m_ui->valueTextEdit->appendPlainText(QStringLiteral("%1 = %2").arg(QString(attributes.at(i))).arg(certificate.subjectInfo(attributes.at(i)).join(QLatin1String(", "))));
}
}
break;
case PublicKeyValueField:
{
const QRegularExpression expression(QLatin1String("Public-Key:[.\\s\\S]+Modulus:([.\\s\\S]+)Exponent:(.+)"), QRegularExpression::MultilineOption);
const QRegularExpressionMatch match(expression.match(certificate.toText()));
if (match.hasMatch())
{
m_ui->valueTextEdit->setPlainText(tr("Modulus:\n%1\n\nExponent: %2").arg(formatHex(match.captured(1).trimmed().mid(3))).arg(match.captured(2).trimmed()));
}
}
break;
case PublicKeyAlgorithmField:
m_ui->valueTextEdit->setPlainText(QRegularExpression(QLatin1String("Public Key Algorithm:(.+)")).match(certificate.toText()).captured(1).trimmed());
break;
case ExtensionField:
{
const QSslCertificateExtension extension(certificate.extensions().value(m_ui->detailsItemView->currentIndex().data(Qt::UserRole + 1).toInt()));
m_ui->valueTextEdit->setPlainText(extension.isCritical() ? tr("Critical") : tr("Not Critical"));
m_ui->valueTextEdit->appendPlainText(tr("OID: %1").arg(extension.oid()));
if (!extension.value().isNull())
{
m_ui->valueTextEdit->appendPlainText(tr("Value:"));
if (extension.value().type() == QVariant::List)
{
const QVariantList list(extension.value().toList());
for (int i = 0; i < list.count(); ++i)
{
m_ui->valueTextEdit->appendPlainText(list.at(i).toString());
}
}
else if (extension.value().type() == QVariant::Map)
{
const QVariantMap map(extension.value().toMap());
QVariantMap::const_iterator iterator;
for (iterator = map.constBegin(); iterator != map.constEnd(); ++iterator)
{
m_ui->valueTextEdit->appendPlainText(QStringLiteral("%1 = %2").arg(iterator.key()).arg(iterator.value().toString()));
}
}
else
{
m_ui->valueTextEdit->appendPlainText(extension.value().toString());
}
}
}
break;
case DigestSha1Field:
m_ui->valueTextEdit->setPlainText(formatHex(QString(certificate.digest(QCryptographicHash::Sha1).toHex())));
break;
case DigestSha256Field:
m_ui->valueTextEdit->setPlainText(formatHex(QString(certificate.digest(QCryptographicHash::Sha256).toHex())));
break;
default:
break;
}
QTextCursor cursor(m_ui->valueTextEdit->textCursor());
cursor.setPosition(0);
m_ui->valueTextEdit->setTextCursor(cursor);
}
void TestDeltaT::testDeltaTByChaprontMeeus()
{
// test data from Astronomical Algorithms, 2ed., p. 79.
QVariantList data;
data << 1620 << 121.0;
data << 1630 << 82.0;
data << 1640 << 60.0;
data << 1650 << 46.0;
data << 1660 << 35.0;
data << 1670 << 24.0;
data << 1680 << 14.0;
data << 1690 << 8.0;
data << 1700 << 7.0;
data << 1710 << 9.0;
data << 1720 << 10.0;
data << 1730 << 10.0;
data << 1740 << 11.0;
data << 1750 << 12.0;
data << 1760 << 14.0;
data << 1770 << 15.0;
data << 1780 << 16.0;
data << 1790 << 16.0;
data << 1800 << 13.1;
data << 1810 << 12.0;
data << 1820 << 11.6;
data << 1830 << 7.1;
data << 1840 << 5.4;
data << 1850 << 6.8;
data << 1860 << 7.7;
data << 1870 << 1.4;
data << 1880 << -5.5;
data << 1890 << -6.0;
data << 1900 << -2.8;
data << 1910 << 10.4;
data << 1920 << 21.1;
data << 1930 << 24.4;
data << 1940 << 24.3;
data << 1950 << 29.1;
data << 1960 << 33.1;
data << 1970 << 40.2;
data << 1980 << 50.5;
data << 1984 << 53.8; // *
data << 1988 << 55.8; // *
data << 1990 << 56.9;
data << 1992 << 58.3; // *
data << 1996 << 61.6; // *
data << 1998 << 63.0;
// test data marked as * taken Mathematical Astronomical Morsels III, p. 8. [ISBN 0-943396-81-6]
// accuracy 0.9 seconds for years range 1800-1997
while(data.count() >= 2)
{
int year = data.takeFirst().toInt();
int yout, mout, dout;
double JD;
double expectedResult = data.takeFirst().toDouble();
double acceptableError = 0.9; // 0.9 seconds
StelUtils::getJDFromDate(&JD, year, 1, 1, 0, 0, 0);
double result = StelUtils::getDeltaTByChaprontMeeus(JD);
double actualError = qAbs(qAbs(expectedResult) - qAbs(result));
StelUtils::getDateFromJulianDay(JD, &yout, &mout, &dout);
QVERIFY2(actualError <= acceptableError, QString("date=%2 year=%3 result=%4 expected=%5 error=%6 acceptable=%7")
.arg(QString("%1-%2-%3 00:00:00").arg(yout).arg(mout).arg(dout))
.arg(year)
.arg(result)
.arg(expectedResult)
.arg(actualError)
.arg(acceptableError)
.toUtf8());
}
}
QVariantMap ReceiptsPlugin::receiptTablesData(int card_id)
{
qfLogFuncFrame() << card_id;
QF_TIME_SCOPE("receiptTablesData()");
QVariantMap ret;
CardReader::ReadCard read_card = cardReaderPlugin()->readCard(card_id);
CardReader::CheckedCard checked_card = cardReaderPlugin()->checkCard(read_card);
int current_stage_id = eventPlugin()->currentStageId();
int run_id = checked_card.runId();
int course_id = checked_card.courseId();
int current_standings = 0;
int competitors_finished = 0;
QMap<int, int> best_laps; //< position->time
///QMap<int, int> missing_codes; //< pos->code
///QSet<int> out_of_order_codes;
{
qf::core::model::SqlTableModel model;
qf::core::sql::QueryBuilder qb;
qb.select2("competitors", "*")
.select2("runs", "*")
.select2("classes", "name")
.select("COALESCE(competitors.lastName, '') || ' ' || COALESCE(competitors.firstName, '') AS competitorName")
.from("runs")
.join("runs.competitorId", "competitors.id")
.join("competitors.classId", "classes.id")
.where("runs.id=" QF_IARG(run_id));
model.setQuery(qb.toString());
model.reload();
if(model.rowCount() == 1) {
int class_id = model.value(0, "competitors.classId").toInt();
{
// find best laps for competitors class
qf::core::sql::QueryBuilder qb_minlaps;
// TODO: remove position field from DB in 0.1.5
qb_minlaps.select("runlaps.position, MIN(runlaps.lapTimeMs) AS minLapTimeMs")
.from("competitors")
.joinRestricted("competitors.id", "runs.competitorId", "runs.stageId=" QF_IARG(current_stage_id) " AND competitors.classId=" QF_IARG(class_id), "JOIN")
.joinRestricted("runs.id", "runlaps.runId", "runlaps.position > 0 AND runlaps.lapTimeMs > 0", "JOIN")
.groupBy("runlaps.position");
QString qs = qb_minlaps.toString();
//qfInfo() << qs;
qf::core::sql::Query q;
q.exec(qs);
while(q.next()) {
int position = q.value("position").toInt();
if(position == 0) {
qfWarning() << "position == 0 in best runlaps";
continue;
}
int lap = q.value("minLapTimeMs").toInt();
if(lap == 0) {
qfWarning() << "minLapTimeMs == 0 in best runlaps";
continue;
}
best_laps[position] = lap;
//qfInfo() << "bestlaps[" << pos << "] =" << lap;
}
}
if(checked_card.isOk()) {
// find current standings
qf::core::sql::QueryBuilder qb;
qb.select2("runs", "timeMs")
.select("runs.disqualified OR NOT runs.isRunning OR runs.isRunning IS NULL OR runs.misPunch AS dis")
.from("competitors")
.joinRestricted("competitors.id", "runs.competitorId", "runs.stageId=" QF_IARG(current_stage_id) " AND competitors.classId=" QF_IARG(class_id))
.where("runs.finishTimeMs > 0")
.orderBy("misPunch, disqualified, isRunning, runs.timeMs");
//qfInfo() << qb.toString();
qf::core::sql::Query q;
q.exec(qb.toString(), qf::core::Exception::Throw);
while (q.next()) {
bool dis = q.value("dis").toBool();
int time = q.value("timeMs").toInt();
if(!dis) {
if(time <= checked_card.timeMs())
current_standings++;
}
competitors_finished++;
}
}
}
qfu::TreeTable tt = model.toTreeTable();
{
qf::core::sql::QueryBuilder qb;
qb.select2("courses", "length, climb")
.select("(SELECT COUNT(*) FROM coursecodes WHERE courseId=courses.id) AS controlCount")
.from("courses")
.where("courses.id=" QF_IARG(course_id));
qf::core::sql::Query q;
q.exec(qb.toString());
if(q.next()) {
QSqlRecord rec = q.record();
for (int i = 0; i < rec.count(); ++i) {
QString fld_name = rec.fieldName(i);
tt.setValue(fld_name, rec.value(i));
}
}
}
{
qf::core::sql::QueryBuilder qb;
qb.select2("config", "ckey, cvalue, ctype")
.from("config")
.where("ckey LIKE 'event.%'");
qf::core::sql::Query q;
q.exec(qb.toString());
while(q.next()) {
QVariant v = qf::core::Utils::retypeStringValue(q.value("cvalue").toString(), q.value("ctype").toString());
tt.setValue(q.value("ckey").toString(), v);
}
}
tt.setValue("stageCount", eventPlugin()->stageCount());
tt.setValue("currentStageId", eventPlugin()->currentStageId());
qfDebug() << "competitor:\n" << tt.toString();
ret["competitor"] = tt.toVariant();
}
{
qfu::TreeTable tt;
tt.appendColumn("position", QVariant::Int);
tt.appendColumn("code", QVariant::Int);
tt.appendColumn("stpTimeMs", QVariant::Int);
tt.appendColumn("lapTimeMs", QVariant::Int);
tt.appendColumn("lossMs", QVariant::Int);
QMapIterator<QString, QVariant> it(checked_card);
while(it.hasNext()) {
it.next();
if(it.key() != QLatin1String("punches"))
tt.setValue(it.key(), it.value());
}
tt.setValue("isOk", checked_card.isOk());
int position = 0;
for(auto v : checked_card.punches()) {
CardReader::CheckedPunch punch(v.toMap());
qfu::TreeTableRow ttr = tt.appendRow();
++position;
int code = punch.code();
ttr.setValue("position", position);
ttr.setValue("code", code);
ttr.setValue("stpTimeMs", punch.stpTimeMs());
int lap = punch.lapTimeMs();
ttr.setValue("lapTimeMs", lap);
int best_lap = best_laps.value(position);
if(lap > 0 && best_lap > 0) {
int loss = lap - best_lap;
ttr.setValue("lossMs", loss);
}
}
/*
{
// runlaps table contains also finish time entry, it is under FINISH_PUNCH_POS
// currently best_laps[999] contains best finish lap time for this class
int loss = 0;
int best_lap = best_laps.value(CardReader::CardReaderPlugin::FINISH_PUNCH_POS);
if(best_lap > 0)
loss = checked_card.finishLapTimeMs() - best_lap;
//qfInfo() << "control_count:" << control_count << "finishLapTimeMs:" << checked_card.finishLapTimeMs() << "- best_lap:" << best_lap << "=" << loss;
tt.setValue("finishLossMs", loss);
}
*/
{
QSet<int> correct_codes;
for (int i = 0; i < checked_card.punchCount(); ++i) {
correct_codes << checked_card.punchAt(i).code();
}
QVariantList xc;
for (int i = 0; i < read_card.punchCount(); ++i) {
int code = read_card.punchAt(i).code();
if(!correct_codes.contains(code)) {
xc.insert(xc.count(), QVariantList() << (i+1) << code);
}
}
tt.setValue("extraCodes", xc);
}
tt.setValue("currentStandings", current_standings);
tt.setValue("competitorsFinished", competitors_finished);
tt.setValue("timeMs", checked_card.timeMs());
qfDebug() << "card:\n" << tt.toString();
ret["card"] = tt.toVariant();
}
return ret;
}
Tileset *VariantToMapConverter::toTileset(const QVariant &variant)
{
const QVariantMap variantMap = variant.toMap();
const int firstGid = variantMap["firstgid"].toInt();
const QString name = variantMap["name"].toString();
const int tileWidth = variantMap["tilewidth"].toInt();
const int tileHeight = variantMap["tileheight"].toInt();
const int spacing = variantMap["spacing"].toInt();
const int margin = variantMap["margin"].toInt();
const QVariantMap tileOffset = variantMap["tileoffset"].toMap();
const int tileOffsetX = tileOffset["x"].toInt();
const int tileOffsetY = tileOffset["y"].toInt();
if (tileWidth <= 0 || tileHeight <= 0 || firstGid == 0) {
mError = tr("Invalid tileset parameters for tileset '%1'").arg(name);
return 0;
}
typedef QScopedPointer<Tileset> TilesetPtr;
TilesetPtr tileset(new Tileset(name,
tileWidth, tileHeight,
spacing, margin));
tileset->setTileOffset(QPoint(tileOffsetX, tileOffsetY));
const QString trans = variantMap["transparentcolor"].toString();
if (!trans.isEmpty() && QColor::isValidColor(trans))
tileset->setTransparentColor(QColor(trans));
QVariant imageVariant = variantMap["image"];
if (!imageVariant.isNull()) {
QString imagePath = resolvePath(mMapDir, imageVariant);
if (!tileset->loadFromImage(imagePath)) {
mError = tr("Error loading tileset image:\n'%1'").arg(imagePath);
return 0;
}
}
tileset->setProperties(toProperties(variantMap["properties"]));
// Read tile terrain and external image information
const QVariantMap tilesVariantMap = variantMap["tiles"].toMap();
QVariantMap::const_iterator it = tilesVariantMap.constBegin();
for (; it != tilesVariantMap.end(); ++it) {
bool ok;
const int tileIndex = it.key().toInt();
if (tileIndex < 0) {
mError = tr("Tileset tile index negative:\n'%1'").arg(tileIndex);
}
if (tileIndex >= tileset->tileCount()) {
// Extend the tileset to fit the tile
if (tileIndex >= tilesVariantMap.count()) {
// If tiles are defined this way, there should be an entry
// for each tile.
// Limit the index to number of entries to prevent running out
// of memory on malicious input.
mError = tr("Tileset tile index too high:\n'%1'").arg(tileIndex);
return 0;
}
int i;
for (i=tileset->tileCount(); i <= tileIndex; i++)
tileset->addTile(QPixmap());
}
Tile *tile = tileset->tileAt(tileIndex);
if (tile) {
const QVariantMap tileVar = it.value().toMap();
QList<QVariant> terrains = tileVar["terrain"].toList();
if (terrains.count() == 4) {
for (int i = 0; i < 4; ++i) {
int terrainID = terrains.at(i).toInt(&ok);
if (ok && terrainID >= 0 && terrainID < tileset->terrainCount())
tile->setCornerTerrain(i, terrainID);
}
}
float terrainProbability = tileVar["probability"].toFloat(&ok);
if (ok)
tile->setTerrainProbability(terrainProbability);
imageVariant = tileVar["image"];
if (!imageVariant.isNull()) {
QString imagePath = resolvePath(mMapDir, imageVariant);
tileset->setTileImage(tileIndex, QPixmap(imagePath), imagePath);
}
QVariantMap objectGroupVariant = tileVar["objectgroup"].toMap();
if (!objectGroupVariant.isEmpty())
tile->setObjectGroup(toObjectGroup(objectGroupVariant));
QVariantList frameList = tileVar["animation"].toList();
if (!frameList.isEmpty()) {
QVector<Frame> frames(frameList.size());
for (int i = frameList.size() - 1; i >= 0; --i) {
const QVariantMap frameVariantMap = frameList[i].toMap();
Frame &frame = frames[i];
frame.tileId = frameVariantMap["tileid"].toInt();
frame.duration = frameVariantMap["duration"].toInt();
}
tile->setFrames(frames);
}
}
}
// Read tile properties
QVariantMap propertiesVariantMap = variantMap["tileproperties"].toMap();
for (it = propertiesVariantMap.constBegin(); it != propertiesVariantMap.constEnd(); ++it) {
const int tileIndex = it.key().toInt();
const QVariant propertiesVar = it.value();
if (tileIndex >= 0 && tileIndex < tileset->tileCount()) {
const Properties properties = toProperties(propertiesVar);
tileset->tileAt(tileIndex)->setProperties(properties);
}
}
// Read terrains
QVariantList terrainsVariantList = variantMap["terrains"].toList();
for (int i = 0; i < terrainsVariantList.count(); ++i) {
QVariantMap terrainMap = terrainsVariantList[i].toMap();
tileset->addTerrain(terrainMap["name"].toString(),
terrainMap["tile"].toInt());
}
mGidMapper.insert(firstGid, tileset.data());
return tileset.take();
}
SharedTileset VariantToMapConverter::toTileset(const QVariant &variant)
{
const QVariantMap variantMap = variant.toMap();
const int firstGid = variantMap[QLatin1String("firstgid")].toInt();
// Handle external tilesets
const QVariant sourceVariant = variantMap[QLatin1String("source")];
if (!sourceVariant.isNull()) {
QString source = resolvePath(mMapDir, sourceVariant);
QString error;
SharedTileset tileset = Tiled::readTileset(source, &error);
if (!tileset) {
// Insert a placeholder to allow the map to load
tileset = Tileset::create(QFileInfo(source).completeBaseName(), 32, 32);
tileset->setFileName(source);
tileset->setLoaded(false);
} else {
mGidMapper.insert(firstGid, tileset.data());
}
return tileset;
}
const QString name = variantMap[QLatin1String("name")].toString();
const int tileWidth = variantMap[QLatin1String("tilewidth")].toInt();
const int tileHeight = variantMap[QLatin1String("tileheight")].toInt();
const int spacing = variantMap[QLatin1String("spacing")].toInt();
const int margin = variantMap[QLatin1String("margin")].toInt();
const QVariantMap tileOffset = variantMap[QLatin1String("tileoffset")].toMap();
const int tileOffsetX = tileOffset[QLatin1String("x")].toInt();
const int tileOffsetY = tileOffset[QLatin1String("y")].toInt();
const int columns = tileOffset[QLatin1String("columns")].toInt();
if (tileWidth <= 0 || tileHeight <= 0 ||
(firstGid == 0 && !mReadingExternalTileset)) {
mError = tr("Invalid tileset parameters for tileset '%1'").arg(name);
return SharedTileset();
}
SharedTileset tileset(Tileset::create(name,
tileWidth, tileHeight,
spacing, margin));
tileset->setTileOffset(QPoint(tileOffsetX, tileOffsetY));
tileset->setColumnCount(columns);
QVariant imageVariant = variantMap[QLatin1String("image")];
if (!imageVariant.isNull()) {
const int imageWidth = variantMap[QLatin1String("imagewidth")].toInt();
const int imageHeight = variantMap[QLatin1String("imageheight")].toInt();
ImageReference imageRef;
imageRef.source = resolvePath(mMapDir, imageVariant);
imageRef.size = QSize(imageWidth, imageHeight);
tileset->setImageReference(imageRef);
}
const QString trans = variantMap[QLatin1String("transparentcolor")].toString();
if (!trans.isEmpty() && QColor::isValidColor(trans))
tileset->setTransparentColor(QColor(trans));
tileset->setProperties(extractProperties(variantMap));
// Read terrains
QVariantList terrainsVariantList = variantMap[QLatin1String("terrains")].toList();
for (int i = 0; i < terrainsVariantList.count(); ++i) {
QVariantMap terrainMap = terrainsVariantList[i].toMap();
Terrain *terrain = tileset->addTerrain(terrainMap[QLatin1String("name")].toString(),
terrainMap[QLatin1String("tile")].toInt());
terrain->setProperties(extractProperties(terrainMap));
}
// Read tile terrain and external image information
const QVariantMap tilesVariantMap = variantMap[QLatin1String("tiles")].toMap();
QVariantMap::const_iterator it = tilesVariantMap.constBegin();
for (; it != tilesVariantMap.end(); ++it) {
bool ok;
const int tileId = it.key().toInt();
if (tileId < 0) {
mError = tr("Invalid (negative) tile id: %1").arg(tileId);
return SharedTileset();
}
Tile *tile = tileset->findOrCreateTile(tileId);
const QVariantMap tileVar = it.value().toMap();
QList<QVariant> terrains = tileVar[QLatin1String("terrain")].toList();
if (terrains.count() == 4) {
for (int i = 0; i < 4; ++i) {
int terrainId = terrains.at(i).toInt(&ok);
if (ok && terrainId >= 0 && terrainId < tileset->terrainCount())
tile->setCornerTerrainId(i, terrainId);
}
}
float probability = tileVar[QLatin1String("probability")].toFloat(&ok);
if (ok)
tile->setProbability(probability);
imageVariant = tileVar[QLatin1String("image")];
if (!imageVariant.isNull()) {
QString imagePath = resolvePath(mMapDir, imageVariant);
tileset->setTileImage(tile, QPixmap(imagePath), imagePath);
}
QVariantMap objectGroupVariant = tileVar[QLatin1String("objectgroup")].toMap();
if (!objectGroupVariant.isEmpty())
tile->setObjectGroup(toObjectGroup(objectGroupVariant));
QVariantList frameList = tileVar[QLatin1String("animation")].toList();
if (!frameList.isEmpty()) {
QVector<Frame> frames(frameList.size());
for (int i = frameList.size() - 1; i >= 0; --i) {
const QVariantMap frameVariantMap = frameList[i].toMap();
Frame &frame = frames[i];
frame.tileId = frameVariantMap[QLatin1String("tileid")].toInt();
frame.duration = frameVariantMap[QLatin1String("duration")].toInt();
}
tile->setFrames(frames);
}
}
// Read tile properties
QVariantMap propertiesVariantMap = variantMap[QLatin1String("tileproperties")].toMap();
QVariantMap propertyTypesVariantMap = variantMap[QLatin1String("tilepropertytypes")].toMap();
for (it = propertiesVariantMap.constBegin(); it != propertiesVariantMap.constEnd(); ++it) {
const int tileId = it.key().toInt();
const QVariant propertiesVar = it.value();
const QVariant propertyTypesVar = propertyTypesVariantMap.value(it.key());
const Properties properties = toProperties(propertiesVar, propertyTypesVar);
tileset->findOrCreateTile(tileId)->setProperties(properties);
}
if (!mReadingExternalTileset)
mGidMapper.insert(firstGid, tileset.data());
return tileset;
}
void CContactManager::doRequestFinished(const CPB::RequestReplyData &response)
{
if(response.statusCode >= 400)
{
ZW_LOG_DEBUG(QString("request is error").arg(QString(response.replyData)));
if(response.type == TYPE_REQUEST_WX_SYNC)
{
QTimer::singleShot(1000, [this]()
{
this->requestWXSync(CLoginManager::getInstance()->m_baseRequestParam,CLoginManager::getInstance()->m_syncKeyList);
});
}
return;
}
switch (response.type)
{
case TYPE_REQUEST_CONTACT:
{
QJsonParseError errorString;
QJsonDocument doc = QJsonDocument::fromJson(response.replyData,&errorString);
ZW_LOG_DEBUG(QString("errorString = %1").arg(errorString.errorString()));
QVariantMap objMap = doc.toVariant().toMap();
ZW_LOG_DEBUG(QString("objMap.keys()=%1").arg(QStringList(objMap.keys()).join("-")));
QVariantList objList = objMap.value("MemberList").toList();
ZW_LOG_DEBUG(QString("objList.count = %1").arg(objList.count()));
m_contackMap.clear();
for(auto obj:objList)
{
Z_WX_USER_DATA d = Z_WX_USER_DATA::parseMap(obj.toMap());
//"ContactFlag": 1-公众号， 2-群组， 3-好友
if(!m_contackMap.contains(d.UserName) && d.VerifyFlag == 0)
{
Z_WX_USER_DATA *pObj = new Z_WX_USER_DATA;
*pObj = d;
m_contackMap.insert(d.UserName,QSharedPointer<Z_WX_USER_DATA>(pObj));
ZW_LOG_DEBUG(QString("UserName = %1,NickName = %2,VerifyFlag = %3").arg(pObj->UserName).arg(pObj->NickName).arg(d.VerifyFlag));
}
}
emit sigDateUpdate(CPB::DATA_UPDATE_TYPE_CONTACT_LIST,"");
ZW_LOG_DEBUG(QString("m_contackMap.count = %1").arg(m_contackMap.count()));
CMessageInterface::getInstance()->init();
break;
}
case TYPE_REQUEST_GROUP:
{
QJsonParseError errorString;
QJsonDocument doc = QJsonDocument::fromJson(response.replyData,&errorString);
ZW_LOG_DEBUG(QString("errorString = %1").arg(errorString.errorString()));
QVariantMap objMap = doc.toVariant().toMap();
ZW_LOG_DEBUG(QString("objMap.keys()=%1").arg(QStringList(objMap.keys()).join("-")));
QVariantList objList = objMap.value("ContactList").toList();
ZW_LOG_DEBUG(QString("objList.count = %1").arg(objList.count()));
m_groupMap.clear();
for(auto obj:objList)
{
Z_WX_USER_DATA d = Z_WX_USER_DATA::parseMap(obj.toMap());
if(!m_groupMap.contains(d.UserName)/* && d.ContactFlag == 3*/)
{
Z_WX_USER_DATA *pObj = new Z_WX_USER_DATA;
*pObj = d;
m_groupMap.insert(d.UserName,QSharedPointer<Z_WX_USER_DATA>(pObj));
ZW_LOG_DEBUG(QString("UserName = %1,NickName = %2,VerifyFlag = %3").arg(pObj->UserName).arg(pObj->NickName).arg(d.VerifyFlag));
}
}
emit sigDateUpdate(CPB::DATA_UPDATE_TYPE_GROUP_LIST,"");
ZW_LOG_DEBUG(QString("m_contackMap.count = %1").arg(m_groupMap.count()));
//TODO
ZW_LOG_DEBUG(QString("CLoginManager::getInstance()->requestSyncCheck()"));
CLoginManager::getInstance()->requestSyncCheck();
break;
}
case TYPE_REQUEST_WX_SYNC:
{
QJsonParseError errorString;
QJsonDocument doc = QJsonDocument::fromJson(response.replyData,&errorString);
ZW_LOG_DEBUG(QString("errorString = %1").arg(errorString.errorString()));
QVariantMap objMap = doc.toVariant().toMap();
ZW_LOG_DEBUG(QString("objMap.keys()=%1").arg(QStringList(objMap.keys()).join("-")));
{
QVariantList AddMsgList = objMap.value("AddMsgList").toList();
for(auto d:AddMsgList)
{
Z_WX_MSG_DATA msg = Z_WX_MSG_DATA::parseMap(d.toMap());
doWXMessage(msg);
}
}
CLoginManager::getInstance()->m_syncKeyList = Z_WX_SyncKeyList::parseList(objMap.value("SyncCheckKey").toMap().value("List").toList());
if(CLoginManager::getInstance()->m_syncKeyList.itemList.isEmpty())
{
ZW_LOG_CRITICAL(QString("SyncCheckKey parse is error"));
exit(-12);;
}
CLoginManager::getInstance()->requestSyncCheck();
break;
}
default:
break;
}
return;
}
QVariantMap QgsProcessingModelAlgorithm::parametersForChildAlgorithm( const QgsProcessingModelChildAlgorithm &child, const QVariantMap &modelParameters, const QVariantMap &results, const QgsExpressionContext &expressionContext ) const
{
QVariantMap childParams;
Q_FOREACH ( const QgsProcessingParameterDefinition *def, child.algorithm()->parameterDefinitions() )
{
if ( def->flags() & QgsProcessingParameterDefinition::FlagHidden )
continue;
if ( !def->isDestination() )
{
if ( !child.parameterSources().contains( def->name() ) )
continue; // use default value
QgsProcessingModelChildParameterSources paramSources = child.parameterSources().value( def->name() );
QVariantList paramParts;
Q_FOREACH ( const QgsProcessingModelChildParameterSource &source, paramSources )
{
switch ( source.source() )
{
case QgsProcessingModelChildParameterSource::StaticValue:
paramParts << source.staticValue();
break;
case QgsProcessingModelChildParameterSource::ModelParameter:
paramParts << modelParameters.value( source.parameterName() );
break;
case QgsProcessingModelChildParameterSource::ChildOutput:
{
QVariantMap linkedChildResults = results.value( source.outputChildId() ).toMap();
paramParts << linkedChildResults.value( source.outputName() );
break;
}
case QgsProcessingModelChildParameterSource::Expression:
{
QgsExpression exp( source.expression() );
paramParts << exp.evaluate( &expressionContext );
break;
}
}
}
if ( paramParts.count() == 1 )
childParams.insert( def->name(), paramParts.at( 0 ) );
else
childParams.insert( def->name(), paramParts );
}
else
{
const QgsProcessingDestinationParameter *destParam = static_cast< const QgsProcessingDestinationParameter * >( def );
// is destination linked to one of the final outputs from this model?
bool isFinalOutput = false;
QMap<QString, QgsProcessingModelOutput> outputs = child.modelOutputs();
QMap<QString, QgsProcessingModelOutput>::const_iterator outputIt = outputs.constBegin();
for ( ; outputIt != outputs.constEnd(); ++outputIt )
{
if ( outputIt->childOutputName() == destParam->name() )
{
QString paramName = child.childId() + ':' + outputIt.key();
if ( modelParameters.contains( paramName ) )
{
QVariant value = modelParameters.value( paramName );
if ( value.canConvert<QgsProcessingOutputLayerDefinition>() )
{
// make sure layout output name is correctly set
QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( value );
fromVar.destinationName = outputIt.key();
value = QVariant::fromValue( fromVar );
}
childParams.insert( destParam->name(), value );
}
isFinalOutput = true;
break;
}
}
if ( !isFinalOutput )
{
// output is temporary
// check whether it's optional, and if so - is it required?
bool required = true;
if ( destParam->flags() & QgsProcessingParameterDefinition::FlagOptional )
{
required = childOutputIsRequired( child.childId(), destParam->name() );
}
// not optional, or required elsewhere in model
if ( required )
childParams.insert( destParam->name(), destParam->generateTemporaryDestination() );
}
}
}
