bool EBTextEdit::writeFile(QString sFileName )
{
Q_ASSERT(m_FullFileName.size());
//save or save as?
if (sFileName.isEmpty())
sFileName = m_FullFileName;
QDomDocument xmlDocument; //has to be first because of EditorView::OnlyPlainData reads it
QFile fileWrite(sFileName);
QIODevice::OpenMode flags = QFile::WriteOnly | QFile::Text;
if (m_ViewType == EditorView::OnlyPlainData) {
QFile fileRead(m_FullFileName); //read always from source/can be the same as fileWrite
if (!fileRead.open(QFile::ReadOnly| QFile::Text))
return false;
QString errotMsg("");
int iErrorLine(0), iErrorCol(0);
if ( !xmlDocument.setContent( &fileRead,false, &errotMsg, &iErrorLine, &iErrorCol))
{
fileRead.close();
qCritical()<< "QDomDocument::setContent: " << errotMsg << " Line " << iErrorLine << " column: " << iErrorCol;
return false;
}
fileRead.close();
}
if (!fileWrite.open(flags))
return false;
QTextStream out(&fileWrite);
QApplication::setOverrideCursor(Qt::WaitCursor);
if (m_ViewType == EditorView::XmlSource) {
qDebug() << "file.write(SOURCE): "<< sFileName;
out << toPlainText();
} else if (m_ViewType == EditorView::Text) {
qDebug() << "file.write(DOM): "<< sFileName;
QDomElement root = xmlDocument.createElement(DataOwnerSingl::XmlKeywords::KEYWORD_ITEM );
xmlDocument.appendChild( root );
//actual reading TXT format and saving to QDomDocument
//1.we divide it to 2 parts - tags and data
//than we red keyword one by one and if some is missing we use default
//than we take the data as a rest
QDomElement tag;
QTextCursor cursor(document());
int iDataCursorPosition = document()->end().position(); //default is end of document
if (!document()->find(DataOwnerSingl::TxtKeywords::KEYWORD_DATA).isNull()) {
cursor.movePosition(QTextCursor::EndOfWord, QTextCursor::MoveAnchor); //remove txt keyword from selection
iDataCursorPosition = document()->find(DataOwnerSingl::TxtKeywords::KEYWORD_DATA).position();
//qDebug() << "First data char:" << document()->characterAt(iDataCursorPosition) << "Next data char:" << document()->characterAt(iDataCursorPosition+1);
//\n should be part of TxtKeywords::KEYWORD_DATA but it can be deleted..
if(document()->characterAt(iDataCursorPosition) == QChar('\r'))
++iDataCursorPosition;
if(document()->characterAt(iDataCursorPosition) == QChar('\n'))
++iDataCursorPosition;
}
//key = xml, value = txt
QList< QPair<QString, QString> >::const_iterator i = DataOwnerSingl::XmlKeywords::Keywords.constBegin();
while (i != DataOwnerSingl::XmlKeywords::Keywords.constEnd()) {
if ((*i).first != DataOwnerSingl::XmlKeywords::KEYWORD_DATA) {
//tag
tag = xmlDocument.createElement((*i).first);
root.appendChild(tag);
//content (before data)
QString sText("");
cursor = document()->find((*i).second);
if (cursor.position() < iDataCursorPosition ) {
//valid record
const QTextBlock block = cursor.block();
if (block.isValid())
sText = block.text();
sText.remove(QRegExp("^"+ (*i).second));
//qDebug() << "writeFile sText:" << sText;
}
//missing or invalid = empty
QDomText text = xmlDocument.createTextNode(sText);
tag.appendChild(text);
}
++i;
}
tag = xmlDocument.createElement(DataOwnerSingl::XmlKeywords::KEYWORD_DATA);
root.appendChild(tag);
//select from iDataCursorPosition till end - if tag is missing it is empty, with \n correction
cursor.setPosition(iDataCursorPosition, QTextCursor::MoveAnchor);
cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
QDomCDATASection data = xmlDocument.createCDATASection(cursor.selectedText().replace(QChar(0x2029), QChar('\n')));
tag.appendChild(data);
//qDebug()<< "save XML:" << xmlDocument.toString();
out << xmlDocument.toString();
} else if (m_ViewType == EditorView::OnlyPlainData) {
QDomNodeList nodeList = xmlDocument.elementsByTagName(DataOwnerSingl::XmlKeywords::KEYWORD_DATA);
QDomElement data;
if (nodeList.isEmpty()) {
data = xmlDocument.createElement(DataOwnerSingl::XmlKeywords::KEYWORD_DATA);
xmlDocument.documentElement().appendChild(data);
}
else
{
data = nodeList.at(0).toElement();
data.removeChild(data.childNodes().at(0));
}
QDomCDATASection dataText = xmlDocument.createCDATASection("\n" + document()->toPlainText());
data.appendChild(dataText);
//qDebug()<< "save XML:" << xmlDocument.toString();
out << xmlDocument.toString();
} else
Q_ASSERT(0);
fileWrite.close();
QApplication::restoreOverrideCursor();
return true;
}
void MainWindow::saveSettings() {
QFile file("settings.xml");
file.open(QIODevice::WriteOnly | QIODevice::Text);
QDomDocument doc ("StreamControl");
QDomElement settingsXML = doc.createElement("settings");
doc.appendChild(settingsXML);
QDomElement xsplitPathE = doc.createElement("xsplitPath");
settingsXML.appendChild(xsplitPathE);
QDomCDATASection xsplitPathT = doc.createCDATASection(settings["xsplitPath"]);
xsplitPathE.appendChild(xsplitPathT);
QDomElement useCDATAE = doc.createElement("useCDATA");
settingsXML.appendChild(useCDATAE);
QDomText useCDATAT = doc.createTextNode(settings["useCDATA"]);
useCDATAE.appendChild(useCDATAT);
QDomElement gamesE = doc.createElement("games");
settingsXML.appendChild(gamesE);
for (int i = 0; i < gameComboBox->count(); ++i) {
QDomElement gameE = doc.createElement("game");
gamesE.appendChild(gameE);
QDomCDATASection gameText = doc.createCDATASection(gameComboBox->itemText(i));
gameE.appendChild(gameText);
}
QDomElement p1E = doc.createElement("player1");
settingsXML.appendChild(p1E);
for (int i = 0; i < ui->p1Color->count(); ++i) {
QDomElement p1colorE = doc.createElement("color");
p1E.appendChild(p1colorE);
QDomCDATASection p1CText = doc.createCDATASection(ui->p1Color->itemText(i));
p1colorE.appendChild(p1CText);
}
QDomElement p2E = doc.createElement("player2");
settingsXML.appendChild(p2E);
for (int i = 0; i < ui->p2Color->count(); ++i) {
QDomElement p2colorE = doc.createElement("color");
p2E.appendChild(p2colorE);
QDomCDATASection p2CText = doc.createCDATASection(ui->p2Color->itemText(i));
p2colorE.appendChild(p2CText);
}
QTextStream out(&file);
out.setCodec("UTF-8");
out << doc.toString();
file.close();
}
bool KisWorkspaceResource::saveToDevice(QIODevice *dev) const
{
QDomDocument doc;
QDomElement root = doc.createElement("Workspace");
root.setAttribute("name", name() );
root.setAttribute("version", WORKSPACE_VERSION);
QDomElement state = doc.createElement("state");
state.appendChild(doc.createCDATASection(m_dockerState.toBase64()));
root.appendChild(state);
// Save KisPropertiesConfiguration settings
QDomElement settings = doc.createElement("settings");
KisPropertiesConfiguration::toXML(doc, settings);
root.appendChild(settings);
doc.appendChild(root);
QTextStream textStream(dev);
textStream.setCodec("UTF-8");
doc.save(textStream, 4);
KoResource::saveToDevice(dev);
return true;
}
// <param name="brush_definition">
// <![CDATA[
// <Brush type="auto_brush" spacing="0.1" angle="0">
// <MaskGenerator radius="5" ratio="1" type="circle" vfade="0.5" spikes="2" hfade="0.5"/>
// </Brush> ]]>
// </param>
void AbrBrushProperties::toXML(QDomDocument& doc, QDomElement& root) const
{
if (m_brushType != BRUSH_TYPE_COMPUTED){
qDebug() << m_brushType << "saved as computed brush...";
}
QDomDocument d;
QDomElement e = d.createElement( "Brush" );
QDomElement shapeElement = d.createElement("MaskGenerator");
shapeElement.setAttribute("radius", (m_diameter * 0.5)); // radius == diameter / 2
shapeElement.setAttribute("ratio", m_roundness / 100.0); // roundness in (0..100) to ratio in (0.0..1.0)
shapeElement.setAttribute("hfade", m_hardness / 100.0); // same here
shapeElement.setAttribute("vfade", m_hardness / 100.0); // and here too
shapeElement.setAttribute("spikes", 2); // just circle so far
shapeElement.setAttribute("type", "circle");
e.appendChild(shapeElement);
e.setAttribute("type", "auto_brush");
e.setAttribute("spacing", m_spacing / 100.0); // spacing from 0..1000 to
e.setAttribute("angle", m_angle < 0 ? m_angle + 360.0 : m_angle); // angle from -180..180 to 0..360
e.setAttribute("randomness", 0); // default here
d.appendChild(e);
QDomElement elementParam = doc.createElement("param");
elementParam.setAttribute("name","brush_definition");
QDomText text = doc.createCDATASection(d.toString());
elementParam.appendChild(text);
root.appendChild(elementParam);
}
QDomCDATASection QDomDocumentProto::createCDATASection(const QString& data)
{
QDomDocument *item = qscriptvalue_cast<QDomDocument*>(thisObject());
if (item)
return item->createCDATASection(data);
return QDomCDATASection();
}
QDomElement State::toXml(QDomDocument doc) const
{
QDomElement node = doc.createElement("state");
node.setAttribute("name", name());
node.appendChild(doc.createCDATASection(mCode));
return node;
}
void TupRequestBuilder::appendData(QDomDocument &doc, QDomElement &element, const QByteArray &data)
{
if (!data.isNull() && !data.isEmpty()) {
QDomElement edata = doc.createElement("data");
QDomCDATASection cdata = doc.createCDATASection(QString(data.toBase64()));
edata.appendChild(cdata);
element.appendChild(edata);
}
}
// FIXME no error handling.
QDomDocument writeShaderXml(const Shader & shader) {
QDomDocument result;
QDomElement root = result.createElement(XML_ROOT_NAME);
result.appendChild(root);
for (int i = 0; i < MAX_CHANNELS; ++i) {
if (!shader.channelTextures[i].isEmpty()) {
QDomElement channelElement = result.createElement(XML_CHANNEL);
channelElement.setAttribute(XML_CHANNEL_ATTR_ID, i);
channelElement.setAttribute(XML_CHANNEL_ATTR_TYPE, shader.channelTypes[i] == ChannelInputType::CUBEMAP ? "cube" : "tex");
channelElement.appendChild(result.createTextNode(shader.channelTextures[i]));
root.appendChild(channelElement);
}
}
root.appendChild(result.createElement(XML_FRAGMENT_SOURCE)).
appendChild(result.createCDATASection(shader.fragmentSource));
if (!shader.name.isEmpty()) {
root.appendChild(result.createElement(XML_NAME)).
appendChild(result.createCDATASection(shader.name));
}
return result;
}
ContactListModelSelection::ContactListModelSelection(QList<ContactListItemProxy*> items)
: QMimeData()
, mimeData_(0)
{
QDomDocument doc;
QDomElement root = doc.createElement("items");
root.setAttribute("version", "2.0");
doc.appendChild(root);
// TODO: maybe also embed a random instance-specific token to
// prevent drag'n'drop with other running Psi instances?
QStringList jids;
foreach(ContactListItemProxy* itemProxy, items) {
Q_ASSERT(itemProxy);
PsiContact* contact = 0;
ContactListNestedGroup* group = 0;
ContactListAccountGroup* account = 0;
if ((contact = dynamic_cast<PsiContact*>(itemProxy->item()))) {
QDomElement tag = textTag(&doc, "contact", contact->jid().full());
tag.setAttribute("account", contact->account()->id());
tag.setAttribute("group", itemProxy->parent() ? itemProxy->parent()->fullName() : "");
root.appendChild(tag);
jids << contact->jid().full();
}
else if ((account = dynamic_cast<ContactListAccountGroup*>(itemProxy->item()))) {
QDomElement tag = doc.createElement("account");
tag.setAttribute("id", account->account()->id());
root.appendChild(tag);
jids << account->displayName();
}
else if ((group = dynamic_cast<ContactListNestedGroup*>(itemProxy->item()))) {
// if group->fullName() consists only of whitespace when we'll try
// to read it back we'll get an empty string, so we're using CDATA
// QDomElement tag = textTag(&doc, "group", group->fullName());
QDomElement tag = doc.createElement("group");
QDomText text = doc.createCDATASection(TextUtil::escape(group->fullName()));
tag.appendChild(text);
root.appendChild(tag);
jids << group->fullName();
}
else {
qWarning("ContactListModelSelection::ContactListModelSelection(): Unable to serialize %d, unsupported type", itemProxy->item()->type());
}
}
void KoProperties::save(QDomElement &root) const
{
QDomDocument doc = root.ownerDocument();
QMap<QString, QVariant>::Iterator it;
for (it = d->properties.begin(); it != d->properties.end(); ++it) {
QDomElement e = doc.createElement("property");
e.setAttribute("name", QString(it.key().toLatin1()));
QVariant v = it.value();
e.setAttribute("type", v.typeName());
QByteArray bytes;
QDataStream out(&bytes, QIODevice::WriteOnly);
out << v;
QDomText text = doc.createCDATASection(QString::fromLatin1(bytes, bytes.size()));
e.appendChild(text);
root.appendChild(e);
}
}
int XmlNotes::saveNotes()
{
//DEBUG_FUNC_NAME
QDomDocument sdoc;
QDomElement root = sdoc.createElement("notes");
root.setAttribute("version", m_version);
sdoc.appendChild(root);
QMapIterator<QString, QString> i(notesType);
while(i.hasNext()) {
i.next();
const QString id = i.key();
if(id.isEmpty())
continue;
QDomElement tag = sdoc.createElement("note");
tag.setAttribute("title", notesTitle.value(id));
tag.setAttribute("type", notesType.value(id));
tag.setAttribute("id", id);
root.appendChild(tag);
QDomElement data = sdoc.createElement("data");
QDomCDATASection text = sdoc.createCDATASection(notesData.value(id));
data.appendChild(text);
tag.appendChild(data);
QDomElement ref = sdoc.createElement("ref");
QMap<QString, QString> map = notesRef.value(id);
QMapIterator<QString, QString> i(map);
while(i.hasNext()) {
i.next();
QDomElement e = sdoc.createElement(i.key());
QDomText t = doc.createTextNode(i.value());
e.appendChild(t);
ref.appendChild(e);
}
tag.appendChild(ref);
}
QFile file(m_fileName);
if(!file.open(QIODevice::WriteOnly | QIODevice::Text))
return 1;
const int IndentSize = 4;
QTextStream out(&file);
sdoc.save(out, IndentSize);
file.close();
doc = sdoc;
return 0;
}
QDomDocument FolderShape::save() const
{
QDomDocument doc;
QDomElement element = doc.createElement("book");
doc.appendChild(element);
foreach (KShape *child, shapes()) {
IconShape *ic = dynamic_cast<IconShape*>(child);
if (ic) {
ic->save(element);
continue;
}
ClipboardProxyShape *proxy = dynamic_cast<ClipboardProxyShape*>(child);
if (proxy) {
QDomElement clipboard = doc.createElement("clipboard");
element.appendChild(clipboard);
QDomText text = doc.createCDATASection( QString::fromAscii( proxy->clipboardData(), proxy->clipboardData().size() ) );
clipboard.appendChild(text);
continue;
}
}
// KOffice-1.3 format
QDomElement KoDocumentInfoAbout::save( QDomDocument& doc )
{
saveParameters();
QDomElement e = doc.createElement( "about" );
QDomElement t = doc.createElement( "abstract" );
e.appendChild( t );
t.appendChild( doc.createCDATASection( m_abstract ) );
t = doc.createElement( "title" );
e.appendChild( t );
t.appendChild( doc.createTextNode( m_title ) );
t = doc.createElement( "keyword" );
e.appendChild( t );
t.appendChild( doc.createTextNode( m_keywords ) );
t = doc.createElement( "subject" );
e.appendChild( t );
t.appendChild( doc.createTextNode( m_subject ) );
t = doc.createElement( "initial-creator" );
e.appendChild( t );
t.appendChild( doc.createTextNode( m_initialCreator ) );
t = doc.createElement( "editing-cycles" );
e.appendChild( t );
t.appendChild( doc.createTextNode( QString::number( m_editingCycles ) ) );
t = doc.createElement( "creation-date" );
e.appendChild( t );
t.appendChild( doc.createTextNode( m_creationDate.toString( Qt::ISODate ) ) );
t = doc.createElement( "date" );
e.appendChild( t );
t.appendChild( doc.createTextNode( m_modificationDate.toString( Qt::ISODate ) ) );
return e;
}
/**
* Creates an XML representation of the view, which can be used for storing the
* model's data in a file.
* The representation is rooted at a <QueryView> element, which holds a <Query>
* element for the query information, a <Columns> element with a list of
* columns, and a <LocationList> element that describes the list or tree of
* locations.
* @param doc The XML document object to use
* @return The root element of the view's representation
*/
QDomElement QueryView::toXML(QDomDocument& doc) const
{
// Create an element for storing the view.
QDomElement viewElem = doc.createElement("QueryView");
viewElem.setAttribute("name", windowTitle());
viewElem.setAttribute("type", QString::number(type_));
// Store query information.
QDomElement queryElem = doc.createElement("Query");
queryElem.setAttribute("type", QString::number(query_.type_));
queryElem.setAttribute("flags", QString::number(query_.flags_));
queryElem.appendChild(doc.createCDATASection(query_.pattern_));
viewElem.appendChild(queryElem);
// Create a "Columns" element.
QDomElement colsElem = doc.createElement("Columns");
viewElem.appendChild(colsElem);
// Add an element for each column.
foreach (Location::Fields field, model()->columns()) {
QDomElement colElem = doc.createElement("Column");
colElem.setAttribute("field", QString::number(field));
colsElem.appendChild(colElem);
}
void MainWindow::saveData()
{
QFile file(settings["xsplitPath"] + "streamcontrol.xml");
file.open(QIODevice::WriteOnly | QIODevice::Text);
QDomDocument doc ("StreamControl");
QDomElement items = doc.createElement("items");
doc.appendChild(items);
QDateTime current = QDateTime::currentDateTime();
uint timestamp_t = current.toTime_t();
QDomElement timestamp = doc.createElement("timestamp");
items.appendChild(timestamp);
QDomText timestampt = doc.createTextNode(QString::number(timestamp_t));;
timestamp.appendChild(timestampt);
QDomElement pName1 = doc.createElement("pName1");
items.appendChild(pName1);
if (useCDATA) {
QDomCDATASection pName1t = doc.createCDATASection(ui->pName1->text());
pName1.appendChild(pName1t);
} else {
QDomText pName1t = doc.createTextNode(ui->pName1->text());
pName1.appendChild(pName1t);
}
QDomElement pScore1 = doc.createElement("pScore1");
items.appendChild(pScore1);
QDomText pScore1t = doc.createTextNode(ui->pScore1->text());
pScore1.appendChild(pScore1t);
QDomElement pName2 = doc.createElement("pName2");
items.appendChild(pName2);
if (useCDATA) {
QDomCDATASection pName2t = doc.createCDATASection(ui->pName2->text());
pName2.appendChild(pName2t);
} else {
QDomText pName2t = doc.createTextNode(ui->pName2->text());
pName2.appendChild(pName2t);
}
QDomElement pScore2 = doc.createElement("pScore2");
items.appendChild(pScore2);
QDomText pScore2t = doc.createTextNode(ui->pScore2->text());
pScore2.appendChild(pScore2t);
QDomElement rounds = doc.createElement("rounds");
items.appendChild(rounds);
QDomText roundst = doc.createTextNode(ui->rounds->text());
rounds.appendChild(roundst);
QDomElement srText = doc.createElement("srText");
items.appendChild(srText);
if (useCDATA) {
QDomCDATASection srTextt = doc.createCDATASection(ui->srText->text());
srText.appendChild(srTextt);
} else {
QDomText srTextt = doc.createTextNode(ui->srText->text());
srText.appendChild(srTextt);
}
QDomElement cTitle1 = doc.createElement("cTitle1");
items.appendChild(cTitle1);
if (useCDATA) {
QDomCDATASection cTitle1t = doc.createCDATASection(ui->cTitle1->text());
cTitle1.appendChild(cTitle1t);
} else {
QDomText cTitle1t = doc.createTextNode(ui->cTitle1->text());
cTitle1.appendChild(cTitle1t);
}
QDomElement cTitle2 = doc.createElement("cTitle2");
items.appendChild(cTitle2);
if (useCDATA) {
QDomCDATASection cTitle2t = doc.createCDATASection(ui->cTitle2->text());
cTitle2.appendChild(cTitle2t);
} else {
QDomText cTitle2t = doc.createTextNode(ui->cTitle2->text());
cTitle2.appendChild(cTitle2t);
}
QDomElement mText1 = doc.createElement("mText1");
items.appendChild(mText1);
if (useCDATA) {
QDomCDATASection mText1t = doc.createCDATASection(ui->mText1->text());
mText1.appendChild(mText1t);
} else {
QDomText mText1t = doc.createTextNode(ui->mText1->text());
mText1.appendChild(mText1t);
}
QDomElement mText2 = doc.createElement("mText2");
items.appendChild(mText2);
if (useCDATA) {
QDomCDATASection mText2t = doc.createCDATASection(ui->mText2->text());
mText2.appendChild(mText2t);
} else {
QDomText mText2t = doc.createTextNode(ui->mText2->text());
mText2.appendChild(mText2t);
}
QDomElement mText3 = doc.createElement("mText3");
items.appendChild(mText3);
if (useCDATA) {
QDomCDATASection mText3t = doc.createCDATASection(ui->mText3->text());
mText3.appendChild(mText3t);
} else {
QDomText mText3t = doc.createTextNode(ui->mText3->text());
mText3.appendChild(mText3t);
}
QDomElement mText4 = doc.createElement("mText4");
items.appendChild(mText4);
if (useCDATA) {
QDomCDATASection mText4t = doc.createCDATASection(ui->mText4->text());
mText4.appendChild(mText4t);
} else {
QDomText mText4t = doc.createTextNode(ui->mText4->text());
mText4.appendChild(mText4t);
}
QDomElement gameE = doc.createElement("game");
items.appendChild(gameE);
if (useCDATA) {
QDomCDATASection gameT = doc.createCDATASection(gameComboBox->currentText());
gameE.appendChild(gameT);
} else {
QDomText gameT = doc.createTextNode(gameComboBox->currentText());
gameE.appendChild(gameT);
}
QDomElement p1cE = doc.createElement("p1c");
items.appendChild(p1cE);
if (useCDATA) {
QDomCDATASection p1cT = doc.createCDATASection(ui->p1Color->currentText());
p1cE.appendChild(p1cT);
} else {
QDomText p1cT = doc.createTextNode(ui->p1Color->currentText());
p1cE.appendChild(p1cT);
}
QDomElement p2cE = doc.createElement("p2c");
items.appendChild(p2cE);
if (useCDATA) {
QDomCDATASection p2cT = doc.createCDATASection(ui->p2Color->currentText());
p2cE.appendChild(p2cT);
} else {
QDomText p2cT = doc.createTextNode(ui->p2Color->currentText());
p2cE.appendChild(p2cT);
}
QTextStream out(&file);
out.setCodec("UTF-8");
out << doc.toString();
file.close();
}
QDomElement Validity::saveXML(QDomDocument& doc, const ValueConverter *converter) const
{
QDomElement validityElement = doc.createElement("validity");
QDomElement param = doc.createElement("param");
param.setAttribute("cond", (int)d->cond);
param.setAttribute("action", (int)d->action);
param.setAttribute("allow", (int)d->restriction);
param.setAttribute("valmin", converter->asString(d->minValue).asString());
param.setAttribute("valmax", converter->asString(d->maxValue).asString());
param.setAttribute("displaymessage", d->displayMessage);
param.setAttribute("displayvalidationinformation", d->displayValidationInformation);
param.setAttribute("allowemptycell", d->allowEmptyCell);
if (!d->listValidity.isEmpty())
param.setAttribute("listvalidity", d->listValidity.join(";"));
validityElement.appendChild(param);
QDomElement titleElement = doc.createElement("title");
titleElement.appendChild(doc.createTextNode(d->title));
validityElement.appendChild(titleElement);
QDomElement messageElement = doc.createElement("message");
messageElement.appendChild(doc.createCDATASection(d->message));
validityElement.appendChild(messageElement);
QDomElement inputTitle = doc.createElement("inputtitle");
inputTitle.appendChild(doc.createTextNode(d->titleInfo));
validityElement.appendChild(inputTitle);
QDomElement inputMessage = doc.createElement("inputmessage");
inputMessage.appendChild(doc.createTextNode(d->messageInfo));
validityElement.appendChild(inputMessage);
QString tmp;
if (d->restriction == Time) {
QDomElement timeMinElement = doc.createElement("timemin");
tmp = converter->asString(d->minValue).asString();
timeMinElement.appendChild(doc.createTextNode(tmp));
validityElement.appendChild(timeMinElement);
if (d->cond == Conditional::Between || d->cond == Conditional::Different) {
QDomElement timeMaxElement = doc.createElement("timemax");
tmp = converter->asString(d->maxValue).asString();
timeMaxElement.appendChild(doc.createTextNode(tmp));
validityElement.appendChild(timeMaxElement);
}
}
if (d->restriction == Date) {
QDomElement dateMinElement = doc.createElement("datemin");
const QDate minDate = d->minValue.asDate(converter->settings());
QString tmp("%1/%2/%3");
tmp = tmp.arg(minDate.year()).arg(minDate.month()).arg(minDate.day());
dateMinElement.appendChild(doc.createTextNode(tmp));
validityElement.appendChild(dateMinElement);
if (d->cond == Conditional::Between || d->cond == Conditional::Different) {
QDomElement dateMaxElement = doc.createElement("datemax");
const QDate maxDate = d->maxValue.asDate(converter->settings());
QString tmp("%1/%2/%3");
tmp = tmp.arg(maxDate.year()).arg(maxDate.month()).arg(maxDate.day());
dateMaxElement.appendChild(doc.createTextNode(tmp));
validityElement.appendChild(dateMaxElement);
}
}
return validityElement;
}
/**
* Recursively transforms the location hierarchy stored in the model to an XML
* sub-tree.
* The XML representation of locations is composed of a <LocationList> element
* holding a list of <Location> elements. For a tree model, <Location> elements
* may in turn hold a <LocationList> sub-element, and so on.
* @param doc The XML document object to use
* @param parentElem XML element under which new location elements should be
* created
* @param index The source index to store (along with its children)
*/
void LocationView::locationToXML(QDomDocument& doc, QDomElement& parentElem,
const QModelIndex& index) const
{
QDomElement elem;
if (index.isValid()) {
// A non-root index.
// Translate the index into a location information structure.
Location loc;
if (!locationModel()->locationFromIndex(index, loc))
return;
// Create an XML element for the location.
elem = doc.createElement("Location");
parentElem.appendChild(elem);
// Add a text node for each structure member.
const QList<Location::Fields>& colList = locationModel()->columns();
foreach (Location::Fields field, colList) {
QString name;
QDomNode node;
switch (field) {
case Location::File:
name = "File";
node = doc.createTextNode(loc.file_);
break;
case Location::Line:
name = "Line";
node = doc.createTextNode(QString::number(loc.line_));
break;
case Location::Column:
name = "Column";
node = doc.createTextNode(QString::number(loc.column_));
break;
case Location::TagName:
name = "TagName";
node = doc.createTextNode(loc.tag_.name_);
break;
case Location::TagType:
name = "TagType";
node = doc.createTextNode(QString::number(loc.tag_.type_));
break;
case Location::Scope:
name = "Scope";
node = doc.createTextNode(loc.tag_.scope_);
break;
case Location::Text:
name = "Text";
node = doc.createCDATASection(loc.text_);
break;
}
QDomElement child = doc.createElement(name);
child.appendChild(node);
elem.appendChild(child);
}
QDomElement getServiceElement( QDomDocument &doc, const QgsProject *project )
{
//Service element
QDomElement serviceElem = doc.createElement( QStringLiteral( "Service" ) );
//Service name
QDomElement nameElem = doc.createElement( QStringLiteral( "name" ) );
QDomText nameText = doc.createTextNode( "WCS" );
nameElem.appendChild( nameText );
serviceElem.appendChild( nameElem );
QString title = QgsServerProjectUtils::owsServiceTitle( *project );
if ( !title.isEmpty() )
{
QDomElement titleElem = doc.createElement( QStringLiteral( "label" ) );
QDomText titleText = doc.createTextNode( title );
titleElem.appendChild( titleText );
serviceElem.appendChild( titleElem );
}
QString abstract = QgsServerProjectUtils::owsServiceAbstract( *project );
if ( !abstract.isEmpty() )
{
QDomElement abstractElem = doc.createElement( QStringLiteral( "description" ) );
QDomText abstractText = doc.createCDATASection( abstract );
abstractElem.appendChild( abstractText );
serviceElem.appendChild( abstractElem );
}
QStringList keywords = QgsServerProjectUtils::owsServiceKeywords( *project );
if ( !keywords.isEmpty() )
{
QDomElement keywordsElem = doc.createElement( QStringLiteral( "keywords" ) );
for ( int i = 0; i < keywords.size(); ++i )
{
QDomElement keywordElem = doc.createElement( QStringLiteral( "keyword" ) );
QDomText keywordText = doc.createTextNode( keywords.at( i ) );
keywordElem.appendChild( keywordText );
keywordsElem.appendChild( keywordElem );
}
serviceElem.appendChild( keywordsElem );
}
QString contactPerson = QgsServerProjectUtils::owsServiceContactPerson( *project );
QString contactOrganization = QgsServerProjectUtils::owsServiceContactOrganization( *project );
QString contactPosition = QgsServerProjectUtils::owsServiceContactPosition( *project );
QString contactMail = QgsServerProjectUtils::owsServiceContactMail( *project );
QString contactPhone = QgsServerProjectUtils::owsServiceContactPhone( *project );
QString onlineResource = QgsServerProjectUtils::owsServiceOnlineResource( *project );
if ( !contactPerson.isEmpty() ||
!contactOrganization.isEmpty() ||
!contactPosition.isEmpty() ||
!contactMail.isEmpty() ||
!contactPhone.isEmpty() ||
!onlineResource.isEmpty() )
{
QDomElement responsiblePartyElem = doc.createElement( QStringLiteral( "responsibleParty" ) );
if ( !contactPerson.isEmpty() )
{
QDomElement contactPersonElem = doc.createElement( QStringLiteral( "individualName" ) );
QDomText contactPersonText = doc.createTextNode( contactPerson );
contactPersonElem.appendChild( contactPersonText );
responsiblePartyElem.appendChild( contactPersonElem );
}
if ( !contactOrganization.isEmpty() )
{
QDomElement contactOrganizationElem = doc.createElement( QStringLiteral( "organisationName" ) );
QDomText contactOrganizationText = doc.createTextNode( contactOrganization );
contactOrganizationElem.appendChild( contactOrganizationText );
responsiblePartyElem.appendChild( contactOrganizationElem );
}
if ( !contactPosition.isEmpty() )
{
QDomElement contactPositionElem = doc.createElement( QStringLiteral( "positionName" ) );
QDomText contactPositionText = doc.createTextNode( contactPosition );
contactPositionElem.appendChild( contactPositionText );
responsiblePartyElem.appendChild( contactPositionElem );
}
if ( !contactMail.isEmpty() ||
!contactPhone.isEmpty() ||
!onlineResource.isEmpty() )
{
QDomElement contactInfoElem = doc.createElement( QStringLiteral( "contactInfo" ) );
if ( !contactMail.isEmpty() )
{
QDomElement contactAddressElem = doc.createElement( QStringLiteral( "address" ) );
QDomElement contactAddressMailElem = doc.createElement( QStringLiteral( "electronicMailAddress" ) );
QDomText contactAddressMailText = doc.createTextNode( contactMail );
contactAddressMailElem.appendChild( contactAddressMailText );
contactAddressElem.appendChild( contactAddressMailElem );
contactInfoElem.appendChild( contactAddressElem );
}
if ( !contactPhone.isEmpty() )
{
QDomElement contactPhoneElem = doc.createElement( QStringLiteral( "phone" ) );
QDomElement contactVoiceElem = doc.createElement( QStringLiteral( "voice" ) );
QDomText contactVoiceText = doc.createTextNode( contactPhone );
contactVoiceElem.appendChild( contactVoiceText );
contactPhoneElem.appendChild( contactVoiceElem );
contactInfoElem.appendChild( contactPhoneElem );
}
if ( !onlineResource.isEmpty() )
{
QDomElement onlineResourceElem = doc.createElement( QStringLiteral( "onlineResource" ) );
onlineResourceElem.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
onlineResourceElem.setAttribute( QStringLiteral( "xlink:type" ), QStringLiteral( "simple" ) );
onlineResourceElem.setAttribute( QStringLiteral( "xlink:href" ), onlineResource );
contactInfoElem.appendChild( onlineResourceElem );
}
responsiblePartyElem.appendChild( contactInfoElem );
}
serviceElem.appendChild( responsiblePartyElem );
}
QDomElement feesElem = doc.createElement( QStringLiteral( "fees" ) );
QDomText feesText = doc.createTextNode( QStringLiteral( "None" ) ); // default value if fees are unknown
QString fees = QgsServerProjectUtils::owsServiceFees( *project );
if ( !fees.isEmpty() )
{
feesText = doc.createTextNode( fees );
}
feesElem.appendChild( feesText );
serviceElem.appendChild( feesElem );
QDomElement accessConstraintsElem = doc.createElement( QStringLiteral( "accessConstraints" ) );
QDomText accessConstraintsText = doc.createTextNode( QStringLiteral( "None" ) ); // default value if access constraints are unknown
QString accessConstraints = QgsServerProjectUtils::owsServiceAccessConstraints( *project );
if ( !accessConstraints.isEmpty() )
{
accessConstraintsText = doc.createTextNode( accessConstraints );
}
accessConstraintsElem.appendChild( accessConstraintsText );
serviceElem.appendChild( accessConstraintsElem );
//End
return serviceElem;
}
// this implementation will be re-coded.
void CircuitDomDocumentExporter::exportCircuitTo(Circuit * _circuit, QIODevice * _device) {
if (_circuit && _device){
QDomDocument doc;
QDomElement rootElement = doc.createElement("xml");
QDomElement circuitElement = doc.createElement("circuit");
QDomElement circuitUUIDElement = doc.createElement("uuid");
circuitUUIDElement.appendChild(doc.createCDATASection(_circuit->getUUID()));
circuitElement.appendChild(circuitUUIDElement);
for (QMap<QString, Circuit::Object*>::const_iterator iter = _circuit->getObjectMap().begin(); iter != _circuit->getObjectMap().end(); ++iter) {
Circuit::Object* obj = *iter;
QDomElement circuitObjectElement = doc.createElement("object");
QDomElement circuitObjectUUIDElement = doc.createElement("uuid");
QDomElement circuitObjectTypeElement = doc.createElement("type");
circuitObjectUUIDElement.appendChild(doc.createCDATASection(obj->getUUID()));
circuitObjectElement.appendChild(circuitObjectUUIDElement);
circuitObjectElement.appendChild(circuitObjectTypeElement);
QString objType("OBJECT");
if (obj->getType() == Circuit::Object::NODE) {
objType = "NODE";
Circuit::Node* node = static_cast<Circuit::Node*>(obj);
//coordinate
QDomElement circuitNodeXElement = doc.createElement("x");
QDomElement circuitNodeYElement = doc.createElement("y");
QDomElement circuitNodeZElement = doc.createElement("z");
circuitNodeXElement.appendChild(doc.createCDATASection(QString("%1").arg(node->getX())));
circuitNodeYElement.appendChild(doc.createCDATASection(QString("%1").arg(node->getY())));
circuitNodeZElement.appendChild(doc.createCDATASection(QString("%1").arg(node->getZ())));
circuitObjectElement.appendChild(circuitNodeXElement);
circuitObjectElement.appendChild(circuitNodeYElement);
circuitObjectElement.appendChild(circuitNodeZElement);
//connections
QDomElement circuitNodeConnectionsElement = doc.createElement("connections");
for(QList<QString>::const_iterator iter = node->connectionList().begin();iter != node->connectionList().end();++iter) {
QDomElement circuitNodeConnectionsUUIDElement = doc.createElement("uuid");
circuitNodeConnectionsUUIDElement.appendChild(doc.createCDATASection(*iter));
circuitNodeConnectionsElement.appendChild(circuitNodeConnectionsUUIDElement);
}
circuitObjectElement.appendChild(circuitNodeConnectionsElement);
}
if (obj->getType() == Circuit::Object::ELEMENT) {
objType = "ELEMENT";
Circuit::Element* element = static_cast<Circuit::Element*>(obj);
//coordinate
QDomElement circuitElementXElement = doc.createElement("x");
QDomElement circuitElementYElement = doc.createElement("y");
QDomElement circuitElementZElement = doc.createElement("z");
circuitElementXElement.appendChild(doc.createCDATASection(QString("%1").arg(element->getX())));
circuitElementYElement.appendChild(doc.createCDATASection(QString("%1").arg(element->getY())));
circuitElementZElement.appendChild(doc.createCDATASection(QString("%1").arg(element->getZ())));
circuitObjectElement.appendChild(circuitElementXElement);
circuitObjectElement.appendChild(circuitElementYElement);
circuitObjectElement.appendChild(circuitElementZElement);
//connections
QDomElement circuitElementConnectionsElement = doc.createElement("connections");
for(QList<QString>::const_iterator iter = element->connectionList().begin();iter != element->connectionList().end();++iter) {
QDomElement circuitElementConnectionsUUIDElement = doc.createElement("uuid");
circuitElementConnectionsUUIDElement.appendChild(doc.createCDATASection(*iter));
circuitElementConnectionsElement.appendChild(circuitElementConnectionsUUIDElement);
}
circuitObjectElement.appendChild(circuitElementConnectionsElement);
}
if (obj->getType() == Circuit::Object::CONNECTION) {
objType = "CONNECTION";
Circuit::Connection* connection = static_cast<Circuit::Connection*>(obj);
//objects
QDomElement circuitConnectionObjectsElement = doc.createElement("objects");
for(QList<QString>::const_iterator iter = connection->objectList().begin();iter != connection->objectList().end();++iter) {
QDomElement circuitConnectionObjectsUUIDElement = doc.createElement("uuid");
circuitConnectionObjectsUUIDElement.appendChild(doc.createCDATASection(*iter));
circuitConnectionObjectsElement.appendChild(circuitConnectionObjectsUUIDElement);
}
circuitObjectElement.appendChild(circuitConnectionObjectsElement);
}
circuitObjectTypeElement.appendChild(doc.createCDATASection(objType));
circuitElement.appendChild(circuitObjectElement);
}
rootElement.appendChild(circuitElement);
doc.appendChild(rootElement);
QTextStream out(_device);
out << doc;
}
}
QDomElement getServiceElement( QDomDocument &doc, const QgsProject *project )
{
//Service element
QDomElement serviceElem = doc.createElement( QStringLiteral( "Service" ) );
//Service name
QDomElement nameElem = doc.createElement( QStringLiteral( "Name" ) );
QDomText nameText = doc.createTextNode( "WFS" );
nameElem.appendChild( nameText );
serviceElem.appendChild( nameElem );
QString title = QgsServerProjectUtils::owsServiceTitle( *project );
if ( !title.isEmpty() )
{
QDomElement titleElem = doc.createElement( QStringLiteral( "Title" ) );
QDomText titleText = doc.createTextNode( title );
titleElem.appendChild( titleText );
serviceElem.appendChild( titleElem );
}
QString abstract = QgsServerProjectUtils::owsServiceAbstract( *project );
if ( !abstract.isEmpty() )
{
QDomElement abstractElem = doc.createElement( QStringLiteral( "Abstract" ) );
QDomText abstractText = doc.createCDATASection( abstract );
abstractElem.appendChild( abstractText );
serviceElem.appendChild( abstractElem );
}
QStringList keywords = QgsServerProjectUtils::owsServiceKeywords( *project );
if ( !keywords.isEmpty() && !keywords.join( QStringLiteral( ", " ) ).isEmpty() )
{
QDomElement keywordsElem = doc.createElement( QStringLiteral( "Keywords" ) );
QDomText keywordsText = doc.createTextNode( keywords.join( QStringLiteral( ", " ) ) );
keywordsElem.appendChild( keywordsText );
serviceElem.appendChild( keywordsElem );
}
QDomElement onlineResourceElem = doc.createElement( QStringLiteral( "OnlineResource" ) );
QString onlineResource = QgsServerProjectUtils::owsServiceOnlineResource( *project );
if ( !onlineResource.isEmpty() )
{
QDomText onlineResourceText = doc.createTextNode( onlineResource );
onlineResourceElem.appendChild( onlineResourceText );
}
serviceElem.appendChild( onlineResourceElem );
QString fees = QgsServerProjectUtils::owsServiceFees( *project );
if ( !fees.isEmpty() )
{
QDomElement feesElem = doc.createElement( QStringLiteral( "Fees" ) );
QDomText feesText = doc.createTextNode( fees );
feesElem.appendChild( feesText );
serviceElem.appendChild( feesElem );
}
QString accessConstraints = QgsServerProjectUtils::owsServiceAccessConstraints( *project );
if ( !accessConstraints.isEmpty() )
{
QDomElement accessConstraintsElem = doc.createElement( QStringLiteral( "AccessConstraints" ) );
QDomText accessConstraintsText = doc.createTextNode( accessConstraints );
accessConstraintsElem.appendChild( accessConstraintsText );
serviceElem.appendChild( accessConstraintsElem );
}
return serviceElem;
}
/**
\todo document this function
*/
QDomElement GCF::UpdateInfo::toDomElement(QDomDocument doc, bool forThisSystem) const
{
QDomElement updateE = doc.createElement("Update");
QDomElement nameE = doc.createElement("Name");
nameE.appendChild( doc.createTextNode(d->name) );
updateE.appendChild(nameE);
QDomElement titleE = doc.createElement("Title");
titleE.appendChild( doc.createTextNode(d->title) );
updateE.appendChild(titleE);
QDomElement sourceE = doc.createElement("Source");
sourceE.appendChild( doc.createTextNode(d->source) );
updateE.appendChild(sourceE);
QDomElement iconE = doc.createElement("Icon");
iconE.appendChild( doc.createTextNode(d->iconUrl.toString()) );
updateE.appendChild(iconE);
QDomElement typeE = doc.createElement("Type");
typeE.appendChild( doc.createTextNode(d->type) );
updateE.appendChild(typeE);
QDomElement forceInstallE = doc.createElement("ForceInstall");
forceInstallE.appendChild( doc.createTextNode( QVariant(d->forceInstall).toString() ) );
updateE.appendChild(forceInstallE);
QDomElement descE = doc.createElement("Description");
descE.appendChild( doc.createCDATASection(d->description) );
updateE.appendChild(descE);
QDomElement releaseE = doc.createElement("Release");
releaseE.appendChild( doc.createTextNode(d->release.toString()) );
updateE.appendChild(releaseE);
QDomElement versionE = doc.createElement("Version");
versionE.appendChild( doc.createTextNode(d->version) );
updateE.appendChild(versionE);
QList<UpdateFileInfo> ufiList;
if( forThisSystem )
{
UpdateFileInfo fileInfo = updateFileForThisSystem();
ufiList.append(fileInfo);
}
else
ufiList = d->updateFiles;
for(int j=0; j<ufiList.count(); j++)
{
UpdateFileInfo ufi = ufiList[j];
QDomElement updateFileE = doc.createElement("UpdateFile");
updateE.appendChild(updateFileE);
updateFileE.setAttribute("OS", ufi.OS);
updateFileE.setAttribute("Arch", ufi.Arch);
updateFileE.appendChild( doc.createTextNode(ufi.UpdateFileURL.toString()) );
}
const QList<UpdateInfo>& deps = d->dependencies;
for(int j=0; j<deps.count(); j++)
{
UpdateInfo dep = deps[j];
QString depStr = QString("%1 [%2]").arg( dep.name() ).arg( dep.version() );
QDomElement dependsOnE = doc.createElement("DependsOn");
dependsOnE.appendChild( doc.createTextNode(depStr) );
updateE.appendChild(dependsOnE);
}
return updateE;
}
