const Animal AnimalDatabase::getData(QXmlStreamReader & reader) {
assert(reader.name() == k_name);
Animal animal;
const auto attr = reader.attributes();
if (!attr.hasAttribute("id")) {
qWarning() << "Animal has no ID!";
return animal;
}
while(!(reader.isEndElement() && reader.name() == k_name)) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
auto name = reader.name();
// name
if (name == "name") {
reader.readNext();
if(!reader.isCharacters()) {
qWarning() << "Name does not contain characters!";
return animal;
} else {
animal.setName(reader.text().toString());
}
} else
// type
if (name == "type") {
while(!(reader.isEndElement() && reader.name() == "type")) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
name = reader.name();
if (name == "primary") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Primary Type does not contain characters!";
return animal;
} else {
animal.setPrimaryType(reader.text().toString());
}
} else if (name == "secondary") {
reader.readNext();
if (!reader.isCharacters() && !reader.text().isEmpty()) {
qWarning() << "Secondary Type does not contain characters!";
return animal;
} else {
animal.setSecondaryType(reader.text().toString());
}
}
}
} else
// basestats
if (name == "basestats") {
while(!(reader.isEndElement() && reader.name() == "basestats")) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
name = reader.name();
if (name == "hp") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "HP does not contain characters!";
return animal;
} else {
animal.setBaseHP(reader.text().toUInt());
}
} else if (name == "attack") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Attack does not contain characters!";
return animal;
} else {
animal.setBaseAttack(reader.text().toUInt());
}
} else if (name == "defense") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Defense does not contain characters!";
return animal;
} else {
animal.setBaseDefense(reader.text().toUInt());
}
} else if (name == "speed") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Speed does not contain characters!";
return animal;
} else {
animal.setBaseSpeed(reader.text().toUInt());
}
} else if (name == "specialattack") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Special Attack does not contain characters!";
return animal;
} else {
animal.setBaseSpecialAttack(reader.text().toUInt());
}
} else if (name == "specialdefense") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Special Defense does not contain characters!";
return animal;
} else {
animal.setBaseSpecialDefense(reader.text().toUInt());
}
} else if (name == "xp") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "base XP does not contain characters!";
return animal;
} else {
animal.setBaseXP(reader.text().toUInt());
}
}
}
} else
// moves
if (name == "moves") {
std::multimap<unsigned int, QString> moves;
while(!(reader.isEndElement() && reader.name() == "moves")) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
name = reader.name();
if (name == "move") {
QString moveName;
unsigned int moveLevel;
while(!(reader.isEndElement() && reader.name() == "move")) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
name = reader.name();
if (name == "name") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Move Name does not contain characters!";
return animal;
} else {
moveName = reader.text().toString();
}
} else if (name == "level") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Move Level does not contain characters!";
return animal;
} else {
moveLevel = reader.text().toUInt();
}
}
}
moves.emplace(moveLevel, moveName);
}
}
animal.setMoves(moves);
} else
// evolutions
if (name == "evolutions") {
std::vector<std::tuple<QString, QString, unsigned int>> evolutions;
while(!(reader.isEndElement() && reader.name() == "evolutions")) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
name = reader.name();
if (name == "evolution") {
QString evolutionName;
QString evolutionMethod;
unsigned int evolutionValue;
while(!(reader.isEndElement() && reader.name() == "evolution")) {
reader.readNext();
if (reader.isEndElement()) {
continue;
}
name = reader.name();
if (name == "name") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Evolution Name does not contain characters!";
return animal;
} else {
evolutionName = reader.text().toString();
}
} else if (name == "method") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Evolution Method does not contain characters!";
return animal;
} else {
evolutionMethod = reader.text().toString();
}
} else if (name == "value") {
reader.readNext();
if (!reader.isCharacters()) {
qWarning() << "Evolution Value does not contain characters!";
return animal;
} else {
evolutionValue = reader.text().toUInt();
}
}
}
evolutions.emplace_back(evolutionName, evolutionMethod, evolutionValue);
}
}
animal.setEvolutions(evolutions);
}
}
return animal;
}
void CardDatabase::loadCardsFromXml(QXmlStreamReader &xml, bool tokens)
{
while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement)
break;
if (xml.name() == "card") {
QString name, manacost, cmc, type, pt, text;
QStringList colors;
QStringMap customPicURLs, customPicURLsHq;
MuidMap muids;
SetList sets;
int tableRow = 0;
int loyalty = 0;
bool cipt = false;
bool isToken = false;
while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement)
break;
if (xml.name() == "name")
name = xml.readElementText();
else if (xml.name() == "manacost")
manacost = xml.readElementText();
else if (xml.name() == "cmc")
cmc = xml.readElementText();
else if (xml.name() == "type")
type = xml.readElementText();
else if (xml.name() == "pt")
pt = xml.readElementText();
else if (xml.name() == "text")
text = xml.readElementText();
else if (xml.name() == "set") {
QXmlStreamAttributes attrs = xml.attributes();
QString setName = xml.readElementText();
sets.append(getSet(setName));
if (attrs.hasAttribute("muId")) {
muids[setName] = attrs.value("muId").toString().toInt();
}
if (attrs.hasAttribute("picURL")) {
customPicURLs[setName] = attrs.value("picURL").toString();
}
if (attrs.hasAttribute("picURLHq")) {
customPicURLsHq[setName] = attrs.value("picURLHq").toString();
}
} else if (xml.name() == "color")
colors << xml.readElementText();
else if (xml.name() == "tablerow")
tableRow = xml.readElementText().toInt();
else if (xml.name() == "cipt")
cipt = (xml.readElementText() == "1");
else if (xml.name() == "loyalty")
loyalty = xml.readElementText().toInt();
else if (xml.name() == "token")
isToken = xml.readElementText().toInt();
}
if (isToken == tokens) {
addCard(new CardInfo(this, name, isToken, manacost, cmc, type, pt, text, colors, loyalty, cipt, tableRow, sets, customPicURLs, customPicURLsHq, muids));
}
}
}
}
bool fb2Creator::create(const QString& path, int width, int height, QImage& img)
{
QFile file(path);
KZip zip(path);
QIODevice *device;
const KArchiveDirectory *dir;
const KZipFileEntry *fb2File;
QXmlStreamReader qxml;
QString fileExt = QFileInfo(path).suffix().toLower();
if (fileExt == "fb2")
{
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
{
qDebug() << "[fb2 thumbnailer]" << "Couldn't open" << path;
return false;
}
else
{
qDebug() << "[fb2 thumbnailer]" << "Reading" << path;
qxml.setDevice(&file);
}
}
else //if *.fb2.zip
{
if (!zip.open(QIODevice::ReadOnly))
{
qDebug() << "[fb2 thumbnailer]" << "Couldn't open" << path;
return false;
}
else
{
qDebug() << "[fb2 thumbnailer]" << "Reading" << path;
dir = zip.directory();
QStringList fileList = dir->entries();
for (int i=0; i < fileList.count(); i++)
{
if (fileList.at(i).endsWith(".fb2"))
{
fb2File = static_cast<const KZipFileEntry*>(dir->entry(fileList.at(i)));
device = fb2File->createDevice();
qxml.setDevice(device);
break;
}
}
}
}
//----
bool inCoverpage = false;
QString coverId = "";
QByteArray coverBase64;
while(!qxml.atEnd() && !qxml.hasError())
{
qxml.readNext();
if (qxml.name() == "coverpage")
{
if (qxml.isStartElement())
inCoverpage = true;
else
inCoverpage = false;
}
if (qxml.name() == "image" && qxml.isStartElement() && inCoverpage == true)
{
//various namespaces: xlink, l, NS2
QXmlStreamAttributes qxmlAttributes = qxml.attributes();
for (int pos = 0; pos < qxmlAttributes.size(); pos++)
{
if (qxmlAttributes.at(pos).name() == "href")
{
coverId = qxmlAttributes.at(pos).value().toString();
break;
}
}
if (coverId != "")
{
coverId.remove("#");
qDebug() << "[fb2 thumbnailer]" << "Found cover id:" << coverId;
}
}
if (qxml.name() == "binary" && qxml.isStartElement())
{
if (coverId != "")
{
if (qxml.attributes().value("id") == coverId)
{
qDebug() << "[fb2 thumbnailer]" << "Found cover data";
coverBase64 = qxml.readElementText().toAscii();
QImage coverImage;
coverImage.loadFromData(QByteArray::fromBase64(coverBase64));
img = coverImage.scaled(width, height, Qt::KeepAspectRatio, Qt::SmoothTransformation);
break;
}
}
else //if coverId not found then the file doesn't follow the specification, try a workaround
{
qDebug() << "[fb2 thumbnailer]" << "Cover id not found";
qDebug() << "[fb2 thumbnailer]" << "Using first image as cover";
coverBase64 = qxml.readElementText().toAscii();
QImage coverImage;
coverImage.loadFromData(QByteArray::fromBase64(coverBase64));
img = coverImage.scaled(width, height, Qt::KeepAspectRatio, Qt::SmoothTransformation);
break;
}
}
}
if (coverBase64.isEmpty())
qDebug() << "[fb2 thumbnailer]" << "Cover data not found";
if (qxml.hasError())
qDebug() << "[fb2 thumbnailer]" << "Parsing error:" << qxml.errorString();
qxml.clear();
if (fileExt == "fb2")
file.close();
else
{
device->close();
delete device;
//delete fb2File;
//delete dir;
}
return !img.isNull();
}
void ParserHafasXml::parseTimeTableMode0(QNetworkReply *networkReply)
{
TimetableEntriesList result;
QString data = QString::fromUtf8(networkReply->readAll());
QXmlStreamReader xml;
xml.addData(data);
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement() && (xml.name() == "STBJourney")) {
TimetableEntry item;
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement() && xml.name() == "Station") {
item.currentStation = xml.attributes().value("name").toString().simplified();
item.latitude = xml.attributes().value("y").toString().toInt();
item.longitude = xml.attributes().value("x").toString().toInt();
}
if (xml.isStartElement() && (xml.name() == "Dep" || xml.name() == "Arr" )) {
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement() && xml.name() == "Time") {
xml.readNext();
item.time = QTime::fromString(xml.text().toString(), "hh:mm");
}
if (xml.isStartElement() && xml.name() == "Platform") {
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement() && xml.name() == "Text") {
xml.readNext();
item.platform = xml.text().toString().simplified();
}
if (xml.isEndElement() && xml.name() == "Platform") {
break;
}
}
}
if (xml.isEndElement() && (xml.name() == "Dep" || xml.name() == "Arr" )) {
break;
}
}
}
if (xml.isStartElement() && xml.name() == "Attribute") {
QString currentAttributeType = xml.attributes().value("type").toString();
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement() && xml.name() == "Text") {
xml.readNext();
if (currentAttributeType == "DIRECTION") {
item.destinationStation = xml.text().toString().simplified();
}
if (currentAttributeType == "NAME") {
item.trainType = xml.text().toString().simplified();
}
}
if (xml.isEndElement() && xml.name() == "Attribute") {
break;
}
}
}
if (xml.isEndElement() && xml.name() == "STBJourney") {
result << item;
break;
}
}
}
}
emit timetableResult(result);
}
void recurse(QXmlStreamReader & reader,
QXmlStreamWriter & writer)
{
std::size_t mud = 0u;
QString locationFilename;
unsigned long long locationLine = 0u;
QString source;
while (!reader.atEnd()) {
switch (reader.readNext()) {
case QXmlStreamReader::Invalid:
readError(reader);
case QXmlStreamReader::StartElement:
if (mud) {
++mud;
PASS;
} else {
if (reader.qualifiedName() == "location") {
auto const attrs(reader.attributes());
locationFilename = attrs.value("filename").toString();
locationLine = attrs.value("line").toULongLong();
++mud;
PASS;
} else if (reader.qualifiedName() == "source") {
PASS;
QString source(reader.readElementText());
if (source.contains(hasPotentialUnicodeEscape)) {
QString const oldSource(source);
if (!checkUnicodeEscape(source,
locationFilename,
locationLine))
{
std::cerr << inFilename << ": \""
<< source.toStdString() << "\" ("
<< locationFilename.toStdString() << ':'
<< locationLine << ") not substituted!"
<< std::endl;
assert(oldSource == source);
} else {
std::cerr << inFilename << ": \""
<< oldSource.toStdString() << "\" -> \""
<< source.toStdString() << "\" ("
<< locationFilename.toStdString() << ':'
<< locationLine << ") substituted."
<< std::endl;
assert(oldSource != source);
}
}
writer.writeCharacters(source);
writer.writeEndElement();
} else {
++mud;
PASS;
}
}
break;
case QXmlStreamReader::EndElement:
if (mud) {
--mud;
PASS;
break;
} else {
PASS;
return;
}
default:
PASS;
break;
};
}
}
/*!
\fn void PluginSpecPrivate::readPluginSpec(QXmlStreamReader &reader)
\internal
*/
void PluginSpecPrivate::readPluginSpec(QXmlStreamReader &reader)
{
QString element = reader.name().toString();
if (element != QString(PLUGIN)) {
reader.raiseError(QCoreApplication::translate("PluginSpec", "Expected element '%1' as top level element").arg(PLUGIN));
return;
}
name = reader.attributes().value(PLUGIN_NAME).toString();
if (name.isEmpty()) {
reader.raiseError(msgAttributeMissing(PLUGIN, PLUGIN_NAME));
return;
}
version = reader.attributes().value(PLUGIN_VERSION).toString();
if (version.isEmpty()) {
reader.raiseError(msgAttributeMissing(PLUGIN, PLUGIN_VERSION));
return;
}
if (!isValidVersion(version)) {
reader.raiseError(msgInvalidFormat(PLUGIN_VERSION));
return;
}
compatVersion = reader.attributes().value(PLUGIN_COMPATVERSION).toString();
if (!compatVersion.isEmpty() && !isValidVersion(compatVersion)) {
reader.raiseError(msgInvalidFormat(PLUGIN_COMPATVERSION));
return;
} else if (compatVersion.isEmpty()) {
compatVersion = version;
}
QString experimentalString = reader.attributes().value(PLUGIN_EXPERIMENTAL).toString();
experimental = (experimentalString.compare(QLatin1String("true"), Qt::CaseInsensitive) == 0);
if (!experimentalString.isEmpty() && !experimental
&& experimentalString.compare(QLatin1String("false"), Qt::CaseInsensitive) != 0) {
reader.raiseError(msgInvalidFormat(PLUGIN_EXPERIMENTAL));
return;
}
disabledByDefault = experimental;
enabled = !experimental;
while (!reader.atEnd()) {
reader.readNext();
switch (reader.tokenType()) {
case QXmlStreamReader::StartElement:
element = reader.name().toString();
if (element == VENDOR)
vendor = reader.readElementText().trimmed();
else if (element == COPYRIGHT)
copyright = reader.readElementText().trimmed();
else if (element == LICENSE)
license = reader.readElementText().trimmed();
else if (element == DESCRIPTION)
description = reader.readElementText().trimmed();
else if (element == URL)
url = reader.readElementText().trimmed();
else if (element == CATEGORY)
category = reader.readElementText().trimmed();
else if (element == DEPENDENCYLIST)
readDependencies(reader);
else if (element == ARGUMENTLIST)
readArgumentDescriptions(reader);
else
reader.raiseError(msgInvalidElement(name));
break;
case QXmlStreamReader::EndDocument:
case QXmlStreamReader::Comment:
case QXmlStreamReader::EndElement:
case QXmlStreamReader::Characters:
break;
default:
reader.raiseError(msgUnexpectedToken());
break;
}
}
}
void ParserHafasXml::parseTimeTableMode1(QNetworkReply *networkReply)
{
TimetableEntriesList result;
QString data = QString::fromLatin1(networkReply->readAll());
//Add a root element, because its sometimes missing
if (data.indexOf("StationTable") == -1) {
data.prepend("<StationTable>");
data.append("</StationTable>");
}
QXmlStreamReader xml;
xml.addData(data);
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement() && (xml.name() == "Err")) {
QString errorMsg = xml.attributes().value("text").toString().simplified();
emit errorOccured(tr("Backend returns an error: ") + errorMsg);
qWarning()<<"ParserHafasXml::parseTimeTableMode1: "<<errorMsg;
}
if (xml.isStartElement() && (xml.name() == "Journey")) {
TimetableEntry item;
QString dest = xml.attributes().value("dir").toString().simplified();
QString station = xml.attributes().value("depStation").toString().simplified();
QString train = xml.attributes().value("hafasname").toString().simplified();
if (dest.isEmpty()) {
dest = xml.attributes().value("targetLoc").toString().simplified();
}
if (train.isEmpty()) {
train = xml.attributes().value("prod").toString().simplified();
if (train.indexOf("#")) {
train = train.left(train.indexOf("#"));
}
}
//get delay infos,
QString txtDelay = xml.attributes().value("delay").toString().simplified();
//QString intDelay = xml.attributes().value("e_delay").toString().simplified();
QString reasonDelay = xml.attributes().value("delayReason").toString().simplified();
QString miscInfo = "";
if (!txtDelay.isEmpty()) {
if (txtDelay == "-") {
miscInfo = "";
} else if (txtDelay == "0") {
miscInfo = tr("On-Time");
} else {
miscInfo = txtDelay;
}
}
if (!reasonDelay.isEmpty()) {
if (!miscInfo.isEmpty()) {
miscInfo.append(": ");
}
miscInfo.append(reasonDelay);
}
item.currentStation = station;
item.destinationStation = dest;
item.trainType = train;
item.platform = xml.attributes().value("platform").toString().simplified();
item.time = QTime::fromString(xml.attributes().value("fpTime").toString(), "hh:mm");
item.miscInfo = miscInfo;
result << item;
}
}
emit timetableResult(result);
}
void TraktorFeature::parseTrack(QXmlStreamReader &xml, QSqlQuery &query) {
QString title;
QString artist;
QString album;
QString year;
QString genre;
//drive letter
QString volume;
QString path;
QString filename;
QString location;
float bpm = 0.0;
int bitrate = 0;
QString key;
//duration of a track
int playtime = 0;
int rating = 0;
QString comment;
QString tracknumber;
//get XML attributes of starting ENTRY tag
QXmlStreamAttributes attr = xml.attributes ();
title = attr.value("TITLE").toString();
artist = attr.value("ARTIST").toString();
//read all sub tags of ENTRY until we reach the closing ENTRY tag
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "ALBUM") {
QXmlStreamAttributes attr = xml.attributes ();
album = attr.value("TITLE").toString();
tracknumber = attr.value("TRACK").toString();
continue;
}
if (xml.name() == "LOCATION") {
QXmlStreamAttributes attr = xml.attributes ();
volume = attr.value("VOLUME").toString();
path = attr.value("DIR").toString();
filename = attr.value("FILE").toString();
// compute the location, i.e, combining all the values
// On Windows the volume holds the drive letter e.g., d:
// On OS X, the volume is supposed to be "Macintosh HD" at all times,
// which is a folder in /Volumes/
#if defined(__APPLE__)
location = "/Volumes/"+volume;
#else
location = volume;
#endif
location += path.replace(QString(":"), QString(""));
location += filename;
continue;
}
if (xml.name() == "INFO") {
QXmlStreamAttributes attr = xml.attributes();
key = attr.value("KEY").toString();
bitrate = attr.value("BITRATE").toString().toInt() / 1000;
playtime = attr.value("PLAYTIME").toString().toInt();
genre = attr.value("GENRE").toString();
year = attr.value("RELEASE_DATE").toString();
comment = attr.value("COMMENT").toString();
QString ranking_str = attr.value("RANKING").toString();
// A ranking in Traktor has ranges between 0 and 255 internally.
// This is same as the POPULARIMETER tag in IDv2,
// see http://help.mp3tag.de/main_tags.html
//
// Our rating values range from 1 to 5. The mapping is defined as follow
// ourRatingValue = TraktorRating / 51
if (ranking_str != "" && qVariantCanConvert<int>(ranking_str)) {
rating = ranking_str.toInt()/51;
}
continue;
}
if (xml.name() == "TEMPO") {
QXmlStreamAttributes attr = xml.attributes ();
bpm = attr.value("BPM").toString().toFloat();
continue;
}
}
//We leave the infinte loop, if twe have the closing tag "ENTRY"
if (xml.name() == "ENTRY" && xml.isEndElement()) {
break;
}
}
// If we reach the end of ENTRY within the COLLECTION tag
// Save parsed track to database
query.bindValue(":artist", artist);
query.bindValue(":title", title);
query.bindValue(":album", album);
query.bindValue(":genre", genre);
query.bindValue(":year", year);
query.bindValue(":duration", playtime);
query.bindValue(":location", location);
query.bindValue(":rating", rating);
query.bindValue(":comment", comment);
query.bindValue(":tracknumber", tracknumber);
query.bindValue(":key", key);
query.bindValue(":bpm", bpm);
query.bindValue(":bitrate", bitrate);
bool success = query.exec();
if (!success) {
qDebug() << "SQL Error in TraktorTableModel.cpp: line"
<< __LINE__ << " " << query.lastError();
return;
}
}
void TraktorFeature::parsePlaylistEntries(
QXmlStreamReader &xml,
QString playlist_path,
QSqlQuery query_insert_into_playlist,
QSqlQuery query_insert_into_playlisttracks) {
// In the database, the name of a playlist is specified by the unique path,
// e.g., /someFolderA/someFolderB/playlistA"
query_insert_into_playlist.bindValue(":name", playlist_path);
if (!query_insert_into_playlist.exec()) {
LOG_FAILED_QUERY(query_insert_into_playlist)
<< "Failed to insert playlist in TraktorTableModel:"
<< playlist_path;
return;
}
// Get playlist id
QSqlQuery id_query(m_database);
id_query.prepare("select id from traktor_playlists where name=:path");
id_query.bindValue(":path", playlist_path);
if (!id_query.exec()) {
LOG_FAILED_QUERY(id_query) << "Could not get inserted playlist id for Traktor playlist::"
<< playlist_path;
return;
}
//playlist_id = id_query.lastInsertId().toInt();
int playlist_id = -1;
const int idColumn = id_query.record().indexOf("id");
while (id_query.next()) {
playlist_id = id_query.value(idColumn).toInt();
}
int playlist_position = 1;
while (!xml.atEnd() && !m_cancelImport) {
//read next XML element
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "PRIMARYKEY") {
QXmlStreamAttributes attr = xml.attributes();
QString key = attr.value("KEY").toString();
QString type = attr.value("TYPE").toString();
if (type == "TRACK") {
key.replace(QString(":"), QString(""));
//TODO: IFDEF
#if defined(__WINDOWS__)
key.insert(1,":");
#else
key.prepend("/Volumes/");
#endif
//insert to database
int track_id = -1;
QSqlQuery finder_query(m_database);
finder_query.prepare("select id from traktor_library where location=:path");
finder_query.bindValue(":path", key);
if (!finder_query.exec()) {
LOG_FAILED_QUERY(finder_query) << "Could not get track id:" << key;
continue;
}
if (finder_query.next()) {
track_id = finder_query.value(finder_query.record().indexOf("id")).toInt();
}
query_insert_into_playlisttracks.bindValue(":playlist_id", playlist_id);
query_insert_into_playlisttracks.bindValue(":track_id", track_id);
query_insert_into_playlisttracks.bindValue(":position", playlist_position++);
if (!query_insert_into_playlisttracks.exec()) {
LOG_FAILED_QUERY(query_insert_into_playlisttracks)
<< "trackid" << track_id << " with path " << key
<< "playlistname; " << playlist_path <<" with ID " << playlist_id;
}
}
}
}
if (xml.isEndElement()) {
//We leave the infinte loop, if twe have the closing "PLAYLIST" tag
if (xml.name() == "PLAYLIST") {
break;
}
}
}
}
void parseDeclensionDictWordGroup(QXmlStreamReader& xml, WordDeclensionGroup* owningWordGroup)
{
while (!xml.atEnd())
{
xml.readNext();
if (xml.isEndElement() && xml.name() == "group")
break;
if (xml.isStartElement() && xml.name() == "word")
{
WordDeclensionForm wordForm;
wordForm.OwningWordGroup = owningWordGroup;
const QXmlStreamAttributes& attrs = xml.attributes();
if (attrs.hasAttribute("name"))
{
QStringRef nameStr = attrs.value("name");
QString nameQ = QString::fromRawData(nameStr.constData(), nameStr.size());
wordForm.Name = nameQ.toStdWString();
}
if (attrs.hasAttribute("class"))
{
QStringRef attrStr = attrs.value("class");
wordForm.WordClass = details::parseWordClass(attrStr);
}
if (attrs.hasAttribute("isInfinitive"))
{
QStringRef attrStr = attrs.value("isInfinitive");
wordForm.IsInfinitive = details::parseBool(attrStr);
}
if (attrs.hasAttribute("person"))
{
QStringRef attrStr = attrs.value("person");
wordForm.Person = details::parseWordPerson(attrStr);
}
if (attrs.hasAttribute("case"))
{
QStringRef attrStr = attrs.value("case");
wordForm.Case = details::parseWordCase(attrStr);
}
if (attrs.hasAttribute("gender"))
{
QStringRef attrStr = attrs.value("gender");
wordForm.Gender = details::parseWordGender(attrStr);
}
if (attrs.hasAttribute("tense"))
{
QStringRef attrStr = attrs.value("tense");
wordForm.Tense = details::parseWordTense(attrStr);
}
if (attrs.hasAttribute("degree"))
{
QStringRef attrStr = attrs.value("degree");
wordForm.Degree = details::parseWordDegree(attrStr);
}
if (attrs.hasAttribute("mandative"))
{
QStringRef attrStr = attrs.value("mandative");
wordForm.Mandative = details::parseBool(attrStr);
}
if (attrs.hasAttribute("number"))
{
QStringRef attrStr = attrs.value("number");
wordForm.NumberCategory = details::parseWordNumber(attrStr);
}
if (attrs.hasAttribute("active"))
{
QStringRef attrStr = attrs.value("active");
wordForm.ActiveOrPassive = details::parseWordActiveOrPassive(attrStr);
}
owningWordGroup->Forms.push_back(wordForm);
}
}
}
bool CAdConfig::fromXml(QXmlStreamReader& reader)
{
// check that it is really an adConfig
if(reader.tokenType() != QXmlStreamReader::StartElement ||
reader.name() != "adConfig")
{
return false;
}
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "adConfig"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if (reader.name() == "serviceId")
{
if (!Helpers::fromXml(reader, m_serviceId))
return false;
}
else if (reader.name() == "pcrPid")
{
if (!Helpers::fromXml(reader, m_pcrPid))
return false;
}
else if (reader.name() == "duration")
{
QTime time;
if (!Helpers::fromXml(reader, "duration", time))
return false;
m_duration = Helpers::timeToTicks(time);
}
else if (reader.name() == "postBlack")
{
if (!Helpers::fromXml(reader, m_postBlack))
return false;
}
else if (reader.name() == "accessType")
{
if (!Helpers::fromXml(reader, m_accessType))
return false;
}
else if (reader.name() == "overridePlaying")
{
if (!Helpers::fromXml(reader, m_overridePlaying))
return false;
}
else if (reader.name() == "returnToPriorChannel")
{
if (!Helpers::fromXml(reader, m_returnToPriorChannel))
return false;
}
else if (reader.name() == "spliceElementaryStreams")
{
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "spliceElementaryStreams"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if (reader.name() == "spliceElementaryStream")
{
CSpliceElementaryStream es;
if (!es.fromXml(reader))
return false;
addElementaryStream(es);
}
else
{
qWarning() << "SpliceElementaryStreams: Unknown element in XML file: " << reader.name();
return false;
}
}
reader.readNext();
}
}
else
{
qWarning() << "AdConfig: Unknown element in XML file: " << reader.name();
return false;
}
}
reader.readNext();
}
return true;
}
bool CAdBlock::fromXml(QXmlStreamReader& reader)
{
// check that it is really an adBlock
if(reader.tokenType() != QXmlStreamReader::StartElement ||
reader.name() != "adBlock")
{
return false;
}
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "adBlock"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if (reader.name() == "name")
{
if (!Helpers::fromXml(reader, m_name))
return false;
}
else if (reader.name() == "startTime")
{
if (!Helpers::fromXml(reader, "startTime", m_startTime))
return false;
}
else if (reader.name() == "recurringTime")
{
if (!Helpers::fromXml(reader, "recurringTime", m_recurringTime))
return false;
}
else if (reader.name() == "adConfigs")
{
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "adConfigs"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if (reader.name() == "adConfig")
{
CAdConfig adConfig;
if (!adConfig.fromXml(reader))
return false;
addAdConfig(adConfig);
}
else
{
qWarning() << "AdConfigs: Unknown element in XML file: " << reader.name();
return false;
}
}
reader.readNext();
}
}
else
{
qWarning() << "AdBlock: Unknown element in XML file: " << reader.name();
return false;
}
}
reader.readNext();
}
return true;
}
void PlcSrConfig::loadPlcConfig()
{
QString fileName = "PlcSrConfig.xml";
QFile file(fileName);
if (false==file.open(QFile::ReadOnly | QFile::Text))
{
return;
}
else
{
QXmlStreamReader reader;
reader.setDevice(&file);
while (false==reader.atEnd())
{
reader.readNext();
if(reader.isStartElement())
{
if((reader.name()=="plc")&&(reader.attributes().hasAttribute("ID")))
{
QStringRef Temp=reader.attributes().value("ID");
plcName=Temp.toString();
if((false==plcList.contains(plcName))&&(false==plcName.isEmpty()))
{//可能有重名的传感器不重复添加,传感器名为空也不添加
plcNameMap[plcName]=plcName;
plcList.append(plcName);
this->ui->nameCbBox->addItem(plcName);
QLOG_INFO()<<plcName<<"传感器配置中...";
}else
QLOG_INFO()<<plcName<<"传感器已存在...";
}else if(reader.name()=="name")
{
plcName=reader.readElementText();
if((false==plcList.contains(plcName))&&(false==plcName.isEmpty()))
{//可能有重名的传感器不重复添加,传感器名为空也不添加
plcNameMap[plcName]=plcName;
plcList.append(plcName);
this->ui->nameCbBox->addItem(plcName);
QLOG_INFO()<<plcName<<"传感器配置中...";
}else
QLOG_INFO()<<plcName<<"传感器已配置完成...";
}
else if(reader.name()=="portId")
{
portId=reader.readElementText();
portIdMap[plcName]=portId;
if((false==portIdList.contains(portId))&&(false==portId.isEmpty()))
{//可能有有复用同一端口的传感器不重复添加,为空也不添加
portIdList.append(portId);
this->ui->portIdCbBox->addItem(portId);
}else
QLOG_INFO()<<"已添加过端口"<<portId;
}else if(reader.name()=="baudRate")
{
baudRate=reader.readElementText();
baudRateMap[plcName]=baudRate;
}else if(reader.name()== "dataBits")
{
dataBits=reader.readElementText();
dataBitsMap[plcName]=dataBits;
}else if(reader.name()=="parity")
{
parity=reader.readElementText();
parityMap[plcName]=parity;
}else if(reader.name()=="stopBits")
{
stopBits=reader.readElementText();
stopBitsMap[plcName]=stopBits;
}else if(reader.name()=="rwDelay")
{
rwDelay=reader.readElementText();
rwDelayMap[plcName]=rwDelay;
}else if(reader.name()=="type")
{
type=reader.readElementText();
typeMap[plcName]=type;
}else if(reader.name()=="rwLen")
{
rwLen=reader.readElementText();
rwLenMap[plcName]=rwLen;
}
else
{
QLOG_INFO()<<"本地配置读取进行中...";
}
}
}
}
QLOG_INFO()<<"本地配置读取完成";
setPlcSensor(plcName);//配置界面为最后添加的传感器
file.close();
}
void SimpleLoggerRoutingInfo::readInternals(QXmlStreamReader& reader, const QString&)
{
// Some elements store a map with the key as an attribute such as: "<Level MessageCategory="UserMessage">3</Level>"
// The nameAttrMapprovides the mapping between the element name and the single attribute used to contain the key.
QMap<QString, QString> nameAttrMap;
nameAttrMap["level"] = "MessageCategory";
nameAttrMap["routing"] = "MessageRouting";
nameAttrMap["format"] = "MessageComponent";
QString name;
QString attributeValue;
bool foundCharacters = false;
while (!reader.atEnd())
{
if (reader.isStartElement())
{
attributeValue = "";
name = reader.name().toString();
foundCharacters = false;
//qDebug(qPrintable(QString("Found start element %1").arg(name)));
if (QString::compare(name, "LocationRegEx", Qt::CaseInsensitive) == 0)
{
if (m_locationRegExp != nullptr)
{
delete m_locationRegExp;
m_locationRegExp = nullptr;
}
m_locationRegExp = XMLUtility::readRegExp(reader);
}
else if (QString::compare(name, "MessageRegEx", Qt::CaseInsensitive) == 0)
{
if (m_messageRegExp != nullptr)
{
delete m_messageRegExp;
m_messageRegExp = nullptr;
}
m_messageRegExp = XMLUtility::readRegExp(reader);
}
else
{
// At a start element that is not a regular expression, so check for the value in the attribute.
if (nameAttrMap.contains(name.toLower()) && reader.attributes().hasAttribute(nameAttrMap[name.toLower()]))
{
attributeValue = reader.attributes().value(nameAttrMap[name.toLower()]).toString();
}
}
}
else if (reader.isCharacters() && !name.isEmpty())
{
QString value = reader.text().toString();
//qDebug(qPrintable(QString("Found characters for name %1 and value (%2)").arg(name, value)));
if (name.compare("Enabled", Qt::CaseInsensitive) == 0)
{
m_enabled = XMLUtility::stringToBoolean(value);
}
else if (name.compare("Name", Qt::CaseInsensitive) == 0)
{
setName(value.trimmed());
}
else if (attributeValue.length() > 0)
{
// These next guys store their value in the attribute as specified in the nameAttrMap.
if (name.compare("Level", Qt::CaseInsensitive) == 0)
{
m_levels->insert(stringToCategory(attributeValue), value.toInt());
}
else if (name.compare("Routing", Qt::CaseInsensitive) == 0)
{
m_routing->insert(stringToRouting(attributeValue), XMLUtility::stringToBoolean(value));
}
else if (name.compare("Format", Qt::CaseInsensitive) == 0)
{
m_format.append(QPair<MessageComponent, QString>(stringToComponent(attributeValue), value));
foundCharacters = true;
}
}
attributeValue = "";
} else if (reader.isEndElement()) {
if (QString::compare(reader.name().toString(), "SimpleLoggerRoutingInfo", Qt::CaseInsensitive) == 0)
{
return;
}
if (name.compare("Format", Qt::CaseInsensitive) == 0 && !foundCharacters)
{
m_format.append(QPair<MessageComponent, QString>(stringToComponent(attributeValue), ""));
}
name = "";
}
reader.readNext();
}
}
/**
* Loads model from xml file.
*/
DatasetTestModel* DatasetTestMdlParser::load(QString path) const{
DatasetTestModel* mdl = new DatasetTestModel();
QFile file(path);
bool succ = file.open(QIODevice::ReadOnly);
if(!succ){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Open dataset test"));
msgBox.setText(tr("Dataset test file can't be opened !!!"));
msgBox.setInformativeText(tr("Check if file exists or program have permission to read it."));
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
delete mdl;
return NULL;
}
QXmlStreamReader rd;
rd.setDevice(&file);
QString elemName;
int state = 0;
//reading
while (!rd.atEnd()) {
switch(rd.readNext()){
case QXmlStreamReader::StartElement:
elemName = rd.name().toString();
if(rd.name() == "header"){
state = 1;
}
break;
case QXmlStreamReader::EndElement:
elemName = "";
if(rd.name() == "header"){
state = 0;
}
break;
case QXmlStreamReader::Characters:
switch(state){
case 1:
if(elemName == "name") mdl->setName(rd.text().toString());
if(elemName == "network") mdl->selectNetwork(rd.text().toString());
if(elemName == "dataset") mdl->selectDataset(rd.text().toString());
break;
}
break;
default:
break;
}
}
//error handling
if(rd.hasError()){
QMessageBox msgBox;
msgBox.setWindowTitle(tr("Open dataset test"));
msgBox.setText(tr("Error parsing dataset test file !!!"));
msgBox.setInformativeText(rd.errorString());
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();
file.close();
delete mdl;
return NULL;
}
file.close();
return mdl;
}
QString read_item( const Outlook::_AppointmentItemPtr &item, QXmlStreamReader &reader, bool dump_exception )
{
TRACE(OutlookSyncPlugin) << "OutlookDatebookSync::read_item";
Outlook::UserPropertiesPtr props = item->GetUserProperties();
Q_ASSERT(props);
// We need to clear the recurrence pattern now or we will fail to update recurring events
if ( !dump_exception )
item->ClearRecurrencePattern();
enum State {
Idle, When, Alarm, Repeat, Exception, Categories
};
State state = Idle;
Outlook::RecurrencePatternPtr recpat = 0;
QString key;
QXmlStreamAttributes attributes;
QString value;
QStringList categories;
bool utc = false;
bool allday = false;
while (!reader.atEnd()) {
bool loop = true;
switch(reader.readNext()) {
case QXmlStreamReader::StartElement:
key = reader.qualifiedName().toString();
value = QString();
attributes = reader.attributes();
if ( key == "When" )
state = When;
if ( state == When && key == "StartDate" ) {
allday = true;
}
if ( state == When && key == "Start" ) {
allday = false;
}
if ( key == "Alarm" ) {
state = Alarm;
LOG() << "item->PutReminderSet" << false;
item->PutReminderSet( false );
}
if ( state == Alarm && key == "Type" || key == "Delay" ) {
// Outlook only wants to see alarms set on events in the future
// If we sync an event in the past with an alarm it will go off
// immediately, something that can be annoying when you do an
// initial sync with lots of events with alarms.
if ( date_to_qdatetime(item->GetStart()) > QDateTime::currentDateTime() ) {
LOG() << "item->PutReminderSet" << true;
item->PutReminderSet( true );
}
}
if ( !dump_exception ) {
if ( key == "Repeat" ) {
state = Repeat;
}
if ( state == Repeat && key == "Type" ) {
recpat = item->GetRecurrencePattern();
recpat->PutPatternStartDate( item->GetStart() );
}
if ( state == Repeat && key == "Exception" ) {
state = Exception;
}
}
if ( key == "Categories" )
state = Categories;
break;
case QXmlStreamReader::Characters:
value += reader.text().toString();
break;
case QXmlStreamReader::EndElement:
key = reader.qualifiedName().toString();
//LOG() << "key" << key << "value" << value;
READ_STRING(Description,Subject);
READ_STRING(Location,Location);
if ( key == "TimeZone" ) {
utc = ( !value.isEmpty() );
}
if ( state == When ) {
if ( allday ) {
item->PutAllDayEvent( true );
READ_DATE(StartDate,Start);
// We can't just read the end date because Outlook does it differently to Qtopia.
// Qtopia gives us something like "starts 7/10/08, ends 7/10/08" but Outlook
// expects "starts 7/10/08 00:00:00, ends 8/10/08 00:00:00".
// Simply add one day to the end date to get something Outlook won't barf over.
if ( key == "EndDate" ) {
QDate dt = stringToDate(value);
QDateTime actual( dt.addDays(1), QTime(0,0,0) );
LOG() << "item->PutEnd" << actual;
item->PutEnd( qdatetime_to_date(actual) );
}
} else {
item->PutAllDayEvent( false );
if ( key == "Start" ) {
QDateTime dt = stringToDateTime(value, utc);
if ( utc ) {
dt.setTimeSpec( Qt::UTC );
dt = dt.toLocalTime();
}
LOG() << "item->PutStart" << dt;
item->PutStart( qdatetime_to_date(dt) );
}
if ( key == "End" ) {
QDateTime dt = stringToDateTime(value, utc);
if ( utc ) {
dt.setTimeSpec( Qt::UTC );
dt = dt.toLocalTime();
}
LOG() << "item->PutEnd" << dt;
item->PutEnd( qdatetime_to_date(dt) );
}
}
if ( key == "When" )
state = Idle;
}
if ( state == Alarm ) {
READ_ENUM(Type,ReminderPlaySound,true,Audible);
READ_ENUM(Type,ReminderPlaySound,false,Visible);
READ_INT(Delay,ReminderMinutesBeforeStart);
if ( key == "Alarm" )
state = Idle;
}
if ( dump_exception == false && state == Repeat ) {
READ_ENUM_ITEM(Type,RecurrenceType,Outlook::olRecursDaily,Daily,recpat);
READ_ENUM_ITEM(Type,RecurrenceType,Outlook::olRecursWeekly,Weekly,recpat);
READ_ENUM_ITEM(Type,RecurrenceType,Outlook::olRecursMonthly,MonthlyDate,recpat);
READ_ENUM_ITEM(Type,RecurrenceType,Outlook::olRecursMonthNth,MonthlyDay,recpat);
READ_ENUM_ITEM(Type,RecurrenceType,Outlook::olRecursMonthNth,MonthlyEndDay,recpat);
READ_ENUM_ITEM(Type,RecurrenceType,Outlook::olRecursYearly,Yearly,recpat);
if ( key == "Type" ) {
if ( value == "MonthlyEndDay" ) {
LOG() << "recpat->PutInstance" << 5;
recpat->PutInstance( 5 );
}
}
if ( key == "Frequency" ) {
int interval = QVariant(value).toInt();
if ( interval >= 12 && interval % 12 == 0 ) {
// since interval is bigger than 12 yet divisible by 12 this is more
// likely to be a YearNth which Qtopia Sync Agent sends down as a
// MonthNth with interval *= 12
recpat->PutRecurrenceType( Outlook::olRecursYearNth );
}
LOG() << "recpat->PutInterval" << interval;
recpat->PutInterval( interval );
}
if ( key == "Until" ) {
if ( value.isEmpty() ) {
LOG() << "recpat->PutNoEndDate" << true;
recpat->PutNoEndDate( true );
} else {
LOG() << "recpat->PutPatternEndDate" << QDateTime( stringToDate(value), QTime(0,0,0) );
recpat->PutPatternEndDate( qdatetime_to_date(QDateTime( stringToDate(value), QTime(0,0,0) )) );
}
}
// Outlook doesn't seem to support Nearest == false (so ignore it)
if ( key == "WeekMask" ) {
int mask = 0;
foreach( const QString &v, value.split(" ") ) {
if ( v == "Monday" ) mask |= Outlook::olMonday;
else if ( v == "Tuesday" ) mask |= Outlook::olTuesday;
else if ( v == "Wednesday" ) mask |= Outlook::olWednesday;
else if ( v == "Thursday" ) mask |= Outlook::olThursday;
else if ( v == "Friday" ) mask |= Outlook::olFriday;
else if ( v == "Saturday" ) mask |= Outlook::olSaturday;
else if ( v == "Sunday" ) mask |= Outlook::olSunday;
}
LOG() << "recpat->PutDayOfWeekMask" << mask;
recpat->PutDayOfWeekMask( (Outlook::OlDaysOfWeek)mask );
}
if ( key == "Repeat" )
state = Idle;
}
if ( dump_exception == false && state == Exception ) {
if ( key == "OriginalDate" ) {
QDate exceptionDate = stringToDate(value);
Outlook::_AppointmentItemPtr eitem = recpat->GetOccurrence( qdatetime_to_date(QDateTime( exceptionDate, QTime(0,0,0) )) );
QString entryid = read_item( eitem, reader, true );
if ( entryid.isEmpty() )
state = Repeat; // the delete case eats the closing Exception tag
}
if ( key == "Exception" ) {
state = Repeat;
}
}
READ_STRING(Notes,Body);
if ( state == Categories ) {
if ( key == "Category" )
categories << value;
if ( key == "Categories" ) {
LOG() << "item->PutCategories" << categories;
item->PutCategories( qstring_to_bstr(categories.join(", ")) );
state = Idle;
}
}
READ_CUSTOM(TimeZone,Qtopia Timezone);
if ( dump_exception && key == "Appointment" )
loop = false;
if ( dump_exception && key == "Exception" ) {
// Oops... no Appointment tag in an Exception tag
// That means we need to delete the existing exception
item->Delete();
return QString();
}
}
void CoordXmlTest::readHumanReadableStream()
{
namespace literal = XmlStreamLiteral;
QFETCH(int, num_coords);
MapCoordVector coords(num_coords, proto_coord);
buffer.buffer().truncate(0);
QBuffer header;
{
QXmlStreamWriter xml(&header);
header.open(QBuffer::ReadWrite);
xml.setAutoFormatting(false);
xml.writeStartDocument();
xml.writeStartElement("root");
xml.writeCharacters(""); // flush root start element
buffer.open(QBuffer::ReadWrite);
xml.setDevice(&buffer);
xml.writeStartElement("coords");
// Using the more efficient string implementation.
writeHumanReadableString_implementation(coords, xml);
xml.writeEndElement();
xml.setDevice(NULL);
buffer.close();
header.close();
}
header.open(QBuffer::ReadOnly);
buffer.open(QBuffer::ReadOnly);
QXmlStreamReader xml;
xml.addData(header.buffer());
xml.readNextStartElement();
QCOMPARE(xml.name().toString(), QString("root"));
bool failed = false;
QBENCHMARK
{
// benchmark iteration overhead
coords.clear();
xml.addData(buffer.data());
xml.readNextStartElement();
if (xml.name() != "coords")
{
failed = true;
break;
}
for( xml.readNext();
xml.tokenType() != QXmlStreamReader::EndElement;
xml.readNext() )
{
if (xml.error())
{
qDebug() << xml.errorString();
failed = true;
break;
}
const QXmlStreamReader::TokenType token = xml.tokenType();
if (token == QXmlStreamReader::EndDocument)
{
failed = true;
break;
}
if (token == QXmlStreamReader::Characters && !xml.isWhitespace())
{
QStringRef text = xml.text();
QString data = QString::fromRawData(text.constData(), text.length());
QTextStream stream(&data, QIODevice::ReadOnly);
stream.setIntegerBase(10);
while (!stream.atEnd())
{
qint32 x, y;
int flags = 0;
char separator;
stream >> x >> y >> separator;
if (separator != ';')
{
stream >> flags >> separator;
}
coords.push_back(MapCoord::fromNative(x, y, flags));
}
if (stream.status() == QTextStream::ReadCorruptData)
{
failed = true;
break;
}
}
// otherwise: ignore element
}
int formMergeSlideCalibrations
::funcReadSensitivities(
const QString &filePath,
structSlideStrSens* slideStrSens
){
QFile *xmlFile = new QFile( filePath );
if (!xmlFile->open(QIODevice::ReadOnly | QIODevice::Text)) {
return _ERROR;
}
QXmlStreamReader *xmlReader = new QXmlStreamReader(xmlFile);
//Parse the XML until we reach end of it
while(!xmlReader->atEnd() && !xmlReader->hasError()) {
// Read next element
QXmlStreamReader::TokenType token = xmlReader->readNext();
if(token == QXmlStreamReader::StartDocument) {
continue;
}
//If token is StartElement - read it
if(token == QXmlStreamReader::StartElement)
{
if( xmlReader->name()=="normedOrigR" )
slideStrSens->normedOrigR.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="normedOrigG" )
slideStrSens->normedOrigG.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="normedOrigB" )
slideStrSens->normedOrigB.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="normedRalfR" )
slideStrSens->normedRalfR.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="normedRalfG" )
slideStrSens->normedRalfG.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="normedRalfB" )
slideStrSens->normedRalfB.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="normedRalfH" )
slideStrSens->normedRalfH.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="originalR" )
slideStrSens->originalR.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="originalG" )
slideStrSens->originalG.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="originalB" )
slideStrSens->originalB.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="originalH" )
slideStrSens->originalH.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="wR" )
slideStrSens->wR.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="wG" )
slideStrSens->wG.append( xmlReader->readElementText().trimmed() );
if( xmlReader->name()=="wB" )
slideStrSens->wB.append( xmlReader->readElementText().trimmed() );
}
}
if(xmlReader->hasError()) {
funcShowMsg("Parse Error",xmlReader->errorString());
return _ERROR;
}
xmlReader->clear();
xmlFile->close();
slideStrSens->filled = 1;
return _OK;
}
void RssParser::parseAtomArticle(QXmlStreamReader& xml, const QString& feedUrl, const QString& baseUrl)
{
QVariantHash article;
bool double_content = false;
while(!xml.atEnd()) {
xml.readNext();
if(xml.isEndElement() && xml.name() == "entry")
break;
if (xml.isStartElement()) {
if (xml.name() == "title") {
// Workaround for CDATA (QString cannot parse html escapes on it's own)
QTextDocument doc;
doc.setHtml(xml.readElementText());
article["title"] = doc.toPlainText();
}
else if (xml.name() == "link") {
QString theLink = ( xml.attributes().isEmpty() ?
xml.readElementText() :
xml.attributes().value("href").toString() );
// Atom feeds can have relative links, work around this and
// take the stress of figuring article full URI from UI
// Assemble full URI
article["news_link"] = ( baseUrl.isEmpty() ?
theLink :
baseUrl + theLink );
}
else if (xml.name() == "summary" || xml.name() == "content"){
if(double_content) { // Duplicate content -> ignore
xml.readNext();
while(xml.name() != "summary" && xml.name() != "content")
xml.readNext();
continue;
}
// Try to also parse broken articles, which don't use html '&' escapes
// Actually works great for non-broken content too
QString feedText = xml.readElementText(QXmlStreamReader::IncludeChildElements);
if (!feedText.isEmpty())
article["description"] = feedText;
double_content = true;
}
else if (xml.name() == "updated"){
// ATOM uses standard compliant date, don't do fancy stuff
QDateTime articleDate = QDateTime::fromString(xml.readElementText(), Qt::ISODate);
article["date"] = ( articleDate.isValid() ?
articleDate :
QDateTime::currentDateTime() );
}
else if (xml.name() == "author") {
xml.readNext();
while(xml.name() != "author") {
if(xml.name() == "name")
article["author"] = xml.readElementText();
xml.readNext();
}
}
else if (xml.name() == "id")
article["id"] = xml.readElementText();
}
}
if (!article.contains("id")) {
// Item does not have a guid, fall back to some other identifier
const QString link = article.value("news_link").toString();
if (!link.isEmpty())
article["id"] = link;
else {
const QString title = article.value("title").toString();
if (!title.isEmpty())
article["id"] = title;
else {
qWarning() << "Item has no guid, link or title, ignoring it...";
return;
}
}
}
emit newArticle(feedUrl, article);
}
/*!
* Read out a widget within a category. This can either be
* enclosed in a <ui> element or a (legacy) <widget> element which may
* contain nested <widget> elements.
*
* Examples:
*
* <ui language="c++">
* <widget class="MultiPageWidget" name="multipagewidget"> ... </widget>
* <customwidgets>...</customwidgets>
* <ui>
*
* or
*
* <widget>
* <widget> ... </widget>
* ...
* <widget>
*
* Returns true on success, false if end was reached or an error has been encountered
* in which case the reader has its error flag set. If successful, the current item
* of the reader will be the closing element (</ui> or </widget>)
*/
bool WidgetBoxTreeWidget::readWidget(Widget *w, const QString &xml, QXmlStreamReader &r)
{
qint64 startTagPosition =0, endTagPosition = 0;
int nesting = 0;
bool endEncountered = false;
bool parsedWidgetTag = false;
QString outmostElement;
while (!endEncountered) {
const qint64 currentPosition = r.characterOffset();
switch(r.readNext()) {
case QXmlStreamReader::StartElement:
if (nesting++ == 0) {
// First element must be <ui> or (legacy) <widget>
const QStringRef name = r.name();
if (name == QLatin1String(uiElementC)) {
startTagPosition = currentPosition;
} else {
if (name == QLatin1String(widgetElementC)) {
startTagPosition = currentPosition;
parsedWidgetTag = true;
} else {
r.raiseError(QDesignerWidgetBox::tr("Unexpected element <%1> encountered when parsing for <widget> or <ui>").arg(name.toString()));
return false;
}
}
} else {
// We are within <ui> looking for the first <widget> tag
if (!parsedWidgetTag && r.name() == QLatin1String(widgetElementC)) {
parsedWidgetTag = true;
}
}
break;
case QXmlStreamReader::EndElement:
// Reached end of widget?
if (--nesting == 0) {
endTagPosition = r.characterOffset();
endEncountered = true;
}
break;
case QXmlStreamReader::EndDocument:
r.raiseError(QDesignerWidgetBox::tr("Unexpected end of file encountered when parsing widgets."));
return false;
case QXmlStreamReader::Invalid:
return false;
default:
break;
}
}
if (!parsedWidgetTag) {
r.raiseError(QDesignerWidgetBox::tr("A widget element could not be found."));
return false;
}
// Oddity: Startposition is 1 off
QString widgetXml = xml.mid(startTagPosition, endTagPosition - startTagPosition);
const QChar lessThan = QLatin1Char('<');
if (!widgetXml.startsWith(lessThan))
widgetXml.prepend(lessThan);
w->setDomXml(widgetXml);
return true;
}
void SaveManager::parseEntity(World * world, QXmlStreamReader& reader)
{
QString type;
double xEntity=0.0, yEntity=0.0, radiusEntity=config::INITIAL_RADIUS;
double angle = 0.0;
int maxSpeed = config::MAX_SPEED;
double attack = -2.0;
double energy = config::DEFAULT_ENERGY;
bool sex = true;
NeuralNetwork * nn = nullptr;
int mating = 0;
int age = 0;
int quantity = 0, maxQuantity = 0;
int hunger = 0;
int thirst = 0;
int health = config::MAX_HEALTH;
if(reader.tokenType() != QXmlStreamReader::StartElement ||
reader.name() != "Entity")
{ //error
std::cout << "reader name is not a entity" << std::endl;
}
QXmlStreamAttributes attributes = reader.attributes();
if(attributes.hasAttribute("type"))
{
type = attributes.value("type").toString();
}
else
{ //error
std::cout << "No Attribute type" << std::endl;
return;
}
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "Entity"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if(reader.name() == "x")
{
xEntity = reader.readElementText().toDouble();
}
else if(reader.name() == "y")
{
yEntity = reader.readElementText().toDouble();
}
else if(reader.name() == "radius")
{
radiusEntity = reader.readElementText().toDouble();
}
else if(reader.name() == "angle")
{
angle = reader.readElementText().toDouble();
}
else if(reader.name() == "attack")
{
attack = reader.readElementText().toDouble();
}
else if(reader.name() == "energy")
{
energy = reader.readElementText().toDouble();
}
else if(reader.name() == "sex")
{
sex = (reader.readElementText().toLower()=="true");
}
else if(reader.name() == "maxSpeed")
{
maxSpeed = reader.readElementText().toInt();
}
else if(reader.name() == "NeuralNetwork")
{
SaveManager savManager;
nn = savManager.LoadNetwork(reader);
}
else if(reader.name() == "mating")
{
mating = reader.readElementText().toInt();
}
else if(reader.name() == "age")
{
age = reader.readElementText().toInt();
}
else if(reader.name() == "quantity")
{
quantity = reader.readElementText().toInt();
}
else if(reader.name() == "maxQuantity")
{
maxQuantity = reader.readElementText().toInt();
}
else if(reader.name() == "hunger")
{
hunger = reader.readElementText().toInt();
}
else if(reader.name() == "thirst")
{
thirst = reader.readElementText().toInt();
}
else if(reader.name() == "health")
{
health = reader.readElementText().toInt();
}
else
{ //error
}
}
reader.readNext();
}
if(type == "Vegetal")
{
if(maxQuantity==0)
maxQuantity=config::VEGETAL_MAXQUANTITY;
if(quantity==0)
quantity=maxQuantity;
std::shared_ptr<Vegetal> entity( std::make_shared<Vegetal>(xEntity, yEntity, radiusEntity, maxQuantity));
entity->setCurrantQuantity(quantity);
world->addEntity(entity);
}
else if(type == "Water")
{
if(maxQuantity==0)
maxQuantity=config::WATER_MAXQUANTITY;
if(quantity==0)
quantity=maxQuantity;
std::shared_ptr<Water> entity( std::make_shared<Water>(xEntity, yEntity, radiusEntity, maxQuantity));
entity->setCurrantQuantity(quantity);
world->addEntity(entity);
}
else if(type == "Meat")
{
std::shared_ptr<Meat> entity( std::make_shared<Meat>(xEntity, yEntity, radiusEntity, maxQuantity));
entity->setCurrantQuantity(quantity);
world->addEntity(entity);
}
else if(type == "Herbivore")
{
if(nn == nullptr)
{
std::vector<unsigned int> layerSizes;
for(unsigned int i = 0; i < NB_LAYERS; i++)
{
layerSizes.push_back(LAYER_SIZES[i]);
}
nn = new NeuralNetwork(layerSizes);
}
if(attack==-2)
attack = config::ATTACK_HERBIVORE;
std::shared_ptr<Herbivore> entity( std::make_shared<Herbivore>(xEntity, yEntity,maxSpeed, attack, energy, 0, world, nn, mating));
entity->setSex(sex);
entity->setAge(age);
entity->setAngle(angle);
entity->setHunger(hunger);
entity->setThirst(thirst);
entity->setHealth(health);
world->addEntity(entity);
}
else if(type == "Carnivore")
{
if(nn == nullptr)
{
std::vector<unsigned int> layerSizes;
for(unsigned int i = 0; i < NB_LAYERS; i++)
{
layerSizes.push_back(LAYER_SIZES[i]);
}
nn = new NeuralNetwork(layerSizes);
}
if(attack==-2)
attack = config::ATTACK_CARNIVORE;
std::shared_ptr<Carnivore> entity( std::make_shared<Carnivore>(xEntity, yEntity,maxSpeed, attack, energy, 0, world, nn, mating));
entity->setSex(sex);
entity->setAge(age);
entity->setAngle(angle);
entity->setHunger(hunger);
entity->setThirst(thirst);
entity->setHealth(health);
world->addEntity(entity);
}
}
void RhythmboxFeature::importTrack(QXmlStreamReader &xml, QSqlQuery &query) {
QString title;
QString artist;
QString album;
QString year;
QString genre;
QString location;
QUrl locationUrl;
int bpm = 0;
int bitrate = 0;
//duration of a track
int playtime = 0;
int rating = 0;
QString comment;
QString tracknumber;
while (!xml.atEnd()) {
xml.readNext();
if (xml.isStartElement()) {
if (xml.name() == "title") {
title = xml.readElementText();
continue;
}
if (xml.name() == "artist") {
artist = xml.readElementText();
continue;
}
if (xml.name() == "genre") {
genre = xml.readElementText();
continue;
}
if (xml.name() == "album") {
album = xml.readElementText();
continue;
}
if (xml.name() == "track-number") {
tracknumber = xml.readElementText();
continue;
}
if (xml.name() == "duration") {
playtime = xml.readElementText().toInt();;
continue;
}
if (xml.name() == "bitrate") {
bitrate = xml.readElementText().toInt();
continue;
}
if (xml.name() == "beats-per-minute") {
bpm = xml.readElementText().toInt();
continue;
}
if (xml.name() == "comment") {
comment = xml.readElementText();
continue;
}
if (xml.name() == "location") {
locationUrl = QUrl::fromEncoded(xml.readElementText().toUtf8());
continue;
}
}
//exit the loop if we reach the closing <entry> tag
if (xml.isEndElement() && xml.name() == "entry") {
break;
}
}
location = locationUrl.toLocalFile();
if (location.isEmpty()) {
// here in case of smb:// location
// TODO(XXX) QUrl does not support SMB:// locations does Mixxx?
// use ~/.gvfs location instead
return;
}
query.bindValue(":artist", artist);
query.bindValue(":title", title);
query.bindValue(":album", album);
query.bindValue(":genre", genre);
query.bindValue(":year", year);
query.bindValue(":duration", playtime);
query.bindValue(":location", location);
query.bindValue(":rating", rating);
query.bindValue(":comment", comment);
query.bindValue(":tracknumber", tracknumber);
query.bindValue(":bpm", bpm);
query.bindValue(":bitrate", bitrate);
bool success = query.exec();
if (!success) {
qDebug() << "SQL Error in rhythmboxfeature.cpp: line" << __LINE__
<< " " << query.lastError();
return;
}
}
void XSPFParser::readTrack(QXmlStreamReader & xml, MediaInfo & mediaInfo) const {
while (!xml.atEnd() && !_stop) {
xml.readNext();
QString element(xml.name().toString());
if (xml.isStartElement()) {
//Filename
if (element == XSPF_LOCATION) {
QUrl url = QUrl::fromEncoded(xml.readElementText().toUtf8());
QString location(url.toString());
bool isUrl = MediaInfo::isUrl(location);
mediaInfo.setUrl(isUrl);
if (isUrl) {
mediaInfo.setFileName(location);
} else {
QString path(QFileInfo(_filename).path());
mediaInfo.setFileName(Util::canonicalFilePath(path, location));
}
}
//Unique ID
else if (element == XSPF_IDENTIFIER) {
QString identifier(xml.readElementText());
//FIXME not implemented yet
}
//Artist
else if (element == XSPF_CREATOR) {
QString creator(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::Artist, creator);
}
//Album
else if (element == XSPF_ALBUM) {
QString album(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::Album, album);
}
//Track number
else if (element == XSPF_TRACKNUM) {
QString trackNum(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::TrackNumber, trackNum);
}
//Title
else if (element == XSPF_TITLE) {
QString title(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::Title, title);
}
//Comment
else if (element == XSPF_ANNOTATION) {
QString annotation(xml.readElementText());
if (mediaInfo.metadataValue(MediaInfo::Title).isEmpty()) {
//Some people didn't understand how XSPF works
//and confused annotation with title
mediaInfo.insertMetadata(MediaInfo::Title, annotation);
}
mediaInfo.insertMetadata(MediaInfo::Comment, annotation);
}
//Length
else if (element == XSPF_DURATION) {
int duration = xml.readElementText().toInt();
//XSPF gives us the duration in milliseconds
//Let's convert it to seconds
mediaInfo.setLength(duration / 1000);
}
//Album art URL
else if (element == XSPF_IMAGE) {
QString image(xml.readElementText());
//FIXME not implemented yet
//mediaInfo.insertMetadata(MediaInfo::AlbumArt, image);
}
//URL of the original web page
else if (element == XSPF_INFO) {
QString info(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::URL, info);
}
//Meta
else if (element == XSPF_META) {
//These tags are specific to foobar2000 XSPF plugin
QXmlStreamAttributes attributes = xml.attributes();
//Date
if (attributes.hasAttribute(XSPF_FOOBAR2000_DATE)) {
QString date(attributes.value(XSPF_FOOBAR2000_DATE).toString());
mediaInfo.insertMetadata(MediaInfo::Year, date);
}
//Genre
else if (attributes.hasAttribute(XSPF_FOOBAR2000_GENRE)) {
QString genre(attributes.value(XSPF_FOOBAR2000_GENRE).toString());
mediaInfo.insertMetadata(MediaInfo::Genre, genre);
}
}
else if (element == XSPF_EXTENSION) {
QString xspfNamespace(xml.attributes().value(XSPF_APPLICATION).toString());
if (xspfNamespace == XSPF_QUARKPLAYER_NAMESPACE) {
while (!xml.atEnd() && !_stop) {
xml.readNext();
QString extensionElement(xml.name().toString());
if (xml.isStartElement()) {
if (extensionElement == XSPF_QUARKPLAYER_CUE_START_INDEX) {
QString cueStartIndex(xml.readElementText());
mediaInfo.setCueStartIndex(cueStartIndex);
}
else if (extensionElement == XSPF_QUARKPLAYER_CUE_END_INDEX) {
QString cueEndIndex(xml.readElementText());
mediaInfo.setCueEndIndex(cueEndIndex);
}
else if (extensionElement == XSPF_QUARKPLAYER_YEAR) {
QString year(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::Year, year);
}
else if (extensionElement == XSPF_QUARKPLAYER_GENRE) {
QString genre(xml.readElementText());
mediaInfo.insertMetadata(MediaInfo::Genre, genre);
}
}
if (xml.isEndElement()) {
if (extensionElement == XSPF_EXTENSION) {
break;
}
}
}
}
}
}
if (xml.isEndElement()) {
if (element == XSPF_TRACK) {
return;
}
}
}
}
int SaveManager::parseNeuralNetwork(QXmlStreamReader& reader, std::vector<std::vector<std::vector<double> > > &neuronWeights)
{ QString weights;
QXmlStreamAttributes attributes;
int inputsNum=0;
if (reader.tokenType() != QXmlStreamReader::StartElement || reader.name() != "NeuralNetwork")
{ std::cout << "Error in reading NeuralNetwork" << std::endl;
}
reader.readNext();
reader.readNext();
while (!(reader.tokenType() == QXmlStreamReader::EndElement && reader.name() == "NeuralNetwork"))
{ attributes = reader.attributes();
// Input layer management
if (reader.name() == "NeuronLayer" && attributes.hasAttribute("id") && attributes.value("id").toString() == "0")
{ reader.readNext();
reader.readNext();
inputsNum=reader.readElementText().toInt();
reader.readNext();
reader.readNext();
reader.readNext();
reader.readNext();
} else if (reader.name() == "NeuronLayer" && attributes.hasAttribute("id"))
// General layer management
{ std::vector<std::vector<double> > neuronsArray;
reader.readNext();
reader.readNext();
while (!(reader.tokenType() == QXmlStreamReader::EndElement && reader.name() == "NeuronLayer"))
{ attributes = reader.attributes();
if (reader.name() == "Neuron" && attributes.hasAttribute("id"))
// Neuron management
{ std::vector<double> weightsArray;
reader.readNext();
reader.readNext();
if (reader.name() == "weights")
{ weights=reader.readElementText();
parseWeights(weights,weightsArray);
} else
// error
{ std::cout << "Error during the loading (Neuron management)" << std::endl;
}
neuronsArray.push_back(weightsArray);
reader.readNext();
reader.readNext();
reader.readNext();
reader.readNext();
} else
// error
{ std::cout << "Error during the loading (General layer management)" << std::endl;
}
}
neuronWeights.push_back(neuronsArray);
reader.readNext();
reader.readNext();
} else
// error
{ std::cout << "Error during the loading" << std::endl;
}
}
return inputsNum;
}
void Parser::parseFiles(QNetworkReply *reply, QMap<QNetworkReply*, Structureelement*> *replies, QString downloadDirectoryPath)
{
// Holen die aktuelle Veranstaltung aus der Map
Structureelement* aktuellerOrdner = replies->value(reply);
// Auslesen der Antwort und Speichern in dem XmlReader
QString replyText = reply->readAll();
QXmlStreamReader Reader;
Reader.addData(replyText);
// Vorbereitung der Daten für die Elemente
QString currentXmlTag;
QUrl url;
QString name;
QString time;
qint32 size = 0;
// Prüfen auf das Ende
while(!Reader.atEnd())
{
// Lese nächstes Element
Reader.readNext();
// 1. Fall: Öffnendes Element <Element>
if(Reader.isStartElement())
{
// Speichern des Namens
currentXmlTag = Reader.name().toString();
}
// 2. Fall: Schließendes Element mit Namen Response </Response>
else if (Reader.isEndElement() && Reader.name() == "response")
{
// Hinzufügen des Slashs bei der Url von Ordnern
if(!size)
url.setUrl(url.toString() % "/");
// Wechsel in den übergeordneten Ordner des aktuellen Elements
QString bla = url.toString();
while(!url.toString().contains((aktuellerOrdner->data(urlRole).toUrl().toString()), Qt::CaseSensitive))//(in = RegExp.indexIn(url.toString())) == -1)
{
aktuellerOrdner->sortChildren(0, Qt::AscendingOrder);
aktuellerOrdner = (Structureelement*)aktuellerOrdner->parent();
if (aktuellerOrdner == 0)
qDebug() << replyText;
}
// Ignorieren aller Adressen, die "/Forms" enthalten
if (!url.toString().contains("/Forms", Qt::CaseSensitive))
{
// Prüfe auf Elementart
// 1. Fall: Datei (size > 0)
if (size)
{
// Erstellen einer neuen Datei
Structureelement* newFile = new Structureelement(name, url, time, size);
// Hinzufügen des endungsabhängigen Icons
// PDF
if (name.contains(QRegExp(".pdf$", Qt::CaseInsensitive)))
newFile->setData(QIcon(":/Icons/Icons/filetype_pdf.png"), Qt::DecorationRole);
// ZIP
else if (name.contains(QRegExp(".zip$", Qt::CaseInsensitive)))
newFile->setData(QIcon(":/Icons/Icons/filetype_zip.png"), Qt::DecorationRole);
// RAR
else if (name.contains(QRegExp(".rar$", Qt::CaseInsensitive)))
newFile->setData(QIcon(":/Icons/Icons/filetype_rar.png"), Qt::DecorationRole);
// Sonstige
else
newFile->setData(QIcon(":/Icons/Icons/file.png"), Qt::DecorationRole);
QString path;
path.append(Utils::getStrukturelementPfad(aktuellerOrdner, downloadDirectoryPath) %"/");
path.append(name);
path.remove(0,8);
if(QFile::exists(path))
{
newFile->setData(SYNCHRONISED, synchronisedRole);
}
else
{
newFile->setData(NOT_SYNCHRONISED, synchronisedRole);
}
QList<QStandardItem*> row;
row.append(newFile);
row.append(new QStandardItem(QString::number(size/1024.0/1024.0, 'f', 2) % " MB"));
row.append(new QStandardItem(QDateTime::fromString(time, Qt::ISODate).toString("yyyy-MM-dd hh:mm")));
// Hinzufügen zum aktuellen Ordner
aktuellerOrdner->appendRow(row);
}
// 2. Fall: Ordner/Veranstaltung
// Ausschließen der Ordnernamen "documents" und "structured"
else if (name != "documents" && name != "structured" && !url.toString().contains("exerciseCourse"))
{
// Erstellen eines neuen Ordners
Structureelement* newDirectory = new Structureelement(name, url, directoryItem);
// Setzen des Zeichens
newDirectory->setData(QIcon(":/Icons/Icons/25_folder.png"), Qt::DecorationRole);
// Hinzufügen zum aktuellen Ordner
aktuellerOrdner->appendRow(newDirectory);
// NeuerOrdner wird zum aktuellen Ordner
aktuellerOrdner = newDirectory;
}
}
// Löschen aller eingelesener Daten
url.clear();
name.clear();
size = 0;
time.clear();
}
// Einlesen der Elementeigenschaften
else if (Reader.isCharacters() && !Reader.isWhitespace())
{
// URL
if(currentXmlTag == "href" && url.isEmpty())
url.setUrl(QString::fromUtf8(Reader.text().toString().toLatin1()));
// Name
else if (currentXmlTag == "displayname")
name = QString::fromUtf8(Reader.text().toString().toLatin1());
// Größe
else if (currentXmlTag == "getcontentlength")
size = Reader.text().toString().toInt();
// Modifizierungsdatum
else if (currentXmlTag == "getlastmodified")
time = QString::fromUtf8(Reader.text().toString().toLatin1());
}
}
// Leere Ordner wieder rausschmeißen.
Structureelement* rootCourse = replies->value(reply);
for (int i = 0; i < rootCourse->rowCount(); i++)
{
Structureelement *item = (Structureelement *)rootCourse->child(i);
if (item->type() == directoryItem && item->rowCount() == 0)
{
rootCourse->removeRow(i);
}
}
// Sortieren aller Dateien
replies->value(reply)->sortChildren(0, Qt::AscendingOrder);
}
void LapTimerThread::writeTxt()
{
QTextStream tmp(&infoFile);
QXmlStreamReader xmlReader;
qWarning()<<coordTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&coordTmpFile);
xmlReader.readNext();
int lapNum=0;
//Reading from the file
xmlReader.readNext();
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if (name == "lap")
{
lapNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
qWarning()<<lapNum;
coordTmpFile.close();
for (int s=0;s<(lapNum-1);s++)
{
qWarning()<<"entering lap "<<s;
tmp<<"-**********************************************\r\n";
tmp<< "Map: " <<mapName<<"\r\n";
qWarning()<<"header";
xmlReader.clear();
coordTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&coordTmpFile);
xmlReader.readNext();
int lapTmpNum=0;
bool lapNumFlag=false;
xmlTextBuffer.clear();
//Reading from the file
QString start;
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if ((name == "when")&& lapNumFlag)//read time of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==s)?true:false;
if (lapNumFlag)
start = xmlReader.attributes().value("start").toString();
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
coordTmpFile.close();
tmp<< "Start Time: "<< QString(start).replace(QRegExp("[TZ]")," ")<<"\r\n";
//tmp<< "End Time: "<< QString(xmlTextBuffer.last()).replace(QRegExp("[TZ]")," ")<<"\r\n";
//tmp<< "Duration: "<< QTime::fromMSecsSinceStartOfDay(QTime::fromString(QString(xmlTextBuffer.first()).section(QRegExp("[TZ]"),1,1),"hh:mm:ss.zzz")
//.msecsTo(QTime::fromString(QString(xmlTextBuffer.last()).section(QRegExp("[TZ]"),1,1),"hh:mm:ss.zzz"))).toString("hh:mm:ss.zzz")<<"\r\n";
xmlReader.clear();
coordTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&coordTmpFile);
xmlReader.readNext();
lapTmpNum=0;
lapNumFlag=false;
xmlTextBuffer.clear();
//Reading from the file
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if ((name == "coord")&& lapNumFlag)//read coord of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==s)?true:false;
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
coordTmpFile.close();
double distance = 0;
double maxAlt = 0, minAlt = 10000;
QList <QString>::iterator i;
for (i=xmlTextBuffer.begin();i!=xmlTextBuffer.end();++i)
{
if ((i+1) == xmlTextBuffer.end())
{
QList <QString>::iterator ii = xmlTextBuffer.begin();
distance +=dist(i->split(" ").at(1).toDouble(),ii->split(" ").at(1).toDouble(),i->split(" ").at(0).toDouble(),ii->split(" ").at(0).toDouble(),true);
}
else
{
distance += dist(i->split(" ").at(1).toDouble(),(i+1)->split(" ").at(1).toDouble(),i->split(" ").at(0).toDouble(),(i+1)->split(" ").at(0).toDouble(),true);
}
minAlt = (i->split(" ").at(2).toDouble()<minAlt)?(i->split(" ").at(2).toDouble()):minAlt;
maxAlt = (i->split(" ").at(2).toDouble()>maxAlt)?(i->split(" ").at(2).toDouble()):maxAlt;
}
tmp<< "Distance: "<< QString::number((int)distance)<<" m"<<"\r\n";
tmp<< "Max Alt: "<< QString::number(maxAlt,'f',4)<<" m"<<"\r\n";
tmp<< "Min Alt: "<< QString::number(minAlt,'f',4)<<" m"<<"\r\n";
tmp<< "Elevation Variance:" << QString::number(maxAlt-minAlt,'f',4)<<" m"<<"\r\n";
xmlReader.clear();
speedTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&speedTmpFile);
xmlReader.readNext();
lapTmpNum=0;
lapNumFlag=false;
xmlTextBuffer.clear();
//Reading from the file
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if ((name == "speed")&& lapNumFlag)//read speed of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==s)?true:false;
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
speedTmpFile.close();
double maxSpeed = 0, minSpeed = 10000, speedSum = 0;
QList <QString>::iterator j;
for (j=xmlTextBuffer.begin();j!=xmlTextBuffer.end();++j)
{
minSpeed = (j->toDouble()<minSpeed)?(j->toDouble()):minSpeed;
maxSpeed = (j->toDouble()>maxSpeed)?(j->toDouble()):maxSpeed;
speedSum += j->toDouble();
}
tmp<< "Max Speed: "<< QString::number(maxSpeed,'f',4)<<" km/h"<<"\r\n";
tmp<< "Min Alt: "<< QString::number(minSpeed,'f',4)<<" km/h"<<"\r\n";
tmp<< "Average Speed **: "<< QString::number(speedSum/(xmlTextBuffer.size()),'f',4)<<" km/h"<<"\r\n";
xmlReader.clear();
wayptTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&wayptTmpFile);
xmlReader.readNext();
lapTmpNum=0;
lapNumFlag=false;
xmlTextBuffer.clear();
//Reading from the file
QStringList tmpWhen,tmpBest,tmpDev;
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if ((name == "time")&& lapNumFlag)//read time of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if ((name == "best")&& lapNumFlag)//read best of each element
{
tmpBest.append(xmlReader.readElementText());
}
else if ((name == "when")&& lapNumFlag)//read when of each element
{
tmpWhen.append(xmlReader.readElementText());
}
else if ((name == "dev")&& lapNumFlag)//read dev of each element
{
tmpDev.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==s)?true:false;
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
wayptTmpFile.close();
for (int k=0;k<xmlTextBuffer.length();k++)
{
if (k==(xmlTextBuffer.length()-1))
{
tmp<<"Finish Point: "<<"\r\n Time: "
<<xmlTextBuffer.at(k)<<"\r\n Best: "
<<tmpBest.at(k)<<"\r\n Time To Best: "
<<tmpDev.at(k)<<"\r\n";
}
else
{
tmp<<"Waypoint "<<QString::number(k+1)<<": "<<"\r\n Time: "
<<xmlTextBuffer.at(k)<<"\r\n Best: "
<<tmpBest.at(k)<<"\r\n Time To Best: "
<<tmpDev.at(k)<<"\r\n";
}
}
tmp<< "End Time: "<< QString(tmpWhen.last()).replace(QRegExp("[TZ]")," ")<<"\r\n";
tmp<< "Average Speed *: "<< QString::number
((distance/(QTime::fromString(start,"hh:mm:ss.zzz").msecsTo(
QTime::fromString(QString(tmpWhen.last()).section(QRegExp("[TZ]"),1,1),"hh:mm:ss.zzz"))))*3.6,'f',4)
<<"\r\n";
tmp<< "\r\n";
}
qWarning()<<"Success";
}
void LapTimerThread::writeXml()
{
QXmlStreamReader xmlReader;
coordTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&coordTmpFile);
xmlReader.readNext();
int lapNum=0;
//Reading from the file
xmlReader.readNext();
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if (name == "lap")
{
lapNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
coordTmpFile.close();
for (int i=0;i<lapNum-1;i++)// loop to generate kml file for each lap
{
QFile xmlKmlFile;
QXmlStreamWriter bufferKml;
xmlKmlFile.setFileName("data/"+dirName+"/"+dirName+"-"+QString::number(i+1)+".kml");
xmlKmlFile.open(QIODevice::WriteOnly | QIODevice::Text);
bufferKml.setDevice(&xmlKmlFile);
bufferKml.setAutoFormatting(true);
bufferKml.writeStartDocument();
bufferKml.writeStartElement("kml");
QXmlStreamAttributes atrr;
atrr.append("xmlns","http://www.opengis.net/kml/2.2");
atrr.append("xmlns:gx","http://www.google.com/kml/ext/2.2");
atrr.append("xmlns:atom","http://www.w3.org/2005/Atom");
bufferKml.writeAttributes(atrr);
bufferKml.writeStartElement("Document");
bufferKml.writeTextElement("open","1");
bufferKml.writeTextElement("visibility","1");
bufferKml.writeStartElement("name");
bufferKml.writeCDATA("GPS Lap Timer - KML Log - "+QDate::currentDate().toString("yyyyMMdd")+QTime::currentTime().toString("hhmmss"));
bufferKml.writeEndElement();
//style - track
bufferKml.writeStartElement("Style");
bufferKml.writeAttribute(QXmlStreamAttribute("id","track"));
bufferKml.writeStartElement("LineStyle");
bufferKml.writeTextElement("color","7f0000ff");
bufferKml.writeTextElement("width","4");
bufferKml.writeEndElement();
bufferKml.writeStartElement("IconStyle");
bufferKml.writeTextElement("scale","1.3");
bufferKml.writeStartElement("Icon");
bufferKml.writeTextElement("href","http://earth.google.com/images/kml-icons/track-directional/track-0.png");
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndElement();
//style - start
bufferKml.writeStartElement("Style");
bufferKml.writeAttribute(QXmlStreamAttribute("id","start"));
bufferKml.writeStartElement("IconStyle");
bufferKml.writeTextElement("scale","1.3");
bufferKml.writeStartElement("Icon");
bufferKml.writeTextElement("href","http://maps.google.com/mapfiles/kml/paddle/grn-circle.png");
bufferKml.writeEndElement();
bufferKml.writeEmptyElement("hotSpot");
atrr.clear();
atrr.append("x","32");
atrr.append("y","1");
atrr.append("xunits","pixels");
atrr.append("yunits","pixels");
bufferKml.writeAttributes(atrr);
bufferKml.writeEndElement();
bufferKml.writeEndElement();
// style - end
bufferKml.writeStartElement("Style");
bufferKml.writeAttribute(QXmlStreamAttribute("id","end"));
bufferKml.writeStartElement("IconStyle");
bufferKml.writeTextElement("scale","1.3");
bufferKml.writeStartElement("Icon");
bufferKml.writeTextElement("href","http://maps.google.com/mapfiles/kml/paddle/red-circle.png");
bufferKml.writeEndElement();
bufferKml.writeEmptyElement("hotSpot");
bufferKml.writeAttributes(atrr);
bufferKml.writeEndElement();
bufferKml.writeEndElement();
// style - statistics
bufferKml.writeStartElement("Style");
bufferKml.writeAttribute(QXmlStreamAttribute("id","statistics"));
bufferKml.writeStartElement("IconStyle");
bufferKml.writeTextElement("scale","1.3");
bufferKml.writeStartElement("Icon");
bufferKml.writeTextElement("href","http://maps.google.com/mapfiles/kml/pushpin/ylw-pushpin.png");
bufferKml.writeEndElement();
bufferKml.writeEmptyElement("hotSpot");
atrr.clear();
atrr.append("x","20");
atrr.append("y","2");
atrr.append("xunits","pixels");
atrr.append("yunits","pixels");
bufferKml.writeAttributes(atrr);
bufferKml.writeEndElement();
bufferKml.writeEndElement();
// style - waypoint
bufferKml.writeStartElement("Style");
bufferKml.writeAttribute(QXmlStreamAttribute("id","waypoint"));
bufferKml.writeStartElement("IconStyle");
bufferKml.writeTextElement("scale","1.3");
bufferKml.writeStartElement("Icon");
bufferKml.writeTextElement("href","http://maps.google.com/mapfiles/kml/pushpin/blue-pushpin.png");
bufferKml.writeEndElement();
bufferKml.writeEmptyElement("hotSpot");
bufferKml.writeAttributes(atrr);
bufferKml.writeEndElement();
bufferKml.writeEndElement();
QStringList xmlTmpTextBuffer;
int lapTmpNum=0;
bool lapNumFlag=false;
bufferKml.writeStartElement("Folder");
bufferKml.writeStartElement("name");
bufferKml.writeCDATA("Lap #"+QString::number(i+1));
bufferKml.writeEndElement();
bufferKml.writeTextElement("open","1");
//waypoints - load
xmlReader.clear();
wayptTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&wayptTmpFile);
xmlReader.readNext();
xmlTmpTextBuffer.clear();
xmlTextBuffer.clear();
lapTmpNum=0;
lapNumFlag=false;
QStringList bestBuffer,devBuffer,timeBuffer;
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if (name == "when" && lapNumFlag)//read time of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if (name == "waypt" && lapNumFlag)
{
xmlTmpTextBuffer.append(xmlReader.readElementText());
}
else if (name == "best" && lapNumFlag)
{
bestBuffer.append(xmlReader.readElementText());
}
else if (name == "time" && lapNumFlag)
{
timeBuffer.append(xmlReader.readElementText());
}
else if (name == "dev" && lapNumFlag)
{
devBuffer.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==i)?true:false;
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
wayptTmpFile.close();
//waypoint - write
for (int j=0;j<xmlTextBuffer.length();j++)
{
bufferKml.writeStartElement("Placemark");
bufferKml.writeStartElement("name");
if ((j+1)==xmlTextBuffer.length())
bufferKml.writeCDATA("Finish");
else
bufferKml.writeCDATA("Waypoint"+QString::number(j+1));
bufferKml.writeEndElement();
bufferKml.writeStartElement("description");
bufferKml.writeCDATA("Time: "+timeBuffer.at(j)+"; To best: "+devBuffer.at(j)+"; Best: "+bestBuffer.at(j));
bufferKml.writeEndElement();
bufferKml.writeStartElement("TimeStamp");
bufferKml.writeTextElement("when",xmlTextBuffer.at(j));
bufferKml.writeEndElement();
if (j==xmlTextBuffer.length()-1)
bufferKml.writeTextElement("styleUrl","#end");
else
bufferKml.writeTextElement("styleUrl","#waypoint");
bufferKml.writeStartElement("Point");
bufferKml.writeTextElement("coordinates",xmlTmpTextBuffer.at(j));
bufferKml.writeEndElement();
bufferKml.writeEndElement();
}
//track - load
xmlReader.clear();
coordTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&coordTmpFile);
xmlReader.readNext();
xmlTmpTextBuffer.clear();
xmlTextBuffer.clear();
lapTmpNum=0;
lapNumFlag=false;
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if (name == "when" && lapNumFlag)//read time of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if (name == "coord" && lapNumFlag)
{
xmlTmpTextBuffer.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==i)?true:false;
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
coordTmpFile.close();
//track - write
bufferKml.writeStartElement("Placemark");
bufferKml.writeAttribute(QXmlStreamAttribute("id","tour"));
bufferKml.writeStartElement("name");
bufferKml.writeCDATA("track");
bufferKml.writeEndElement();
bufferKml.writeStartElement("description");
bufferKml.writeCDATA("");
bufferKml.writeEndElement();
bufferKml.writeTextElement("styleUrl","#track");
bufferKml.writeStartElement("gx:MultiTrack");
bufferKml.writeTextElement("altitudeMode","absolute");
bufferKml.writeTextElement("gx:interpolate","1");
bufferKml.writeStartElement("gx:Track");
for (int j=0;j<xmlTextBuffer.length();j++)
{
bufferKml.writeTextElement("when",xmlTextBuffer.at(j));
bufferKml.writeTextElement("gx:coord",xmlTmpTextBuffer.at(j));
}
//data - alt - write
bufferKml.writeStartElement("ExtendedData");
bufferKml.writeEmptyElement("SchemaData");
bufferKml.writeAttribute(QXmlStreamAttribute("schemaUrl","#schema"));
bufferKml.writeStartElement("gx:SimpleArrayData");
bufferKml.writeAttribute(QXmlStreamAttribute("name","elevation"));
for (int j=0;j<xmlTextBuffer.length();j++)
{
bufferKml.writeTextElement("gx:value",QString(xmlTmpTextBuffer.at(j)).section(" ",2,2));
}
bufferKml.writeEndElement();
//data - speed - load
xmlReader.clear();
speedTmpFile.open(QIODevice::ReadOnly | QIODevice::Text);
xmlReader.setDevice(&speedTmpFile);
xmlReader.readNext();
xmlTmpTextBuffer.clear();
xmlTextBuffer.clear();
lapTmpNum=0;
lapNumFlag=false;
while (!xmlReader.isEndDocument())
{
if (xmlReader.isStartElement())
{
QString name = xmlReader.name().toString();
if (name == "speed" && lapNumFlag)//read time of each element
{
xmlTextBuffer.append(xmlReader.readElementText());
}
else if (name == "lap")
{
lapNumFlag=(lapTmpNum==i)?true:false;
lapTmpNum++;
}
}
else if (xmlReader.isEndElement())
{
}
xmlReader.readNext();
}
speedTmpFile.close();
//data - speed - write
bufferKml.writeStartElement("gx:SimpleArrayData");
bufferKml.writeAttribute(QXmlStreamAttribute("name","speed"));
for (int j=0;j<xmlTextBuffer.length();j++)
{
bufferKml.writeTextElement("gx:value",xmlTextBuffer.at(j));
}
bufferKml.writeEndElement();
// close all opened element
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndElement();
bufferKml.writeEndDocument();
xmlKmlFile.close();
}
}
void core::BasicTable::pasteClick()
{
if(!getPasteAction()->isEnabled() || !getPasteAction()->isVisible()) return;
QModelIndexList selList = selectionModel()->selectedIndexes();
if(selList.empty()){
return;
}else{
clipboard = QApplication::clipboard();
QString line = clipboard->text();
QXmlStreamReader reader;
reader.addData(line);
QXmlStreamReader::TokenType tt;
QStringRef name;
QXmlStreamAttributes attributes;
bool getInItem = false;
QVector<QPair<QPoint, double> > replaceList;
if(line != ""){
while(!reader.atEnd()){
tt = reader.readNext();
if(tt == QXmlStreamReader::StartElement){
name = reader.name();
if(name == STR_TABLE){
getInItem = true;
continue;
}else if(name == STR_ITEM && getInItem){
attributes = reader.attributes();
if(attributes.hasAttribute(STR_COL) &&
attributes.hasAttribute(STR_ROW) &&
attributes.hasAttribute(STR_DATA))
{
replaceList.push_back(qMakePair(QPoint(attributes.value(STR_ROW).toInt(), attributes.value(STR_COL).toInt()), attributes.value(STR_DATA).toDouble()));
}
}else{
break;
}
}
}
if(replaceList.count() > 1){
QMessageBox msg;
msg.setIcon(QMessageBox::Warning);
msg.setWindowTitle("Pegar");
msg.setText(QString::fromLatin1("Existe mas de un elemento en el portapapeles."));
msg.setInformativeText(QString::fromLatin1("¿Desea reemplazar los elementos correspondientes?"));
msg.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
if(msg.exec() == QMessageBox::Yes){
for(int i = 0; i < replaceList.count(); i++){
model()->setData(model()->index(replaceList[i].first.x() + selList[0].row(), replaceList[i].first.y() + selList[0].column()), replaceList[i].second);
}
}
}else if(replaceList.count() == 1){
model()->setData(model()->index(replaceList[0].first.x() + selList[0].row(), replaceList[0].first.y() + selList[0].column()), replaceList[0].second);
}
}
}
}
bool CChannelConfig::fromXml(QXmlStreamReader& reader)
{
if(reader.tokenType() != QXmlStreamReader::StartElement ||
reader.name() != "channelConfig")
{
return false;
}
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "channelConfig"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if (reader.name() == "splicerAddress")
{
if (!Helpers::fromXml(reader, m_splicerAddress))
return false;
}
else if (reader.name() == "channelName")
{
if (!Helpers::fromXml(reader, m_channelName))
return false;
}
else if (reader.name() == "splicerName")
{
if (!Helpers::fromXml(reader, m_splicerName))
return false;
}
else if (reader.name() == "chassis")
{
if (!Helpers::fromXml(reader, m_chassis))
return false;
}
else if (reader.name() == "card")
{
if (!Helpers::fromXml(reader, m_card))
return false;
}
else if (reader.name() == "port")
{
if (!Helpers::fromXml(reader, m_port))
return false;
}
else if (reader.name() == "secondsBeforeSpliceRequest")
{
if (!Helpers::fromXml(reader, m_secondsBeforeSpliceRequest))
return false;
}
else if (reader.name() == "processScte35")
{
if (!Helpers::fromXml(reader, m_processScte35))
return false;
}
else if (reader.name() == "adBlocks")
{
reader.readNext();
while(!(reader.tokenType() == QXmlStreamReader::EndElement &&
reader.name() == "adBlocks"))
{
if(reader.tokenType() == QXmlStreamReader::StartElement)
{
if (reader.name() == "adBlock")
{
CAdBlock adBlock;
if (!adBlock.fromXml(reader))
return false;
addAdBlock(adBlock);
}
else
{
qWarning() << "AdBlocks: Unknown element in XML file: " << reader.name();
return false;
}
}
reader.readNext();
}
}
else
{
qWarning() << "ChannelConfig: Unknown element in XML file: " << reader.name();
return false;
}
}
reader.readNext();
}
return true;
}
bool Document::loadXOJ(QString fileName)
{
QFile file(fileName);
if (!file.open(QIODevice::ReadOnly))
{
return false;
}
QXmlStreamReader reader;
// check if it is a gzipped xoj
QByteArray s = file.read(2);
if (s.size() == 2)
{
if (s.at(0) == static_cast<char>(0x1f) && s.at(1) == static_cast<char>(0x8b))
{
// this is a gzipped file
file.reset();
QByteArray compressedData = file.readAll();
QByteArray uncompressedData;
if (!QCompressor::gzipDecompress(compressedData, uncompressedData))
{
return false;
}
reader.addData(uncompressedData);
}
else
{
file.reset();
reader.setDevice(&file);
}
}
else
{
return false;
}
pages.clear();
int strokeCount = 0;
while (!reader.atEnd())
{
reader.readNext();
if (reader.name() == "page" && reader.tokenType() == QXmlStreamReader::StartElement)
{
QXmlStreamAttributes attributes = reader.attributes();
QStringRef width = attributes.value("", "width");
QStringRef height = attributes.value("", "height");
Page newPage;
newPage.setWidth(width.toDouble());
newPage.setHeight(height.toDouble());
pages.append(newPage);
}
if (reader.name() == "background" && reader.tokenType() == QXmlStreamReader::StartElement)
{
QXmlStreamAttributes attributes = reader.attributes();
QStringRef color = attributes.value("", "color");
QColor newColor = stringToColor(color.toString());
pages.last().setBackgroundColor(newColor);
}
if (reader.name() == "stroke" && reader.tokenType() == QXmlStreamReader::StartElement)
{
QXmlStreamAttributes attributes = reader.attributes();
QStringRef tool = attributes.value("", "tool");
if (tool == "pen")
{
Stroke newStroke;
newStroke.pattern = MrDoc::solidLinePattern;
QStringRef color = attributes.value("", "color");
newStroke.color = stringToColor(color.toString());
QStringRef strokeWidth = attributes.value("", "width");
QStringList strokeWidthList = strokeWidth.toString().split(" ");
newStroke.penWidth = strokeWidthList.at(0).toDouble();
newStroke.pressures.append(newStroke.penWidth / strokeWidthList.at(0).toDouble());
for (int i = 1; i < strokeWidthList.size(); ++i)
{
newStroke.pressures.append(2 * strokeWidthList.at(i).toDouble() / newStroke.penWidth - newStroke.pressures.at(i - 1));
}
QString elementText = reader.readElementText();
QStringList elementTextList = elementText.split(" ");
for (int i = 0; i + 1 < elementTextList.size(); i = i + 2)
{
newStroke.points.append(QPointF(elementTextList.at(i).toDouble(), elementTextList.at(i + 1).toDouble()));
}
while (newStroke.points.size() > newStroke.pressures.size())
{
newStroke.pressures.append(1.0);
}
pages.last().appendStroke(newStroke);
strokeCount++;
qDebug() << strokeCount;
}
}
}
// QFileInfo fileInfo(file);
file.close();
for (auto &page : pages)
{
page.clearDirtyRect();
}
if (reader.hasError())
{
return false;
}
else
{
setDocumentChanged(true);
return true;
}
}
