bool WBSDefinition::loadXML(KoXmlElement &element, XMLLoaderObject & ) {
m_projectCode = element.attribute( "project-code" );
m_projectSeparator = element.attribute( "project-separator" );
m_levelsEnabled = (bool)element.attribute( "levels-enabled", "0" ).toInt();
KoXmlNode n = element.firstChild();
for ( ; ! n.isNull(); n = n.nextSibling() ) {
if ( ! n.isElement() ) {
continue;
}
KoXmlElement e = n.toElement();
if (e.tagName() == "default") {
m_defaultDef.code = e.attribute( "code", "Number" );
m_defaultDef.separator = e.attribute( "separator", "." );
} else if (e.tagName() == "levels") {
KoXmlNode n = e.firstChild();
for ( ; ! n.isNull(); n = n.nextSibling() ) {
if ( ! n.isElement() ) {
continue;
}
KoXmlElement el = n.toElement();
CodeDef d;
d.code = el.attribute( "code" );
d.separator = el.attribute( "separator" );
int lvl = el.attribute( "level", "-1" ).toInt();
if ( lvl >= 0 ) {
setLevelsDef( lvl, d );
} else kError()<<"Invalid levels definition";
}
}
}
return true;
}
bool ComponentTransferEffect::load(const KoXmlElement &element, const KoFilterEffectLoadingContext &)
{
if (element.tagName() != id())
return false;
// reset data
m_data[ChannelR] = Data();
m_data[ChannelG] = Data();
m_data[ChannelB] = Data();
m_data[ChannelA] = Data();
for (KoXmlNode n = element.firstChild(); !n.isNull(); n = n.nextSibling()) {
KoXmlElement node = n.toElement();
if (node.tagName() == "feFuncR") {
loadChannel(ChannelR, node);
} else if (node.tagName() == "feFuncG") {
loadChannel(ChannelG, node);
} else if (node.tagName() == "feFuncB") {
loadChannel(ChannelB, node);
} else if (node.tagName() == "feFuncA") {
loadChannel(ChannelA, node);
}
}
return true;
}
KoFilterEffectStack * FilterEffectResource::toFilterStack() const
{
KoFilterEffectStack * filterStack = new KoFilterEffectStack();
if (!filterStack)
return 0;
QByteArray data = m_data.toByteArray();
KoXmlDocument doc;
doc.setContent(data);
KoXmlElement e = doc.documentElement();
// only allow obect bounding box units
if (e.hasAttribute("filterUnits") && e.attribute("filterUnits") != "objectBoundingBox")
return 0;
if (e.attribute("primitiveUnits") != "objectBoundingBox")
return 0;
// parse filter region rectangle
QRectF filterRegion;
filterRegion.setX(fromPercentage(e.attribute("x", "-0.1")));
filterRegion.setY(fromPercentage(e.attribute("y", "-0.1")));
filterRegion.setWidth(fromPercentage(e.attribute("width", "1.2")));
filterRegion.setHeight(fromPercentage(e.attribute("height", "1.2")));
filterStack->setClipRect(filterRegion);
KoFilterEffectLoadingContext context(QString(""));
KoFilterEffectRegistry * registry = KoFilterEffectRegistry::instance();
// create the filter effects and add them to the shape
for (KoXmlNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
KoXmlElement primitive = n.toElement();
KoFilterEffect * filterEffect = registry->createFilterEffectFromXml(primitive, context);
if (!filterEffect) {
qWarning() << "filter effect" << primitive.tagName() << "is not implemented yet";
continue;
}
// parse subregion
qreal x = fromPercentage(primitive.attribute("x", "0"));
qreal y = fromPercentage(primitive.attribute("y", "0"));
qreal w = fromPercentage(primitive.attribute("width", "1"));
qreal h = fromPercentage(primitive.attribute("height", "1"));
QRectF subRegion(QPointF(x, y), QSizeF(w, h));
if (primitive.hasAttribute("in"))
filterEffect->setInput(0, primitive.attribute("in"));
if (primitive.hasAttribute("result"))
filterEffect->setOutput(primitive.attribute("result"));
filterEffect->setFilterRect(subRegion);
filterStack->appendFilterEffect(filterEffect);
}
return filterStack;
}
bool KoInlineNote::loadOdf(const KoXmlElement & element, KoShapeLoadingContext &context, KoStyleManager *styleManager, KoChangeTracker *changeTracker)
{
QTextDocument *document = new QTextDocument();
QTextCursor cursor(document);
KoTextDocument textDocument(document);
textDocument.setStyleManager(styleManager);
d->styleManager = styleManager;
textDocument.setChangeTracker(changeTracker);
KoTextLoader loader(context);
if (element.namespaceURI() == KoXmlNS::text && element.localName() == "note") {
QString className = element.attributeNS(KoXmlNS::text, "note-class");
if (className == "footnote") {
d->type = Footnote;
}
else if (className == "endnote") {
d->type = Endnote;
}
else {
delete document;
return false;
}
d->id = element.attributeNS(KoXmlNS::text, "id");
for (KoXmlNode node = element.firstChild(); !node.isNull(); node = node.nextSibling()) {
setAutoNumbering(false);
KoXmlElement ts = node.toElement();
if (ts.namespaceURI() != KoXmlNS::text)
continue;
if (ts.localName() == "note-body") {
loader.loadBody(ts, cursor);
} else if (ts.localName() == "note-citation") {
d->label = ts.attributeNS(KoXmlNS::text, "label");
if (d->label.isEmpty()) {
setAutoNumbering(true);
d->label = ts.text();
}
}
}
}
else if (element.namespaceURI() == KoXmlNS::office && element.localName() == "annotation") {
d->author = element.attributeNS(KoXmlNS::text, "dc-creator");
d->date = QDateTime::fromString(element.attributeNS(KoXmlNS::text, "dc-date"), Qt::ISODate);
loader.loadBody(element, cursor); // would skip author and date, and do just the <text-p> and <text-list> elements
}
else {
delete document;
return false;
}
d->text = QTextDocumentFragment(document);
delete document;
return true;
}
void KisKraLoader::loadCompositions(const KoXmlElement& elem, KisImageWSP image)
{
KoXmlNode child;
for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
KoXmlElement e = child.toElement();
QString name = e.attribute("name");
bool exportEnabled = e.attribute("exportEnabled", "1") == "0" ? false : true;
KisLayerComposition* composition = new KisLayerComposition(image, name);
composition->setExportEnabled(exportEnabled);
KoXmlNode value;
for (value = child.lastChild(); !value.isNull(); value = value.previousSibling()) {
KoXmlElement e = value.toElement();
QUuid uuid(e.attribute("uuid"));
bool visible = e.attribute("visible", "1") == "0" ? false : true;
composition->setVisible(uuid, visible);
bool collapsed = e.attribute("collapsed", "1") == "0" ? false : true;
composition->setCollapsed(uuid, collapsed);
}
image->addComposition(composition);
}
}
bool KPlatoXmlLoader::load( const KoXmlElement& plan )
{
kDebug(kplatoXmlDebugArea())<<"plan";
QString syntaxVersion = plan.attribute( "version" );
m_loader.setVersion( syntaxVersion );
if ( syntaxVersion.isEmpty() ) {
int ret = KMessageBox::warningContinueCancel(
0, i18n( "This document has no syntax version.\n"
"Opening it in Plan may lose information." ),
i18n( "File-Format Error" ), KGuiItem( i18n( "Continue" ) ) );
if ( ret == KMessageBox::Cancel ) {
m_message = "USER_CANCELED";
return false;
}
// set to max version and hope for the best
m_loader.setVersion( KPLATO_MAX_FILE_SYNTAX_VERSION );
} else if ( syntaxVersion > KPLATO_MAX_FILE_SYNTAX_VERSION ) {
int ret = KMessageBox::warningContinueCancel(
0, i18n( "This document was created with a newer version of KPlato than Plan can load.\n"
"Syntax version: %1\n"
"Opening it in this version of Plan may lose some information.", syntaxVersion ),
i18n( "File-Format Mismatch" ), KGuiItem( i18n( "Continue" ) ) );
if ( ret == KMessageBox::Cancel ) {
m_message = "USER_CANCELED";
return false;
}
}
m_loader.startLoad();
bool result = false;
KoXmlNode n = plan.firstChild();
for ( ; ! n.isNull(); n = n.nextSibling() ) {
if ( ! n.isElement() ) {
continue;
}
KoXmlElement e = n.toElement();
if ( e.tagName() == "project" ) {
m_loader.setProject( m_project );
result = load( m_project, e, m_loader );
if ( result ) {
if ( m_project->id().isEmpty() ) {
m_project->setId( m_project->uniqueNodeId() );
m_project->registerNodeId( m_project );
}
} else {
m_loader.addMsg( XMLLoaderObject::Errors, "Loading of project failed" );
kError()<<"Loading of project failed";
//TODO add some ui here
}
}
}
m_loader.stopLoad();
return result;
}
bool KPrPlaceholderShapeFactory::supports(const KoXmlElement & e) const
{
// check parent if placeholder is set to true
KoXmlNode parent = e.parentNode();
if ( !parent.isNull() ) {
KoXmlElement element = parent.toElement();
if ( !element.isNull() ) {
kDebug(33001) << "placeholder:" << ( element.attributeNS( KoXmlNS::presentation, "placeholder", "false" ) == "true" );
return ( element.attributeNS( KoXmlNS::presentation, "placeholder", "false" ) == "true" );
}
}
return false;
}
void KisKraLoader::loadAssistantsList(const KoXmlElement &elem)
{
KoXmlNode child;
int count = 0;
for (child = elem.firstChild(); !child.isNull(); child = child.nextSibling()) {
KoXmlElement e = child.toElement();
QString type = e.attribute("type");
QString file_name = e.attribute("filename");
m_d->assistantsFilenames.insert(file_name,type);
count++;
}
}
bool Context::load( const KoXmlDocument &document ) {
m_document = document; // create a copy, document is deleted under our feet
// Check if this is the right app
KoXmlElement elm = m_document.documentElement();
QString value = elm.attribute( "mime", QString() );
if ( value.isEmpty() ) {
errorPlan << "No mime type specified!";
// setErrorMessage( i18n( "Invalid document. No mimetype specified." ) );
return false;
} else if ( value != "application/x-vnd.kde.plan" ) {
if ( value == "application/x-vnd.kde.kplato" ) {
// accept, since we forgot to change kplato to plan for so long...
} else {
errorPlan << "Unknown mime type " << value;
// setErrorMessage( i18n( "Invalid document. Expected mimetype application/x-vnd.kde.kplato, got %1", value ) );
return false;
}
}
/* QString m_syntaxVersion = elm.attribute( "version", "0.0" );
if ( m_syntaxVersion > "0.0" ) {
int ret = KMessageBox::warningContinueCancel(
0, i18n( "This document was created with a newer version of Plan (syntax version: %1)\n"
"Opening it in this version of Plan will lose some information.", m_syntaxVersion ),
i18n( "File-Format Mismatch" ), KGuiItem( i18n( "Continue" ) ) );
if ( ret == KMessageBox::Cancel ) {
setErrorMessage( "USER_CANCELED" );
return false;
}
}
*/
/*
#ifdef KOXML_USE_QDOM
int numNodes = elm.childNodes().count();
#else
int numNodes = elm.childNodesCount();
#endif
*/
KoXmlNode n = elm.firstChild();
for ( ; ! n.isNull(); n = n.nextSibling() ) {
if ( ! n.isElement() ) {
continue;
}
KoXmlElement element = n.toElement();
if ( element.tagName() == "context" ) {
m_context = element;
m_contextLoaded = true;
}
}
return true;
}
void SvgStyleParser::parseColorStops(QGradient *gradient, const KoXmlElement &e)
{
QGradientStops stops;
QColor c;
for (KoXmlNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
KoXmlElement stop = n.toElement();
if (stop.tagName() == "stop") {
float offset;
QString temp = stop.attribute("offset");
if (temp.contains('%')) {
temp = temp.left(temp.length() - 1);
offset = temp.toFloat() / 100.0;
} else
offset = temp.toFloat();
QString stopColorStr = stop.attribute("stop-color");
if (!stopColorStr.isEmpty()) {
if (stopColorStr == "inherit") {
stopColorStr = inheritedAttribute("stop-color", stop);
}
parseColor(c, stopColorStr);
}
else {
// try style attr
QString style = stop.attribute("style").simplified();
QStringList substyles = style.split(';', QString::SkipEmptyParts);
for (QStringList::Iterator it = substyles.begin(); it != substyles.end(); ++it) {
QStringList substyle = it->split(':');
QString command = substyle[0].trimmed();
QString params = substyle[1].trimmed();
if (command == "stop-color")
parseColor(c, params);
if (command == "stop-opacity")
c.setAlphaF(params.toDouble());
}
}
QString opacityStr = stop.attribute("stop-opacity");
if (!opacityStr.isEmpty()) {
if (opacityStr == "inherit") {
opacityStr = inheritedAttribute("stop-opacity", stop);
}
c.setAlphaF(opacityStr.toDouble());
}
stops.append(QPair<qreal, QColor>(offset, c));
}
}
if (stops.count())
gradient->setStops(stops);
}
bool KoDocumentInfo::loadOasis(const KoXmlDocument& metaDoc)
{
KoXmlNode t = KoXml::namedItemNS(metaDoc, KoXmlNS::office, "document-meta");
KoXmlNode office = KoXml::namedItemNS(t, KoXmlNS::office, "meta");
if (office.isNull())
return false;
if (!loadOasisAboutInfo(office))
return false;
if (!loadOasisAuthorInfo(office))
return false;
return true;
}
bool KoDocumentInfo::loadAuthorInfo(const KoXmlElement &e)
{
KoXmlNode n = e.namedItem("author").firstChild();
for (; !n.isNull(); n = n.nextSibling()) {
KoXmlElement e = n.toElement();
if (e.isNull())
continue;
if (e.tagName() == "full-name")
setActiveAuthorInfo("creator", e.text().trimmed());
else
setActiveAuthorInfo(e.tagName(), e.text().trimmed());
}
return true;
}
bool KPlatoXmlLoader::loadWorkpackage( const KoXmlElement& plan )
{
kDebug(kplatoXmlDebugArea());
bool ok = false;
if ( m_loader.workVersion() > KPLATOWORK_MAX_FILE_SYNTAX_VERSION ) {
int ret = KMessageBox::warningContinueCancel(
0, i18n( "This document was created with a newer version of KPlatoWork (syntax version: %1)\n"
"Opening it in this version of PlanWork will lose some information.", m_loader.workVersion() ),
i18n( "File-Format Mismatch" ), KGuiItem( i18n( "Continue" ) ) );
if ( ret == KMessageBox::Cancel ) {
m_message = "USER_CANCELED";
return false;
}
}
m_loader.startLoad();
Project *proj = new Project();
Package *package = new Package();
package->project = proj;
KoXmlNode n = plan.firstChild();
for ( ; ! n.isNull(); n = n.nextSibling() ) {
if ( ! n.isElement() ) {
continue;
}
KoXmlElement e = n.toElement();
if ( e.tagName() == "project" ) {
m_loader.setProject( proj );
ok = load( proj, e, m_loader );
if ( ! ok ) {
m_loader.addMsg( XMLLoaderObject::Errors, "Loading of work package failed" );
//TODO add some ui here
}
} else if ( e.tagName() == "workpackage" ) {
m_timeTag = e.attribute( "time-tag" );
package->ownerId = e.attribute( "owner-id" );
package->ownerName = e.attribute( "owner" );
KoXmlElement elem;
forEachElement( elem, e ) {
if ( elem.tagName() != "settings" ) {
continue;
}
package->settings.usedEffort = (bool)elem.attribute( "used-effort" ).toInt();
package->settings.progress = (bool)elem.attribute( "progress" ).toInt();
package->settings.documents = (bool)elem.attribute( "documents" ).toInt();
}
}
}
// static
QHash<QString, KoXmlElement> Validity::preloadValidities(const KoXmlElement& body)
{
QHash<QString, KoXmlElement> validities;
KoXmlNode validation = KoXml::namedItemNS(body, KoXmlNS::table, "content-validations");
kDebug() << "validation.isNull?" << validation.isNull();
if (!validation.isNull()) {
KoXmlElement element;
forEachElement(element, validation) {
if (element.tagName() == "content-validation" && element.namespaceURI() == KoXmlNS::table) {
const QString name = element.attributeNS(KoXmlNS::table, "name", QString());
validities.insert(name, element);
kDebug() << " validation found:" << name;
} else {
kDebug() << " Tag not recognized:" << element.tagName();
}
}
}
bool InfoVariable::loadOdf(const KoXmlElement & element, KoShapeLoadingContext & /*context*/)
{
if (!s_loadInfo.exists() ) {
for (unsigned int i = 0; i < numPropertyData; ++i) {
s_loadInfo->insert(propertyData[i].tag, propertyData[i].property);
}
}
const QString localName(element.localName());
m_type = s_loadInfo->value(localName);
for(KoXmlNode node = element.firstChild(); !node.isNull(); node = node.nextSibling() ) {
if (node.isText()) {
setValue(node.toText().data());
break;
}
}
return true;
}
bool KPrPlaceholderShapeFactory::supports(const KoXmlElement & e, KoShapeLoadingContext &context) const
{
Q_UNUSED(context);
// check parent if placeholder is set to true
KoXmlNode parent = e.parentNode();
if ( !parent.isNull() ) {
KoXmlElement element = parent.toElement();
if ( !element.isNull() ) {
bool supported = element.attributeNS( KoXmlNS::presentation, "placeholder", "false" ) == "true";
kDebug(33001) << "placeholder:" << supported;
#ifndef NWORKAROUND_ODF_BUGS
if (!supported && KoOdfWorkaround::fixPresentationPlaceholder() && element.hasAttributeNS(KoXmlNS::presentation, "class")) {
supported = true;
kDebug(33001) << "workaround OO placeholder bug" << supported;
}
#endif
return supported;
}
}
return false;
}
void KoOdfStylesReader::createStyleMap(const KoXmlDocument& doc, bool stylesDotXml)
{
const KoXmlElement docElement = doc.documentElement();
// We used to have the office:version check here, but better let the apps do that
KoXmlElement fontStyles = KoXml::namedItemNS(docElement, KoXmlNS::office, "font-face-decls");
if (!fontStyles.isNull()) {
//kDebug(30003) <<"Starting reading in font-face-decls...";
insertStyles(fontStyles, stylesDotXml ? AutomaticInStyles : AutomaticInContent);
}// else
// kDebug(30003) <<"No items found";
//kDebug(30003) <<"Starting reading in office:automatic-styles. stylesDotXml=" << stylesDotXml;
KoXmlElement autoStyles = KoXml::namedItemNS(docElement, KoXmlNS::office, "automatic-styles");
if (!autoStyles.isNull()) {
insertStyles(autoStyles, stylesDotXml ? AutomaticInStyles : AutomaticInContent);
}// else
// kDebug(30003) <<"No items found";
//kDebug(30003) <<"Reading in master styles";
KoXmlNode masterStyles = KoXml::namedItemNS(docElement, KoXmlNS::office, "master-styles");
if (!masterStyles.isNull()) {
KoXmlElement master;
forEachElement(master, masterStyles) {
if (master.localName() == "master-page" &&
master.namespaceURI() == KoXmlNS::style) {
const QString name = master.attributeNS(KoXmlNS::style, "name", QString());
kDebug(30003) << "Master style: '" << name << "' loaded";
d->masterPages.insert(name, new KoXmlElement(master));
} else if (master.localName() == "layer-set" && master.namespaceURI() == KoXmlNS::draw) {
kDebug(30003) << "Master style: layer-set loaded";
d->layerSet = master;
} else
// OASIS docu mentions style:handout-master and draw:layer-set here
kWarning(30003) << "Unknown tag " << master.tagName() << " in office:master-styles";
}
}
bool KoInlineNote::loadOdf(const KoXmlElement & element)
{
if (element.namespaceURI() != KoXmlNS::text || element.localName() != "note")
return false;
QString className = element.attributeNS(KoXmlNS::text, "note-class");
if (className == "footnote")
d->type = Footnote;
else if (className == "endnote")
d->type = Endnote;
else
return false;
d->id = element.attributeNS(KoXmlNS::text, "id");
for (KoXmlNode node = element.firstChild(); !node.isNull(); node = node.nextSibling()) {
setAutoNumbering(false);
KoXmlElement ts = node.toElement();
if (ts.namespaceURI() != KoXmlNS::text)
continue;
if (ts.localName() == "note-body") {
d->text = "";
KoXmlNode node = ts.firstChild();
while (!node.isNull()) {
KoXmlElement commentElement = node.toElement();
if (!commentElement.isNull()) {
if (commentElement.localName() == "p" && commentElement.namespaceURI() == KoXmlNS::text) {
if (!d->text.isEmpty())
d->text.append('\n');
d->text.append(commentElement.text());
}
}
node = node.nextSibling();
}
} else if (ts.localName() == "note-citation") {
d->label = ts.attributeNS(KoXmlNS::text, "label");
if (d->label.isEmpty()) {
setAutoNumbering(true);
d->label = ts.text();
}
}
}
return true;
}
bool KraConverter::loadXML(const KoXmlDocument &doc, KoStore *store)
{
Q_UNUSED(store);
KoXmlElement root;
KoXmlNode node;
if (doc.doctype().name() != "DOC") {
m_doc->setErrorMessage(i18n("The format is not supported or the file is corrupted"));
return false;
}
root = doc.documentElement();
int syntaxVersion = root.attribute("syntaxVersion", "3").toInt();
if (syntaxVersion > 2) {
m_doc->setErrorMessage(i18n("The file is too new for this version of Krita (%1).", syntaxVersion));
return false;
}
if (!root.hasChildNodes()) {
m_doc->setErrorMessage(i18n("The file has no layers."));
return false;
}
m_kraLoader = new KisKraLoader(m_doc, syntaxVersion);
// Legacy from the multi-image .kra file period.
for (node = root.firstChild(); !node.isNull(); node = node.nextSibling()) {
if (node.isElement()) {
if (node.nodeName() == "IMAGE") {
KoXmlElement elem = node.toElement();
if (!(m_image = m_kraLoader->loadXML(elem))) {
if (m_kraLoader->errorMessages().isEmpty()) {
m_doc->setErrorMessage(i18n("Unknown error."));
}
else {
m_doc->setErrorMessage(m_kraLoader->errorMessages().join(".\n"));
}
return false;
}
return true;
}
else {
if (m_kraLoader->errorMessages().isEmpty()) {
m_doc->setErrorMessage(i18n("The file does not contain an image."));
}
return false;
}
}
}
return false;
}
bool KoDocumentInfo::loadOasisAuthorInfo(const KoXmlNode &metaDoc)
{
KoXmlElement e = KoXml::namedItemNS(metaDoc, KoXmlNS::dc, "creator");
if (!e.isNull() && !e.text().isEmpty())
setActiveAuthorInfo("creator", e.text());
KoXmlNode n = metaDoc.firstChild();
for (; !n.isNull(); n = n.nextSibling()) {
if (!n.isElement())
continue;
KoXmlElement e = n.toElement();
if (!(e.namespaceURI() == KoXmlNS::meta &&
e.localName() == "user-defined" && !e.text().isEmpty()))
continue;
QString name = e.attributeNS(KoXmlNS::meta, "name", QString());
setActiveAuthorInfo(name, e.text());
}
return true;
}
bool Context::load( const KoXmlDocument &document ) {
m_document = document; // create a copy, document is deleted under our feet
// Check if this is the right app
KoXmlElement elm = m_document.documentElement();
QString value = elm.attribute( "mime", QString() );
if ( value.isEmpty() ) {
kError() << "No mime type specified!" << endl;
// setErrorMessage( i18n( "Invalid document. No mimetype specified." ) );
return false;
} else if ( value != "application/x-vnd.kde.kplato" ) {
kError() << "Unknown mime type " << value << endl;
// setErrorMessage( i18n( "Invalid document. Expected mimetype application/x-vnd.kde.kplato, got %1", value ) );
return false;
}
QString m_syntaxVersion = elm.attribute( "version", "0.0" );
if ( m_syntaxVersion > "0.0" ) {
/* int ret = KMessageBox::warningContinueCancel(
0, i18n( "This document was created with a newer version of KPlato (syntax version: %1)\n"
"Opening it in this version of KPlato will lose some information.", m_syntaxVersion ),
i18n( "File-Format Mismatch" ), KGuiItem( i18n( "Continue" ) ) );
if ( ret == KMessageBox::Cancel ) {
setErrorMessage( "USER_CANCELED" );
return false;
}*/
}
#ifdef KOXML_USE_QDOM
int numNodes = elm.childNodes().count();
#else
int numNodes = elm.childNodesCount();
#endif
KoXmlNode n = elm.firstChild();
for ( ; ! n.isNull(); n = n.nextSibling() ) {
if ( ! n.isElement() ) {
continue;
}
KoXmlElement element = n.toElement();
if ( element.tagName() == "context" ) {
m_context = element;
m_contextLoaded = true;
/* currentView = element.attribute("current-view");
currentEstimateType = element.attribute("estimate-type").toInt();
currentSchedule = element.attribute("current-schedule").toLong();
actionViewExpected = element.attribute("view-expected").toInt();
actionViewOptimistic = element.attribute("view-optimistic").toInt();
actionViewPessimistic = element.attribute("view-pessimistic").toInt();
QDomNodeList list = element.childNodes();
for (int i=0; i<list.count(); ++i) {
if (list.item(i).isElement()) {
QDomElement e = list.item(i).toElement();
if (e.tagName() == "gantt-view") {
ganttview.ganttviewsize = e.attribute("ganttview-size").toInt();
ganttview.taskviewsize = e.attribute("taskview-size").toInt();
ganttview.currentNode = e.attribute("current-node");
ganttview.showResources = e.attribute("show-resources").toInt();
ganttview.showTaskName = e.attribute("show-taskname").toInt();
ganttview.showTaskLinks = e.attribute("show-tasklinks").toInt();
ganttview.showProgress = e.attribute("show-progress").toInt();
ganttview.showPositiveFloat = e.attribute("show-positivefloat").toInt();
ganttview.showCriticalTasks = attribute("show-criticaltasks").toInt();
ganttview.showCriticalPath = e.attribute("show-criticalpath").toInt();
ganttview.showNoInformation = e.attribute("show-noinformation").toInt();
QDomNodeList list = e.childNodes();
for (int i=0; i<list.count(); ++i) {
if (list.item(i).isElement()) {
QDomElement g = list.item(i).toElement();
if (g.tagName() == "closed-nodes") {
QDomNodeList list = g.childNodes();
for (int i=0; i<list.count(); ++i) {
if (list.item(i).isElement()) {
QDomElement ei = list.item(i).toElement();
if (ei.tagName() == "node") {
ganttview.closedNodes.append(ei.attribute("id"));
}
}
}
}
}
}
} else if (e.tagName() == "accounts-view") {
accountsview.accountsviewsize = e.attribute("accountsview-size").toInt();
accountsview.periodviewsize = e.attribute("periodview-size").toInt();
accountsview.date = QDate::fromString(e.attribute("date"), Qt::ISODate);
accountsview.period = e.attribute("period").toInt();
accountsview.cumulative = e.attribute("cumulative").toInt();
QDomNodeList list = e.childNodes();
for (int i=0; i<list.count(); ++i) {
if (list.item(i).isElement()) {
QDomElement g = list.item(i).toElement();
if (g.tagName() == "closed-items") {
QDomNodeList list = g.childNodes();
for (int i=0; i<list.count(); ++i) {
if (list.item(i).isElement()) {
QDomElement ei = list.item(i).toElement();
if (ei.tagName() == "account") {
accountsview.closedItems.append(ei.attribute("name"));
}
}
}
}
}
}
} else {
kError()<<"Unknown tag: "<<e.tagName()<<endl;
}
}
}*/
}
}
return true;
}
KisNodeSP KisKraLoader::loadNodes(const KoXmlElement& element, KisImageWSP image, KisNodeSP parent)
{
KoXmlNode node = element.firstChild();
KoXmlNode child;
if (!node.isNull()) {
if (node.isElement()) {
if (node.nodeName().toUpper() == LAYERS.toUpper() || node.nodeName().toUpper() == MASKS.toUpper()) {
for (child = node.lastChild(); !child.isNull(); child = child.previousSibling()) {
KisNodeSP node = loadNode(child.toElement(), image, parent);
if (node) {
image->nextLayerName(); // Make sure the nameserver is current with the number of nodes.
image->addNode(node, parent);
if (node->inherits("KisLayer") && child.childNodesCount() > 0) {
loadNodes(child.toElement(), image, node);
}
}
}
}
}
}
return parent;
}
KisImageWSP KisKraLoader::loadXML(const KoXmlElement& element)
{
QString attr;
KisImageWSP image = 0;
QString name;
qint32 width;
qint32 height;
QString profileProductName;
double xres;
double yres;
QString colorspacename;
const KoColorSpace * cs;
if ((attr = element.attribute(MIME)) == NATIVE_MIMETYPE) {
if ((m_d->imageName = element.attribute(NAME)).isNull()) {
m_d->errorMessages << i18n("Image does not have a name.");
return KisImageWSP(0);
}
if ((attr = element.attribute(WIDTH)).isNull()) {
m_d->errorMessages << i18n("Image does not specify a width.");
return KisImageWSP(0);
}
width = attr.toInt();
if ((attr = element.attribute(HEIGHT)).isNull()) {
m_d->errorMessages << i18n("Image does not specify a height.");
return KisImageWSP(0);
}
height = attr.toInt();
m_d->imageComment = element.attribute(DESCRIPTION);
xres = 100.0 / 72.0;
if (!(attr = element.attribute(X_RESOLUTION)).isNull()) {
if (attr.toDouble() > 1.0) {
xres = attr.toDouble() / 72.0;
}
}
yres = 100.0 / 72.0;
if (!(attr = element.attribute(Y_RESOLUTION)).isNull()) {
if (attr.toDouble() > 1.0) {
yres = attr.toDouble() / 72.0;
}
}
if ((colorspacename = element.attribute(COLORSPACE_NAME)).isNull()) {
// An old file: take a reasonable default.
// Krita didn't support anything else in those
// days anyway.
colorspacename = "RGBA";
}
profileProductName = element.attribute(PROFILE);
// A hack for an old colorspacename
convertColorSpaceNames(colorspacename, profileProductName);
QString colorspaceModel = KoColorSpaceRegistry::instance()->colorSpaceColorModelId(colorspacename).id();
QString colorspaceDepth = KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(colorspacename).id();
if (profileProductName.isNull()) {
// no mention of profile so get default profile";
cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
} else {
cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, profileProductName);
}
if (cs == 0) {
// try once more without the profile
cs = KoColorSpaceRegistry::instance()->colorSpace(colorspaceModel, colorspaceDepth, "");
if (cs == 0) {
m_d->errorMessages << i18n("Image specifies an unsupported color model: %1.", colorspacename);
return KisImageWSP(0);
}
}
if (m_d->document) {
image = new KisImage(m_d->document->createUndoStore(), width, height, cs, name);
}
else {
image = new KisImage(0, width, height, cs, name);
}
image->setResolution(xres, yres);
loadNodes(element, image, const_cast<KisGroupLayer*>(image->rootLayer().data()));
KoXmlNode child;
for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
KoXmlElement e = child.toElement();
if(e.tagName() == "ProjectionBackgroundColor") {
if (e.hasAttribute("ColorData")) {
QByteArray colorData = QByteArray::fromBase64(e.attribute("ColorData").toLatin1());
KoColor color((const quint8*)colorData.data(), image->colorSpace());
image->setDefaultProjectionColor(color);
}
}
if (e.tagName().toLower() == "animation") {
loadAnimationMetadata(e, image);
}
}
for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
KoXmlElement e = child.toElement();
if(e.tagName() == "compositions") {
loadCompositions(e, image);
}
}
}
KoXmlNode child;
for (child = element.lastChild(); !child.isNull(); child = child.previousSibling()) {
KoXmlElement e = child.toElement();
if (e.tagName() == "assistants") {
loadAssistantsList(e);
}
}
return image;
}
MetaInfo ZefaniaLex::buildIndexFromXmlDoc(KoXmlDocument *xmldoc)
{
try {
MetaInfo info;
int couldBe = 0;//1 = RMac
Document indexdoc;
const QString index = indexPath();
QString fileTitle;
QString uid;
QString type;
QDir dir("/");
dir.mkpath(index);
RefText refText;
refText.setSettings(m_settings);
IndexWriter* writer = NULL;
const TCHAR* stop_words[] = { NULL };
standard::StandardAnalyzer an(stop_words);
if(IndexReader::indexExists(index.toStdString().c_str())) {
if(IndexReader::isLocked(index.toStdString().c_str())) {
myDebug() << "Index was locked... unlocking it.";
IndexReader::unlock(index.toStdString().c_str());
}
}
writer = new IndexWriter(index.toStdString().c_str() , &an, true);
writer->setMaxFieldLength(0x7FFFFFFFL);
writer->setUseCompoundFile(false);
KoXmlNode item = xmldoc->documentElement().firstChild();
type = xmldoc->documentElement().toElement().attribute("type", "");
for(int c = 0; !item.isNull();) {
QString key = "";
QString title = "";
QString trans = "";
QString pron = "";
QString desc = "";
KoXmlElement e = item.toElement();
if(e.tagName().compare("INFORMATION", Qt::CaseInsensitive) == 0) {
KoXmlNode title = item.namedItem("subject");
KoXmlNode identifer = item.namedItem("identifier");
fileTitle = title.toElement().text();
uid = identifer.toElement().text();
} else if(e.tagName().compare("item", Qt::CaseInsensitive) == 0) {
key = e.attribute("id");
KoXmlNode details = item.firstChild();
while(!details.isNull()) {
KoXmlElement edetails = details.toElement();
if(edetails.tagName().compare("title", Qt::CaseInsensitive) == 0) {
title = edetails.text();
} else if(edetails.tagName().compare("transliteration", Qt::CaseInsensitive) == 0) {
trans = edetails.text();
} else if(edetails.tagName().compare("pronunciation", Qt::CaseInsensitive) == 0) {
KoXmlNode em = details.firstChild();
while(!em.isNull()) {
if(em.toElement().tagName().compare("em", Qt::CaseInsensitive) == 0)
pron = "<em>" + em.toElement().text() + "</em>";
em = em.nextSibling();
}
} else if(edetails.tagName().compare("description", Qt::CaseInsensitive) == 0) {
KoXmlNode descNode = details.firstChild();
while(!descNode.isNull()) {
if(descNode.nodeType() == 2) {
desc += descNode.toText().data();
} else if(descNode.nodeType() == 1) {
KoXmlElement descElement = descNode.toElement();
if(descElement.tagName().compare("reflink", Qt::CaseInsensitive) == 0) {
if(descElement.hasAttribute("mscope")) {
const QString mscope = descElement.attribute("mscope", ";;;");
VerseUrl url;
url.fromMscope(mscope);
desc += " <a href=\"" + url.toString() + "\">" + refText.toString(url) + "</a> ";
} else if(descElement.hasAttribute("target")) {
desc += descElement.text();
}
} else if(descElement.tagName().compare("see", Qt::CaseInsensitive) == 0) {
const QString target = descElement.attribute("target", "");
//todo: currently we assume target = x-self
StrongUrl url;
bool ok = url.fromText(descElement.text());
if(ok)
desc += " <a href=\"" + url.toString() + "\">" + descElement.text() + "</a> ";
}
}
descNode = descNode.nextSibling();
}
desc += "<hr />";
}
details = details.nextSibling();
}
if(couldBe == 0) {
if(key.toUpper() == "A-APF" || key.toUpper() == "X-NSN" || key.toUpper() == "V-PAP-DPN") {
couldBe = 1;
}
}
QString content = "<h3 class='strongTitle'>" + key + " - " + title + "</h3>";
if(!trans.isEmpty()) {
content += " (" + trans + ") ";
}
if(!pron.isEmpty()) {
content += " [" + pron + "] ";
}
content += "<br />" + desc;
indexdoc.clear();
#ifdef OBV_USE_WSTRING
indexdoc.add(*_CLNEW Field(_T("key"), key.toStdWString().c_str(), Field::STORE_YES | Field::INDEX_TOKENIZED));
indexdoc.add(*_CLNEW Field(_T("content"), content.toStdWString().c_str(), Field::STORE_YES | Field::INDEX_TOKENIZED));
#else
indexdoc.add(*_CLNEW Field(_T("key"), reinterpret_cast<const wchar_t *>(key.utf16()), Field::STORE_YES | Field::INDEX_TOKENIZED));
indexdoc.add(*_CLNEW Field(_T("content"), reinterpret_cast<const wchar_t *>(content.utf16()), Field::STORE_YES | Field::INDEX_TOKENIZED));
#endif
writer->addDocument(&indexdoc);
}
item = item.nextSibling();
c++;
}
writer->setUseCompoundFile(true);
writer->optimize();
writer->close();
delete writer;
info.setName(fileTitle);
info.setUID(uid);
if(type == "x-strong") {
info.setDefaultModule(OBVCore::DefaultStrongDictModule);
info.setContent(OBVCore::StrongsContent);
} else if(type == "x-dictionary") {
if(couldBe == 1) {
info.setDefaultModule(OBVCore::DefaultRMACDictModule);
info.setContent(OBVCore::RMacContent);
} else {
info.setDefaultModule(OBVCore::DefaultDictModule);
}
}
return info;
}
catch(...) {
return MetaInfo();
}
}
void SvgParser::applyFilter(KoShape *shape)
{
SvgGraphicsContext *gc = m_context.currentGC();
if (! gc)
return;
if (gc->filterId.isEmpty())
return;
SvgFilterHelper *filter = findFilter(gc->filterId);
if (! filter)
return;
KoXmlElement content = filter->content();
// parse filter region
QRectF bound(shape->position(), shape->size());
// work on bounding box without viewbox tranformation applied
// so user space coordinates of bounding box and filter region match up
bound = gc->viewboxTransform.inverted().mapRect(bound);
QRectF filterRegion(filter->position(bound), filter->size(bound));
// convert filter region to boundingbox units
QRectF objectFilterRegion;
objectFilterRegion.setTopLeft(SvgUtil::userSpaceToObject(filterRegion.topLeft(), bound));
objectFilterRegion.setSize(SvgUtil::userSpaceToObject(filterRegion.size(), bound));
KoFilterEffectLoadingContext context(m_context.xmlBaseDir());
context.setShapeBoundingBox(bound);
// enable units conversion
context.enableFilterUnitsConversion(filter->filterUnits() == SvgFilterHelper::UserSpaceOnUse);
context.enableFilterPrimitiveUnitsConversion(filter->primitiveUnits() == SvgFilterHelper::UserSpaceOnUse);
KoFilterEffectRegistry *registry = KoFilterEffectRegistry::instance();
KoFilterEffectStack *filterStack = 0;
QSet<QString> stdInputs;
stdInputs << "SourceGraphic" << "SourceAlpha";
stdInputs << "BackgroundImage" << "BackgroundAlpha";
stdInputs << "FillPaint" << "StrokePaint";
QMap<QString, KoFilterEffect*> inputs;
// create the filter effects and add them to the shape
for (KoXmlNode n = content.firstChild(); !n.isNull(); n = n.nextSibling()) {
KoXmlElement primitive = n.toElement();
KoFilterEffect *filterEffect = registry->createFilterEffectFromXml(primitive, context);
if (!filterEffect) {
debugFlake << "filter effect" << primitive.tagName() << "is not implemented yet";
continue;
}
const QString input = primitive.attribute("in");
if (!input.isEmpty()) {
filterEffect->setInput(0, input);
}
const QString output = primitive.attribute("result");
if (!output.isEmpty()) {
filterEffect->setOutput(output);
}
QRectF subRegion;
// parse subregion
if (filter->primitiveUnits() == SvgFilterHelper::UserSpaceOnUse) {
const QString xa = primitive.attribute("x");
const QString ya = primitive.attribute("y");
const QString wa = primitive.attribute("width");
const QString ha = primitive.attribute("height");
if (xa.isEmpty() || ya.isEmpty() || wa.isEmpty() || ha.isEmpty()) {
bool hasStdInput = false;
bool isFirstEffect = filterStack == 0;
// check if one of the inputs is a standard input
foreach(const QString &input, filterEffect->inputs()) {
if ((isFirstEffect && input.isEmpty()) || stdInputs.contains(input)) {
hasStdInput = true;
break;
}
}
if (hasStdInput || primitive.tagName() == "feImage") {
// default to 0%, 0%, 100%, 100%
subRegion.setTopLeft(QPointF(0, 0));
subRegion.setSize(QSizeF(1, 1));
} else {
// defaults to bounding rect of all referenced nodes
foreach(const QString &input, filterEffect->inputs()) {
if (!inputs.contains(input))
continue;
KoFilterEffect *inputFilter = inputs[input];
if (inputFilter)
subRegion |= inputFilter->filterRect();
}
}
} else {
const qreal x = parseUnitX(xa);
const qreal y = parseUnitY(ya);
const qreal w = parseUnitX(wa);
const qreal h = parseUnitY(ha);
subRegion.setTopLeft(SvgUtil::userSpaceToObject(QPointF(x, y), bound));
subRegion.setSize(SvgUtil::userSpaceToObject(QSizeF(w, h), bound));
}
} else {
void CalculationSettings::loadOdf(const KoXmlElement& body)
{
KoXmlNode settings = KoXml::namedItemNS( body, KoXmlNS::table, "calculation-settings" );
kDebug() <<"Calculation settings found?"<< !settings.isNull();
if ( !settings.isNull() )
{
KoXmlElement element = settings.toElement();
if ( element.hasAttributeNS( KoXmlNS::table, "case-sensitive" ) )
{
d->caseSensitiveComparisons = true;
QString value = element.attributeNS( KoXmlNS::table, "case-sensitive", "true" );
if ( value == "false" )
d->caseSensitiveComparisons = false;
}
else if ( element.hasAttributeNS( KoXmlNS::table, "precision-as-shown" ) )
{
d->precisionAsShown = false;
QString value = element.attributeNS( KoXmlNS::table, "precision-as-shown", "false" );
if ( value == "true" )
d->precisionAsShown = true;
}
else if ( element.hasAttributeNS( KoXmlNS::table, "search-criteria-must-apply-to-whole-cell" ) )
{
d->wholeCellSearchCriteria = true;
QString value = element.attributeNS( KoXmlNS::table, "search-criteria-must-apply-to-whole-cell", "true" );
if ( value == "false" )
d->wholeCellSearchCriteria = false;
}
else if ( element.hasAttributeNS( KoXmlNS::table, "automatic-find-labels" ) )
{
d->automaticFindLabels = true;
QString value = element.attributeNS( KoXmlNS::table, "automatic-find-labels", "true" );
if ( value == "false" )
d->automaticFindLabels = false;
}
else if ( element.hasAttributeNS( KoXmlNS::table, "use-regular-expressions" ) )
{
d->useRegularExpressions = true;
QString value = element.attributeNS( KoXmlNS::table, "use-regular-expressions", "true" );
if ( value == "false" )
d->useRegularExpressions = false;
}
else if ( element.hasAttributeNS( KoXmlNS::table, "null-year" ) )
{
d->refYear = 1930;
QString value = element.attributeNS( KoXmlNS::table, "null-year", "1930" );
if ( value == "false" )
d->refYear = false;
}
forEachElement( element, settings )
{
if ( element.namespaceURI() != KoXmlNS::table )
continue;
else if ( element.tagName() == "null-date" )
{
d->refDate = QDate( 1899, 12, 30 );
QString valueType = element.attributeNS( KoXmlNS::table, "value-type", "date" );
if( valueType == "date" )
{
QString value = element.attributeNS( KoXmlNS::table, "date-value", "1899-12-30" );
QDate date = QDate::fromString( value, Qt::ISODate );
if ( date.isValid() )
d->refDate = date;
}
else
{
kDebug() <<"CalculationSettings: Error on loading null date."
<< "Value type """ << valueType << """ not handled"
<< ", falling back to default." << endl;
// NOTE Stefan: I don't know why different types are possible here!
}
}
else if ( element.tagName() == "iteration" )
{
// TODO
}
}
}
bool KoOdfLoadingContext::parseManifest(const KoXmlDocument &manifestDocument)
{
// First find the manifest:manifest node.
KoXmlNode n = manifestDocument.firstChild();
kDebug(30006) << "Searching for manifest:manifest " << n.toElement().nodeName();
for (; !n.isNull(); n = n.nextSibling()) {
if (!n.isElement()) {
kDebug(30006) << "NOT element";
continue;
} else {
kDebug(30006) << "element";
}
kDebug(30006) << "name:" << n.toElement().localName()
<< "namespace:" << n.toElement().namespaceURI();
if (n.toElement().localName() == "manifest"
&& n.toElement().namespaceURI() == KoXmlNS::manifest)
{
kDebug(30006) << "found manifest:manifest";
break;
}
}
if (n.isNull()) {
kDebug(30006) << "Could not find manifest:manifest";
return false;
}
// Now loop through the children of the manifest:manifest and
// store all the manifest:file-entry elements.
const KoXmlElement manifestElement = n.toElement();
for (n = manifestElement.firstChild(); !n.isNull(); n = n.nextSibling()) {
if (!n.isElement())
continue;
KoXmlElement el = n.toElement();
if (!(el.localName() == "file-entry" && el.namespaceURI() == KoXmlNS::manifest))
continue;
QString fullPath = el.attributeNS(KoXmlNS::manifest, "full-path", QString());
QString mediaType = el.attributeNS(KoXmlNS::manifest, "media-type", QString(""));
QString version = el.attributeNS(KoXmlNS::manifest, "version", QString());
// Only if fullPath is valid, should we store this entry.
// If not, we don't bother to find out exactly what is wrong, we just skip it.
if (!fullPath.isNull()) {
d->manifestEntries.insert(fullPath,
new KoOdfManifestEntry(fullPath, mediaType, version));
}
}
return true;
}
