bool KoDocumentInfo::saveOasis(KoStore *store)
{
updateParametersAndBumpNumCycles();
KoStoreDevice dev(store);
KoXmlWriter* xmlWriter = KoOdfWriteStore::createOasisXmlWriter(&dev,
"office:document-meta");
xmlWriter->startElement("office:meta");
xmlWriter->startElement("meta:generator");
xmlWriter->addTextNode(QString("Calligra/%1")
.arg(CALLIGRA_VERSION_STRING));
xmlWriter->endElement();
if (!saveOasisAboutInfo(*xmlWriter))
return false;
if (!saveOasisAuthorInfo(*xmlWriter))
return false;
xmlWriter->endElement();
xmlWriter->endElement(); // root element
xmlWriter->endDocument();
delete xmlWriter;
return true;
}
QByteArray HancomWordImport::Private::createStyles()
{
KoXmlWriter* stylesWriter;
QByteArray stylesData;
QBuffer stylesBuffer( &stylesData );
stylesBuffer.open( QIODevice::WriteOnly );
stylesWriter = new KoXmlWriter( &stylesBuffer );
stylesWriter->startDocument( "office:document-styles" );
stylesWriter->startElement( "office:document-styles" );
stylesWriter->addAttribute( "xmlns:office", "urn:oasis:names:tc:opendocument:xmlns:office:1.0" );
stylesWriter->addAttribute( "xmlns:style", "urn:oasis:names:tc:opendocument:xmlns:style:1.0" );
stylesWriter->addAttribute( "xmlns:text", "urn:oasis:names:tc:opendocument:xmlns:text:1.0" );
stylesWriter->addAttribute( "xmlns:table", "urn:oasis:names:tc:opendocument:xmlns:table:1.0" );
stylesWriter->addAttribute( "xmlns:draw", "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" );
stylesWriter->addAttribute( "xmlns:fo", "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" );
stylesWriter->addAttribute( "xmlns:svg","urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" );
stylesWriter->addAttribute( "office:version","1.0" );
stylesWriter->startElement( "office:styles" );
// dummy default paragraph style
stylesWriter->startElement( "style:default-style" );
stylesWriter->addAttribute( "style:family", "paragraph" );
stylesWriter->startElement( "style:paragraph-properties" );
stylesWriter->addAttribute( "fo:hyphenation-ladder-count", "no-limit" );
stylesWriter->addAttribute( "style:text-autospace", "ideograph-alpha" );
stylesWriter->addAttribute( "style:punctuation-wrap", "hanging" );
stylesWriter->addAttribute( "style:line-break", "strict" );
stylesWriter->addAttribute( "tyle:tab-stop-distance", "0.5in" );
stylesWriter->addAttribute( "style:writing-mode", "page" );
stylesWriter->endElement(); // style:paragraph-properties
stylesWriter->startElement( "style:text-properties" );
stylesWriter->addAttribute( "style:use-window-font-color", "true" );
stylesWriter->addAttribute( "style:font-name", "Sans Serif" );
stylesWriter->addAttribute( "fo:font-size", "12pt" );
stylesWriter->addAttribute( "fo:hyphenate", "false" );
stylesWriter->endElement(); // style:text-properties
stylesWriter->endElement(); // style:default-style
stylesWriter->endElement(); // office:styles
// office:automatic-styles
stylesWriter->startElement( "office:automatic-styles" );
stylesWriter->endElement(); // office:automatic-styles
stylesWriter->endElement(); // office:document-styles
stylesWriter->endDocument();
delete stylesWriter;
return stylesData;
}
QByteArray HancomWordImport::Private::createContent()
{
KoXmlWriter* contentWriter;
QByteArray contentData;
QBuffer contentBuffer( &contentData );
contentBuffer.open( QIODevice::WriteOnly );
contentWriter = new KoXmlWriter( &contentBuffer );
contentWriter->startDocument( "office:document-content" );
contentWriter->startElement( "office:document-content" );
contentWriter->addAttribute( "xmlns:office", "urn:oasis:names:tc:opendocument:xmlns:office:1.0" );
contentWriter->addAttribute( "xmlns:style", "urn:oasis:names:tc:opendocument:xmlns:style:1.0" );
contentWriter->addAttribute( "xmlns:text", "urn:oasis:names:tc:opendocument:xmlns:text:1.0" );
contentWriter->addAttribute( "xmlns:table", "urn:oasis:names:tc:opendocument:xmlns:table:1.0" );
contentWriter->addAttribute( "xmlns:draw", "urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" );
contentWriter->addAttribute( "xmlns:fo", "urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" );
contentWriter->addAttribute( "xmlns:svg","urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" );
contentWriter->addAttribute( "office:version","1.0" );
contentWriter->startElement( "office:automatic-styles" );
contentWriter->endElement(); // office:automatic-style
// office:body
contentWriter->startElement( "office:body" );
contentWriter->startElement( "office:text" );
contentWriter->startElement( "text:sequence-decls" );
contentWriter->endElement(); // text:sequence-decls
for( int i = 0; i < paragraphs.count(); i++ )
{
QString text = paragraphs[i];
text.replace( '\r', ' ' );
contentWriter->startElement( "text:p" );
contentWriter->addTextNode( text );
contentWriter->endElement(); // text:p
}
contentWriter->endElement(); //office:text
contentWriter->endElement(); // office:body
contentWriter->endElement(); // office:document-content
contentWriter->endDocument();
delete contentWriter;
return contentData;
}
QByteArray HancomWordImport::Private::createManifest()
{
KoXmlWriter* manifestWriter;
QByteArray manifestData;
QBuffer manifestBuffer( &manifestData );
manifestBuffer.open( QIODevice::WriteOnly );
manifestWriter = new KoXmlWriter( &manifestBuffer );
manifestWriter->startDocument( "manifest:manifest" );
manifestWriter->startElement( "manifest:manifest" );
manifestWriter->addAttribute( "xmlns:manifest", "urn:oasis:names:tc:openoffice:xmlns:manifest:1.0" );
manifestWriter->addManifestEntry( "/", "application/vnd.oasis.opendocument.text" );
manifestWriter->addManifestEntry( "styles.xml", "text/xml" );
manifestWriter->addManifestEntry( "content.xml", "text/xml" );
manifestWriter->endElement();
manifestWriter->endDocument();
delete manifestWriter;
return manifestData;
}
bool KoGenStyles::saveOdfStylesDotXml(KoStore* store, KoXmlWriter* manifestWriter) const
{
if (!store->open("styles.xml"))
return false;
manifestWriter->addManifestEntry("styles.xml", "text/xml");
KoStoreDevice stylesDev(store);
KoXmlWriter* stylesWriter = KoOdfWriteStore::createOasisXmlWriter(&stylesDev, "office:document-styles");
d->saveOdfFontFaceDecls(stylesWriter);
d->saveOdfDocumentStyles(stylesWriter);
d->saveOdfAutomaticStyles(stylesWriter, true, d->rawOdfAutomaticStyles_stylesDotXml);
d->saveOdfMasterStyles(stylesWriter);
stylesWriter->endElement(); // root element (office:document-styles)
stylesWriter->endDocument();
delete stylesWriter;
if (!store->close()) // done with styles.xml
return false;
return true;
}
bool KoDocumentInfo::saveOasis( KoStore* store )
{
KoStoreDevice dev( store );
KoXmlWriter* xmlWriter = KoDocument::createOasisXmlWriter( &dev, "office:document-meta" );
xmlWriter->startElement( "office:meta" );
xmlWriter->startElement( "meta:generator");
xmlWriter->addTextNode( QString( "KOffice/%1" ).arg( KOFFICE_VERSION_STRING ) );
xmlWriter->endElement();
QStringList lst = pages();
QStringList::ConstIterator it = lst.begin();
for( ; it != lst.end(); ++it )
{
KoDocumentInfoPage* p = page( *it );
Q_ASSERT( p );
if ( !p->saveOasis( *xmlWriter ) )
return false;
}
xmlWriter->endElement();
xmlWriter->endElement(); // root element
xmlWriter->endDocument();
delete xmlWriter;
return true;
}
bool DocBase::saveOdfHelper(SavingContext & documentContext, SaveFlag saveFlag,
QString* /*plainText*/)
{
Q_UNUSED(saveFlag);
KoStore * store = documentContext.odfStore.store();
KoXmlWriter * manifestWriter = documentContext.odfStore.manifestWriter();
KoStoreDevice dev(store);
KoGenStyles mainStyles;//for compile
KoXmlWriter* contentWriter = documentContext.odfStore.contentWriter();
KoXmlWriter* bodyWriter = documentContext.odfStore.bodyWriter();
KoShapeSavingContext savingContext(*bodyWriter, mainStyles, documentContext.embeddedSaver);
//todo fixme just add a element for testing saving content.xml
bodyWriter->startElement("office:body");
bodyWriter->startElement("office:spreadsheet");
// Saving the map.
map()->saveOdf(*contentWriter, savingContext);
bodyWriter->endElement(); ////office:spreadsheet
bodyWriter->endElement(); ////office:body
// Done with writing out the contents to the tempfile, we can now write out the automatic styles
mainStyles.saveOdfStyles(KoGenStyles::DocumentAutomaticStyles, contentWriter);
documentContext.odfStore.closeContentWriter();
//add manifest line for content.xml
manifestWriter->addManifestEntry("content.xml", "text/xml");
mainStyles.saveOdfStylesDotXml(store, manifestWriter);
if (!store->open("settings.xml"))
return false;
KoXmlWriter* settingsWriter = KoOdfWriteStore::createOasisXmlWriter(&dev, "office:document-settings");
settingsWriter->startElement("office:settings");
settingsWriter->startElement("config:config-item-set");
settingsWriter->addAttribute("config:name", "view-settings");
saveUnitOdf(settingsWriter);
saveOdfSettings(*settingsWriter);
settingsWriter->endElement(); // config:config-item-set
settingsWriter->startElement("config:config-item-set");
settingsWriter->addAttribute("config:name", "configuration-settings");
settingsWriter->addConfigItem("SpellCheckerIgnoreList", d->spellListIgnoreAll.join(","));
settingsWriter->endElement(); // config:config-item-set
settingsWriter->endElement(); // office:settings
settingsWriter->endElement(); // Root:element
settingsWriter->endDocument();
delete settingsWriter;
if (!store->close())
return false;
if (!savingContext.saveDataCenter(store, manifestWriter)) {
return false;
}
manifestWriter->addManifestEntry("settings.xml", "text/xml");
setModified(false);
return true;
}
KoFilter::ConversionStatus KoOdfExporter::convert(const QByteArray& from, const QByteArray& to)
{
// check for proper conversion
if (!acceptsSourceMimeType(from)) {
kWarning(30003) << "Invalid source mimetype" << from;
return KoFilter::NotImplemented;
}
if (!acceptsDestinationMimeType(to)) {
kWarning(30003) << "Invalid destination mimetype" << to;
return KoFilter::NotImplemented;
}
//create output files
KoStore *outputStore = KoStore::createStore(m_chain->outputFile(), KoStore::Write, to, KoStore::Zip);
if (!outputStore || outputStore->bad()) {
kWarning(30003) << "Unable to open output file!";
delete outputStore;
return KoFilter::FileNotFound;
}
outputStore->disallowNameExpansion();
kDebug(30003) << "created outputStore.";
KoOdfWriteStore oasisStore(outputStore);
kDebug(30003) << "created oasisStore.";
// KoGenStyles for writing styles while we're parsing
KoGenStyles mainStyles;
KoOdfWriters writers;
writers.mainStyles = &mainStyles;
// create a writer for meta.xml
QBuffer buf;
buf.open(QIODevice::WriteOnly);
KoXmlWriter metaWriter(&buf);
writers.meta = &metaWriter;
// create a writer for manifest.xml
QBuffer manifestBuf;
manifestBuf.open(QIODevice::WriteOnly);
KoXmlWriter manifestWriter(&manifestBuf);
writers.manifest = &manifestWriter;
//open contentWriter & bodyWriter *temp* writers
//so we can write picture files while we parse
QBuffer contentBuf;
KoXmlWriter contentWriter(&contentBuf);
writers.content = &contentWriter;
QBuffer bodyBuf;
KoXmlWriter bodyWriter(&bodyBuf);
writers.body = &bodyWriter;
// open main tags
bodyWriter.startElement("office:body");
bodyWriter.startElement(d->bodyContentElement.constData());
RETURN_IF_ERROR( createDocument(outputStore, &writers) )
//save the office:automatic-styles & and fonts in content.xml
mainStyles.saveOdfStyles(KoGenStyles::FontFaceDecls, &contentWriter);
mainStyles.saveOdfStyles(KoGenStyles::DocumentAutomaticStyles, &contentWriter);
//close tags in body
bodyWriter.endElement();//office:*
bodyWriter.endElement();//office:body
//now create real content/body writers & dump the information there
KoXmlWriter* realContentWriter = oasisStore.contentWriter();
if (!realContentWriter) {
kWarning(30003) << "Error creating the content writer.";
delete outputStore;
return KoFilter::CreationError;
}
realContentWriter->addCompleteElement(&contentBuf);
KoXmlWriter* realBodyWriter = oasisStore.bodyWriter();
if (!realBodyWriter) {
kWarning(30003) << "Error creating the body writer.";
delete outputStore;
return KoFilter::CreationError;
}
realBodyWriter->addCompleteElement(&bodyBuf);
//now close content & body writers
if (!oasisStore.closeContentWriter()) {
kWarning(30003) << "Error closing content.";
delete outputStore;
return KoFilter::CreationError;
}
kDebug(30003) << "closed content & body writers.";
//create the manifest file
KoXmlWriter* realManifestWriter = oasisStore.manifestWriter(to);
//create the styles.xml file
mainStyles.saveOdfStylesDotXml(outputStore, realManifestWriter);
realManifestWriter->addManifestEntry("content.xml", "text/xml");
realManifestWriter->addCompleteElement(&manifestBuf);
kDebug(30003) << "created manifest and styles.xml";
// create settings.xml, apparently it is used to note calligra that msoffice files should
// have different behavior with some things
if (!outputStore->open("settings.xml")) {
delete outputStore;
return KoFilter::CreationError;
}
KoStoreDevice settingsDev(outputStore);
KoXmlWriter* settings = KoOdfWriteStore::createOasisXmlWriter(&settingsDev, "office:document-settings");
settings->startElement("office:settings");
settings->startElement("config:config-item-set");
settings->addAttribute("config:name", "ooo:configuration-settings");
writeConfigurationSettings(settings);
settings->endElement(); // config:config-item-set
settings->endElement(); // office:settings
settings->endElement(); // office:document-settings
settings->endDocument();
delete settings;
realManifestWriter->addManifestEntry("settings.xml", "text/xml");
if (!outputStore->close()) {
delete outputStore;
return KoFilter::CreationError;
}
//create meta.xml
if (!outputStore->open("meta.xml")) {
delete outputStore;
return KoFilter::CreationError;
}
KoStoreDevice metaDev(outputStore);
KoXmlWriter* meta = KoOdfWriteStore::createOasisXmlWriter(&metaDev, "office:document-meta");
meta->startElement("office:meta");
meta->addCompleteElement(&buf);
meta->endElement(); //office:meta
meta->endElement(); //office:document-meta
meta->endDocument();
delete meta;
if (!outputStore->close()) {
delete outputStore;
return KoFilter::CreationError;
}
realManifestWriter->addManifestEntry("meta.xml", "text/xml");
oasisStore.closeManifestWriter();
delete outputStore;
return KoFilter::OK;
}
KoFilter::ConversionStatus AsciiImport::convert(const QByteArray& from, const QByteArray& to)
{
// check for proper conversion
if (to != "application/vnd.oasis.opendocument.text" || from != "text/plain") {
return KoFilter::NotImplemented;
}
QFile in(m_chain->inputFile());
if (!in.open(QIODevice::ReadOnly)) {
kError(30502) << "Unable to open input file!" << endl;
in.close();
return KoFilter::FileNotFound;
}
#ifdef OUTPUT_AS_ODT_FILE
#else
KoDocument* document = m_chain->outputDocument();
if (!document)
return KoFilter::StupidError;
KWDocument *outputDoc = qobject_cast<KWDocument*>(document);
outputDoc->setOutputMimeType(to);
//outputDoc->setSaveInBatchMode(true);
QPointer<KoUpdater> loadUpdater = outputDoc->progressUpdater()->startSubtask(2, "load");
loadUpdater->setRange(0, in.size());
QPointer<KoUpdater> layoutUpdater = outputDoc->progressUpdater()->startSubtask(3, "layout");
#endif
// try to read 100000 bytes so we can be quite sure the guessed encoding is correct.
// this code is inspired by the kate encoding guessing first try UTF-8
QByteArray data = in.read(100000);
in.seek(0);
QTextCodec *codec = QTextCodec::codecForName("UTF-8");
if (!checkEncoding(codec, data)) {
KEncodingProber prober(KEncodingProber::Universal);
prober.feed(data);
kDebug(30502) << "guessed" << prober.encoding() << prober.confidence();
if (prober.confidence() > 0.5)
codec = QTextCodec::codecForName(prober.encoding());
if (!codec || !checkEncoding(codec, data )) {
codec = QTextCodec::codecForName("ISO 8859-15");
if (!checkEncoding(codec, data))
codec = QTextCodec::codecForName("UTF-8");
}
}
int paragraphStrategy = 0;
if (!m_chain->manager()->getBatchMode()) {
QPointer<AsciiImportDialog> dialog = new AsciiImportDialog(codec->name(), QApplication::activeWindow());
if (!dialog) { in.close(); return KoFilter::StupidError; }
if (!dialog->exec()) { in.close(); return KoFilter::UserCancelled; }
codec = dialog->getCodec();
paragraphStrategy = dialog->getParagraphStrategy();
}
if (!codec) return KoFilter::StupidError;
kDebug(30502) << "Charset used:" << codec->name();
#ifdef OUTPUT_AS_ODT_FILE
KoStore *store = KoStore::createStore(m_chain->outputFile(), KoStore::Write, to, KoStore::Zip);
if (!store || store->bad()) {
kWarning(30502) << "Unable to open output file!";
delete store;
return KoFilter::FileNotFound;
}
store->disallowNameExpansion();
kDebug(30502) << "created store.";
KoOdfWriteStore odfStore(store);
odfStore.manifestWriter(to);
KoXmlWriter* contentWriter = odfStore.contentWriter();
if (!contentWriter) {
delete store;
return KoFilter::CreationError;
}
KoGenStyles mainStyles;
KoXmlWriter *bodyWriter = odfStore.bodyWriter();
bodyWriter->startElement("office:body");
bodyWriter->startElement("office:text");
QString styleName("txt");
KoGenStyle style(KoGenStyle::ParagraphStyle, "paragraph");
style.addAttribute("style:display-name", styleName);
style.addProperty("fo:font-family", "dejavu sans mono", KoGenStyle::TextType);
style.addProperty("fo:font-family-generic", "modern", KoGenStyle::TextType);
style.addProperty("fo:font-size", "10pt", KoGenStyle::TextType);
style.addProperty("fo:font-weight", "normal", KoGenStyle::TextType);
QString name(QString(QUrl::toPercentEncoding(styleName, "", " ")).replace('%', '_'));
name = mainStyles.insert(style, name, KoGenStyles::DontAddNumberToName);
#else
KoStyleManager *styleManager = outputDoc->resourceManager()->resource(KoText::StyleManager).value<KoStyleManager*>();
KoParagraphStyle *p = styleManager->defaultParagraphStyle();
p->setFontFamily("dejavu sans mono");
p->setFontPointSize(10);
p->setFontStyleHint(QFont::TypeWriter);
outputDoc->appendPage();
QTextDocument *doc = outputDoc->mainFrameSet()->document();
//doc->setDefaultFont(p->font());
KoTextDocumentLayout *lay = dynamic_cast<KoTextDocumentLayout*>(doc->documentLayout());
Q_ASSERT(lay);
lay->setBlockLayout(true);
connect(lay, SIGNAL(layoutProgressChanged(int)), layoutUpdater, SLOT(setProgress(int)));
QTextCursor cursor(doc);
cursor.beginEditBlock();
QTextCharFormat charFormat;
((KoCharacterStyle*)p)->applyStyle(charFormat);
cursor.setCharFormat(charFormat);
#endif
QTextStream stream(&in);
Q_ASSERT(codec);
stream.setCodec(codec);
switch (paragraphStrategy) {
case 1: { // Sentence: Line-break at the end of a sentence.
QString stoppingPunctuation(".!?");
QString skippingEnd(" \"')");
while (!stream.atEnd()) {
QString paragraph;
for (;;) {
const QString line = stream.readLine();
if (line.isEmpty())
break;
paragraph += line + ' ';
int lastPos = line.length() - 1;
int maxCheck = lastPos >= 10 ? 10: lastPos + 1;
QChar lastChar;
// Skip a maximum of 10 quotes (or similar) at the end of the line
for (int i = 0; i < maxCheck; ++i, --lastPos) {
lastChar = line[lastPos];
if (lastPos == 0 || lastChar.isNull() || skippingEnd.indexOf(lastChar) == -1)
break;
}
lastChar = line[lastPos];
if (lastChar.isNull())
continue;
if (stoppingPunctuation.indexOf(lastChar) != -1)
break;
}
if (!paragraph.isNull()) {
QString s = paragraph.simplified();
#ifdef OUTPUT_AS_ODT_FILE
bodyWriter->startElement("text:p");
bodyWriter->addAttribute("text:style-name", styleName);
if (!s.isEmpty())
bodyWriter->addTextSpan(s);
bodyWriter->endElement();
#else
if (!s.isEmpty())
cursor.insertText(s /*, charFormat*/);
cursor.insertBlock();
loadUpdater->setValue(stream.device()->pos());
#endif
}
}
} break;
case 2: { // Empty Line: Line-break if the line is empty.
while (!stream.atEnd()) {
QString paragraph;
do {
const QString line = stream.readLine();
if (line.isEmpty())
break;
paragraph.append(line + ' ');
} while(true);
if (!paragraph.isNull()) {
QString s = paragraph.simplified();
#ifdef OUTPUT_AS_ODT_FILE
bodyWriter->startElement("text:p");
bodyWriter->addAttribute("text:style-name", styleName);
if (!s.isEmpty())
bodyWriter->addTextSpan(s);
bodyWriter->endElement();
#else
if (!s.isEmpty()) {
cursor.insertText(s /*, charFormat*/);
cursor.insertBlock();
loadUpdater->setValue(stream.device()->pos());
}
#endif
}
}
} break;
default: { // As Is: Line-break at the end of line.
while (!stream.atEnd()) {
QString s = stream.readLine();
#ifdef OUTPUT_AS_ODT_FILE
bodyWriter->startElement("text:p");
bodyWriter->addAttribute("text:style-name", styleName);
if (!s.isEmpty())
bodyWriter->addTextSpan(s);
bodyWriter->endElement();
#else
if (!s.isEmpty())
cursor.insertText(s /*, charFormat*/);
cursor.insertBlock();
loadUpdater->setValue(stream.device()->pos());
#endif
}
} break;
}
#ifdef OUTPUT_AS_ODT_FILE
bodyWriter->endElement(); // office:text
bodyWriter->endElement(); // office:body
mainStyles.saveOdfStyles(KoGenStyles::DocumentAutomaticStyles, contentWriter);
odfStore.closeContentWriter();
odfStore.manifestWriter()->addManifestEntry("content.xml", "text/xml");
if (!mainStyles.saveOdfStylesDotXml(odfStore.store(), odfStore.manifestWriter())) {
delete store;
return KoFilter::CreationError;
}
if (store->open("meta.xml")) {
KoStoreDevice dev(store);
KoXmlWriter* xmlWriter = KoOdfWriteStore::createOasisXmlWriter(&dev, "office:document-meta");
xmlWriter->startElement("office:meta");
xmlWriter->startElement("meta:generator");
xmlWriter->addTextNode(QString("Calligra %1").arg(CALLIGRA_VERSION_STRING));
xmlWriter->endElement();
xmlWriter->startElement("meta:creation-date");
xmlWriter->addTextNode(QDateTime::currentDateTime().toString(Qt::ISODate));
xmlWriter->endElement();
xmlWriter->endElement(); // office:meta
xmlWriter->endElement(); // root element
xmlWriter->endDocument();
delete xmlWriter;
if (store->close())
odfStore.manifestWriter()->addManifestEntry("meta.xml", "text/xml" );
}
if (!odfStore.closeManifestWriter()) {
kWarning() << "Error while trying to write 'META-INF/manifest.xml'. Partition full?";
delete store;
return KoFilter::CreationError;
}
delete store;
#else
cursor.endEditBlock();
lay->setBlockLayout(false);
lay->layout();
#endif
return KoFilter::OK;
}