QList<KoEventAction*> KoEventActionRegistry::createEventActionsFromOdf(const KoXmlElement & e, KoShapeLoadingContext & context) const
{
QList<KoEventAction *> eventActions;
if (e.namespaceURI() == KoXmlNS::office && e.tagName() == "event-listeners") {
KoXmlElement element;
forEachElement(element, e) {
if (element.tagName() == "event-listener") {
if (element.namespaceURI() == KoXmlNS::presentation) {
QString action(element.attributeNS(KoXmlNS::presentation, "action", QString()));
QHash<QString, KoEventActionFactory *>::const_iterator it(d->presentationEventActions.find(action));
if (it != d->presentationEventActions.constEnd()) {
KoEventAction * eventAction = it.value()->createEventAction();
if (eventAction) {
if (eventAction->loadOdf(element, context)) {
eventActions.append(eventAction);
} else {
delete eventAction;
}
}
} else {
kWarning(30006) << "presentation:event-listerer action = " << action << "not supported";
}
} else if (element.namespaceURI() == KoXmlNS::script) {
// TODO
} else {
kWarning(30006) << "element" << e.namespaceURI() << e.tagName() << "not supported";
}
} else {
kWarning(30006) << "element" << e.namespaceURI() << e.tagName() << "not supported";
}
}
} else {
bool StarShapeFactory::supports(const KoXmlElement &e, KoShapeLoadingContext &context) const
{
Q_UNUSED(context);
if (e.localName() == "regular-polygon" && e.namespaceURI() == KoXmlNS::draw) {
return true;
}
return (e.localName() == "custom-shape" && e.namespaceURI() == KoXmlNS::draw
&& e.attributeNS(KoXmlNS::draw, "engine", "") == "calligra:star");
}
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;
}
bool KoEnhancedPathShape::loadOdf( const KoXmlElement & element, KoShapeLoadingContext &context )
{
reset();
KoXmlElement child;
forEachElement( child, element )
{
if( child.localName() == "enhanced-geometry" && child.namespaceURI() == KoXmlNS::draw )
{
// load the viewbox
QRectF viewBox = loadOdfViewbox( child );
if( ! viewBox.isEmpty() )
m_viewBox = viewBox;
// load the modifiers
QString modifiers = child.attributeNS( KoXmlNS::draw, "modifiers", "" );
if( ! modifiers.isEmpty() )
{
addModifiers( modifiers );
}
KoXmlElement grandChild;
forEachElement( grandChild, child )
{
if( grandChild.namespaceURI() != KoXmlNS::draw )
continue;
if( grandChild.localName() == "equation" )
{
QString name = grandChild.attributeNS( KoXmlNS::draw, "name" );
QString formula = grandChild.attributeNS( KoXmlNS::draw, "formula" );
addFormula( name, formula );
}
else if( grandChild.localName() == "handle" )
{
KoEnhancedPathHandle * handle = new KoEnhancedPathHandle( this );
if( handle->loadOdf( grandChild ) )
{
m_enhancedHandles.append( handle );
evaluateHandles();
}
else
delete handle;
}
}
// load the enhanced path data
QString path = child.attributeNS( KoXmlNS::draw, "enhanced-path", "" );
#ifndef NWORKAROUND_ODF_BUGS
KoOdfWorkaround::fixEnhancedPath(path, child, context);
#endif
if ( !path.isEmpty() ) {
parsePathData( path );
}
}
}
bool KPrPageLayout::loadOdf( const KoXmlElement &element, const QRectF & pageRect )
{
if ( element.hasAttributeNS( KoXmlNS::style, "display-name" ) ) {
m_name = element.attributeNS( KoXmlNS::style, "display-name" );
}
else {
m_name = element.attributeNS( KoXmlNS::style, "name" );
}
KoXmlElement child;
forEachElement( child, element ) {
if ( child.tagName() == "placeholder" && child.namespaceURI() == KoXmlNS::presentation ) {
KPrPlaceholder * placeholder = new KPrPlaceholder;
if ( placeholder->loadOdf( child, pageRect ) ) {
m_placeholders.append( placeholder );
if ( placeholder->presentationObject() == "handout" ) {
m_layoutType = Handout;
}
}
else {
warnStage << "loading placeholder failed";
delete placeholder;
}
}
else {
warnStage << "unknown tag" << child.namespaceURI() << child.tagName() << "when loading page layout";
}
}
bool retval = true;
if ( m_placeholders.isEmpty() ) {
warnStage << "no placeholder for page layout" << m_name << "found";
retval = false;
}
else {
/*
* do fixups for wrong saved data from OO somehow they save negative values for width and height somethimes
* <style:presentation-page-layout style:name="AL10T12">
* <presentation:placeholder presentation:object="title" svg:x="2.057cm" svg:y="1.743cm" svg:width="23.911cm" svg:height="3.507cm"/>
* <presentation:placeholder presentation:object="outline" svg:x="2.057cm" svg:y="5.838cm" svg:width="11.669cm" svg:height="13.23cm"/>
* <presentation:placeholder presentation:object="object" svg:x="14.309cm" svg:y="5.838cm" svg:width="-0.585cm" svg:height="6.311cm"/>
* <presentation:placeholder presentation:object="object" svg:x="14.309cm" svg:y="12.748cm" svg:width="-0.585cm" svg:height="-0.601cm"/>
* </style:presentation-page-layout>
*/
QList<KPrPlaceholder *>::iterator it( m_placeholders.begin() );
KPrPlaceholder * last = *it;
++it;
for ( ; it != m_placeholders.end(); ++it ) {
( *it )->fix( last->rect( QSizeF( 1, 1 ) ) );
last = *it;
}
}
return retval;
}
bool KoFormulaShapeFactory::supports(const KoXmlElement& e, KoShapeLoadingContext &context) const
{
Q_UNUSED(context);
bool retval = ((e.localName() == "math"
&& e.namespaceURI() == KoXmlNS::math)
|| (e.localName() == "object"
&& e.namespaceURI() == KoXmlNS::draw));
// Should be 39001 (kformula) instead of 31000 (koffice)
//kDebug(31000) << e.nodeName() << " - "<< e.namespaceURI();
//kDebug(31000) << "Return value = " << retval;
return retval;
}
bool VectorShapeFactory::supports(const KoXmlElement & e, KoShapeLoadingContext &context) const
{
if (e.localName() == "image" && e.namespaceURI() == KoXmlNS::draw) {
QString href = e.attribute("href");
if (!href.isEmpty()) {
// check the mimetype
if (href.startsWith(QLatin1String("./"))) {
href.remove(0, 2);
}
// LO 3.5 does not write a mimetype for embedded wmf files, so guess also from content
const QString mimetype = context.odfLoadingContext().mimeTypeForPath(href, true);
return
mimetype == QLatin1String("image/x-svm") ||
mimetype == QLatin1String("image/x-emf") ||
mimetype == QLatin1String("image/x-wmf") ||
// Note: the Vector Shape supports SVG, but _NOT_ in this method, otherwise it will stomp all over loading the artistic text shape's svg
//mimetype == QLatin1String("image/svg+xml") ||
// next three for backward compatibility with Calligra
mimetype == QLatin1String("application/x-svm") ||
mimetype == QLatin1String("application/x-emf") ||
mimetype == QLatin1String("application/x-wmf") ||
// seems like MSO does not always write a mimetype
// see jeffcoweb.jeffco.k12.co.us%2Fhigh%2Fchatfield%2Fdepartments%2Fbusiness%2Fbanking_finance%2Funit_Plan_Budget.odp
mimetype.isEmpty() ||
// next for compatibility with OO/LO and our filters
// see drwho.virtadpt.net%2Ffiles%2FNOVALUG-Tor.odp
mimetype.startsWith(QLatin1String("application/x-openoffice"));
}
return true;
}
return false;
}
bool PictureShapeFactory::supports(const KoXmlElement &e, KoShapeLoadingContext &context) const
{
if (e.localName() == "image" && e.namespaceURI() == KoXmlNS::draw) {
QString href = e.attribute("href");
if (!href.isEmpty()) {
// check the mimetype
if (href.startsWith(QLatin1String("./"))) {
href.remove(0, 2);
}
QString mimetype = context.odfLoadingContext().mimeTypeForPath(href);
if (!mimetype.isEmpty()) {
return mimetype.startsWith("image");
}
else {
return ( href.endsWith("bmp") ||
href.endsWith("jpg") ||
href.endsWith("gif") ||
href.endsWith("eps") ||
href.endsWith("png") ||
href.endsWith("tif") ||
href.endsWith("tiff"));
}
}
else {
return !KoXml::namedItemNS(e, KoXmlNS::office, "binary-data").isNull();
}
}
return false;
}
bool VideoShapeFactory::supports(const KoXmlElement &e, KoShapeLoadingContext &context) const
{
Q_UNUSED(context);
if (e.localName() != "plugin" || e.namespaceURI() != KoXmlNS::draw) {
return false;
}
return e.attribute("mime-type") == "application/vnd.sun.star.media";
}
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 ThreedShapeFactory::supports(const KoXmlElement &e, KoShapeLoadingContext &context) const
{
Q_UNUSED(context);
if (e.localName() == "scene" && e.namespaceURI() == KoXmlNS::dr3d) {
return true;
}
return false;
}
bool KPrDeclarations::loadOdf(const KoXmlElement &body, KoPALoadingContext &context)
{
Q_UNUSED(context);
KoXmlElement element;
forEachElement( element, body ) {
if (element.namespaceURI() == KoXmlNS::presentation) {
if (element.tagName() == "header-decl") {
const QString name = element.attributeNS(KoXmlNS::presentation, "name", QString());
m_declarations[Header].insert(name, element.text());
}
else if(element.tagName() == "footer-decl") {
const QString name = element.attributeNS(KoXmlNS::presentation, "name", QString());
m_declarations[Footer].insert(name, element.text());
}
else if(element.tagName() == "date-time-decl") {
QMap<QString, QVariant> data;
const QString name = element.attributeNS(KoXmlNS::presentation, "name", QString());
data["fixed"] = element.attributeNS(KoXmlNS::presentation, "source", "fixed") == "fixed";
QString styleName = element.attributeNS(KoXmlNS::style, "data-style-name", "");
if (!styleName.isEmpty()) {
KoOdfStylesReader::DataFormatsMap::const_iterator it = context.odfLoadingContext().stylesReader().dataFormats().constFind(styleName);
if (it != context.odfLoadingContext().stylesReader().dataFormats().constEnd()) {
QString formatString = (*it).first.prefix + (*it).first.formatStr + (*it).first.suffix;
data["format"] = formatString;
}
}
else {
data["format"] = QString("");
data["fixed value"] = element.text();
}
m_declarations[DateTime].insert(name, data);
}
}
else if (element.tagName() == "page" && element.namespaceURI() == KoXmlNS::draw) {
break;
}
}
return true;
}
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;
}
KoOasisSettings::Items KoOasisSettings::NamedMap::entry(const QString& entryName) const
{
KoXmlElement entry;
forEachElement(entry, m_element) {
if (entry.localName() == "config-item-map-entry" &&
entry.namespaceURI() == m_settings->m_configNsUri &&
entry.attributeNS(m_settings->m_configNsUri, "name", QString()) == entryName) {
return Items(entry, m_settings);
}
}
return Items(KoXmlElement(), m_settings);
}
KoOasisSettings::NamedMap KoOasisSettings::Items::namedMap(const QString& itemMapName) const
{
KoXmlElement configItem;
forEachElement(configItem, m_element) {
if (configItem.localName() == "config-item-map-named" &&
configItem.namespaceURI() == m_settings->m_configNsUri &&
configItem.attributeNS(m_settings->m_configNsUri, "name", QString()) == itemMapName) {
return NamedMap(configItem, m_settings);
}
}
return NamedMap(KoXmlElement(), m_settings);
}
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";
}
}
KoOasisSettings::Items KoOasisSettings::itemSet(const QString& itemSetName) const
{
KoXmlElement e;
forEachElement(e, m_settingsElement) {
if (e.localName() == "config-item-set" &&
e.namespaceURI() == m_configNsUri &&
e.attributeNS(m_configNsUri, "name", QString()) == itemSetName) {
return Items(e, this);
}
}
return Items(KoXmlElement(), this);
}
// helper method
QString KoOasisSettings::Items::findConfigItem(const KoXmlElement& element,
const QString& item, bool* ok) const
{
KoXmlElement it;
forEachElement(it, element) {
if (it.localName() == "config-item" &&
it.namespaceURI() == m_settings->m_configNsUri &&
it.attributeNS(m_settings->m_configNsUri, "name", QString()) == item) {
*ok = true;
return it.text();
}
}
*ok = false;
return QString();
}
KoOasisSettings::Items KoOasisSettings::IndexedMap::entry(int entryIndex) const
{
int i = 0;
KoXmlElement entry;
forEachElement(entry, m_element) {
if (entry.localName() == "config-item-map-entry" &&
entry.namespaceURI() == m_settings->m_configNsUri) {
if (i == entryIndex)
return Items(entry, m_settings);
else
++i;
}
}
return Items(KoXmlElement(), m_settings);
}
bool KoPathShapeFactory::supports(const KoXmlElement & e, KoShapeLoadingContext &context) const
{
Q_UNUSED(context);
if (e.namespaceURI() == KoXmlNS::draw) {
if (e.localName() == "path")
return true;
if (e.localName() == "line")
return true;
if (e.localName() == "polyline")
return true;
if (e.localName() == "polygon")
return true;
}
return false;
}
// 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 EnhancedPathHandle::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
{
if (element.localName() != "handle" || element.namespaceURI() != KoXmlNS::draw) {
return false;
}
QString position = element.attributeNS(KoXmlNS::draw, "handle-position");
#ifndef NWORKAROUND_ODF_BUGS
KoOdfWorkaround::fixEnhancedPathPolarHandlePosition(position, element, context);
#endif
QStringList tokens = position.simplified().split(' ');
if (tokens.count() != 2) {
return false;
}
setPosition(m_parent->parameter(tokens[0]), m_parent->parameter(tokens[1]));
// check if we have a polar handle
if (element.hasAttributeNS(KoXmlNS::draw, "handle-polar")) {
QString polar = element.attributeNS(KoXmlNS::draw, "handle-polar");
QStringList tokens = polar.simplified().split(' ');
if (tokens.count() == 2) {
setPolarCenter(m_parent->parameter(tokens[0]), m_parent->parameter(tokens[1]));
QString minRadius = element.attributeNS(KoXmlNS::draw, "handle-radius-range-minimum");
QString maxRadius = element.attributeNS(KoXmlNS::draw, "handle-radius-range-maximum");
if (!minRadius.isEmpty() && !maxRadius.isEmpty()) {
setRadiusRange(m_parent->parameter(minRadius), m_parent->parameter(maxRadius));
}
}
} else {
QString minX = element.attributeNS(KoXmlNS::draw, "handle-range-x-minimum");
QString maxX = element.attributeNS(KoXmlNS::draw, "handle-range-x-maximum");
if (!minX.isEmpty() && ! maxX.isEmpty()) {
setRangeX(m_parent->parameter(minX), m_parent->parameter(maxX));
}
QString minY = element.attributeNS(KoXmlNS::draw, "handle-range-y-minimum");
QString maxY = element.attributeNS(KoXmlNS::draw, "handle-range-y-maximum");
if (!minY.isEmpty() && ! maxY.isEmpty()) {
setRangeY(m_parent->parameter(minY), m_parent->parameter(maxY));
}
}
return hasPosition();
}
bool SvgShapeFactory::supports(const KoXmlElement &element, KoShapeLoadingContext &context) const
{
if (element.localName() == "image" && element.namespaceURI() == KoXmlNS::draw) {
QString href = element.attribute("href");
if (href.isEmpty())
return false;
// check the mimetype
if (href.startsWith("./")) {
href.remove(0,2);
}
QString mimetype = context.odfLoadingContext().mimeTypeForPath(href, true);
return (mimetype == "image/svg+xml");
}
return false;
}
void KoChangeTracker::loadOdfChanges(const KoXmlElement& element)
{
if (element.namespaceURI() == KoXmlNS::text) {
KoXmlElement tag;
forEachElement(tag, element) {
if (! tag.isNull()) {
const QString localName = tag.localName();
if (localName == "changed-region") {
KoChangeTrackerElement *changeElement = 0;
KoXmlElement region;
forEachElement(region, tag) {
if (!region.isNull()) {
if (region.localName() == "insertion") {
changeElement = new KoChangeTrackerElement(kundo2_noi18n(tag.attributeNS(KoXmlNS::text,"id")),KoGenChange::InsertChange);
} else if (region.localName() == "format-change") {
changeElement = new KoChangeTrackerElement(kundo2_noi18n(tag.attributeNS(KoXmlNS::text,"id")),KoGenChange::FormatChange);
} else if (region.localName() == "deletion") {
changeElement = new KoChangeTrackerElement(kundo2_noi18n(tag.attributeNS(KoXmlNS::text,"id")),KoGenChange::DeleteChange);
}
KoXmlElement metadata = region.namedItemNS(KoXmlNS::office,"change-info").toElement();
if (!metadata.isNull()) {
KoXmlElement date = metadata.namedItem("dc:date").toElement();
if (!date.isNull()) {
changeElement->setDate(date.text());
}
KoXmlElement creator = metadata.namedItem("dc:creator").toElement();
if (!date.isNull()) {
changeElement->setCreator(creator.text());
}
//TODO load comments
/* KoXmlElement extra = metadata.namedItem("dc-").toElement();
if (!date.isNull()) {
kDebug() << "creator: " << creator.text();
changeElement->setCreator(creator.text());
}*/
}
changeElement->setEnabled(d->recordChanges);
d->changes.insert( d->changeId, changeElement);
d->loadedChanges.insert(tag.attributeNS(KoXmlNS::text,"id"), d->changeId++);
}
}
}
}
}
bool DatabaseManager::loadOdf(const KoXmlElement& body)
{
const KoXmlNode databaseRanges = KoXml::namedItemNS(body, KoXmlNS::table, "database-ranges");
KoXmlElement element;
forEachElement(element, databaseRanges) {
if (element.namespaceURI() != KoXmlNS::table)
continue;
if (element.localName() == "database-range") {
Database database;
if (!database.loadOdf(element, d->map))
return false;
const Region region = database.range();
if (!region.isValid())
continue;
const Sheet* sheet = region.lastSheet();
if (!sheet)
continue;
sheet->cellStorage()->setDatabase(region, database);
}
}
return true;
}
bool CommentShape::loadOdf(const KoXmlElement& element, KoShapeLoadingContext& context)
{
loadOdfAttributes(element, context, OdfPosition);
KoXmlElement child;
forEachElement(child, element)
{
if(child.namespaceURI() == KoXmlNS::dc) {
if(child.localName() == "creator") {
m_creator = child.text();
QStringList creatorNames = m_creator.split(' ');
QString initials;
if(KoApplication::isLeftToRight()) {
foreach(const QString& name, creatorNames) {
initials += name.left(1);
}
}
else {
foreach(const QString& name, creatorNames) {
initials += name.right(1);
}
}
void Conditions::loadOdfConditions(const KoXmlElement &element, const ValueParser *parser, const StyleManager *styleManager)
{
kDebug(36003) << "Loading conditional styles";
KoXmlNode node(element);
while (!node.isNull()) {
KoXmlElement elementItem = node.toElement();
if (elementItem.tagName() == "map" && elementItem.namespaceURI() == KoXmlNS::style) {
QString conditionValue = elementItem.attributeNS(KoXmlNS::style, "condition", QString());
QString applyStyleName;
if (elementItem.hasAttributeNS(KoXmlNS::style, "apply-style-name"))
applyStyleName = elementItem.attributeNS(KoXmlNS::style, "apply-style-name", QString());
if (!applyStyleName.isEmpty() && styleManager) {
QString odfStyle = styleManager->openDocumentName(applyStyleName);
if (!odfStyle.isEmpty()) applyStyleName = odfStyle;
}
QString baseCellAddress = elementItem.attributeNS(KoXmlNS::style, "base-cell-address");
loadOdfCondition(conditionValue, applyStyleName, baseCellAddress, parser);
}
node = node.nextSibling();
}
}
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 TableShape::loadOdf(const KoXmlElement &element, KoShapeLoadingContext &context)
{
//kDebug() << "LOADING TABLE SHAPE";
if (sheet() && element.namespaceURI() == KoXmlNS::table && element.localName() == "table") {
// pre-load auto styles
KoOdfLoadingContext& odfContext = context.odfLoadingContext();
OdfLoadingContext tableContext(odfContext);
QHash<QString, Conditions> conditionalStyles;
Map *const map = sheet()->map();
StyleManager *const styleManager = map->styleManager();
ValueParser *const parser = map->parser();
Styles autoStyles = styleManager->loadOdfAutoStyles(odfContext.stylesReader(), conditionalStyles, parser);
if (!element.attributeNS(KoXmlNS::table, "name", QString()).isEmpty()) {
sheet()->setSheetName(element.attributeNS(KoXmlNS::table, "name", QString()), true);
}
const bool result = sheet()->loadOdf(element, tableContext, autoStyles, conditionalStyles);
// delete any styles which were not used
sheet()->map()->styleManager()->releaseUnusedAutoStyles(autoStyles);
if (!result) {
return false;
}
const QRect usedArea = sheet()->usedArea();
d->columns = usedArea.width();
d->rows = usedArea.height();
QSizeF size(0.0, 0.0);
for (int col = 1; col <= d->columns; ++col) {
size.rwidth() += sheet()->columnFormat(col)->visibleWidth();
}
size.rheight() = sheet()->rowFormats()->totalVisibleRowHeight(1, d->rows);
KoShape::setSize(size);
return true;
}
return false;
}
void KoTextLoader::loadBody(const KoXmlElement &bodyElem, QTextCursor &cursor)
{
const QTextBlockFormat defaultBlockFormat = cursor.blockFormat();
const QTextCharFormat defaultCharFormat = cursor.charFormat();
const QTextDocument *document = cursor.block().document();
d->styleManager = KoTextDocument(document).styleManager();
Q_ASSERT(d->styleManager);
d->changeTracker = KoTextDocument(document).changeTracker();
// if (!d->changeTracker)
// d->changeTracker = dynamic_cast<KoChangeTracker *>(d->context.dataCenterMap().value("ChangeTracker"));
// Q_ASSERT(d->changeTracker);
kDebug(32500) << "text-style:" << KoTextDebug::textAttributes( cursor.blockCharFormat() );
#if 0
if ((document->isEmpty()) && (d->styleManager)) {
QTextBlock block = cursor.block();
d->styleManager->defaultParagraphStyle()->applyStyle(block);
}
#endif
startBody(KoXml::childNodesCount(bodyElem));
KoXmlElement tag;
bool usedParagraph = false; // set to true if we found a tag that used the paragraph, indicating that the next round needs to start a new one.
forEachElement(tag, bodyElem) {
if (! tag.isNull()) {
const QString localName = tag.localName();
if (tag.namespaceURI() == KoXmlNS::text) {
if (usedParagraph)
cursor.insertBlock(defaultBlockFormat, defaultCharFormat);
usedParagraph = true;
if (d->changeTracker && localName == "tracked-changes") {
d->changeTracker->loadOdfChanges(tag);
usedParagraph = false;
} else if (d->changeTracker && localName == "change-start") {
loadChangedRegion(tag, cursor);
usedParagraph = false;
} else if (d->changeTracker && localName == "change-end") {
d->currentChangeId = 0;
usedParagraph = false;
} else if (localName == "p") { // text paragraph
loadParagraph(tag, cursor);
} else if (localName == "h") { // heading
loadHeading(tag, cursor);
} else if (localName == "unordered-list" || localName == "ordered-list" // OOo-1.1
|| localName == "list" || localName == "numbered-paragraph") { // OASIS
loadList(tag, cursor);
} else if (localName == "section") { // Temporary support (###TODO)
loadSection(tag, cursor);
} else {
KoVariable *var = KoVariableRegistry::instance()->createFromOdf(tag, d->context);
if (var) {
KoTextDocumentLayout *layout = dynamic_cast<KoTextDocumentLayout*>(cursor.block().document()->documentLayout());
if (layout) {
KoInlineTextObjectManager *textObjectManager = layout->inlineTextObjectManager();
if (textObjectManager) {
KoVariableManager *varManager = textObjectManager->variableManager();
if (varManager) {
textObjectManager->insertInlineObject(cursor, var);
}
}
}
} else {
usedParagraph = false;
kWarning(32500) << "unhandled text:" << localName;
}
}
} else if (tag.namespaceURI() == KoXmlNS::draw) {
loadShape(tag, cursor);
} else if (tag.namespaceURI() == KoXmlNS::table) {
if (localName == "table") {
loadTable(tag, cursor);
} else {
kWarning(32500) << "unhandled table:" << localName;
}
#if 0 // TODO commented out for now
if (localName == "table") {
cursor.insertText("\n");
cursor.movePosition(QTextCursor::Left, QTextCursor::MoveAnchor, 1);
QTextTable *tbl = cursor.insertTable(1, 1);
int rows = 0;
int columns = 0;
kDebug(32500) << "Table inserted";
KoXmlElement tblTag;
forEachElement(tblTag, tag) {
if (! tblTag.isNull()) {
const QString tblLocalName = tblTag.localName();
if (tblTag.namespaceURI() == KoXmlNS::table) {
if (tblLocalName == "table-column") {
// Do some parsing with the column, see §8.2.1, ODF 1.1 spec
int repeatColumn = tblTag.attributeNS(KoXmlNS::table, "number-columns-repeated", "1").toInt();
columns = columns + repeatColumn;
if (rows > 0)
tbl->resize(rows, columns);
else
tbl->resize(1, columns);
} else if (tblLocalName == "table-row") {
// Lot of work to do here...
rows++;
if (columns > 0)
tbl->resize(rows, columns);
else
tbl->resize(rows, 1);
// Added a row
int currentCell = 0;
KoXmlElement rowTag;
forEachElement(rowTag, tblTag) {
if (!rowTag.isNull()) {
const QString rowLocalName = rowTag.localName();
if (rowTag.namespaceURI() == KoXmlNS::table) {
if (rowLocalName == "table-cell") {
// Ok, it's a cell...
const int currentRow = tbl->rows() - 1;
QTextTableCell cell = tbl->cellAt(currentRow, currentCell);
if (cell.isValid()) {
cursor = cell.firstCursorPosition();
loadBody(context, rowTag, cursor);
} else
kDebug(32500) << "Invalid table-cell row=" << currentRow << " column=" << currentCell;
currentCell++;
}
}
}
}
}
}
}
}
cursor = tbl->lastCursorPosition();
cursor.movePosition(QTextCursor::Right, QTextCursor::MoveAnchor, 1);
} else {
kWarning(32500) << "KoTextLoader::loadBody unhandled table::" << localName;
}
#endif
}
