/*! \brief Retrieves the episode data for a given series
\param showDetail A ShowDetail object for which to retrieve an episode listing
\return A QList of EpisodeDetail for the show requested
\sa ShowDetail EpisodeDetail
Using QNetworkAccessManager and QNetworkReply, a blocking connection is made
to an XML service provider (in this case TVRage), for the episode listing of
the show.
Once the XML data is retrived, it is parsed with QXmlStreamReader and
necessary EpisodeDetial objects are contructed and returned.
*/
QList< EpisodeDetail > ShowHolder::Fetch( ShowDetail const& showDetail )
{
QEventLoop waitLoop;
QNetworkAccessManager netManager;
QNetworkReply* netReply = netManager.get( QNetworkRequest( QUrl( "http://services.tvrage.com/feeds/episode_list.php?sid=" + QString::number( showDetail.id ) ) ) );
QObject::connect( netReply, SIGNAL( finished() ), &waitLoop, SLOT( quit() ) );
waitLoop.exec();
int currentSeason = 0;
QList< EpisodeDetail > episodes;
QXmlStreamReader xmlData;
xmlData.addData( netReply->readAll() );
while( !xmlData.atEnd() )
{
if( xmlData.readNextStartElement() )
{
if( xmlData.name() == "Special" )
xmlData.skipCurrentElement();
else if( xmlData.name() == "Season" )
currentSeason = xmlData.attributes().value( "no" ).toString().toInt();
else if( xmlData.name() == "episode" )
{
episodes.append( EpisodeDetail() );
episodes.back().show = showDetail.name;
episodes.back().season = currentSeason;
}
else if( xmlData.name() == "epnum" )
episodes.back().show_episode = xmlData.readElementText().toInt();
else if( xmlData.name() == "seasonnum" )
episodes.back().episode = xmlData.readElementText().toInt();
else if( xmlData.name() == "title" )
episodes.back().title = xmlData.readElementText();
}
}
netReply->deleteLater();
qSort( episodes );
return episodes;
}
void Completer::completion(QXmlStreamReader &xml, const bool extract)
{
if ((xml.tokenType() != QXmlStreamReader::StartElement) && (xml.name() == QString("completion")))
return;
QStandardItem *item = new QStandardItem();
QXmlStreamAttributes attributes = xml.attributes();
QString label = attributes.value("label").toString();
QString tooltip = xml.readElementText();
item->setIcon(icon(attributes.value("type").toString().toStdString().c_str()));
if (extract && label.contains(' ')) {
QString keyword = label.split(' ').at(0);
QString howto = QString("[<strong>Usage:</strong> <i>%0</i>]<br/><br/>").arg(label);
item->setText(keyword);
item->setToolTip(QString(tooltip).prepend(howto));
} else {
item->setText(label);
item->setToolTip(tooltip);
}
this->_definitions->appendRow(item);
}
// Copy&paste from above to call a setter of BaseFileParameters.
// Implementation of a sophisticated mem_fun pattern is left
// as an exercise to the reader.
static inline bool assignLanguageElementText(QXmlStreamReader &reader,
const QString &desiredLanguage,
BaseFileWizardParameters *bp,
void (BaseFileWizardParameters::*setter)(const QString &))
{
const QStringRef elementLanguage = reader.attributes().value(QLatin1String(langAttributeC));
if (elementLanguage.isEmpty()) {
// Try to find a translation for our built-in Wizards
const QString translated = QCoreApplication::translate("ProjectExplorer::CustomWizard", reader.readElementText().toLatin1().constData());
(bp->*setter)(translated);
return true;
}
if (elementLanguage == desiredLanguage) {
(bp->*setter)(reader.readElementText());
return true;
}
// Language mismatch: forward to end element.
skipOverElementText(reader);
return false;
}
void ProjectFile::ReadCheckPaths(QXmlStreamReader &reader)
{
QXmlStreamReader::TokenType type;
bool allRead = false;
do
{
type = reader.readNext();
switch (type)
{
case QXmlStreamReader::StartElement:
// Read dir-elements
if (reader.name().toString() == PathName)
{
QXmlStreamAttributes attribs = reader.attributes();
QString name = attribs.value("", PathNameAttrib).toString();
if (!name.isEmpty())
mPaths << name;
}
break;
case QXmlStreamReader::EndElement:
if (reader.name().toString() == PathsElementName)
allRead = true;
break;
// Not handled
case QXmlStreamReader::NoToken:
case QXmlStreamReader::Invalid:
case QXmlStreamReader::StartDocument:
case QXmlStreamReader::EndDocument:
case QXmlStreamReader::Characters:
case QXmlStreamReader::Comment:
case QXmlStreamReader::DTD:
case QXmlStreamReader::EntityReference:
case QXmlStreamReader::ProcessingInstruction:
break;
}
}
while (!allRead);
}
static bool parseTemplateXml(QXmlStreamReader &reader, TemplateInfo *info)
{
const QString locale = languageSetting();
static const QLatin1String tag_template("template");
static const QLatin1String tag_displayName("displayname");
static const QLatin1String tag_description("description");
static const QLatin1String attribute_id("id");
static const QLatin1String attribute_featuresRequired("featuresRequired");
static const QLatin1String attribute_openEditor("openeditor");
static const QLatin1String attribute_priority("priority");
while (!reader.atEnd() && !reader.hasError()) {
reader.readNext();
if (reader.tokenType() != QXmlStreamReader::StartElement)
continue;
if (reader.name() == tag_template) {
info->openFile = reader.attributes().value(attribute_openEditor).toString();
if (reader.attributes().hasAttribute(attribute_priority))
info->priority = reader.attributes().value(attribute_priority).toString().toInt();
if (reader.attributes().hasAttribute(attribute_id))
info->wizardId = reader.attributes().value(attribute_id).toString();
if (reader.attributes().hasAttribute(attribute_featuresRequired))
info->featuresRequired = reader.attributes().value(attribute_featuresRequired).toString();
} else if (reader.name() == tag_displayName) {
if (!assignLanguageElementText(reader, locale, &info->displayName))
continue;
} else if (reader.name() == tag_description) {
if (!assignLanguageElementText(reader, locale, &info->description))
continue;
}
}
if (reader.hasError()) {
qWarning() << reader.errorString();
return false;
}
return true;
}
void QgsOSMXmlImport::readTag( bool way, QgsOSMId id, QXmlStreamReader& xml )
{
QXmlStreamAttributes attrs = xml.attributes();
QByteArray k = attrs.value( "k" ).toString().toUtf8();
QByteArray v = attrs.value( "v" ).toString().toUtf8();
xml.skipCurrentElement();
sqlite3_stmt* stmtInsertTag = way ? mStmtInsertWayTag : mStmtInsertNodeTag;
sqlite3_bind_int64( stmtInsertTag, 1, id );
sqlite3_bind_text( stmtInsertTag, 2, k.constData(), -1, SQLITE_STATIC );
sqlite3_bind_text( stmtInsertTag, 3, v.constData(), -1, SQLITE_STATIC );
int res = sqlite3_step( stmtInsertTag );
if ( res != SQLITE_DONE )
{
xml.raiseError( QString( "Storing tag failed [%1]" ).arg( res ) );
}
sqlite3_reset( stmtInsertTag );
}
void AnalyzeTask::parseTrackInfo(QXmlStreamReader &xmlStream, const MI_trackType_t trackType, AudioFileModel &audioFile)
{
QString coverMimeType;
while (xmlStream.readNextStartElement())
{
const MI_propertyId_t idx = m_mediaInfoIdx.value(qMakePair(trackType, xmlStream.name().toString().simplified().toLower()), MI_propertyId_t(-1));
if (idx != MI_propertyId_t(-1))
{
const QString encoding = findAttribute(QLatin1String("dt"), xmlStream.attributes());
const QString value = xmlStream.readElementText(QXmlStreamReader::SkipChildElements).simplified();
if (!value.isEmpty())
{
parseProperty(encoding.isEmpty() ? value : decodeStr(value, encoding), idx, audioFile, coverMimeType);
}
}
else
{
xmlStream.skipCurrentElement();
}
}
}
QT_BEGIN_NAMESPACE
static void tokenUntil(QXmlStreamReader &reader, QXmlStreamReader::TokenType target,
QList<int> &lineNumbers)
{
int level = 0;
while (!reader.atEnd()) {
QXmlStreamReader::TokenType t = reader.readNext();
if ((t == target) && (level == 0))
return;
if (t == QXmlStreamReader::StartElement) {
++level;
QString line = reader.attributes().value(QLatin1String("line")).toString();
if (!line.isEmpty())
lineNumbers.append(line.toInt());
} else if (t == QXmlStreamReader::EndElement) {
--level;
}
}
// Q_ASSERT_X(false, "QScriptXmlParser", "premature end of file");
}
//------------------------------------------------------------------------------
QStringList getListWord(QString filename)
{
QStringList r_list;
QXmlStreamReader xmlReader;
xmlReader.addData(getTextFromHtmlFile(filename));
while(!xmlReader.atEnd())
{
if(xmlReader.isStartElement())
{
QStringList sl;
sl << xmlReader.name().toString();
QXmlStreamAttributes attrs = xmlReader.attributes();
// myDebug() << attrs.value("name").toString();
r_list.append(attrs.value("name").toString());
}
xmlReader.readNext();
}
r_list = removeEmptyQStringFromQStringList(&r_list);
return r_list;
}
void Colors::load(QXmlStreamReader &reader) {
if (reader.name().toString() == "colors") {
ui->x->setText(reader.attributes().value("x").toString());
ui->y->setText(reader.attributes().value("y").toString());
ui->width->setText(reader.attributes().value("width").toString());
ui->height->setText(reader.attributes().value("height").toString());
ui->captionX->setText(reader.attributes().value("captionX").toString());
ui->captionY->setText(reader.attributes().value("captionY").toString());
ui->captionPt->setText(reader.attributes().value("captionPt").toString());
on_x_returnPressed();
if (reader.attributes().hasAttribute("colorStyle")) {
on_colorStyle_currentIndexChanged(reader.attributes().value("colorStyle").toString().toInt());
} else {
on_colorStyle_currentIndexChanged(1);
on_colorStyle_currentIndexChanged(0);
}
do { reader.readNext(); } while (!reader.isStartElement() && !reader.isEndDocument());
}
}
void
DirectParser::ParseMessage (QXmlStreamReader & xread,
DirectMessage & msg,
qint64 & offset,
bool & complete,
bool & good)
{
QXmlStreamReader::TokenType tokt = NoWhite (xread);
offset = xread.characterOffset ();
QXmlStreamAttributes atts;
QString op;
QString tag;
switch (tokt) {
case QXmlStreamReader::StartElement:
atts = xread.attributes();
tag = xread.name().toString();
op = atts.value ("op").toString().toLower();
msg.SetOp (op);
if (tag == "cmd") {
if (op == "xmpp") {
ParseXmpp (xread, msg, offset, complete, good, atts);
} else if (op == "ctl") {
ParseCtl (xread, msg, offset, complete, good, atts);
} else if (op == "sendfile") {
ParseSendfile (xread, msg, offset, complete, good, atts);
}
offset = xread.characterOffset ();
if (xread.tokenType() != QXmlStreamReader::EndElement
|| xread.name() != tag) {
complete = false;
good = false;
}
}
break;
default:
complete = false;
good = false;
break;
}
}
void MyHttpEngine::parseScore(QXmlStreamReader& xml) {
QString name;
QString description;
QString id;
/* Let's check that we're really getting a score. */
if(xml.tokenType() != QXmlStreamReader::StartElement &&
xml.name() == "score") {
return;
}
/* Let's get the attributes for person */
QXmlStreamAttributes attributes = xml.attributes();
/* Next element... */
xml.readNext();
/*
* We're going to loop over the things because the order might change.
* We'll continue the loop until we hit an EndElement named person.
*/
while(!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == "score")) {
if(xml.tokenType() == QXmlStreamReader::StartElement) {
/* We've found title. */
if(xml.name() == "title") {
xml.readNext();
name = xml.text().toString();
}
/* We've found description. */
if(xml.name() == "genre") {
xml.readNext();
description = xml.text().toString();
}
/* We've found id. */
if(xml.name() == "id") {
xml.readNext();
id = xml.text().toString();
}
}
/* ...and next... */
xml.readNext();
}
scoreList.append(new ScoreInfo(name, description, id));
}
bool NPushReportSpeed::load_from_dir(QString &dirName)
{
QString data_in_filename = (dirName + FSC_FSYS_SLASH) + "Speed.xml";
QFile data_input(data_in_filename);
data_input.open(QFile::ReadOnly | QFile::Text);
QXmlStreamReader xml;
xml.setDevice(&data_input);
if(xml.readNextStartElement())
{
if(xml.name() != "SpeedReport") {
qDebug() << "Invalid file format";
return false;
}
} else {
qDebug() << "Could not read first start Element";
return false;
}
do
{
while(xml.readNextStartElement())
{
if(xml.name() == "stats")
{
Speed_max = xml.attributes().value("max").toString().toDouble();
Speed_avg = xml.attributes().value("avg").toString().toDouble();
} else if(xml.name() == "graph") {
read_points_from_xml(xml);
} else {
xml.skipCurrentElement();
}
}
} while(xml.name() != "SpeedReport");
return true;
// qDebug() << "Done; " << Speed_max << "/" << Speed_avg << "; " << graphPoints.count() << "points";
}
static QStringList readArgumentAttributes(QXmlStreamReader &reader, Settings::ParseMode parseMode,
const QString &tagName, bool lc = false)
{
QStringList arguments;
while (QXmlStreamReader::TokenType token = reader.readNext()) {
switch (token) {
case QXmlStreamReader::StartElement: {
if (!reader.attributes().isEmpty()) {
raiseError(reader, QString::fromLatin1("Unexpected attribute for element \"%1\".")
.arg(reader.name().toString()), parseMode);
return arguments;
} else {
if (reader.name().toString() == tagName) {
(lc) ? arguments.append(reader.readElementText().toLower()) :
arguments.append(reader.readElementText());
} else {
raiseError(reader, QString::fromLatin1("Unexpected element \"%1\".").arg(reader.name()
.toString()), parseMode);
return arguments;
}
}
}
break;
case QXmlStreamReader::Characters: {
if (reader.isWhitespace())
continue;
arguments.append(reader.text().toString().split(QRegularExpression(QLatin1String("\\s+")),
QString::SkipEmptyParts));
}
break;
case QXmlStreamReader::EndElement: {
return arguments;
}
default:
break;
}
}
return arguments;
}
static CppcheckLibraryData::MemoryResource loadMemoryResource(QXmlStreamReader &xmlReader)
{
CppcheckLibraryData::MemoryResource memoryresource;
memoryresource.type = xmlReader.name().toString();
QXmlStreamReader::TokenType type;
while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
xmlReader.name().toString() != memoryresource.type) {
if (type != QXmlStreamReader::StartElement)
continue;
const QString elementName = xmlReader.name().toString();
if (elementName == "alloc") {
CppcheckLibraryData::MemoryResource::Alloc alloc;
alloc.init = (xmlReader.attributes().value("init").toString() == "true");
alloc.name = xmlReader.readElementText();
memoryresource.alloc.append(alloc);
} else if (elementName == "dealloc")
memoryresource.dealloc.append(xmlReader.readElementText());
else if (elementName == "use")
memoryresource.use.append(xmlReader.readElementText());
}
return memoryresource;
}
EwsId::EwsId(QXmlStreamReader &reader)
: mDid(EwsDIdCalendar)
{
// Don't check for this element's name as a folder id may be contained in several elements
// such as "FolderId" or "ParentFolderId".
const QXmlStreamAttributes &attrs = reader.attributes();
QStringRef idRef = attrs.value(QStringLiteral("Id"));
QStringRef changeKeyRef = attrs.value(QStringLiteral("ChangeKey"));
if (idRef.isNull())
return;
mId = idRef.toString();
if (!changeKeyRef.isNull())
mChangeKey = changeKeyRef.toString();
#ifdef HAVE_INBOX_FILTERING_WORKAROUND
if (mId == inboxId) {
mId = QStringLiteral("INBOX");
}
#endif
mType = Real;
}
shared_ptr<Shape> Scene::parseShape(QXmlStreamReader &xml)
{
shared_ptr<Shape> sp;
/*
*
* Typical shape blocks
*
* <shape type="sphere" name="ball"/>
* <shape type="mesh" name="bunny" file="./meshes/bun_zip_res4.obj"/>
* <shape type="mesh" name="box" file="./meshes/cube.obj"/>
*
*/
if(xml.tokenType() != QXmlStreamReader::StartElement &&
xml.name() == "config") {
return sp;
}
QXmlStreamAttributes attributes = xml.attributes();
assert( attributes.hasAttribute("type") );
assert( attributes.hasAttribute("name") );
string typestr = attributes.value("type").toString().toStdString();
string namestr = attributes.value("name").toString().toStdString();
if( typestr == "sphere" ) {
sp = shared_ptr<Shape>(new Sphere(namestr));
}
else if( typestr == "mesh" ) {
assert( attributes.hasAttribute("file") );
string filestr = attributes.value("file").toString().toStdString();
sp = shared_ptr<Shape>(new Mesh(namestr, filestr));
}
xml.readNext();
return sp;
}
void CCommandXml::format_head_data(QXmlStreamReader& reader, int ncount)
{
for (int i = 0; i < ncount; i++)
{
if(reader.attributes()[i].name() == "head")
{
head.head.append( reader.attributes()[i].value());
}
else if (reader.attributes()[i].name() == "end")
{
head.end.append(reader.attributes()[i].value());
}
else if (reader.attributes()[i].name() == "usersignal")
{
head.userSignal.append(reader.attributes()[i].value());
}
else if (reader.attributes()[i].name() == "returnhead")
{
head.returnHead.append(reader.attributes()[i].value());
}
}
qDebug()<<" contatnts head="<<head.head << "end="<<head.end << "usersignal="<<head.userSignal<<"returnhead="<<head.returnHead;
}
bool OracleImporter::readSetsFromXml(QXmlStreamReader &xml)
{
QList<SetToDownload> newSetList;
QString edition;
QString editionLong;
QString editionURL;
while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement)
break;
if (xml.name() == "set") {
bool import = xml.attributes().value("import").toString().toInt();
while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement)
break;
if (xml.name() == "name")
edition = xml.readElementText();
else if (xml.name() == "longname")
editionLong = xml.readElementText();
else if (xml.name() == "url")
editionURL = xml.readElementText();
}
newSetList.append(SetToDownload(edition, editionLong, editionURL, import));
edition = editionLong = editionURL = QString();
} else if (xml.name() == "picture_url")
pictureUrl = xml.readElementText();
else if (xml.name() == "picture_url_hq")
pictureUrlHq = xml.readElementText();
else if (xml.name() == "picture_url_st")
pictureUrlSt = xml.readElementText();
else if (xml.name() == "set_url")
setUrl = xml.readElementText();
}
if (newSetList.isEmpty())
return false;
allSets = newSetList;
return true;
}
bool DeliciousApi::ParseAuthReply (const QByteArray& content)
{
QXmlStreamReader xml (content);
while (!xml.atEnd () &&
!xml.hasError ())
{
QXmlStreamReader::TokenType token = xml.readNext ();
if (token == QXmlStreamReader::StartDocument)
continue;
if (token == QXmlStreamReader::StartElement &&
xml.name() == "update" &&
xml.attributes ().hasAttribute ("time"))
return true;
}
qWarning () << Q_FUNC_INFO
<< "Parsing finished with error"
<< xml.errorString ();
return false;
}
void LineStyle::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "LineStyle::loadXml";
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_LINE_STYLE_WIDTH) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_LINE_STYLE_COLOR) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_LINE_STYLE_CONNECT_AS)) {
setWidth (attributes.value(DOCUMENT_SERIALIZE_LINE_STYLE_WIDTH).toInt());
setPaletteColor ((ColorPalette) attributes.value(DOCUMENT_SERIALIZE_LINE_STYLE_COLOR).toInt());
setCurveConnectAs ((CurveConnectAs) attributes.value(DOCUMENT_SERIALIZE_COLOR_FILTER_INTENSITY_HIGH).toInt());
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_LINE_STYLE)){
loadNextFromReader(reader);
}
} else {
reader.raiseError ("Cannot read line style data");
}
}
void xmlReader::parseBuild(QXmlStreamReader& xml) {
if(xml.tokenType() != QXmlStreamReader::StartElement && xml.name() == "build") {
return;
}
QXmlStreamAttributes attributes = xml.attributes();
if(attributes.hasAttribute("buildNumber")) {
buildNumber.insertMulti("buildNumber",attributes.value("buildNumber").toString());
qDebug()<<attributes.value("buildNumber").toString();
}
if(attributes.hasAttribute("buildName")) {
buildName.insertMulti("buildName",attributes.value("buildName").toString());
qDebug()<<attributes.value("buildName").toString();
}
if(attributes.hasAttribute("buildDescription")) {
buildDescription.insertMulti("buildDescription",attributes.value("buildDescription").toString());
qDebug()<<attributes.value("buildDescription").toString();
}
if(attributes.hasAttribute("buildDirectory")) {
buildDirectory.insertMulti("buildDirectory",attributes.value("buildDirectory").toString());
qDebug()<<attributes.value("buildDirectory").toString();
}
xml.readNext();
}
void MenuBarTree::loadMenuRecursive(QXmlStreamReader& reader, QTreeWidgetItem* parentItem)
{
while (reader.readNextStartElement())
{
if (reader.name() == "menu")
{
QString title = reader.attributes().value("title").toString();
MenuBarSubmenuItem *subMenu = new MenuBarSubmenuItem(parentItem, title);
loadMenuRecursive(reader, subMenu);
}
else if (reader.name() == "command")
{
QString cmdName = reader.readElementText();
QAction* action = CommandManager::instance()->getAction(cmdName.toStdString().c_str());
if (action)
MenuBarCommandItem* item = new MenuBarCommandItem(parentItem, action);
}
else if (reader.name() == "command_debug")
{
#ifndef NDEBUG
QString cmdName = reader.readElementText();
QAction* action = CommandManager::instance()->getAction(cmdName.toStdString().c_str());
if (action)
MenuBarCommandItem* item = new MenuBarCommandItem(parentItem, action);
#else
reader.skipCurrentElement();
#endif
}
else if (reader.name() == "separator")
{
MenuBarSeparatorItem* sep = new MenuBarSeparatorItem(parentItem);
reader.skipCurrentElement();
}
else
reader.skipCurrentElement();
}
}
void XmlUtil::readAuthorModeScoreEntry(QXmlStreamReader &reader, ProjectorConfig::AuthorMode &am) {
while ( !reader.atEnd() ) {
reader.readNext();
if ( reader.isStartElement() ) {
if ( reader.name() == "entry" ) {
const QXmlStreamAttributes &attr = reader.attributes();
ProjectorConfig::AuthorMode::ScoreEntry entry;
entry.name = attr.value("name").toString();
entry.group = attr.value("group").toString();
const QString &scores = reader.readElementText();
const QStringList &scoreList = scores.split(' ', QString::SkipEmptyParts);
for ( size_t i = 0; i < scoreList.size(); ++i )
entry.scores.push_back(scoreList.at(i).toUInt());
am.scores.push_back(entry);
} else if ( reader.name() == "scores" ) {
throw InvalidXmlException("Tag 'scores' found inside 'scores'.", reader);
} else {
//barf?
}
} else if ( reader.isEndElement() && reader.name() == "scores" )
break;
}
}
void Parser::parseAction(QXmlStreamReader &xml, Action *parent) {
while (!xml.atEnd() && !xml.hasError()) {
QXmlStreamReader::TokenType token = xml.readNext();
if (token == QXmlStreamReader::StartElement) {
//parse action..
Action *a;
QXmlStreamAttributes a_attr = xml.attributes();
if (xml.name().toString() == "move") {
a = new Move(a_attr.value("range").toString(), a_attr.value("rule").toString());
} else {
a = new Response(a_attr.value("rule").toString());
}
parent->addAction(a);
parseAction(xml, a);
}
if (token == QXmlStreamReader::EndElement &&
(xml.name().toString() == "move" || xml.name().toString() == "resp")) {
//strategy end..
return ;
}
}
}
void DocumentModelDigitizeCurve::loadXml(QXmlStreamReader &reader)
{
LOG4CPP_INFO_S ((*mainCat)) << "DocumentModelDigitizeCurve::loadXml";
bool success = true;
QXmlStreamAttributes attributes = reader.attributes();
if (attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_INNER_RADIUS) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_LINE_WIDTH) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_SIZE) &&
attributes.hasAttribute(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_STANDARD_CROSS)) {
// Boolean values
QString standardCrossValue = attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_STANDARD_CROSS).toString();
setCursorInnerRadius (attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_INNER_RADIUS).toInt());
setCursorLineWidth (attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_LINE_WIDTH).toInt());
setCursorSize ((CursorSize) attributes.value(DOCUMENT_SERIALIZE_DIGITIZE_CURVE_CURSOR_SIZE).toInt());
setCursorStandardCross (standardCrossValue == DOCUMENT_SERIALIZE_BOOL_TRUE);
// Read until end of this subtree
while ((reader.tokenType() != QXmlStreamReader::EndElement) ||
(reader.name() != DOCUMENT_SERIALIZE_DIGITIZE_CURVE)){
loadNextFromReader(reader);
if (reader.atEnd()) {
success = false;
break;
}
}
}
if (!success) {
reader.raiseError ("Cannot read digitize curve data");
}
}
static void recurseParse(QXmlStreamReader &reader, QXmlStreamWriter &writer, int ¶graphs, const QMap<QString, QString> &opstyle = QMap<QString, QString>(), const int close = 0, bool ignore = true) {
while (! reader.atEnd()) {
QXmlStreamReader::TokenType tt = reader.readNext();
QXmlStreamAttributes a = reader.attributes();
QMap<QString, QString> style;
QMap<QString, QString> pstyle = opstyle;
QStringRef styleref = a.value(QLatin1String("style"));
if (!styleref.isNull()) {
QString stylestring = styleref.toString();
QStringList styles = stylestring.split(QLatin1String(";"), QString::SkipEmptyParts);
foreach(QString s, styles) {
s = s.simplified();
int idx = s.indexOf(QLatin1Char(':'));
QString key = (idx > 0) ? s.left(idx).simplified() : s;
QString val = (idx > 0) ? s.mid(idx+1).simplified() : QString();
if (! pstyle.contains(key) || (pstyle.value(key) != val)) {
style.insert(key,val);
pstyle.insert(key,val);
}
}
}
//-------------------------------------------------------------------------------
QStringList getBookmarks(QString pathToFile)
{
QXmlStreamReader xmlReader;
// QString r_str;
QStringList r_list;
xmlReader.addData(getTextFromHtmlFile(pathToFile));
while(!xmlReader.atEnd())
{
if(xmlReader.isStartElement())
{
QStringList sl;
sl << xmlReader.name().toString();
QXmlStreamAttributes attrs = xmlReader.attributes();
r_list << attrs.value("name").toString();
}
// if (xmlReader.isEndElement())
// {
// }
xmlReader.readNext();
}
r_list = removeEmptyQStringFromQStringList(&r_list);
return r_list;
}
// Read all current Rotor controls from an XML stream
bool US_RunProtocol::RunProtoRotor::fromXml( QXmlStreamReader& xmli )
{
while( ! xmli.atEnd() )
{
QString ename = xmli.name().toString();
if ( xmli.isStartElement() )
{
if ( ename == "rotor" )
{
QXmlStreamAttributes attr = xmli.attributes();
laboratory = attr.value( "laboratory" ).toString();
rotor = attr.value( "rotor" ).toString();
calibration = attr.value( "calibration" ).toString();
labID = attr.value( "labid" ).toString().toInt();
rotID = attr.value( "rotid" ).toString().toInt();
calID = attr.value( "calid" ).toString().toInt();
absID = attr.value( "absid" ).toString().toInt();
labGUID = attr.value( "labguid" ).toString();
rotGUID = attr.value( "rotguid" ).toString();
calGUID = attr.value( "calguid" ).toString();
absGUID = attr.value( "absguid" ).toString();
}
else
break;
}
else if ( xmli.isEndElement() && ename == "rotor" )
break;
xmli.readNext();
}
return ( ! xmli.hasError() );
}
void FluidLauncher::parseDemos(QXmlStreamReader& reader)
{
while (!reader.atEnd()) {
reader.readNext();
if (reader.isStartElement() && reader.name() == "example") {
QXmlStreamAttributes attrs = reader.attributes();
QStringRef filename = attrs.value("filename");
if (!filename.isEmpty()) {
QStringRef name = attrs.value("name");
QStringRef image = attrs.value("image");
QStringRef args = attrs.value("args");
DemoApplication* newDemo = new DemoApplication(
filename.toString(),
name.isEmpty() ? "Unnamed Demo" : name.toString(),
image.toString(),
args.toString().split(" "));
demoList.append(newDemo);
}
} else if(reader.isEndElement() && reader.name() == "demos") {
return;
}
}
}
