bool XmlNotation::write(const std::vector<Moves> &mv)
{
QDomDocument doc;
auto proc = doc.createProcessingInstruction(
u8"xml", u8"version=\"1.0\" encoding=\"utf-8\"");
doc.appendChild(proc);
auto cAuthors = doc.createComment(fromU8Str(impl::comment));
doc.appendChild(cAuthors), doc.appendChild(doc.createTextNode("\n"));
auto eRoot = doc.createElementNS(fromU8Str(impl::xmlns),
fromU8Str(impl::eRoot));
doc.appendChild(eRoot);
for (auto &i : mv) {
auto eTurn = doc.createElement(fromU8Str(impl::eTurn));
eRoot.appendChild(eTurn);
eTurn.setAttribute(fromU8Str(impl::aWhite),
QString::fromStdString(i.white_move.to_string()));
eTurn.setAttribute(fromU8Str(impl::aBlack),
QString::fromStdString(i.black_move.to_string()));
}
QByteArray raw = doc.toByteArray(4);
std::ofstream f(_pImpl->fileName,
std::ios_base::binary |
std::ios_base::trunc);
f.write(raw.data(), raw.count());
return true;
}
bool StandardContactList::save()
{
if(!ProfileManager::instance()->profilePath().isEmpty())
{
QString cfgName = ProfileManager::instance()->profilePath() + QDir::separator() + "contacts.xml";
ProfileManager::instance()->sync();
QDomDocument doc;
doc.appendChild(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\""));
QDomElement root = doc.createElement("contactlist");
QDomElement global = doc.createElement("global");
m_userData->serialize(global);
root.appendChild(global);
QDomElement owner = doc.createElement("owner");
save_owner(owner);
root.appendChild(owner);
QDomElement groups = doc.createElement("groups");
if(save_groups(groups))
root.appendChild(groups);
QDomElement contacts = doc.createElement("contacts");
if(save_contacts(contacts))
root.appendChild(contacts);
doc.appendChild(root);
QFile f(cfgName);
f.open(QIODevice::WriteOnly | QIODevice::Truncate);
f.write(doc.toByteArray());
f.close();
}
return true;
}
bool ConfigXML::createDeclFile()
{
QDomDocument document;
QDomProcessingInstruction xmldecl = document.createProcessingInstruction("xml", "version=\"1.0\"");
document.appendChild(xmldecl);
QDomElement config = document.createElement("config");
document.appendChild(config);
QDomElement modules = document.createElement("modules");
config.appendChild(modules);
QDomElement module = document.createElement(CnMn);
modules.appendChild(module);
QDomElement active = document.createElement("active");
active.appendChild(document.createTextNode("true"));
module.appendChild(active);
QDomElement poolElement = document.createElement("codePool");
poolElement.appendChild(document.createTextNode(moduleConf->getPool()));
module.appendChild(poolElement);
return writeXML(getDeclFilePath(), document);
}
void MyMoneyStatement::writeXMLFile(const MyMoneyStatement& _s, const QString& _filename)
{
static unsigned filenum = 1;
QString filename = _filename;
if (filename.isEmpty()) {
filename = QString("statement-%1%2.xml").arg((filenum < 10) ? "0" : "").arg(filenum);
filenum++;
}
QDomDocument* doc = new QDomDocument("KMYMONEY-STATEMENT");
Q_CHECK_PTR(doc);
//writeStatementtoXMLDoc(_s,doc);
QDomProcessingInstruction instruct = doc->createProcessingInstruction(QString("xml"), QString("version=\"1.0\" encoding=\"utf-8\""));
doc->appendChild(instruct);
QDomElement eroot = doc->createElement("KMYMONEY-STATEMENT");
doc->appendChild(eroot);
_s.write(eroot, doc);
QFile g(filename);
if (g.open(QIODevice::WriteOnly)) {
QTextStream stream(&g);
stream.setCodec("UTF-8");
stream << doc->toString();
g.close();
}
delete doc;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
QFile file("test.xml");
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate ))
return;
else
qDebug()<<"ths file is existing!";
QDomDocument doc;
QDomText text;
QDomProcessingInstruction instruction;
instruction=doc.createProcessingInstruction("xml", "version = \'1.0\'");
doc.appendChild(instruction);
QDomElement school=doc.createElement("school");
doc.appendChild(school);
QDomElement schoolGuangMing=doc.createElement("schoolGuangMing");
school.appendChild(schoolGuangMing);
QDomElement grate1=doc.createElement("grate1");
text=doc.createTextNode("一年级");
grate1.appendChild(text);
schoolGuangMing.appendChild(grate1);
QDomElement student= doc.createElement("student1");
QDomAttr name=doc.createAttribute("name");
name.setValue("李明");
QDomAttr number=doc.createAttribute("number");
number.setValue("0x12313");
student.setAttributeNode(name);
student.setAttributeNode(number);
schoolGuangMing.appendChild(student);
QDomElement grate2=doc.createElement("grate2");
text=doc.createTextNode("二年级");
grate2.appendChild(text);
schoolGuangMing.appendChild(grate2);
QDomElement grate3=doc.createElement("grate3");
text=doc.createTextNode("三年级");
grate3.appendChild(text);
schoolGuangMing.appendChild(grate3);
QDomElement grate4=doc.createElement("grate4");
text=doc.createTextNode("四年级");
grate4.appendChild(text);
schoolGuangMing.appendChild(grate4);
QTextStream out( &file );
doc.save( out, 7 );
file.close();
}
void MIPControl::saveColorConfig()
{
const QString filename = QFileDialog::getSaveFileName
( this
, "Save MIP Layers"
, ""
, "XML-Files (*.XML)"
, 0
, QFileDialog::DontResolveSymlinks
| QFileDialog::HideNameFilterDetails );
if( filename.isEmpty() )
{
return;
}
QDomDocument dom;
dom.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"utf-8\"" );
QDomElement root = dom.createElement( "MIPLayers" );
dom.appendChild( root );
// see: http://www.digitalfanatics.org/projects/qt_tutorial/chapter09.html
for( std::size_t layerIdx = 0; layerIdx < mip.layersCount(); ++layerIdx )
{
const presets::MIPLayer& layer = mip.layer( layerIdx );
QDomElement node = dom.createElement( "Layer" );
node.setAttribute( "minHuv", layer.huRange.first );
node.setAttribute( "maxHuv", layer.huRange.last );
const base::Color& color = layer.color;
node.setAttribute( "colorR", color.r );
node.setAttribute( "colorG", color.g);
node.setAttribute( "colorB", color.b );
node.setAttribute( "colorA", color.a );
const unsigned int functionIdx = MIPLayerEditor::functionIndex( layer.function() );
const std::string functionName = MIPLayerEditor::functionName( functionIdx );
node.setAttribute( "function", QString::fromStdString( functionName ) );
root.appendChild( node );
}
QFile file( filename );
if( !file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
{
throw base::CarnaException
( "Save MIP Layers"
, "Failed opening file for writing."
, ( "Filename: '" + filename + "'" ).toStdString() );
}
QTextStream stream( &file );
stream << dom.toString();
file.close();
}
void MainWindow::saveConfig() {
QString fileName =
QFileDialog::getSaveFileName(this,
tr("Save File"),
QDir::currentPath(),
tr("All files (*.xml)"));
if (fileName.isEmpty()) {
return;
}
QFile file(fileName);
if (!file.open(QFile::WriteOnly | QFile::Text)) {
QMessageBox::warning(this, tr("Circle"),
tr("Cannot write file %1:\n%2.")
.arg(fileName)
.arg(file.errorString()));
return;
}
QDomDocument doc;
doc.appendChild(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"")) ;
QDomElement properties = doc.createElement("properties");
properties.appendChild(newOption(doc,
"option",
"posX",
"int",
QString::number(ui->horizontalSlider->minimum()),
QString::number(ui->horizontalSlider->maximum()),
QString::number(ui->horizontalSlider->value()),
"X position of circle's center"));
properties.appendChild(newOption(doc,
"option",
"posY",
"int",
QString::number(ui->horizontalSlider_2->minimum()),
QString::number(ui->horizontalSlider_2->maximum()),
QString::number(ui->horizontalSlider_2->value()),
"Y position of circle's center"));
properties.appendChild(newOption(doc,
"option",
"R",
"int",
QString::number(ui->horizontalSlider_3->minimum()),
QString::number(ui->horizontalSlider_3->maximum()),
QString::number(ui->horizontalSlider_3->value()),
QString("Radius of circle's center")));
doc.appendChild(properties);
QTextStream out(&file);
out << doc.toString();
file.close();
}
QDomDocument Manager::creerXml()
{
QDomDocument doc;
QDomNode xmlNode = doc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"UTF-8\"");
doc.insertBefore(xmlNode, doc.firstChild());
return doc;
}
void XMLOperations::touchMainConfigFile()
{
QFile mainConfigFile(MAINCONFIGFILE_PATH);
if (!mainConfigFile.exists())
{
if (!mainConfigFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
{
return;
}
QDomDocument domDocument;
QDomProcessingInstruction instruction;
instruction=domDocument.createProcessingInstruction("xml","version=\'1.0\' encoding=\'UTF-8\'");
domDocument.appendChild(instruction);
//创建MainConfig根节点
QDomElement mainConfigNode = domDocument.createElement("MainConfig");
//将各个子节点添加到@mainConfigNode节点上
#ifdef Q_OS_LINUX
mainConfigNode.appendChild(createChildElement("OperatingSystem", "Linux"));
#elif Q_OS_WIN
mainConfigNode.appendChild(createChildElement("OperatingSystem", "Windows"));
#else
mainConfigNode.appendChild(createChildElement("OperatingSystem", "UnSupport"));
#endif
mainConfigNode.appendChild(createChildElement("Version", "1.0.0"));
mainConfigNode.appendChild(createChildElement("DownloadSpeed", "2000"));
mainConfigNode.appendChild(createChildElement("UploadSpeed", "500"));
mainConfigNode.appendChild(createChildElement("WindowsSavePath",
QStandardPaths::standardLocations(QStandardPaths::DownloadLocation).at(0) + "/PointDownload"));
mainConfigNode.appendChild(createChildElement("LinuxSavePath",
QStandardPaths::standardLocations(QStandardPaths::DownloadLocation).at(0) + "/PointDownload"));
mainConfigNode.appendChild(createChildElement("Beep", "true"));
mainConfigNode.appendChild(createChildElement("EnableUpload", "true"));
mainConfigNode.appendChild(createChildElement("ThreadCount", "5"));
mainConfigNode.appendChild(createChildElement("VideoDetectType", "mov;mkv;swf;flv;mp4;avi;rmvb;rm;3gp"));
mainConfigNode.appendChild(createChildElement("AudioDetectType", "mp3;wma;flac;ape;wav;acc"));
mainConfigNode.appendChild(createChildElement("MaxJobCount", "10"));
mainConfigNode.appendChild(createChildElement("clipboard", "true"));
mainConfigNode.appendChild(createChildElement("exitOnClose", "false"));
mainConfigNode.appendChild(createChildElement("aria2Path", ""));
mainConfigNode.appendChild(createChildElement("yougetPath", ""));
//添加元素节点到父节点
domDocument.appendChild(mainConfigNode);
//写xml文件
QTextStream textStream(&mainConfigFile);
domDocument.save(textStream,4);
mainConfigFile.close();
}
}
void DataManipulation::presetLibrary() {
if(!file->open(QIODevice::ReadWrite | QIODevice::Text | QIODevice::Truncate) ){
}
QByteArray content = file->readAll();
QDomDocument doc;
doc.setContent(content);
QDomProcessingInstruction instr = doc.createProcessingInstruction(
"xml", "version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild(instr);
QDomElement data = doc.createElement("data");
//---- writing exercises ----//
QDomElement exLib = doc.createElement("ExerciseLibrary");
QList<ExerciseName> exer;
exer.append("Bench Press");
exer.append("Bicep Curl");
exer.append("Crunch");
exer.append("Deadlift");
exer.append("Dips");
exer.append("Leg Press");
exer.append("Leg Throw");
exer.append("Lunge");
exer.append("Plank");
exer.append("Pull Up");
exer.append("Russian Twist");
exer.append("Sit Up");
exer.append("Squat");
exer.append("Tricep Extension");
int numE = exer.count();
for (int i = 1; i <= numE; i++) {
QDomElement newEx = doc.createElement("Exercise");
newEx.setAttribute("drill", i);
QDomText name = doc.createTextNode(exer[i-1]);
newEx.appendChild(name);
exLib.appendChild(newEx);
}
data.appendChild(exLib);
doc.appendChild(data);
QTextStream out(file);
out << doc.toString();
file->close();
return;
}
//XML
//Converts the given lists and puts them in an XML tree
QString TaskList_Main::listsToXML(const QListWidget &inList){
QDomDocument doc;
QDomProcessingInstruction instr = doc.createProcessingInstruction(
"xml", "version='1.0' encoding='UTF-8'");
doc.appendChild(instr);
//Create list to hold individual task lists
QDomElement listElement = addElement(doc, doc, "listset");
//Iteratore through available 'lists'
for(int i = 0; i < inList.count(); ++i){
QDomElement list = addElement(doc, listElement, "list");
addElement(doc, list, "list_title", inList.item(i)->text());
//Find associated note mapping
my_listwidget *listPtr = notePane->listMap[inList.item(i)];
//Iterates through 'tasks' in 'list'
bool nextIsSub = false;
for(int j = 0; j < listPtr->count(); ++j){
QDomElement task = addElement(doc, list, "task");
QListWidgetItem *taskPtr = listPtr->item(j);
//If next item is subtext...
if(nextIsSub){
nextIsSub = false;
task.setAttribute("task_type", "sub");
addElement(doc, task, "task_title", taskPtr->text());
addElement(doc, task, "task_font", taskPtr->font().toString());
}
//Else, we know it's main task
else{
task.setAttribute("task_type", "main");
addElement(doc, task, "task_title", taskPtr->text());
if(taskPtr->checkState() == Qt::Unchecked)
addElement(doc, task, "task_check", "unchecked");
if(taskPtr->checkState() == Qt::Checked)
addElement(doc, task, "task_check", "checked");
if(taskPtr->checkState() == Qt::PartiallyChecked)
addElement(doc, task, "task_check", "part_check");
addElement(doc, task, "task_note", taskPtr->data(32).toString());
addElement(doc, task, "task_display", taskPtr->data(33).toString());
addElement(doc, task, "task_date", taskPtr->data(34).toDate().toString(Qt::ISODate));
addElement(doc, task, "task_font", taskPtr->font().toString());
if(taskPtr->data(35).toBool() == true){
nextIsSub = true;
}
}
}
}
//Return DOM document
return doc.toString();
}
QString MaiaFault::toString() {
QDomDocument doc;
QDomProcessingInstruction header = doc.createProcessingInstruction( "xml", QString("version=\"1.0\" encoding=\"UTF-8\"" ));
doc.appendChild(header);
QDomElement methodResponse = doc.createElement("methodResponse");
doc.appendChild(methodResponse);
QDomElement faultelement = doc.createElement("fault");
methodResponse.appendChild(faultelement);
faultelement.appendChild(MaiaObject::toXml(fault));
return doc.toString();
}
//创建xml文件
bool MainWindow::create_xml(const QString &strFilePath, const QString &strRoot)
{
QDomDocument domDoc; //整个文档
QDomProcessingInstruction instruction = domDoc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"GB2312\"");
domDoc.appendChild(instruction);
QDomElement root = domDoc.createElement(strRoot); //根节点
domDoc.appendChild(root);
return save_xmlFile(strFilePath,domDoc);
}
QString SyncSchedule::toString() const
{
QDomDocument doc;
QDomProcessingInstruction xmlHeading =
doc.createProcessingInstruction("xml",
"version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild(xmlHeading);
QDomElement root = toXml(doc);
doc.appendChild(root);
return doc.toString(PROFILE_INDENT);
}
QByteArray TestModel::save()
{
QDomDocument doc;
QDomProcessingInstruction pi = doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf8\"");
doc.appendChild(pi);
QDomElement modelEl = doc.createElement("model");
doc.appendChild(modelEl);
QDomElement cellsEl = doc.createElement("cells");
cellsEl.setAttribute("rows", rowCount());
cellsEl.setAttribute("cols", columnCount());
modelEl.appendChild(cellsEl);
QDomElement titlesEl = doc.createElement("titles");
for (int i = 0; i < columnCount(); i++) {
QDomElement col = doc.createElement(QString("col%1").arg(i));
QDomText text = doc.createTextNode(headerData(i, Qt::Horizontal, Qt::DisplayRole).toString());
col.appendChild(text);
titlesEl.appendChild(col);
}
modelEl.appendChild(titlesEl);
for (int row = 0; row < rowCount(); row++) {
QDomElement itemRow = doc.createElement(QString("row%1").arg(row));
for (int col = 0; col < columnCount(); col++ ) {
//TODO save images
if (index(row, col).data().toString().simplified().isEmpty()) {
continue;
}
QDomElement itemCol = doc.createElement(QString("col%1").arg(col));
itemCol.setAttribute("type", QVariant::typeToName(columnType(col)));
QDomText text = doc.createTextNode(index(row, col).data().toByteArray());
itemCol.appendChild(text);
itemRow.appendChild(itemCol);
}
if (itemRow.childNodes().count() > 0)
cellsEl.appendChild(itemRow);
}
// QFile file("c:/test.xml");
// if(file.open(QIODevice::WriteOnly)) {
// QTextStream(&file) << doc.toString();
// file.close();
// }
return doc.toByteArray().toBase64();
}
///
/// Save the preferences file
///
void Preferences::savePreferences()
{
//string prefDir = QDir::homePath().append("/.composite").toLocal8Bit().constData();
QString filename = m_sPreferencesFilename;
DEBUGLOG( "Saving preferences file: " + filename );
QDomDocument doc;
QDomProcessingInstruction header = doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild( header );
QDomNode rootNode = doc.createElement( "hydrogen_preferences" );
// Hydrogen/Tritium/Composite version
LocalFileMng::writeXmlString( rootNode, "version", QString( get_version().c_str() ) );
////// GENERAL ///////
LocalFileMng::writeXmlString( rootNode, "restoreLastSong", restoreLastSong ? "true": "false" );
LocalFileMng::writeXmlString( rootNode, "patternModePlaysSelected", m_bPatternModePlaysSelected ? "true": "false" );
//show development version warning
LocalFileMng::writeXmlString( rootNode, "showDevelWarning", m_bShowDevelWarning ? "true": "false" );
// hear new notes in the pattern editor
LocalFileMng::writeXmlString( rootNode, "hearNewNotes", hearNewNotes ? "true": "false" );
// key/midi event prefs
LocalFileMng::writeXmlString( rootNode, "recordEvents", recordEvents ? "true": "false" );
LocalFileMng::writeXmlString( rootNode, "quantizeEvents", quantizeEvents ? "true": "false" );
// Recent used songs
QDomNode recentUsedSongsNode = doc.createElement( "recentUsedSongs" );
{
unsigned nSongs = 5;
if ( m_recentFiles.size() < 5 ) {
nSongs = m_recentFiles.size();
}
for ( unsigned i = 0; i < nSongs; i++ ) {
LocalFileMng::writeXmlString( recentUsedSongsNode, "song", m_recentFiles[ i ] );
}
}
rootNode.appendChild( recentUsedSongsNode );
QDomNode recentFXNode = doc.createElement( "recentlyUsedEffects" );
{
int nFX = 0;
QString FXname;
foreach( FXname, m_recentFX ) {
LocalFileMng::writeXmlString( recentFXNode, "FX", FXname );
if ( ++nFX > 10 ) break;
}
}
bool BCLXML::save() const
{
if (m_path.empty()){
return false;
}
QDomDocument doc;
doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
QDomElement docElement;
if (m_bclXMLType == BCLXMLType::ComponentXML){
docElement = doc.createElement("component");
doc.appendChild(docElement);
}else if (m_bclXMLType == BCLXMLType::MeasureXML){
docElement = doc.createElement("measure");
doc.appendChild(docElement);
}else{
return false;
}
QDomElement element = doc.createElement("name");
docElement.appendChild(element);
element.appendChild(doc.createTextNode(toQString(escapeString(m_name))));
element = doc.createElement("uid");
docElement.appendChild(element);
element.appendChild(doc.createTextNode(toQString(m_uid)));
element = doc.createElement("version_id");
docElement.appendChild(element);
element.appendChild(doc.createTextNode(toQString(m_versionId)));
element = doc.createElement("description");
docElement.appendChild(element);
element.appendChild(doc.createTextNode(toQString(escapeString(m_description))));
if (m_bclXMLType == BCLXMLType::MeasureXML){
element = doc.createElement("modeler_description");
docElement.appendChild(element);
element.appendChild(doc.createTextNode(toQString(escapeString(m_modelerDescription))));
}
// TODO: write provenances
element = doc.createElement("provenances");
docElement.appendChild(element);
// write tags
element = doc.createElement("tags");
Q_FOREACH(const std::string& tag, m_tags){
QDomElement tagElement = doc.createElement("tag");
element.appendChild(tagElement);
tagElement.appendChild(doc.createTextNode(toQString(tag)));
}
QString SearchManager::toXML() const
{
QDomDocument doc;
doc.appendChild(doc.createProcessingInstruction( "xml",
"version=\"1.0\" encoding=\"UTF-8\""));
QDomElement root = doc.createElement("klinkstatus");
doc.appendChild(root);
save(root);
return doc.toString(4);
}
void MSWordImport::prepareDocument( QDomDocument& mainDocument, QDomElement& framesetsElem )
{
mainDocument.appendChild( mainDocument.createProcessingInstruction( "xml","version=\"1.0\" encoding=\"UTF-8\"" ) );
QDomElement elementDoc;
elementDoc=mainDocument.createElement("DOC");
elementDoc.setAttribute("editor","KWord's MS Word Import Filter");
elementDoc.setAttribute("mime","application/x-kword");
elementDoc.setAttribute("syntaxVersion",2);
mainDocument.appendChild(elementDoc);
framesetsElem=mainDocument.createElement("FRAMESETS");
mainDocument.documentElement().appendChild(framesetsElem);
}
KoFilter::ConversionStatus MSWordImport::convert( const QCString& from, const QCString& to )
{
// check for proper conversion
if ( to != "application/x-kword" || from != "application/msword" )
return KoFilter::NotImplemented;
kdDebug(30513) << "######################## MSWordImport::convert ########################" << endl;
QDomDocument mainDocument;
QDomElement framesetsElem;
prepareDocument( mainDocument, framesetsElem );
QDomDocument documentInfo;
documentInfo.appendChild (documentInfo.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
Document document( QFile::encodeName( m_chain->inputFile() ).data(), mainDocument, documentInfo, framesetsElem, m_chain );
if ( !document.hasParser() )
return KoFilter::WrongFormat;
if ( !document.parse() )
return KoFilter::ParsingError;
document.processSubDocQueue();
document.finishDocument();
if ( !document.bodyFound() )
return KoFilter::WrongFormat;
KoStoreDevice* out = m_chain->storageFile( "root", KoStore::Write );
if ( !out ) {
kdError(30502) << "Unable to open output file!" << endl;
return KoFilter::StorageCreationError;
}
QCString cstr = mainDocument.toCString();
// WARNING: we cannot use KoStore::write(const QByteArray&) because it gives an extra NULL character at the end.
out->writeBlock( cstr, cstr.length() );
out->close();
out = m_chain->storageFile( "documentinfo.xml", KoStore::Write );
if ( !out ) {
return KoFilter::StorageCreationError;
}
cstr = documentInfo.toCString();
out->writeBlock( cstr, cstr.length() );
out->close();
kdDebug(30513) << "######################## MSWordImport::convert done ####################" << endl;
return KoFilter::OK;
}
void SessionStorageServiceImpl::generateSaveDoc(QDomDocument& doc)
{
doc.appendChild(doc.createProcessingInstruction("xml version =", "'1.0'"));
QDomElement patientNode = doc.createElement("patient");
// note: all nodes must be below <patient>. XML requires only one root node per file.
QDomElement versionName = doc.createElement("version_name");
versionName.appendChild(doc.createTextNode(this->getVersionName()));
patientNode.appendChild(versionName);
QDomElement activePatientNode = doc.createElement("active_patient");
activePatientNode.appendChild(doc.createTextNode(mActivePatientFolder.toStdString().c_str()));
patientNode.appendChild(activePatientNode);
doc.appendChild(patientNode);
}
void XMLWriter::Write(QFile& file){
QDomDocument doc;
auto instruction = doc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild(instruction);
QDomElement root = doc.createElement("map");
root.setAttribute("version","1.0");
doc.appendChild(root);
//Head
Head(root);
//Body
Body(root);
//写入到xml文件
QTextStream out(&file);
doc.save(out, 4);
file.close();
}
void save(const char* filename, const Grammar& grammar) {
QFile file(filename);
file.open(QFile::WriteOnly);
QDomDocument doc;
QDomElement root = doc.createElement("grammar");
root.setAttribute("version", "1.0");
root.setAttribute("author", "Gen Nishida");
doc.appendChild(root);
save(doc, root, grammar);
QTextStream out(&file);
QDomNode xmlNode = doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"ISO-8859-1\"");
doc.insertBefore(xmlNode, doc.firstChild());
doc.save(out, 4);
}
void Qtfe::save()
{
QDomDocument doc;
QDomElement MultiEditor;
QFile file;
QTextStream out;
file.setFileName(filename);
if (!file.open(QIODevice::WriteOnly))
return;
out.setDevice(&file);
MultiEditor = doc.createElement("Qtfe");
doc.appendChild(MultiEditor);
for(int i=0 ; i<canals.size() ; ++i)
{
QDomElement func = doc.createElement("Function");
MultiEditor.appendChild(func);
for(int j=0 ; j<canals[i]->getPoints().size() ; ++j)
{
QDomElement point = doc.createElement("point");
func.appendChild(point);
point.setAttribute("x", QString::number(canals[i]->getPoints()[j]->x()));
point.setAttribute("y", QString::number(canals[i]->getPoints()[j]->y()));
}
}
for(int i=0 ; i<outputs.size() ; ++i)
{
QDomElement output = doc.createElement("Output");
MultiEditor.appendChild(output);
output.setAttribute("R", QString::number(outputs[i]->R));
output.setAttribute("G", QString::number(outputs[i]->G));
output.setAttribute("B", QString::number(outputs[i]->B));
output.setAttribute("A", QString::number(outputs[i]->A));
}
QDomNode noeud = doc.createProcessingInstruction("xml","version=\"1.0\"");
doc.insertBefore(noeud,doc.firstChild());
doc.save(out,2);
file.close();
}
/*
* 把user信息写到相应的xml文件中
*/
bool SysInfoIO::writetofileforUser(QList<User *> listUser)
{
QString filepath = QDir::currentPath() + UserPath;
QFile file(filepath);
if (!file.exists()) {
if (file.open(QIODevice::ReadWrite)) {
file.close();
}
}
if (!file.open(QFile::WriteOnly | QFile::Text)) {
return false;
}
file.flush();
QDomDocument doc;
QDomNode xmlNode = doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild(xmlNode);
QDomNode root = doc.createElement("Root");
foreach (User *tmp, listUser) {
QString userCode = tmp->getUserCode();
QString password = tmp->getUserPsw();
int userType = tmp->getUserType();
QDomElement user = doc.createElement("User");
QDomElement xmlname = doc.createElement("UserCode");
xmlname.setAttribute("value", userCode);
user.appendChild(xmlname);
QDomElement xmlpasswor = doc.createElement("Psw");
xmlpasswor.setAttribute("value", password);
user.appendChild(xmlpasswor);
QDomElement xmlusertype = doc.createElement("UserType");
xmlusertype.setAttribute("value", QString::number(userType));
user.appendChild(xmlusertype);
root.appendChild(user);
}
void BookmarkWidget::buildDOMDocument(QDomDocument& doc, QDomElement& root)
{
QDomProcessingInstruction instruct = doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild(instruct);
root = doc.createElement(BOOKMARK_XML_ROOT);
QDir* dir = new QDir();
QFileInfo finfo(bfn);
QString fn = QDir::toNativeSeparators(dir->relativeFilePath(finfo.absoluteFilePath()));
root.setAttribute(FILENAME, fn);
root.setAttribute(UUID_NAME, QUuid::createUuid());
QString dt = QDateTime::currentDateTimeUtc().toString();
root.setAttribute(DATE_CREATED, dt);
root.setAttribute(DATE_MODIFIED, dt);
root.setAttribute(DATE_ACCESSED, dt);
doc.appendChild(root);
}
void StreamMonitor::getHbBaseData()
{
QDomDocument doc;
QDomProcessingInstruction instruction;
instruction = doc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"UTF-8\"");
doc.appendChild(instruction);
QDomElement message = doc.createElement("message"); //<message>
doc.appendChild(message);
QDomElement type = doc.createElement("TYPE");//<TYPE>
QDomText typeContent = doc.createTextNode(QString::number(Send_GetData_Req));
type.appendChild(typeContent);
message.appendChild(type);
QString bsDataXml = doc.toString();
qInfo()<<bsDataXml;
if(sendMsg(bsDataXml)) //如果发送成功，则不再发送，停掉计时器，否则继续
{
getHbTimer->stop();
}
}
bool SimpleXMLExporter::Export(QByteArray& out) {
QDomDocument doc;
doc.appendChild(doc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"utf-8\"" ));
QDomElement root = doc.createElement("Font");
doc.appendChild(root);
root.appendChild(text(doc, "size", QString::number(fontConfig()->size())));
root.appendChild(text(doc, "height", QString::number(metrics().height)));
int offset = metrics().ascender;
foreach (const Symbol& c , symbols()) {
QDomElement ce = doc.createElement("Char");
ce.appendChild(text(doc, "code", QString::number(c.id)));
{
QDomElement place = doc.createElement("place");
place.appendChild(text(doc, "x", QString::number(c.placeX)));
place.appendChild(text(doc, "y", QString::number(c.placeY)));
ce.appendChild(place);
}
{
QDomElement dim = doc.createElement("dimensions");
dim.appendChild(text(doc, "x", QString::number(c.placeW)));
dim.appendChild(text(doc, "y", QString::number(c.placeH)));
ce.appendChild(dim);
}
{
QDomElement rect = doc.createElement("rect");
rect.appendChild(text(doc, "x", QString::number(c.offsetX)));
rect.appendChild(text(doc, "y", QString::number(offset - c.offsetY)));
ce.appendChild(rect);
}
ce.appendChild(text(doc, "width", QString::number(c.advance)));
assert(c.kerning.begin() == c.kerning.end());
root.appendChild(ce);
}
void save(const char* filename, const std::vector<Grammar>& grammars) {
QFile file(filename);
file.open(QFile::WriteOnly);
QDomDocument doc;
QDomElement root = doc.createElement("grammars");
root.setAttribute("version", "1.0");
root.setAttribute("author", "Gen Nishida");
doc.appendChild(root);
for (int i = 0; i < grammars.size(); ++i) {
QDomElement grammar_node = doc.createElement("grammar");
root.appendChild(grammar_node);
save(doc, grammar_node, grammars[i]);
}
QTextStream out(&file);
QDomNode xmlNode = doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"ISO-8859-1\"");
doc.insertBefore(xmlNode, doc.firstChild());
doc.save(out, 4);
}
QString MaiaObject::prepareResponse(QVariant arg) {
QDomDocument doc;
QDomProcessingInstruction header = doc.createProcessingInstruction( "xml", QString("version=\"1.0\" encoding=\"UTF-8\"" ));
doc.appendChild(header);
QDomElement methodResponse = doc.createElement("methodResponse");
QDomElement params = doc.createElement("params");
QDomElement param;
doc.appendChild(methodResponse);
methodResponse.appendChild(params);
if(!arg.isNull()) {
param = doc.createElement("param");
param.appendChild(toXml(arg));
params.appendChild(param);
}
return doc.toString();
}
