void Api::RunGraphicsAlgorithm() {
/* TODO: ADD YOUR GRAPHIC CODE HERE */
CvPoint3D32f aa, bb;
CvPoint3D32f a, b;
CvPoint3D32f c, d;
CvPoint3D32f color;
// // Init camera 1
// camera *mycameraA = new camera("cameras/calibA");
// myCamA = mycameraA->readConfig();
xmlReader(&myCamA, "cameras/calibA.xml");
//
// // Init camera 2
// camera *mycameraB = new camera("cameras/calibB");
// myCamB = mycameraB->readConfig();
xmlReader(&myCamB, "cameras/calibB.xml");
// ///////////// EJEMPLO DE USO DE OPTICAS2GRAFICAS y GRAFICAS2OPTICAS ////////////////////
// HPoint2D punto2Daux; //punto 2D (graficas)
// HPoint3D punto3Daux; //punto 3D (opticas)
// double x;
// double y;
//
//
// this->graficas2opticas(punto2D1.x,punto2D1.y,&punto2Daux); //
//
// backproject(&punto3D1, punto2Daux, myCamA);
//
//
// click1.x=punto3D1.X;
// click1.y=punto3D1.Y;
// click1.z=punto3D1.Z;
//
// this->opticas2graficas(punto2Daux, &x, &y);
// std::cout << "Xafter: " << x << "Yafter: " << y << std::endl;
//
// ///////////// FIN EJEMPLO DE USO DE OPTICAS2GRAFICAS y GRAFICAS2OPTICAS ////////////////////
bb.x = this->destino.x;
bb.y = this->destino.y;
bb.z = 0.;
aa.x = encodersData->robotx;
aa.y = encodersData->roboty;
aa.z = 0;
color.x = 1.; // Red
color.y = 0.; // Green
color.z = 0.; // Blue
this->pintaSegmento(aa, bb, color); // ROJO - Pinta un segmento desde el punto "aa" hasta el punto "bb"
this->pintaDestino(aa, bb, color); // ROJO - Marca con una estrella el destino seleccionado al hacer click con el botón central en el mundo 3D.
this->drawSphere(bb, color);
/* this->drawProjectionLines();*/
}
void Gui::initCameras() {
// Init camera 1
xmlReader(&myCamA, "cameras/calibA.xml");
// camera *mycameraA = new camera("cameras/calibA");
// myCamA = mycameraA->readConfig();
// Init camera 2
// camera *mycameraB = new camera("cameras/calibB");
// myCamB = mycameraB->readConfig();
xmlReader(&myCamB, "cameras/calibB.xml");
}
bool Argument1DDouble::readValues(const QString &value, bool isFile)
{
if(isFile)
{
m_inputFile = modelComponentInternal()->getRelativeFilePath(value);
if(m_inputFile.exists())
{
QFile file(m_inputFile.absoluteFilePath());
if(file.open(QIODevice::ReadOnly))
{
QXmlStreamReader xmlReader(&file);
while(!xmlReader.isEndDocument() && !xmlReader.hasError())
{
if(!xmlReader.name().compare("Argument1D", Qt::CaseInsensitive) && !xmlReader.hasError() && xmlReader.tokenType() == QXmlStreamReader::StartElement )
{
readData(xmlReader);
}
xmlReader.readNext();
}
if(!xmlReader.hasError())
{
setArgumentIOType(HydroCouple::File);
return true;
}
}
}
}
else
{
QXmlStreamReader xmlReader(value);
while(!xmlReader.isEndDocument() && !xmlReader.hasError())
{
if(!xmlReader.name().compare("Argument1D", Qt::CaseInsensitive) && !xmlReader.hasError() && xmlReader.tokenType() == QXmlStreamReader::StartElement )
{
readData(xmlReader);
}
xmlReader.readNext();
}
if(!xmlReader.hasError())
{
setArgumentIOType(HydroCouple::String);
return true;
}
}
return false;
}
void VCProperties_Test::saveXML()
{
VCProperties p;
p.m_size = QSize(33, 44);
p.m_gmChannelMode = GrandMaster::AllChannels;
p.m_gmValueMode = GrandMaster::Limit;
p.m_gmInputUniverse = 3;
p.m_gmInputChannel = 42;
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
QVERIFY(p.saveXML(&xmlWriter) == true);
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
VCProperties p2;
QVERIFY(p2.loadXML(xmlReader) == true);
QCOMPARE(p2.size(), QSize(33, 44));
QCOMPARE(p2.grandMasterChannelMode(), GrandMaster::AllChannels);
QCOMPARE(p2.grandMasterValueMode(), GrandMaster::Limit);
QCOMPARE(p2.grandMasterInputUniverse(), quint32(3));
QCOMPARE(p2.grandMasterInputChannel(), quint32(42));
}
void VCProperties_Test::loadXMLSad()
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("VirtualConsole");
xmlWriter.writeStartElement("Properties");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Frame");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Foo");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.seek(0);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
VCProperties p;
QVERIFY(p.loadXML(xmlReader) == false);
}
bool preferences::readXml(const QString &fileName)
{
QFile *file = new QFile(fileName);
if (!file->open(QFile::ReadOnly | QFile::Text)) {
return false;
}
QXmlStreamReader xmlReader(file);
xmlReader.readNext();
xmlReader.readNext();
xmlReader.readNext();
xmlReader.readNext();
hostName = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
dataBaseName = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
userName = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
password = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
port = xmlReader.readElementText();
file->close();
return true;
}
/// <summary>
/// Fetches all available reports for the given device
/// </summary>
/// <param name="device">Name of the device to select reports for (GL_RENDERER) </param>
/// <returns></returns>
vector<reportInfo> VulkanDatabase::fetchDeviceReports(string device)
{
vector<reportInfo> reportList;
string httpReply;
stringstream urlss;
urlss << getBaseUrl() << "services/gl_getdevicereports.php?glrenderer=" << device;
string url;
url = encodeUrl(urlss.str());
httpReply = httpGet(url);
if (!httpReply.empty())
{
QXmlStreamReader xmlReader(&httpReply[0]);
while (!xmlReader.atEnd()) {
if ((xmlReader.name() == "report") && (xmlReader.isStartElement())) {
reportInfo report;
report.device = device;
QXmlStreamAttributes xmlAttribs = xmlReader.attributes();
report.operatingSystem = xmlAttribs.value("os").toString().toStdString();
report.reportId = xmlAttribs.value("id").toInt();
report.version = xmlReader.readElementText().toStdString();
reportList.push_back(report);
}
xmlReader.readNext();
}
};
return reportList;
}
void caddons_installer_dialog::step1_get_repositorities_from_file()
{
//getting the repos from ~/.gnurpgm/repos
//and the cache from ~/.gnurpgm/repo-chache
QFile targetFile( QDir::homePath() + "/.gnurpgm/repos" );
if ( !targetFile.exists() )
{
QMessageBox::information( this, tr( "Repositorities" ), tr( "The repo file in your ~/.gnurpgm folder\nis empty and get's now created." ) );
targetFile.open( QIODevice::WriteOnly );
QTextStream out( &targetFile );
out << "<repoz>\n";
out << "\t<repo name=\"std repo\" link=\"http://master.dl.sourceforge.net/project/gnurpgm/addons/repo_index.ini\" />\n";
out << "<repoz>";
}
targetFile.close();
targetFile.open( QIODevice::ReadOnly );
// QTextStream in( &targetFile );
//copied and pasted from the project_preferences.cpp
this->repositority_names.clear();
this->repositority_links.clear();
QXmlStreamReader xmlReader( &targetFile );
while ( !xmlReader.atEnd() )
{
//move the cursor ;D
xmlReader.readNext();
//finding out what thing we're parsing
if (xmlReader.isStartElement())
{
QString a = xmlReader.attributes().value( "name" ).toString();
//parsing a topic - there are only topic-s in the file -> LOL
// if (xmlReader.name().toString() == "name")
// {
//fetch the name andappend it to the list
if ( xmlReader.attributes().value( "name" ).toString() != "" )
this->repositority_names.append( xmlReader.attributes().value( "name" ).toString() );
// }
// else if (xmlReader.name().toString() == "link")
// {
if ( xmlReader.attributes().value( "link" ).toString() != "" )
this->repositority_links.append( xmlReader.attributes().value( "link" ).toString() );
// }
// else
// QMessageBox::information(this->renderArea_easy_widget, "DD", xmlReader.name().toString());
}
}
if (this->repositority_names.count() == 0)
this->repositority_names.append( "ERROR: FILE IS EMPTY (" + targetFile.fileName() + ")" );
targetFile.close();
// return names;
this->label_headline_repo_comboBox->clear();
this->label_headline_repo_comboBox->addItems( this->repositority_names );
}
void Fixture_Test::loadWrongID()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Fixture");
xmlWriter.writeTextElement("Channels", "9");
xmlWriter.writeTextElement("Name", "Foobar");
xmlWriter.writeTextElement("Universe", "0");
xmlWriter.writeTextElement("Model", "MAC250+");
xmlWriter.writeTextElement("Mode", "Mode 1");
xmlWriter.writeTextElement("Manufacturer", "Martin");
xmlWriter.writeTextElement("ID", QString::number(Fixture::invalidId()));
xmlWriter.writeTextElement("Address", "21");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
Fixture fxi(this);
QVERIFY(fxi.loadXML(xmlReader, m_doc, m_doc->fixtureDefCache()) == false);
}
void QLCFixtureHead_Test::load()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Head");
xmlWriter.writeTextElement("Channel", "0");
xmlWriter.writeTextElement("Channel", "1");
xmlWriter.writeTextElement("Channel", "15");
xmlWriter.writeTextElement("Foo", "25");
xmlWriter.writeTextElement("Channel", "42");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
QLCFixtureHead head;
QVERIFY(head.loadXML(xmlReader));
QCOMPARE(head.channels().size(), 4);
QVERIFY(head.channels().contains(0));
QVERIFY(head.channels().contains(1));
QVERIFY(head.channels().contains(15));
QVERIFY(head.channels().contains(42));
}
void Fixture_Test::loadWrongUniverse()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Fixture");
xmlWriter.writeTextElement("Channels", "18");
xmlWriter.writeTextElement("Name", "Foobar");
xmlWriter.writeTextElement("Universe", "4");
xmlWriter.writeTextElement("Model", "Foobar");
xmlWriter.writeTextElement("Mode", "Foobar");
xmlWriter.writeTextElement("Manufacturer", "Foobar");
xmlWriter.writeTextElement("ID", "42");
xmlWriter.writeTextElement("Address", "25");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
Fixture fxi(this);
QVERIFY(fxi.loadXML(xmlReader, m_doc, m_doc->fixtureDefCache()) == true);
QVERIFY(fxi.name() == "Foobar");
QVERIFY(fxi.channels() == 18);
QVERIFY(fxi.address() == 25);
QVERIFY(fxi.universe() == 4);
}
/* gets the calibration of the camera from a file */
void myprogeo::load_cam(char *fich_in,int cam, int w, int h)
{
//FILE *entrada;
//int i;
if (strlen(fich_in) ==0 ){
std::cout << w << ", " << h << std::endl;
this->cameras[cam].fdistx=515;
this->cameras[cam].fdisty=515;
this->cameras[cam].u0=h/2;
this->cameras[cam].v0=w/2;
this->cameras[cam].position.X=0;
this->cameras[cam].position.Y=0;
this->cameras[cam].position.Z=0;
this->cameras[cam].foa.X=0;
this->cameras[cam].foa.Y=1;
this->cameras[cam].foa.Z=0;
this->cameras[cam].skew=0;
this->cameras[cam].roll=0;
update_camera_matrix(&cameras[cam]);
}
else{
xmlReader(&(this->cameras[cam]), fich_in);
update_camera_matrix(&cameras[cam]);
}
display_camerainfo(cameras[cam]);
}
bool CppcheckLibraryData::open(QIODevice &file)
{
clear();
QStringList comments;
QXmlStreamReader xmlReader(&file);
while (!xmlReader.atEnd()) {
const QXmlStreamReader::TokenType t = xmlReader.readNext();
switch (t) {
case QXmlStreamReader::Comment:
comments.append(xmlReader.text().toString());
break;
case QXmlStreamReader::StartElement:
if (xmlReader.name() == "container")
containers.append(loadContainer(xmlReader));
if (xmlReader.name() == "define")
defines.append(loadDefine(xmlReader));
else if (xmlReader.name() == "function")
functions.append(loadFunction(xmlReader, comments));
else if (xmlReader.name() == "memory" || xmlReader.name() == "resource")
memoryresource.append(loadMemoryResource(xmlReader));
else if (xmlReader.name() == "podtype")
podtypes.append(loadPodType(xmlReader));
comments.clear();
break;
default:
break;
}
}
return true;
}
bool psqlDriver::readPreferences(QString fileName)
{
QFile *file = new QFile(fileName);
if (!file->open(QFile::ReadOnly | QFile::Text)) {
return false;
}
QXmlStreamReader xmlReader(file);
xmlReader.readNext();
xmlReader.readNext();
xmlReader.readNext();
xmlReader.readNext();
server = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
dbname = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
user = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
pass = xmlReader.readElementText();
xmlReader.readNext();
xmlReader.readNext();
port = xmlReader.readElementText().toInt();
file->close();
return true;
}
bool SettingsFormatXML::readXMLFile(QIODevice &device, QSettings::SettingsMap &map)
{
Q_UNUSED(device);
QXmlStreamReader xmlReader(&device);
QStringList elements;
// read until end is reached or error occurs
while (!xmlReader.atEnd() && !xmlReader.hasError()) {
// get next token
xmlReader.readNext();
// if node push it to element list
if (xmlReader.isStartElement()) {
elements.append(xmlReader.name().toString());
// if end node pop
} else if (xmlReader.isEndElement()) {
if (!elements.isEmpty()) {
elements.removeLast();
}
// if it is some data (excl. whitespaces) parse it
} else if (xmlReader.isCharacters() && !xmlReader.isWhitespace()) {
QString key = elements.join('/');
map[key] = xmlReader.text().toString();
}
}
// show warning on error
if (xmlReader.hasError()) {
qDebug() << xmlReader.errorString();
return false;
}
return true;
}
void QLCInputProfile_Test::load()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartDocument();
xmlWriter.writeDTD("<!DOCTYPE InputProfile>");
xmlWriter.writeStartElement("InputProfile");
xmlWriter.writeTextElement("Manufacturer", "Behringer");
xmlWriter.writeTextElement("Model", "BCF2000");
xmlWriter.writeStartElement("Channel");
xmlWriter.writeAttribute("Number", "492");
xmlWriter.writeTextElement("Name", "Foobar");
xmlWriter.writeTextElement("Type", "Slider");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
QLCInputProfile ip;
QVERIFY(ip.loadXML(xmlReader) == true);
QVERIFY(ip.manufacturer() == "Behringer");
QVERIFY(ip.model() == "BCF2000");
QVERIFY(ip.channels().size() == 1);
QVERIFY(ip.channel(492) != NULL);
QVERIFY(ip.channel(492)->name() == "Foobar");
QVERIFY(ip.channel(492)->type() == QLCInputChannel::Slider);
}
void VCProperties_Test::loadXMLInput()
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Input");
xmlWriter.writeAttribute("Universe", "3");
xmlWriter.writeAttribute("Channel", "78");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.seek(0);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
quint32 universe = 0;
quint32 channel = 0;
QVERIFY(VCProperties::loadXMLInput(xmlReader, &universe, &channel) == true);
QCOMPARE(universe, quint32(3));
QCOMPARE(channel, quint32(78));
buffer.close();
QByteArray bData = buffer.data();
bData.replace("<Input", "<Inputt");
buffer.setData(bData);
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
buffer.seek(0);
xmlReader.setDevice(&buffer);
xmlReader.readNextStartElement();
universe = channel = 0;
QVERIFY(VCProperties::loadXMLInput(xmlReader, &universe, &channel) == false);
QCOMPARE(universe, quint32(0));
QCOMPARE(channel, quint32(0));
QBuffer buffer2;
buffer2.open(QIODevice::ReadWrite | QIODevice::Text);
xmlWriter.setDevice(&buffer2);
xmlWriter.writeStartElement("Input");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer2.seek(0);
xmlReader.setDevice(&buffer2);
xmlReader.readNextStartElement();
universe = channel = 0;
QVERIFY(VCProperties::loadXMLInput(xmlReader, &universe, &channel) == false);
QCOMPARE(universe, InputOutputMap::invalidUniverse());
QCOMPARE(channel, QLCChannel::invalid());
}
void RssFetcher::parseXml(QIODevice *device)
{
QXmlStreamReader xmlReader(device);
TagElement currentTag = otherElement;
RssItem item;
while (!xmlReader.atEnd()) {
switch (xmlReader.readNext()) {
case QXmlStreamReader::StartElement:
currentTag = tagElement(xmlReader.name(), currentTag);
if (currentTag == itemElement) {
item = RssItem();
}
break;
case QXmlStreamReader::EndElement:
if (xmlReader.name() == QLatin1String("item")) {
m_items++;
if ((uint)m_items > (uint)m_maxItems)
return;
emit newsItemReady(item.title, item.description, item.url);
emit rssItemReady(item);
}
break;
case QXmlStreamReader::Characters:
if (!xmlReader.isWhitespace()) {
switch (currentTag) {
case titleElement:
item.title += xmlReader.text().toString();
break;
case descriptionElement:
item.description += xmlReader.text().toString();
break;
case categoryElement:
item.category += xmlReader.text().toString();
break;
case linkElement:
item.url += xmlReader.text().toString();
break;
case imageLinkElement:
item.imagePath += xmlReader.text().toString();
break;
default:
break;
}
} // !xmlReader.isWhitespace()
break;
default:
break;
}
}
if (xmlReader.error() && xmlReader.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
qWarning("Welcome::Internal::RSSFetcher: XML ERROR: %d: %s (%s)",
int(xmlReader.lineNumber()),
qPrintable(xmlReader.errorString()),
qPrintable(item.title));
}
}
void Doc_Test::load()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Engine");
createFixtureNode(xmlWriter, 0, m_currentAddr, 18);
m_currentAddr += 18;
createFixtureNode(xmlWriter, 72, m_currentAddr, 18);
m_currentAddr += 18;
createFixtureNode(xmlWriter, 15, m_currentAddr, 18);
m_currentAddr += 18;
createFixtureGroupNode(xmlWriter, 0);
createFixtureGroupNode(xmlWriter, 42);
createFixtureGroupNode(xmlWriter, 72);
createCollectionNode(xmlWriter, 5);
createCollectionNode(xmlWriter, 9);
createCollectionNode(xmlWriter, 1);
createCollectionNode(xmlWriter, 7);
createBusNode(xmlWriter, 0, 1);
createBusNode(xmlWriter, 7, 2);
createBusNode(xmlWriter, 12, 3);
createBusNode(xmlWriter, 29, 4);
createBusNode(xmlWriter, 31, 500);
xmlWriter.writeStartElement("ExtraTag");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
QVERIFY(m_doc->fixtures().size() == 0);
QVERIFY(m_doc->functions().size() == 0);
QVERIFY(m_doc->loadXML(xmlReader) == true);
QVERIFY(m_doc->fixtures().size() == 3);
QVERIFY(m_doc->functions().size() == 4);
QVERIFY(m_doc->fixtureGroups().size() == 3);
QVERIFY(Bus::instance()->value(0) == 1);
QVERIFY(Bus::instance()->value(7) == 2);
QVERIFY(Bus::instance()->value(12) == 3);
QVERIFY(Bus::instance()->value(29) == 4);
QVERIFY(Bus::instance()->value(31) == 500);
}
void MetaWindow::loadLastSettings(){
QFile *file = new QFile("settings.xml");
if(file->open(QIODevice::ReadOnly)){
QXmlStreamReader xmlReader(file);
while(!xmlReader.isEndDocument()){
if(xmlReader.isStartElement()){
if(xmlReader.name() == "lastsavedir"){
QString tempCurSave = xmlReader.readElementText();
if(tempCurSave != ""){
currentSaveDir = tempCurSave;
}
}
else if(xmlReader.name() == "lastloaddir"){
QString tempCurLoad = xmlReader.readElementText();
if(tempCurLoad != ""){
currentLoadDir = tempCurLoad;
}
}
else if(xmlReader.name() == "xres"){
QString theWidth = xmlReader.readElementText();
if(theWidth != ""){
resize(theWidth.toInt(), height());
}
}
else if(xmlReader.name() == "yres"){
QString theHeight = xmlReader.readElementText();
if(theHeight != ""){
resize(width(), theHeight.toInt());
}
}
else if(xmlReader.name() == "xpos"){
QString xpos = xmlReader.readElementText();
if(xpos != ""){
move(xpos.toInt(), y());
}
}
else if(xmlReader.name() == "ypos"){
QString ypos = xmlReader.readElementText();
if(ypos != ""){
move(x(), ypos.toInt());
}
}
else if(xmlReader.name() == "recentdoc"){
addRecentDocument(xmlReader.readElementText());
}
}
xmlReader.readNext();
}
file->close();
}
delete file;
}
void SvgView::loadFile(QString fileName)
{
qWarning() << "SVG load file " << fileName;
mFilename = fileName;
QFile file(fileName);
file.open(QIODevice::ReadOnly);
QXmlStreamReader xmlReader( file.readAll() );
file.close();
mSvgRenderer->load(&xmlReader);
refresh();
}
void QLCChannel_Test::loadWrongRoot()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Chanel");
xmlWriter.writeAttribute("Name", "Channel1");
xmlWriter.writeStartElement("Group");
xmlWriter.writeAttribute("Byte", "1");
xmlWriter.writeCharacters("Tilt");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Capability");
xmlWriter.writeAttribute("Min", "0");
xmlWriter.writeAttribute("Max", "10");
xmlWriter.writeCharacters("Cap1");
xmlWriter.writeEndElement();
/* Overlaps with cap1, shouldn't appear in the channel */
xmlWriter.writeStartElement("Capability");
xmlWriter.writeAttribute("Min", "5");
xmlWriter.writeAttribute("Max", "15");
xmlWriter.writeCharacters("Cap2");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Capability");
xmlWriter.writeAttribute("Min", "11");
xmlWriter.writeAttribute("Max", "20");
xmlWriter.writeCharacters("Cap3");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
QLCChannel ch;
QVERIFY(ch.loadXML(xmlReader) == false);
QVERIFY(ch.name().isEmpty());
QVERIFY(ch.group() == QLCChannel::Intensity);
QVERIFY(ch.controlByte() == QLCChannel::MSB);
QVERIFY(ch.capabilities().size() == 0);
}
bool clsProjectFile::ReadDataFromFile(const QString &loadFilePath)
{
QFile loadFile(loadFilePath);
if(!loadFile.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
m_pMainWindow->ClearDebugData(true);
QXmlStreamReader xmlReader(&loadFile);
while(!xmlReader.atEnd() && !xmlReader.hasError())
{
QXmlStreamReader::TokenType token = xmlReader.readNext();
if(token == QXmlStreamReader::StartDocument)
{
continue;
}
else if(token == QXmlStreamReader::StartElement)
{
if(xmlReader.name() == "NANOMITE_DATA")
{
continue;
}
else if(xmlReader.name() == "TARGET")
{
if(!ReadDebugDataFromFile(xmlReader))
{
loadFile.close();
return false;
}
}
else if(xmlReader.name().contains("BOOKMARK_"))
{
ReadBookmarkDataFromFile(xmlReader);
}
else if(xmlReader.name().contains("PATCH_"))
{
ReadPatchDataFromFile(xmlReader);
}
else if(xmlReader.name().contains("BREAKPOINT_"))
{
ReadBreakpointDataFromFile(xmlReader);
}
}
}
loadFile.close();
return true;
}
void D3MFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler)
{
D3MF::D3MFOpcPackage opcPackage(pIOHandler, pFile);
std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream()));
std::unique_ptr<D3MF::XmlReader> xmlReader(irr::io::createIrrXMLReader(xmlStream.get()));
D3MF::XmlSerializer xmlSerializer(xmlReader.get());
xmlSerializer.ImportXml(pScene);
}
void Updater::parseXml(const QByteArray& data)
{
QXmlStreamReader xmlReader(data);
while (!xmlReader.atEnd()) {
xmlReader.readNext();
if (xmlReader.isStartElement() && xmlReader.name() == "name") {
m_name = xmlReader.readElementText();
#if DEBUG
qDebug() << m_name;
#endif
}
if (xmlReader.isStartElement() && xmlReader.name() == "version") {
m_version = xmlReader.readElementText();
#if DEBUG
qDebug() << m_version;
#endif
}
if (xmlReader.isStartElement() && xmlReader.name() == "versionStr") {
m_versionStr = xmlReader.readElementText();
#if DEBUG
qDebug() << m_versionStr;
#endif
}
if (xmlReader.isStartElement() && xmlReader.name() == "url") {
m_downloadUrl = xmlReader.readElementText();
#if DEBUG
qDebug() << m_downloadUrl;
#endif
}
if (xmlReader.isStartElement() && xmlReader.name() == "webPage") {
m_webPage = xmlReader.readElementText();
#if DEBUG
qDebug() << m_webPage;
#endif
}
}
if (xmlReader.hasError())
qDebug() << xmlReader.errorString();
}
void VCProperties_Test::loadXMLHappy()
{
QBuffer buffer;
buffer.open(QIODevice::ReadWrite | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Properties");
// Size
xmlWriter.writeStartElement("Size");
xmlWriter.writeAttribute("Width", "10");
xmlWriter.writeAttribute("Height", "20");
xmlWriter.writeEndElement();
// Grand Master
xmlWriter.writeStartElement("GrandMaster");
xmlWriter.writeAttribute("ChannelMode", "All");
xmlWriter.writeAttribute("ValueMode", "Limit");
xmlWriter.writeStartElement("Input");
xmlWriter.writeAttribute("Universe", "2");
xmlWriter.writeAttribute("Channel", "15");
xmlWriter.writeEndElement();
xmlWriter.writeEndElement();
// Extra crap
xmlWriter.writeStartElement("Foo");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.seek(0);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
qDebug() << "Buffer:" << buffer.data();
VCProperties p;
QVERIFY(p.loadXML(xmlReader) == true);
QCOMPARE(p.size(), QSize(10, 20));
QCOMPARE(p.grandMasterChannelMode(), GrandMaster::AllChannels);
QCOMPARE(p.grandMasterValueMode(), GrandMaster::Limit);
QCOMPARE(p.grandMasterInputUniverse(), quint32(2));
QCOMPARE(p.grandMasterInputChannel(), quint32(15));
}
/************************************************************************
*
* GetAddressXML()
*
************************************************************************/
void SetupTab::GetAddressXML()
{
if (ui->leShipToDealer_ID->text().isEmpty() == false || ui->leShipToDealer_ID->text().contains("END USER") == false)
{
//Create custom temporary event loop on stack
QEventLoop eventLoop;
QNetworkAccessManager mgr;
QObject::connect(&mgr, SIGNAL(finished(QNetworkReply*)), &eventLoop, SLOT(quit()));
QString textSearch = ui->leShipToDealer_ID->text();
//HTTP request
QNetworkRequest req( QUrl( QString("http://spi-rabbit2:8080/addresses/address/" + textSearch)));
QNetworkReply *reply = mgr.get(req);
//Blocking
eventLoop.exec();
QByteArray result = reply->readAll();
QXmlStreamReader xmlReader(result);
XmlAddressSearchRequestParsing(xmlReader);
}
void Fixture_Test::loadWrongRoot()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Function");
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
Fixture fxi(this);
QVERIFY(fxi.loadXML(xmlReader, m_doc, m_doc->fixtureDefCache()) == false);
}
void Doc_Test::loadWrongRoot()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Enjine");
createFixtureNode(xmlWriter, 0, m_currentAddr, 18);
m_currentAddr += 18;
createFixtureNode(xmlWriter, 72, m_currentAddr, 18);
m_currentAddr += 18;
createFixtureNode(xmlWriter, 15, m_currentAddr, 18);
m_currentAddr += 18;
createFixtureGroupNode(xmlWriter, 0);
createFixtureGroupNode(xmlWriter, 42);
createFixtureGroupNode(xmlWriter, 72);
createCollectionNode(xmlWriter, 5);
createCollectionNode(xmlWriter, 9);
createCollectionNode(xmlWriter, 1);
createCollectionNode(xmlWriter, 7);
createBusNode(xmlWriter, 0, 1);
createBusNode(xmlWriter, 7, 2);
createBusNode(xmlWriter, 12, 3);
createBusNode(xmlWriter, 29, 4);
createBusNode(xmlWriter, 31, 500);
xmlWriter.writeStartElement("ExtraTag");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
QVERIFY(m_doc->loadXML(xmlReader) == false);
}
void Chaser_Test::loadWrongRoot()
{
QBuffer buffer;
buffer.open(QIODevice::WriteOnly | QIODevice::Text);
QXmlStreamWriter xmlWriter(&buffer);
xmlWriter.writeStartElement("Chaser");
xmlWriter.writeAttribute("Type", "Chaser");
xmlWriter.writeStartElement("Bus");
xmlWriter.writeAttribute("Role", "Hold");
xmlWriter.writeCharacters("16");
xmlWriter.writeEndElement();
xmlWriter.writeTextElement("Direction", "Backward");
xmlWriter.writeTextElement("RunOrder", "SingleShot");
xmlWriter.writeStartElement("Step");
xmlWriter.writeAttribute("Number", "1");
xmlWriter.writeCharacters("50");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Step");
xmlWriter.writeAttribute("Number", "2");
xmlWriter.writeCharacters("12");
xmlWriter.writeEndElement();
xmlWriter.writeStartElement("Step");
xmlWriter.writeAttribute("Number", "0");
xmlWriter.writeCharacters("87");
xmlWriter.writeEndElement();
xmlWriter.writeEndDocument();
xmlWriter.setDevice(NULL);
buffer.close();
buffer.open(QIODevice::ReadOnly | QIODevice::Text);
QXmlStreamReader xmlReader(&buffer);
xmlReader.readNextStartElement();
Chaser c(m_doc);
QVERIFY(c.loadXML(xmlReader) == false);
}
