/***************************************************************************
- export a KEduVocDocument to a KVTML file
+* this file is from kdeedu project. Filename: keduvockvtml2writer.cpp
+***************************************************************************/
+
+/***************************************************************************
+ export a QmVocDocument to a KVTML file
-----------------------------------------------------------------------
copyright : (C) 2007 Jeremy Whiting <jpwhiting@kde.org>
Copyright 2007-2010 Frederik Gladhorn <gladhorn@kde.org>
+ Copyright 2010, 2012 Reto Zingg <g.d0b3rm4n@gmail.com>
+
***************************************************************************/
/***************************************************************************
* *
***************************************************************************/
-#include "keduvockvtml2writer.h"
+#include "qmvockvtml2writer.h"
#include <QtCore/QTextStream>
#include <QtCore/QFile>
-#include <KDebug>
+// #include <KDebug>
+#include <QDebug>
-#include "keduvocdocument.h"
-#include "keduvocexpression.h"
-#include "keduvoclesson.h"
-#include "keduvocleitnerbox.h"
-#include "keduvocwordtype.h"
+#include "qmvocdocument.h"
+#include "qmvocexpression.h"
+#include "qmvoclesson.h"
+#include "qmvocleitnerbox.h"
+#include "qmvocwordtype.h"
#include "kvtml2defs.h"
-KEduVocKvtml2Writer::KEduVocKvtml2Writer( QFile *file )
+QmVocKvtml2Writer::QmVocKvtml2Writer( QFile *file )
{
// the file must be already open
m_outputFile = file;
}
-bool KEduVocKvtml2Writer::writeDoc( KEduVocDocument *doc, const QString &generator )
+bool QmVocKvtml2Writer::writeDoc( QmVocDocument *doc, const QString &generator )
{
if (createXmlDocument(doc, generator)) {
QTextStream ts( m_outputFile );
return false;
}
-QByteArray KEduVocKvtml2Writer::toByteArray(KEduVocDocument * doc, const QString & generator)
+QByteArray QmVocKvtml2Writer::toByteArray(QmVocDocument * doc, const QString & generator)
{
if (createXmlDocument(doc, generator)) {
return m_domDoc.toByteArray();
return QByteArray();
}
-bool KEduVocKvtml2Writer::createXmlDocument( KEduVocDocument *doc, const QString &generator )
+bool QmVocKvtml2Writer::createXmlDocument( QmVocDocument *doc, const QString &generator )
{
m_doc = doc;
return true;
}
-bool KEduVocKvtml2Writer::writeInformation( QDomElement &informationElement, const QString &generator )
+bool QmVocKvtml2Writer::writeInformation( QDomElement &informationElement, const QString &generator )
{
QDomElement currentElement;
QDomText textNode;
}
-bool KEduVocKvtml2Writer::writeIdentifiers( QDomElement &identifiersElement )
+bool QmVocKvtml2Writer::writeIdentifiers( QDomElement &identifiersElement )
{
for ( int i = 0; i < m_doc->identifierCount(); ++i ) {
// create the node
return true;
}
-bool KEduVocKvtml2Writer::writeLessons( KEduVocLesson *parentLesson, QDomElement &lessonsElement )
+bool QmVocKvtml2Writer::writeLessons( QmVocLesson *parentLesson, QDomElement &lessonsElement )
{
// iterate over child lessons.
// the first time this is called with the root lesson which does not have a <lesson> entry.
for( int i = 0; i < parentLesson->childContainerCount(); i++ ) {
- KEduVocLesson *lesson = static_cast<KEduVocLesson*>(parentLesson->childContainer(i));
+ QmVocLesson *lesson = static_cast<QmVocLesson*>(parentLesson->childContainer(i));
// make lesson element
QDomElement thisLessonElement = m_domDoc.createElement( KVTML_CONTAINER );
writeLessons(lesson, thisLessonElement);
// child entries
- foreach(KEduVocExpression *entry, lesson->entries()) {
+ foreach(QmVocExpression *entry, lesson->entries()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(entry)) );
thisLessonElement.appendChild(entryElement);
-void KEduVocKvtml2Writer::writeSynonymAntonymFalseFriend(QDomElement & parentElement)
+void QmVocKvtml2Writer::writeSynonymAntonymFalseFriend(QDomElement & parentElement)
{
- QList< KEduVocTranslation* > currentList;
+ QList< QmVocTranslation* > currentList;
QDomElement synonymElement;
// synonym, antonym, false friend
- for(int type = KEduVocTranslation::Synonym; type <= KEduVocTranslation::FalseFriend; type++) {
+ for(int type = QmVocTranslation::Synonym; type <= QmVocTranslation::FalseFriend; type++) {
switch (type) {
- case KEduVocTranslation::Synonym:
+ case QmVocTranslation::Synonym:
synonymElement = m_domDoc.createElement( KVTML_SYNONYM );
currentList = m_synonyms;
break;
- case KEduVocTranslation::Antonym:
+ case QmVocTranslation::Antonym:
synonymElement = m_domDoc.createElement( KVTML_ANTONYM );
currentList = m_antonyms;
break;
- case KEduVocTranslation::FalseFriend:
+ case QmVocTranslation::FalseFriend:
synonymElement = m_domDoc.createElement( KVTML_FALSEFRIEND );
currentList = m_falseFriends;
break;
while (!currentList.isEmpty()) {
// after writing a translation, remove it from the list
- KEduVocTranslation* translation = currentList.takeFirst();
+ QmVocTranslation* translation = currentList.takeFirst();
QDomElement relatedElement;
- QList <KEduVocTranslation*> list;
+ QList <QmVocTranslation*> list;
switch (type) {
- case KEduVocTranslation::Synonym:
+ case QmVocTranslation::Synonym:
list = translation->synonyms();
break;
- case KEduVocTranslation::Antonym:
+ case QmVocTranslation::Antonym:
list = translation->antonyms();
break;
- case KEduVocTranslation::FalseFriend:
+ case QmVocTranslation::FalseFriend:
list = translation->falseFriends();
break;
}
- foreach (KEduVocTranslation* synonym, list) {
+ foreach (QmVocTranslation* synonym, list) {
// if it is not in the list it has already been written and we can move on
if (currentList.contains(synonym)) {
relatedElement = m_domDoc.createElement( KVTML_PAIR );
} // iterate over types
}
/*
-bool KEduVocKvtml2Writer::writeRelated(QDomElement & parentElement, QList< KEduVocTranslation * > relatedList)
+bool QmVocKvtml2Writer::writeRelated(QDomElement & parentElement, QList< QmVocTranslation * > relatedList)
{
- foreach (KEduVocTranslation* synonym, translation->synonyms()) {
+ foreach (QmVocTranslation* synonym, translation->synonyms()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(translation->entry())) );
}
}*/
-bool KEduVocKvtml2Writer::writeArticle( QDomElement &articleElement, int language )
+bool QmVocKvtml2Writer::writeArticle( QDomElement &articleElement, int language )
{
///@todo only write if not empty
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> genders;
- genders[0] = KEduVocWordFlag::Masculine;
- genders[1] = KEduVocWordFlag::Feminine;
- genders[2] = KEduVocWordFlag::Neuter;
- QMap<int, KEduVocWordFlag::Flags> defs;
- defs[0] = KEduVocWordFlag::Definite;
- defs[1] = KEduVocWordFlag::Indefinite;
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> genders;
+ genders[0] = QmVocWordFlag::Masculine;
+ genders[1] = QmVocWordFlag::Feminine;
+ genders[2] = QmVocWordFlag::Neuter;
+ QMap<int, QmVocWordFlag::Flags> defs;
+ defs[0] = QmVocWordFlag::Definite;
+ defs[1] = QmVocWordFlag::Indefinite;
for (int num = 0; num <= 2; num++)
{
}
-bool KEduVocKvtml2Writer::writeWordTypes( QDomElement &typesElement, KEduVocWordType* parentContainer )
+bool QmVocKvtml2Writer::writeWordTypes( QDomElement &typesElement, QmVocWordType* parentContainer )
{
- foreach( KEduVocContainer* container, parentContainer->childContainers() ) {
- KEduVocWordType* wordType = static_cast<KEduVocWordType*>(container);
+ foreach( QmVocContainer* container, parentContainer->childContainers() ) {
+ QmVocWordType* wordType = static_cast<QmVocWordType*>(container);
QDomElement typeDefinitionElement = m_domDoc.createElement( KVTML_CONTAINER );
typeDefinitionElement.appendChild( newTextElement( KVTML_NAME, wordType->name() ) );
- if (wordType->wordType().testFlag(KEduVocWordFlag::Noun))
+ if (wordType->wordType().testFlag(QmVocWordFlag::Noun))
{
- if (wordType->wordType().testFlag(KEduVocWordFlag::Masculine))
+ if (wordType->wordType().testFlag(QmVocWordFlag::Masculine))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_MALE ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Feminine))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Feminine))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_FEMALE ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Neuter))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Neuter))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN_NEUTRAL ) );
else
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_NOUN ) );
}
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Verb))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Verb))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_VERB ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Adjective))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Adjective))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_ADJECTIVE ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Adverb))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Adverb))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_ADVERB ) );
- else if (wordType->wordType().testFlag(KEduVocWordFlag::Conjunction))
+ else if (wordType->wordType().testFlag(QmVocWordFlag::Conjunction))
typeDefinitionElement.appendChild( newTextElement( KVTML_SPECIALWORDTYPE, KVTML_SPECIALWORDTYPE_CONJUNCTION ) );
// child entries
// child entries
- foreach(KEduVocExpression *entry, wordType->entries()) {
+ foreach(QmVocExpression *entry, wordType->entries()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(entry)) );
for(int translation = 0; translation<m_doc->identifierCount(); translation++) {
return true;
}
-bool KEduVocKvtml2Writer::writeLeitnerBoxes( QDomElement &leitnerParentElement, KEduVocLeitnerBox* parentContainer )
+bool QmVocKvtml2Writer::writeLeitnerBoxes( QDomElement &leitnerParentElement, QmVocLeitnerBox* parentContainer )
{
- foreach( KEduVocContainer* container, parentContainer->childContainers() ) {
- KEduVocLeitnerBox* leitnerBox = static_cast<KEduVocLeitnerBox*>(container);
+ foreach( QmVocContainer* container, parentContainer->childContainers() ) {
+ QmVocLeitnerBox* leitnerBox = static_cast<QmVocLeitnerBox*>(container);
QDomElement containerElement = m_domDoc.createElement( KVTML_CONTAINER );
containerElement.appendChild( newTextElement( KVTML_NAME, leitnerBox->name() ) );
// child entries
- foreach(KEduVocExpression *entry, leitnerBox->entries()) {
+ foreach(QmVocExpression *entry, leitnerBox->entries()) {
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
entryElement.setAttribute( KVTML_ID, QString::number(m_allEntries.indexOf(entry)) );
for(int translation = 0; translation<m_doc->identifierCount(); translation++) {
return true;
}
-bool KEduVocKvtml2Writer::writeEntries( QDomElement &entriesElement )
+bool QmVocKvtml2Writer::writeEntries( QDomElement &entriesElement )
{
- m_allEntries = m_doc->lesson()->entries(KEduVocLesson::Recursive);
+ m_allEntries = m_doc->lesson()->entries(QmVocLesson::Recursive);
// loop through entries
for ( int i = 0; i < m_allEntries.count(); ++i ) {
- KEduVocExpression *thisEntry = m_allEntries.value(i);
+ QmVocExpression *thisEntry = m_allEntries.value(i);
// write entry tag
QDomElement entryElement = m_domDoc.createElement( KVTML_ENTRY );
}
-bool KEduVocKvtml2Writer::writeTranslation( QDomElement &translationElement, KEduVocTranslation* translation )
+bool QmVocKvtml2Writer::writeTranslation( QDomElement &translationElement, QmVocTranslation* translation )
{
- // so far only for KEduVocWord - text and grades
+ // so far only for QmVocWord - text and grades
translation->toKVTML2(translationElement);
// comparison
if ( !(translation->comparativeForm().text().isEmpty() || translation->superlativeForm().text().isEmpty())) {
- kDebug() << "Write comp";
+ qDebug() << "Write comp";
QDomElement comparisonElement = m_domDoc.createElement( KVTML_COMPARISON );
translationElement.appendChild(comparisonElement);
// image
if ( !translation->imageUrl().isEmpty() ) {
- QString urlString;
- if ( translation->imageUrl().url().startsWith(m_doc->url().upUrl().url()) ) {
- // try to save as relative url
- urlString = KUrl::relativeUrl( m_doc->url() , translation->imageUrl() );
- } else {
- urlString = translation->imageUrl().url();
- }
- translationElement.appendChild( newTextElement( KVTML_IMAGE, urlString ) );
+ qCritical("Fixme: imageURL is Empty...");
+// QString urlString;
+// if ( translation->imageUrl().url().startsWith(m_doc->url().upUrl().url()) ) {
+// // try to save as relative url
+// urlString = KUrl::relativeUrl( m_doc->url() , translation->imageUrl() );
+// } else {
+// urlString = translation->imageUrl().url();
+// }
+// translationElement.appendChild( newTextElement( KVTML_IMAGE, urlString ) );
}
// sound
if ( !translation->soundUrl().isEmpty() ) {
- QString urlString;
- if ( translation->soundUrl().url().startsWith(m_doc->url().upUrl().url()) ) {
- // try to save as relative url
- urlString = KUrl::relativeUrl( m_doc->url() , translation->soundUrl() );
- } else {
- urlString = translation->soundUrl().url();
- }
- translationElement.appendChild( newTextElement( KVTML_SOUND, urlString ) );
+ qCritical("Fixme: soundURL is Empty...");
+// QString urlString;
+// if ( translation->soundUrl().url().startsWith(m_doc->url().upUrl().url()) ) {
+// // try to save as relative url
+// urlString = KUrl::relativeUrl( m_doc->url() , translation->soundUrl() );
+// } else {
+// urlString = translation->soundUrl().url();
+// }
+// translationElement.appendChild( newTextElement( KVTML_SOUND, urlString ) );
}
// }
// }
-bool KEduVocKvtml2Writer::writeMultipleChoice( QDomElement &multipleChoiceElement, KEduVocTranslation* translation )
+bool QmVocKvtml2Writer::writeMultipleChoice( QDomElement &multipleChoiceElement, QmVocTranslation* translation )
/*
<multiplechoice>
<choice>good</choice>
return true;
}
-QDomElement KEduVocKvtml2Writer::newTextElement( const QString &elementName, const QString &text )
+QDomElement QmVocKvtml2Writer::newTextElement( const QString &elementName, const QString &text )
{
QDomElement retval = m_domDoc.createElement( elementName );
QDomText textNode = m_domDoc.createTextNode( text );
return retval;
}
-bool KEduVocKvtml2Writer::writePersonalPronoun(QDomElement & pronounElement, const KEduVocPersonalPronoun & pronoun)
+bool QmVocKvtml2Writer::writePersonalPronoun(QDomElement & pronounElement, const QmVocPersonalPronoun & pronoun)
{
// general pronoun properties
if ( pronoun.maleFemaleDifferent() ) {
}
- QMap<int, KEduVocWordFlag::Flags> numbers;
- numbers[0] = KEduVocWordFlag::Singular;
- numbers[1] = KEduVocWordFlag::Dual;
- numbers[2] = KEduVocWordFlag::Plural;
- QMap<int, KEduVocWordFlag::Flags> persons;
- persons[0] = KEduVocWordFlag::First;
- persons[1] = KEduVocWordFlag::Second;
- persons[2] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Masculine);
- persons[3] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Feminine);
- persons[4] = (KEduVocWordFlag::Flags)((int)KEduVocWordFlag::Third | (int)KEduVocWordFlag::Neuter);
+ QMap<int, QmVocWordFlag::Flags> numbers;
+ numbers[0] = QmVocWordFlag::Singular;
+ numbers[1] = QmVocWordFlag::Dual;
+ numbers[2] = QmVocWordFlag::Plural;
+ QMap<int, QmVocWordFlag::Flags> persons;
+ persons[0] = QmVocWordFlag::First;
+ persons[1] = QmVocWordFlag::Second;
+ persons[2] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Masculine);
+ persons[3] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Feminine);
+ persons[4] = (QmVocWordFlag::Flags)((int)QmVocWordFlag::Third | (int)QmVocWordFlag::Neuter);
return true;
}
-void KEduVocKvtml2Writer::appendTextElement(QDomElement & parent, const QString & elementName, const QString & text)
+void QmVocKvtml2Writer::appendTextElement(QDomElement & parent, const QString & elementName, const QString & text)
{
// empty will never be written
if (text.isEmpty()) {
GIT / libqmvoc.git / commitdiff