Example #1
0
void CLandmarkPoint::dumpGPX( QXmlStreamWriter & _rqXmlStreamWriter ) const
{
  // GPX format reference: see http://www.topografix.com/GPX/1/1/

  // Data
  _rqXmlStreamWriter.writeStartElement( "wpt" );
  // ... position
  _rqXmlStreamWriter.writeAttribute( "lon", QString::number( CDataPosition::getLongitude() ) );
  _rqXmlStreamWriter.writeAttribute( "lat", QString::number( CDataPosition::getLatitude() ) );
  // ... name
  if( !qsName.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "name" );
    _rqXmlStreamWriter.writeCharacters( qsName );
    _rqXmlStreamWriter.writeEndElement(); // name
  }
  // ... elevation
  if( CDataPosition::getElevation() != CDataPosition::UNDEFINED_ELEVATION )
  {
    _rqXmlStreamWriter.writeStartElement( "ele" );
    _rqXmlStreamWriter.writeCharacters( QString::number( CDataPosition::getElevation() ) );
    _rqXmlStreamWriter.writeEndElement(); // ele
  }
  // ... type
  if( !qsType.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "type" );
    _rqXmlStreamWriter.writeCharacters( qsType );
    _rqXmlStreamWriter.writeEndElement(); // type
  }
  // ... description
  if( !qsDescription.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "desc" );
    _rqXmlStreamWriter.writeCDATA( qsDescription );
    _rqXmlStreamWriter.writeEndElement(); // desc
  }
  // ... comment
  if( !qsComment.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "cmt" );
    _rqXmlStreamWriter.writeCDATA( qsComment );
    _rqXmlStreamWriter.writeEndElement(); // cmt
  }
  // ... symbol
  if( !qsSymbol.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "sym" );
    _rqXmlStreamWriter.writeCharacters( qsSymbol );
    _rqXmlStreamWriter.writeEndElement(); // sym
  }
  // ... url
  if( !qsUrl.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "link" );
    _rqXmlStreamWriter.writeAttribute( "href", qsUrl );
    _rqXmlStreamWriter.writeEndElement(); // link
  }
  // ... [end]
  _rqXmlStreamWriter.writeEndElement(); // wpt
}
Example #2
0
void radeon_profile::saveTopbarItemsSchemas(QXmlStreamWriter &xml) {
    xml.writeStartElement("TopbarItems");

    for (const TopbarItemDefinitionSchema &tis : topbarManager.schemas) {
        xml.writeStartElement("topbarItem");

        xml.writeAttribute("type", QString::number(tis.type));
        xml.writeAttribute("primaryValueId", QString::number(tis.primaryValueId));
        xml.writeAttribute("primaryColor", tis.primaryColor.name());
        xml.writeAttribute("secondaryValueIdEnabled", QString::number(tis.secondaryValueIdEnabled));
        xml.writeAttribute("secondaryValueId", QString::number(tis.secondaryValueId));
        xml.writeAttribute("secondaryColor", tis.secondaryColor.name());
        xml.writeAttribute("pieMaxValue", QString::number(tis.pieMaxValue));

        xml.writeEndElement();
    }
    xml.writeEndElement();
}
void ProfileManagement::on_pushButton_4_clicked()
{
    int AllRowNumber;
    AllRowNumber = ui->tableWidget->rowCount();
    QDateTime DateTime =  QDateTime::currentDateTime();
    QString DateTime11 = DateTime.toString();
    if(AllRowNumber==0)
    {
        ui->textEdit->setText("<"+DateTime11+"> Brak danych do zapisu!\n");
        return;
    }
    QString fileName = QFileDialog::getSaveFileName(this, tr("Save File"),
                                                    "",
                                                    tr("Files (*.xml)"));
    if(fileName==0)
    {
        ui->textEdit->setText("<"+DateTime11+"> Brak sciezki!\n");
        return;
    }
    else
    {
        ui->textEdit->setText("<"+DateTime11+"> Plik pomyślnie wczytany!\n");
    }

    QFile file(fileName);
    file.open(QIODevice::WriteOnly);

    QXmlStreamWriter *xmlWriter = new QXmlStreamWriter(&file);
    xmlWriter->writeStartDocument();
    xmlWriter->setAutoFormatting(true);

    int tmpsila;
    int tmpkat;
    int tmppozycja;
    QString tmprotacja;
    int tmpprocent;

    int hitss;
    for(int i2=0; i2<AllRowNumber; i2++)
    {
        hitss = Profil::Profile_Array.at(i2)->Hits;
        xmlWriter->writeStartElement("Uderzenia");
        xmlWriter->writeAttribute("Ilosc", QString::number(hitss));
        xmlWriter->writeTextElement("Nazwa", ui->tableWidget->item(i2,0)->text());
        for(int i=0;i<Profil::Profile_Array.at(i2)->Rows;i++)
        {
            tmppozycja = Profil::Profile_Array.at(i2)->Position.at(i);
            tmpkat = Profil::Profile_Array.at(i2)->Angle.at(i);
            tmpsila = Profil::Profile_Array.at(i2)->Power.at(i);
            tmprotacja = Profil::Profile_Array.at(i2)->Rotation.at(i);
            tmpprocent = (float)Profil::Profile_Array.at(i2)->Percent.at(i);
            xmlWriter->writeStartElement("Uderzenie");
            xmlWriter->writeTextElement("Procent", QString::number(tmpprocent/100.0));
            xmlWriter->writeTextElement("Sila",QString::number(tmpsila));
            QString Rotacja = tmprotacja;
            if(Rotacja=="Boczna")
            {
                xmlWriter->writeTextElement("Rotacja","Boczna");
            }
            if(Rotacja=="Wsteczna")
            {
                xmlWriter->writeTextElement("Rotacja","Wsteczna");
            }
            if(Rotacja=="Gorna")
            {
                xmlWriter->writeTextElement("Rotacja","Gorna");
            }
            if(Rotacja=="Brak")
            {
                xmlWriter->writeTextElement("Rotacja","Brak");
            }
            xmlWriter->writeTextElement("Kat",QString::number(tmpkat));
            xmlWriter->writeTextElement("Pozycja",QString::number(tmppozycja));
            xmlWriter->writeEndElement();
        }
    }
    xmlWriter->writeEndElement();
    xmlWriter->writeEndDocument();
    ui->textEdit->setText("<"+DateTime11+">Plik pomyślnie zapisany!\n");

    file.close();
}
void Generate_Xml::appendXMLFile(QLineEdit *s,QVector<QLineEdit *> p,int track_subfield,int track_tabchild,int track_tabsibling)
{
	
	int j=0;
	QFile Default("default1.xml");
	std::cout << "You are now inside appendXmlFile";
    QXmlStreamWriter *xmlWriter = new QXmlStreamWriter();
    QXmlStreamWriter *xmlWriter2 = new QXmlStreamWriter();
	if (!Default.open(QIODevice::Append))
	{
	/* show wrror message if not able to open file */
	QMessageBox::warning(0, "Read only", "The file is in read only mode");
	}	
	else
	{  
		QString tem;
		QString temp1;
		
		 xmlWriter->setAutoFormatting (true);
		 xmlWriter->setDevice(&Default);
		 xmlWriter2->setDevice(&Default);
		 xmlWriter->autoFormatting();
		 tem=s->displayText();
		 xmlWriter2->writeEndDocument();
		 for(int i=0;i<track_tabchild;i++)
		 {
			 xmlWriter->writeCharacters("\t");
		 }
		 xmlWriter->writeStartElement(tem);
		 /* std::cout << "You are now appending to the file";*/
		
		  
	 
	 /*xmlWriter1->setDevice(&Default);*/
	 
	 /*xmlWriter1->autoFormatting();*/
	  /*xmlWriter1->setAutoFormatting (true);*/
			
	 
	
		
		
		
	   
		
		//while(i<t)
		//{
		//	if(p.at(i)==0 && i != (t-1))
		//	{
		//		i++;
		//		
		//	tem=(p.at(i))->displayText();
		//	/*temp=tem.toStdString();*/
		//	xmlWriter->writeStartElement(tem);
		//	    i++;
		//		
		//		
		//	}
		//	if(p.at(i-1)!= 0 && p.at(i)== 0)
		//	{
		//		//xmlWriter1->writeCharacters(" ");
		//		xmlWriter->writeEndDocument();
		//		i++;
		//		
		//		if(i=t)
		//			break;
		//		
		//	}
		//	if(p.at(i)!= 0)
		//	{
		//		tem=(p.at(i))->displayText();
		//		i++;
		//		
		//		temp1=(p.at(i))->displayText();
		//		i++;
		//		
		//		xmlWriter->writeAttribute(tem,temp1);
		//		
		//	}
		//}
		
			 
			 xmlWriter->writeCharacters(" ");
		Default.close();
	
		for(int i=0;i<track_subfield;++i)
			j=rewriteXMLFile(p,j+1,track_tabsibling);
		
	
    
	 
	 //xmlWriter->writeStartDocument();
	 
	 //xmlWriter->writeAttribute("name"," ");//This is only useful
	
	
	 //xmlWriter->writeEndDocument();


	}
	delete xmlWriter2;
	bool a;
	Default.open(QIODevice::Append);
	QXmlStreamWriter *xmlWriter1 = new QXmlStreamWriter();
	xmlWriter1->setDevice(&Default);
	xmlWriter1->writeEndDocument();
	a=xmlWriter->autoFormatting();
	xmlWriter->setAutoFormatting(a);
	//xmlWriter->writeCharacters(" ");
	for(int i=0;i<track_tabchild;i++)
		 {
			 xmlWriter->writeCharacters("\t");
		 }
	xmlWriter->writeEndDocument();
	delete xmlWriter;
	delete xmlWriter1;

}
Example #5
0
void radeon_profile::saveOcProfiles(QXmlStreamWriter &xml) {
    xml.writeStartElement("OcProfiles");

    for (QString k : ocProfiles.keys()) {
        xml.writeStartElement("ocProfile");
        xml.writeAttribute("name", k);

        auto oct = ocProfiles.value(k);
        xml.writeAttribute("powerCap", QString::number(oct.powerCap));

        for (auto tk : oct.tables.keys()) {
            const FVTable &fvt = oct.tables.value(tk);

            xml.writeStartElement("table");
            xml.writeAttribute("tableName", tk);

            for (auto fvtk : fvt.keys()) {
                const FreqVoltPair &fvp = fvt.value(fvtk);

                xml.writeStartElement("state");
                xml.writeAttribute("enabled", QString::number(true));
                xml.writeAttribute("stateNumber", QString::number(fvtk));
                xml.writeAttribute("frequency", QString::number(fvp.frequency));
                xml.writeAttribute("voltage", QString::number(fvp.voltage));

                xml.writeEndElement();
            }

            xml.writeEndElement();
        }

        xml.writeEndElement();
    }

    xml.writeEndElement();
}
Example #6
0
void Distance::writeXml(QXmlStreamWriter& writer) const {
    writer.writeStartElement("distance");
    writer.writeTextElement("dist", QString::number(dist));
    writer.writeTextElement("unit", unitToQString(unit));
    writer.writeEndElement();
}
Example #7
0
void ScaleBarOverlay::writeCurrentConfig(QXmlStreamWriter &writer)
{
    RectOverlay::writeCurrentConfig(writer);
    writer.writeTextElement("color", mPen.color().name());
}
Example #8
0
/** Writes <tagName>Base64_encoded_value</tagName> to the XML stream. */
void PwStreamUtilsV4::writeBase64(QXmlStreamWriter& xml, const QString& tagName, const QByteArray& value) {
    xml.writeTextElement(tagName, value.toBase64());
}
Example #9
0
/** Writes <tagName>bool_value_as_string</tagName> to the XML stream. */
void PwStreamUtilsV4::writeBool(QXmlStreamWriter& xml, const QString& tagName, const bool value) {
    xml.writeTextElement(tagName, value ? XML_TRUE : XML_FALSE);
}
Example #10
0
/** Writes <tagName>time_value</tagName> to the XML stream. */
void PwStreamUtilsV4::writeTime(QXmlStreamWriter& xml, const QString& tagName, const QDateTime& time) {
    xml.writeTextElement(tagName, time.toTimeSpec(Qt::UTC).toString(Qt::ISODate)); // YYYY-MM-DDTHH:mm:ssZ
}
Example #11
0
/** Writes <tagName>UUID_as_base64</tagName> to the XML stream. */
void PwStreamUtilsV4::writeUuid(QXmlStreamWriter& xml, const QString& tagName, const PwUuid& uuid) {
    xml.writeTextElement(tagName, uuid.toByteArray().toBase64());
}
Example #12
0
void OsmWriter::_writeRelations(shared_ptr<const OsmMap> map, QXmlStreamWriter& writer)
{
  RelationMap::const_iterator it = map->getRelationMap().begin();
  while (it != map->getRelationMap().end())
  {
    const shared_ptr<Relation>& r = it->second;
    writer.writeStartElement("relation");
    writer.writeAttribute("visible", "true");
    writer.writeAttribute("id", QString::number(r->getId()));

    _writeMetadata(writer, r.get());

    const vector<RelationData::Entry>& members = r->getMembers();
    for (size_t j = 0; j < members.size(); j++)
    {
      const RelationData::Entry& e = members[j];
      writer.writeStartElement("member");
      writer.writeAttribute("type", _typeName(e.getElementId().getType()));
      writer.writeAttribute("ref", QString::number(e.getElementId().getId()));
      writer.writeAttribute("role", _e(e.role));
      writer.writeEndElement();
    }

    const Tags& tags = r->getTags();
    for (Tags::const_iterator tit = tags.constBegin(); tit != tags.constEnd(); ++tit)
    {
      if (tit.key().isEmpty() == false && tit.value().isEmpty() == false)
      {
        writer.writeStartElement("tag");
        writer.writeAttribute("k", _e(tit.key()));
        writer.writeAttribute("v", _e(tit.value()));
        writer.writeEndElement();
      }
    }

    if (r->getType() != "")
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "type");
      writer.writeAttribute("v", _e(r->getType()));
      writer.writeEndElement();
    }

    if (r->getCircularError() >= 0)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "error:circular");
      writer.writeAttribute("v", QString("%1").arg(r->getCircularError()));
      writer.writeEndElement();
    }

    if (_includeDebug || _includeIds)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:id");
      writer.writeAttribute("v", QString("%1").arg(r->getId()));
      writer.writeEndElement();
    }

    if (_includeDebug)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:status");
      writer.writeAttribute("v", QString("%1").arg(r->getStatus().getEnum()));
      writer.writeEndElement();
    }

    writer.writeEndElement();

    ++it;
  }
}
Example #13
0
void OsmWriter::_writeWays(shared_ptr<const OsmMap> map, QXmlStreamWriter& writer)
{
  WayMap::const_iterator it = map->getWays().begin();
  while (it != map->getWays().end())
  {
    const Way* w = it->second.get();
    writer.writeStartElement("way");
    writer.writeAttribute("visible", "true");
    writer.writeAttribute("id", QString::number(w->getId()));

    _writeMetadata(writer, w);

    for (size_t j = 0; j < w->getNodeCount(); j++)
    {
      writer.writeStartElement("nd");
      long nid = w->getNodeId(j);
      writer.writeAttribute("ref", QString::number(w->getNodeId(j)));
      if (_includePointInWays)
      {
        shared_ptr<const Node> n = map->getNode(nid);
        writer.writeAttribute("x", QString::number(n->getX(), 'g', _precision));
        writer.writeAttribute("y", QString::number(n->getY(), 'g', _precision));
      }
      writer.writeEndElement();
    }

    const Tags& tags = w->getTags();
    for (Tags::const_iterator tit = tags.constBegin(); tit != tags.constEnd(); ++tit)
    {
      if (tit.key().isEmpty() == false && tit.value().isEmpty() == false)
      {
        writer.writeStartElement("tag");
        writer.writeAttribute("k", _e(tit.key()));
        writer.writeAttribute("v", _e(tit.value()));
        writer.writeEndElement();
      }
    }

    if (w->getCircularError() >= 0)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "error:circular");
      writer.writeAttribute("v", QString("%1").arg(w->getCircularError()));
      writer.writeEndElement();
    }

    if (_includeDebug || _includeIds)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:id");
      writer.writeAttribute("v", QString("%1").arg(w->getId()));
      writer.writeEndElement();
    }

    if (_includeDebug)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:status");
      writer.writeAttribute("v", QString("%1").arg(w->getStatus().getEnum()));
      writer.writeEndElement();
    }

    writer.writeEndElement();

    ++it;
  }
}
Example #14
0
void OsmWriter::_writeNodes(shared_ptr<const OsmMap> map, QXmlStreamWriter& writer)
{
  QList<long> nids;
  NodeMap::const_iterator it = map->getNodeMap().begin();
  while (it != map->getNodeMap().end()) {
    nids.append(it->first);
    ++it;
  }

  // sort the values to give consistent results.
  qSort(nids.begin(), nids.end(), qGreater<long>());
  for (int i = 0; i < nids.size(); i++)
  {
    const Node* n = map->getNode(nids[i]).get();
    writer.writeStartElement("node");
    writer.writeAttribute("visible", "true");
    writer.writeAttribute("id", QString::number(n->getId()));
    _writeMetadata(writer, n);
    writer.writeAttribute("lat", QString::number(n->getY(), 'f', _precision));
    writer.writeAttribute("lon", QString::number(n->getX(), 'f', _precision));

    const Tags& tags = n->getTags();
    for (Tags::const_iterator it = tags.constBegin(); it != tags.constEnd(); it++)
    {
      if (it.key().isEmpty() == false && it.value().isEmpty() == false)
      {
        writer.writeStartElement("tag");
        writer.writeAttribute("k", _e(it.key()));
        writer.writeAttribute("v", _e(it.value()));
        writer.writeEndElement();
      }
    }

    // turn this on when we start using node circularError.
    if (n->getCircularError() >= 0 && n->getTags().getNonDebugCount() > 0)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "error:circular");
      writer.writeAttribute("v", QString("%1").arg(n->getCircularError()));
      writer.writeEndElement();
    }

    if (_includeDebug || _includeIds)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:id");
      writer.writeAttribute("v", QString("%1").arg(n->getId()));
      writer.writeEndElement();
    }

    if (_includeDebug)
    {
      writer.writeStartElement("tag");
      writer.writeAttribute("k", "hoot:status");
      writer.writeAttribute("v", QString("%1").arg(n->getStatus().getEnum()));
      writer.writeEndElement();
    }

    writer.writeEndElement();
  }
}
void SharedStrings::writeRichStringPart_rPr(QXmlStreamWriter &writer, const Format &format) const
{
    if (!format.hasFontData())
        return;

    if (format.fontBold())
        writer.writeEmptyElement(QStringLiteral("b"));
    if (format.fontItalic())
        writer.writeEmptyElement(QStringLiteral("i"));
    if (format.fontStrikeOut())
        writer.writeEmptyElement(QStringLiteral("strike"));
    if (format.fontOutline())
        writer.writeEmptyElement(QStringLiteral("outline"));
    if (format.boolProperty(FormatPrivate::P_Font_Shadow))
        writer.writeEmptyElement(QStringLiteral("shadow"));
    if (format.hasProperty(FormatPrivate::P_Font_Underline)) {
        Format::FontUnderline u = format.fontUnderline();
        if (u != Format::FontUnderlineNone) {
            writer.writeEmptyElement(QStringLiteral("u"));
            if (u== Format::FontUnderlineDouble)
                writer.writeAttribute(QStringLiteral("val"), QStringLiteral("double"));
            else if (u == Format::FontUnderlineSingleAccounting)
                writer.writeAttribute(QStringLiteral("val"), QStringLiteral("singleAccounting"));
            else if (u == Format::FontUnderlineDoubleAccounting)
                writer.writeAttribute(QStringLiteral("val"), QStringLiteral("doubleAccounting"));
        }
    }
    if (format.hasProperty(FormatPrivate::P_Font_Script)) {
        Format::FontScript s = format.fontScript();
        if (s != Format::FontScriptNormal) {
            writer.writeEmptyElement(QStringLiteral("vertAlign"));
            if (s == Format::FontScriptSuper)
                writer.writeAttribute(QStringLiteral("val"), QStringLiteral("superscript"));
            else
                writer.writeAttribute(QStringLiteral("val"), QStringLiteral("subscript"));
        }
    }

    if (format.hasProperty(FormatPrivate::P_Font_Size)) {
        writer.writeEmptyElement(QStringLiteral("sz"));
        writer.writeAttribute(QStringLiteral("val"), QString::number(format.fontSize()));
    }

    if (format.hasProperty(FormatPrivate::P_Font_Color)) {
        XlsxColor color = format.property(FormatPrivate::P_Font_Color).value<XlsxColor>();
        color.saveToXml(writer);
    }

    if (!format.fontName().isEmpty()) {
        writer.writeEmptyElement(QStringLiteral("rFont"));
        writer.writeAttribute(QStringLiteral("val"), format.fontName());
    }
    if (format.hasProperty(FormatPrivate::P_Font_Family)) {
        writer.writeEmptyElement(QStringLiteral("family"));
        writer.writeAttribute(QStringLiteral("val"), QString::number(format.intProperty(FormatPrivate::P_Font_Family)));
    }

    if (format.hasProperty(FormatPrivate::P_Font_Scheme)) {
        writer.writeEmptyElement(QStringLiteral("scheme"));
        writer.writeAttribute(QStringLiteral("val"), format.stringProperty(FormatPrivate::P_Font_Scheme));
    }
}
Example #16
0
/** Writes <tagName>value</tagName> to the XML stream. */
void PwStreamUtilsV4::writeInt32(QXmlStreamWriter& xml, const QString& tagName, const qint32 value) {
    xml.writeTextElement(tagName, QString::number(value));
}
Example #17
0
void Film::sauvegarde(QXmlStreamWriter & stream)
{
    qDebug()<<"Sauvegade de "<<nom();
    stream.writeStartElement("media");
    stream.writeTextElement("nom", nom());
    stream.writeTextElement("genre", genre());
    stream.writeTextElement("date", date().toString("d/M/yyyy"));
    stream.writeTextElement("vue", QString::number(isFini()));
    stream.writeTextElement("url", url().toString());
    stream.writeTextElement("type", getType());
    stream.writeTextElement("realisateur", getRealisateur());
    stream.writeTextElement("scenariste", getScenariste());
    stream.writeTextElement("support", QString::number(getSupport()));
    stream.writeTextElement("duree", getDuree().toString());

    foreach(QString jupiter, getActeursPrincipaux())
    {
        stream.writeTextElement("acteur", jupiter);
    }
Example #18
0
bool TrainingSetFile::flush()
{
	QXmlStreamWriter tsWriteXML;

	int
			nPatterns = ts->getPatternCount(),
			nInputs = ts->getInputsSize(),
			nTargets = ts->getTargetsSize();

	QString strInputs,
			strTargets;

	vector<vector<double> >
			inputs = ts->getInputs(),
			targets = ts->getTargets();

	Normalization
			*inputsNorm = ts->getInputsNormalization(),
			*targetsNorm = ts->getTargetsNormalization();

	QString
			strInputsNorm = inputsNorm->getName(),
			strTargetsNorm = targetsNorm->getName();

	DataRepresentation
			*idr = ts->getInputsDataRepresentation(),
			*tdr = ts->getTargetsDataRepresentation();

	tsWriteXML.setDevice(this);
	tsWriteXML.setAutoFormatting(true);
	tsWriteXML.setAutoFormattingIndent(3);

	tsWriteXML.writeStartDocument();

	tsWriteXML.writeStartElement(STR_TRAININGSET);
	//Indica el numero de patrones a almacenar
	tsWriteXML.writeAttribute(STR_PATTERNSIZE, QString::number(nPatterns));

	//Indica el tamaño de las entradas
	tsWriteXML.writeAttribute(STR_INPUTSSIZE, QString::number(nInputs));

	//Indica el tamaño de las salidas
	tsWriteXML.writeAttribute(STR_TARGETSSIZE, QString::number(nTargets));

	//Indica propiedades particulares del archivo
	tsWriteXML.writeStartElement(STR_PROPERTIES);
	tsWriteXML.writeAttribute(STR_VERSION, "1.0.0");
	tsWriteXML.writeEndElement();

	//Este parametro indica que representacion grafica se usara para visualizar entradas
	tsWriteXML.writeStartElement(STR_INPUTSDATAREPRESENTATION);
	tsWriteXML.writeAttribute(STR_NAME, idr->getName());
	tsWriteXML.writeAttribute(STR_FORMAT, idr->getImageFormatName());
	tsWriteXML.writeAttribute(STR_WIDTH, QString::number(idr->getWidth()));
	tsWriteXML.writeAttribute(STR_HEIGHT, QString::number(idr->getHeight()));
	tsWriteXML.writeEndElement();

	//Este parametro indica que representacion grafica se usara para visualizar las salidas
	tsWriteXML.writeStartElement(STR_TARGETSDATAREPRESENTATION);
	tsWriteXML.writeAttribute(STR_NAME, tdr->getName());
	tsWriteXML.writeAttribute(STR_FORMAT, tdr->getImageFormatName());
	tsWriteXML.writeAttribute(STR_WIDTH, QString::number(tdr->getWidth()));
	tsWriteXML.writeAttribute(STR_HEIGHT, QString::number(tdr->getHeight()));
	tsWriteXML.writeEndElement();

	//Normalizacion de entradas
	tsWriteXML.writeStartElement(STR_INPUTSNORMALIZATION);
	tsWriteXML.writeAttribute(STR_TYPE, strInputsNorm);
	tsWriteXML.writeAttribute(STR_MAXVALUE, QString::number(inputsNorm->getMaxValue(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_MINVALUE, QString::number(inputsNorm->getMinValue(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_THRESHOLD, QString::number(inputsNorm->getThreshold(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_AMPLITUDE, QString::number(inputsNorm->getAmplitude(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_ELONGATION, QString::number(inputsNorm->getElongation(), decimalformat, decimals));
	tsWriteXML.writeEndElement();

	//Normalizacion de salidas
	tsWriteXML.writeStartElement(STR_TARGETSNORMALIZATION);
	tsWriteXML.writeAttribute(STR_TYPE, strTargetsNorm);
	tsWriteXML.writeAttribute(STR_MAXVALUE, QString::number(targetsNorm->getMaxValue(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_MINVALUE, QString::number(targetsNorm->getMinValue(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_THRESHOLD, QString::number(targetsNorm->getThreshold(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_AMPLITUDE, QString::number(targetsNorm->getAmplitude(), decimalformat, decimals));
	tsWriteXML.writeAttribute(STR_ELONGATION, QString::number(targetsNorm->getElongation(), decimalformat, decimals));
	tsWriteXML.writeEndElement();

	for(int p = 0; p < nPatterns; p++){
		tsWriteXML.writeStartElement(STR_PATTERN);
		tsWriteXML.writeAttribute(STR_INDEX, QString::number(p));
		//Se escriben las entradas
		tsWriteXML.writeStartElement(STR_INPUTS);
		strInputs = "";
		for(int i = 0; i < nInputs; i++){
			strInputs += QString::number(inputs[p][i], decimalformat, decimals);
			if(i != nInputs - 1){
				strInputs += STR_SEPARATOR;
			}
		}
		tsWriteXML.writeCharacters(strInputs);
		tsWriteXML.writeEndElement();//inputs

		//Se escriben las salidas
		tsWriteXML.writeStartElement(STR_TARGETS);
		strTargets = "";
		for(int t = 0; t < nTargets; t++){
			strTargets += QString::number(targets[p][t], decimalformat, decimals);
			if(t != nTargets - 1){
				strTargets += STR_SEPARATOR;
			}
		}
		//		tsXML.writeTextElement("targets", strTargets);
		tsWriteXML.writeCharacters(strTargets);
		tsWriteXML.writeEndElement();//targets
		tsWriteXML.writeEndElement();//pattern
	}
	tsWriteXML.writeEndElement();//trainingset
	tsWriteXML.writeEndDocument();

	return true;
}
void
SoundSettings::saveXML (
        const QString   &xmlFileName,
        const QString   &origFileName,
        const QString   &copyFileName,
        const QString   &title)
{
    QXmlStreamWriter *writer;
    QFile             file (xmlFileName);

    SYS_DEBUG ("-----------------------------------------------------");
    SYS_DEBUG ("*** xmlFileName = %s", SYS_STR(xmlFileName));

    if (!file.open(QIODevice::WriteOnly)) {
        SYS_WARNING ("Unable to open file for writing: %s",
                SYS_STR(xmlFileName));
        return;
    }

    /*
     *
     */
    writer = new QXmlStreamWriter();
    writer->setDevice (&file);
    writer->setAutoFormatting(true);
    writer->setCodec ("UTF-8");
    writer->writeStartDocument ();
    writer->writeStartElement ("soundsettings-applet");

    writer->writeStartElement("orig-file");
        writer->writeCharacters (origFileName);
    writer->writeEndElement ();

    writer->writeStartElement("copy-file");
        writer->writeCharacters (copyFileName);
    writer->writeEndElement ();

    writer->writeStartElement("title");
        writer->writeCharacters (title);
    writer->writeEndElement ();

    /*
     *
     */
    writer->writeEndElement();
    writer->writeEndDocument();

    delete writer;
    file.close ();
}
Example #20
0
void CVesselContainer::dumpQVCT( QXmlStreamWriter & _rqXmlStreamWriter, bool bOnlySelected ) const
{
  // Data
  _rqXmlStreamWriter.writeStartElement( "Flotilla" );
  // ... name
  if( !qsName.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "name", qsName );
  // ... visibility
  _rqXmlStreamWriter.writeAttribute( "visibility", QString::number( COverlayVisibility::getVisibility() ) );
  // ... type
  if( !qsType.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "type", qsType );
  // ... url
  if( !qsUrl.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "url", qsUrl );
  // ... description
  if( !qsDescription.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "Description" );
    _rqXmlStreamWriter.writeCDATA( qsDescription );
    _rqXmlStreamWriter.writeEndElement(); // Description
  }
  // ... comment
  if( !qsComment.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "Comment" );
    _rqXmlStreamWriter.writeCDATA( qsComment );
    _rqXmlStreamWriter.writeEndElement(); // Comment
  }
  // ... points
  if( !bDynamic )
  {
    int __iCount = QTreeWidgetItem::childCount();
    for( int __i = 0; __i < __iCount; __i++ )
    {
      CVesselPoint* __poVesselPoint = (CVesselPoint*)QTreeWidgetItem::child( __i );
      if( bOnlySelected && !__poVesselPoint->isMultiSelected() ) continue;
      __poVesselPoint->dumpQVCT( _rqXmlStreamWriter );
    }
  }
  else
  {
    CVesselContainerDevice* __poVesselContainerDevice = (CVesselContainerDevice*)QTreeWidgetItem::child( 0 );
    __poVesselContainerDevice->dumpQVCT( _rqXmlStreamWriter );
  }
  // ... [end]
  _rqXmlStreamWriter.writeEndElement(); // Flotilla
}
Example #21
0
bool TrackNode::toGPX(QXmlStreamWriter& stream, QProgressDialog * progress, QString element, bool forExport)
{
    bool OK = true;

    if (isVirtual())
        return OK;

    if (!tagValue("_waypoint_","").isEmpty() ||!sizeParents())
        stream.writeStartElement("wpt");
    else
        stream.writeStartElement(element);

    if (!forExport)
        stream.writeAttribute("xml:id", xmlId());
    stream.writeAttribute("lon",COORD2STRING(BBox.topRight().x()));
    stream.writeAttribute("lat", COORD2STRING(BBox.topRight().y()));

    stream.writeTextElement("time", time().toString(Qt::ISODate)+"Z");

    QString s = tagValue("name","");
    if (!s.isEmpty()) {
        stream.writeTextElement("name", s);
    }
    if (elevation()) {
        stream.writeTextElement("ele", QString::number(elevation(),'f',6));
    }
    if (speed()) {
        stream.writeTextElement("speed", QString::number(speed(),'f',6));
    }
    s = tagValue("_comment_","");
    if (!s.isEmpty()) {
        stream.writeTextElement("cmt", s);
    }
    s = tagValue("_description_","");
    if (!s.isEmpty()) {
        stream.writeTextElement("desc", s);
    }

    // OpenStreetBug
    s = tagValue("_special_","");
    if (!s.isEmpty() && id().type & IFeature::Special) {
        stream.writeStartElement("extensions");
        QString sid = stripToOSMId(id());
        stream.writeTextElement("id", sid);
        stream.writeEndElement();
    }
    stream.writeEndElement();

    if (progress)
        progress->setValue(progress->value()+1);

    return OK;
}
Example #22
0
void DB::save() const
{
    /*
      The QFile class provides an interface for reading from and writing to files.
      QFile is an I/O device for reading and writing text and binary files and resources.
      A QFile may be used by itself or, more conveniently, with a QTextStream or QDataStream.
    */
    QFile* file = new QFile("../database.xml");
    /*
      The QIODevice class is the base interface class of all I/O devices in Qt.
      QIODevice provides both a common implementation and an abstract interface for
      devices that support reading and writing of blocks of data, such as QFile, QBuffer and QTcpSocket.
      QIODevice is abstract and can not be instantiated, but it is common to use the interface it defines
      to provide device-independent I/O features. For example, Qt's XML classes operate on a QIODevice pointer,
      allowing them to be used with various devices (such as files and buffers).
    */
    if(!file->open(QIODevice::WriteOnly | QIODevice::Text))
    {
       QMessageBox err;
       err.setText("Errore nell'apertura del file");
       err.exec();
    }
    else
    {
       /*
         The QXmlStreamWriter class provides an XML writer with a simple streaming API.
         QXmlStreamWriter is the counterpart to QXmlStreamReader for writing XML.
         Like its related class, it operates on a QIODevice specified with setDevice().
         The API is simple and straightforward: for every XML token or event you want to write,
         the writer provides a specialized function.
         You start a document with writeStartDocument() and end it with writeEndDocument().
         This will implicitly close all remaining open tags.
       */
       QXmlStreamWriter* inp = new QXmlStreamWriter;
       inp->setAutoFormatting(true);
       //Sets the current device to device.
       inp->setDevice(file);
       inp->writeStartDocument();
       inp->writeStartElement("utenti");
       for(vector<Utente*>::const_iterator it = db.begin(); it != db.end(); ++it)
       {
           inp->writeStartElement("utente");
           inp->writeTextElement("nome", QString::fromStdString(((*it)->getProfilo()).getNome()));
           inp->writeTextElement("cognome", QString::fromStdString(((*it)->getProfilo()).getCognome()));
           inp->writeTextElement("username", QString::fromStdString(((*it)->getUsername()).getLogin()));
           inp->writeTextElement("email", QString::fromStdString(((*it)->getProfilo()).getEmail()));
           if(dynamic_cast<UtenteBasic*>(*(it)))
           {
               inp->writeTextElement("tipoutente", QString::fromStdString("Utente Basic"));
           }
           else if(dynamic_cast<UtenteBusiness*>(*(it)))
           {
               inp->writeTextElement("tipoutente", QString::fromStdString("Utente Business"));
           }
           else
           {
               inp->writeTextElement("tipoutente", QString::fromStdString("Utente Executive"));
           }
           inp->writeTextElement("competenze", QString::fromStdString((*it)->getProfilo().tutteCompetenze()));
           inp->writeTextElement("esperienze", QString::fromStdString((*it)->getProfilo().tutteEsperienze()));
           inp->writeTextElement("lingue", QString::fromStdString((*it)->getProfilo().tutteLingue()));
           inp->writeTextElement("titolistudio", QString::fromStdString((*it)->getProfilo().tuttiTitoliStudio()));
           inp->writeTextElement("contatti", QString::fromStdString(((*it)->getRete())->tuttiContatti()));
           inp->writeEndElement();
        }
        inp->writeEndElement();
        inp->writeEndDocument();
        file->close();

        QMessageBox msgBox;
        msgBox.setText("Salvataggio avvenuto con successo");
        msgBox.exec();
    }
}
int Generate_Xml::rewriteXMLFile(QVector<QLineEdit *> p,int j,int track_tabsibling)
{
	bool tab;
	int tab_get;
	QFile Default("default1.xml");
	
	QXmlStreamWriter *xmlWriter = new QXmlStreamWriter();
	QXmlStreamWriter *newline = new QXmlStreamWriter();
	xmlWriter->setDevice(&Default);
	newline->setDevice(&Default);
	xmlWriter->setAutoFormatting (true);
	xmlWriter->setAutoFormatting(true);
	tab=xmlWriter->autoFormatting();
	
	xmlWriter->setAutoFormattingIndent(-10);
	tab_get=xmlWriter->autoFormattingIndent();
	
		
	
	if (!Default.open(QIODevice::Append))
	{
	/* show wrror message if not able to open file */
	QMessageBox::warning(0, "Read only", "The file is in read only mode");
	}	
	QString temp1;
	QString temp2;
		 
		 
	temp1=(p.at(j))->displayText();
		
	newline->writeEndDocument();

	for(int i=0;i<track_tabsibling;i++)//changed tab here actaully multiplied by two
	xmlWriter->writeCharacters("\t");

	xmlWriter->writeStartElement(temp1);
		
	j++;
				
	while(p.at(j)!=0)
	{
	temp1=(p.at(j))->displayText();
	j++;
	temp2=(p.at(j))->displayText();
	j++;
	xmlWriter->writeAttribute(temp1,temp2);
	}

	xmlWriter->writeEndElement();

	Default.close();
	delete xmlWriter;
	delete newline;
	return j;
}
Example #24
0
void CSD::save(QXmlStreamWriter &s) {
  s.writeStartElement(staticTypeTag);
  s.writeAttribute("vector", _inputVectors[CSD_INVECTOR]->Name());
  s.writeAttribute("samplerate", QString::number(_frequency));
  s.writeAttribute("gaussiansigma", QString::number(_gaussianSigma));
  s.writeAttribute("average", QVariant(_average).toString());
  s.writeAttribute("fftlength", QString::number(int(ceil(log(double(_length*2)) / log(2.0)))));
  s.writeAttribute("removemean", QVariant(_removeMean).toString());
  s.writeAttribute("apodize", QVariant(_apodize).toString());
  s.writeAttribute("apodizefunction", QString::number(_apodizeFxn));
  s.writeAttribute("windowsize", QString::number(_windowSize));
  s.writeAttribute("vectorunits", _vectorUnits);
  s.writeAttribute("rateunits", _rateUnits);
  s.writeAttribute("outputtype", QString::number(_outputType));
  saveNameInfo(s,VNUM|XNUM|MNUM|CSDNUM);

  s.writeEndElement();
}
Example #25
0
void radeon_profile::writePlotAxisSchemaToXml(QXmlStreamWriter &xml, const QString side, const PlotAxisSchema &pas) {
    xml.writeStartElement("axis");
    xml.writeAttribute("align", side);
    xml.writeAttribute("enabled", QString::number(pas.enabled));
    xml.writeAttribute("unit", QString::number(pas.unit));
    xml.writeAttribute("ticks", QString::number(pas.ticks));
    xml.writeAttribute("penStyle", QString::number(pas.penGrid.style()));
    xml.writeAttribute("penWidth", QString::number(pas.penGrid.width()));
    xml.writeAttribute("penColor", pas.penGrid.color().name());
    xml.writeEndElement();

    for (const ValueID &sk : pas.dataList.keys()) {
        xml.writeStartElement("serie");
        xml.writeAttribute("align", side);
        xml.writeAttribute("id", QString::number(sk));
        xml.writeAttribute("color", pas.dataList.value(sk).name());
        xml.writeEndElement();
    }
}
Example #26
0
void DeviceInfo::WriteXml(QXmlStreamWriter& xml) const
{
	xml.writeStartElement("device");

	xml.writeStartElement("manufacturer");
	xml.writeCharacters(manufacturer);
	xml.writeEndElement();

	xml.writeStartElement("product");
	xml.writeCharacters(product);
	xml.writeEndElement();

	xml.writeStartElement("name");
	xml.writeCharacters(name);
	xml.writeEndElement();

	xml.writeEndElement();
}
Example #27
0
void radeon_profile::saveRpevents(QXmlStreamWriter &xml) {
    xml.writeStartElement("RPEvents");

    for (RPEvent rpe : events) {
        xml.writeStartElement("rpevent");
        xml.writeAttribute("name", rpe.name);
        xml.writeAttribute("enabled", QString::number(rpe.enabled));
        xml.writeAttribute("tiggerType", QString::number(rpe.type));
        xml.writeAttribute("activationBinary", rpe.activationBinary);
        xml.writeAttribute("activationTemperature", QString::number(rpe.activationTemperature));
        xml.writeAttribute("dpmProfileChange", QString::number(rpe.dpmProfileChange));
        xml.writeAttribute("powerLevelChange", QString::number(rpe.powerLevelChange));
        xml.writeAttribute("fixedFanSpeedChange", QString::number(rpe.fixedFanSpeedChange));
        xml.writeAttribute("fanProfileNameChange",rpe.fanProfileNameChange);
        xml.writeAttribute("fanComboIndex", QString::number(rpe.fanComboIndex));
        xml.writeEndElement();
    }

    xml.writeEndElement();
}
Example #28
0
void FirmwareInfo::WriteXml(QXmlStreamWriter& xml) const
{
	xml.writeStartDocument();
	xml.writeStartElement("firmware");
	xml.writeAttribute("version", QString::number(FirmwareInfo::kVersion));

	xml.writeStartElement("name");
	xml.writeCharacters(name);
	xml.writeEndElement();

	xml.writeStartElement("version");
	xml.writeCharacters(version);
	xml.writeEndElement();

	platformInfo.WriteXml(xml);

	xml.writeStartElement("developers");

	for (int i = 0; i < developers.length(); i++)
	{
		xml.writeStartElement("name");
		xml.writeCharacters(developers[i]);
		xml.writeEndElement();
	}

	xml.writeEndElement();

	if (!url.isEmpty())
	{
		xml.writeStartElement("url");
		xml.writeCharacters(url);
		xml.writeEndElement();
	}

	if (!donateUrl.isEmpty())
	{
		xml.writeStartElement("donateurl");
		xml.writeCharacters(donateUrl);
		xml.writeEndElement();
	}

	xml.writeStartElement("devices");

	for (int i = 0; i < deviceInfos.length(); i++)
		deviceInfos[i].WriteXml(xml);

	xml.writeEndElement();

	xml.writeStartElement("pit");

	int lastSlash = pitFilename.lastIndexOf('/');

	if (lastSlash < 0)
		lastSlash = pitFilename.lastIndexOf('\\');

	xml.writeCharacters(pitFilename.mid(lastSlash + 1));

	xml.writeEndElement();

	xml.writeStartElement("repartition");
	xml.writeCharacters((repartition) ? "1" : "0");
	xml.writeEndElement();

	xml.writeStartElement("noreboot");
	xml.writeCharacters((noReboot) ? "1" : "0");
	xml.writeEndElement();

	xml.writeStartElement("files");

	for (int i = 0; i < fileInfos.length(); i++)
	{
		fileInfos[i].WriteXml(xml, Packaging::ClashlessFilename(fileInfos, i));
	}

	xml.writeEndElement();

	xml.writeEndElement();
	xml.writeEndDocument();
}
bool OsmAnd::FavoriteLocationsGpxCollection_P::saveTo(QXmlStreamWriter& writer) const
{
	QReadLocker scopedLocker(&_collectionLock);

	writer.writeStartDocument(QLatin1String("1.0"), true);
	
	//<gpx
	//	  version="1.1"
	//	  creator="OsmAnd"
	//	  xmlns="http://www.topografix.com/GPX/1/1"
	//	  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	//	  xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd">
	writer.writeStartElement(QLatin1String("gpx"));
	writer.writeAttribute(QLatin1String("version"), QLatin1String("1.1"));
	writer.writeAttribute(QLatin1String("creator"), QLatin1String("OsmAnd"));
	writer.writeAttribute(QLatin1String("xmlns"), QLatin1String("http://www.topografix.com/GPX/1/1"));
	writer.writeAttribute(QLatin1String("xmlns:xsi"), QLatin1String("http://www.w3.org/2001/XMLSchema-instance"));
	writer.writeAttribute(QLatin1String("xsi:schemaLocation"), QLatin1String("http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd"));

	for (const auto& item : constOf(_collection))
	{
		// <wpt>
		writer.writeStartElement(QLatin1String("wpt"));
		writer.writeAttribute(QLatin1String("lat"), QString::number(item->latLon.latitude, 'f', 12));
        writer.writeAttribute(QLatin1String("lon"), QString::number(item->latLon.longitude, 'f', 12));

		// <name>
		writer.writeTextElement(QLatin1String("name"), item->getTitle());

		const auto group = item->getGroup();
		if (!group.isEmpty())
		{
			// <category>
			writer.writeTextElement(QLatin1String("category"), group);
		}

		const auto color = item->getColor();
		if (color != ColorRGB())
		{
			// <extensions>
			writer.writeStartElement(QLatin1String("extensions"));

			// <color>
            const auto colorValue = color.toString();
			writer.writeTextElement(QLatin1String("color"), colorValue);

            // <hidden>
            if (item->isHidden())
                writer.writeEmptyElement(QLatin1String("hidden"));

			// </extensions>
			writer.writeEndElement();
		}

		// </wpt>
		writer.writeEndElement();
	}

	// </gpx>
	writer.writeEndElement();
	
	writer.writeEndDocument();

	return true;
}
Example #30
0
void CLandmarkPoint::dumpQVCT( QXmlStreamWriter & _rqXmlStreamWriter ) const
{

  // Data
  _rqXmlStreamWriter.writeStartElement( "Point" );
  // ... name
  if( !qsName.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "name", qsName );
  // ... visibility
  _rqXmlStreamWriter.writeAttribute( "visibility", QString::number( COverlayVisibility::getVisibility() ) );
  // ... position
  _rqXmlStreamWriter.writeAttribute( "longitude", QString::number( CDataPosition::getLongitude() ) );
  _rqXmlStreamWriter.writeAttribute( "latitude", QString::number( CDataPosition::getLatitude() ) );
  // ... elevation
  if( CDataPosition::getElevation() != CDataPosition::UNDEFINED_ELEVATION )
    _rqXmlStreamWriter.writeAttribute( "elevation", QString::number( CDataPosition::getElevation() ) );
  // ... type
  if( !qsType.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "type", qsType );
  // ... symbol
  if( !qsSymbol.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "symbol", qsSymbol );
  // ... url
  if( !qsUrl.isEmpty() ) _rqXmlStreamWriter.writeAttribute( "url", qsUrl );
  // ... description
  if( !qsDescription.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "Description" );
    _rqXmlStreamWriter.writeCDATA( qsDescription );
    _rqXmlStreamWriter.writeEndElement(); // Description
  }
  // ... comment
  if( !qsComment.isEmpty() )
  {
    _rqXmlStreamWriter.writeStartElement( "Comment" );
    _rqXmlStreamWriter.writeCDATA( qsComment );
    _rqXmlStreamWriter.writeEndElement(); // Comment
  }
  // ... [end]
  _rqXmlStreamWriter.writeEndElement(); // Point
}