adapt qmvoctranslation.cpp for querymee

diff --git a/qmvoctranslation.cpp b/qmvoctranslation.cpp
index 1d7a5eb3c2ca05f04b6790f77f11897c9618ca73..eda9c286ae653a96eccc57e7c572ff8835647a9a 100644 (file)
--- a/qmvoctranslation.cpp
+++ b/qmvoctranslation.cpp
@@ -1,8 +1,14 @@
+/***************************************************************************
+*   this file is from kdeedu project. Filename: keduvoctranslation.cpp
+***************************************************************************/
+
 /***************************************************************************
                         Vocabulary Expression Translation for KDE Edu
     -----------------------------------------------------------------------
 
     Copyright 2007-2010 Frederik Gladhorn <gladhorn@kde.org>
+    Copyright 2010, 2012 Reto Zingg <g.d0b3rm4n@gmail.com>
+
  ***************************************************************************/
 
 /***************************************************************************
@@ -15,30 +21,29 @@
  ***************************************************************************/
 
 
-#include "keduvoctranslation.h"
+#include "qmvoctranslation.h"
 
-#include "keduvocdeclension.h"
-#include "keduvocwordtype.h"
-#include "keduvocleitnerbox.h"
+#include "qmvocdeclension.h"
+#include "qmvocwordtype.h"
+#include "qmvocleitnerbox.h"
 #include "kvtml2defs.h"
-#include "keduvockvtml2writer.h"
-
+#include "qmvockvtml2writer.h"
 #include <QtCore/QMap>
 
-class KEduVocTranslation::KEduVocTranslationPrivate
+class QmVocTranslation::QmVocTranslationPrivate
 {
 public:
-    KEduVocTranslationPrivate(KEduVocExpression* parent);
+    QmVocTranslationPrivate(QmVocExpression* parent);
 
-    ~KEduVocTranslationPrivate();
+    ~QmVocTranslationPrivate();
 
-    KEduVocExpression* m_entry;
+    QmVocExpression* m_entry;
 
     /// Type of a word noun, verb, adjective etc
-    KEduVocWordType* m_wordType;
+    QmVocWordType* m_wordType;
 
     /// Leitner box of the translation.
-    KEduVocLeitnerBox* m_leitnerBox;
+    QmVocLeitnerBox* m_leitnerBox;
 
     /// A comment giving additional information.
     QString m_comment;
@@ -51,35 +56,35 @@ public:
     /// Pronunciation
     QString m_pronunciation;
     /// Image url
-    KUrl m_imageUrl;
+    QUrl m_imageUrl;
     /// Sound url
-    KUrl m_soundUrl;
+    QUrl m_soundUrl;
 
     /// When creating multiple choice tests, these are possible answers. (otherwise other words are added randomly)
     QStringList m_multipleChoice;
 
     /// Conjugations of a word (I go, you go, he goes... boring in english)
-    QMap <QString, KEduVocConjugation> m_conjugations;
+    QMap <QString, QmVocConjugation> m_conjugations;
 
     /// The comparison forms of adjectives and adverbs: (fast), faster, fastest
-    KEduVocText* m_comparative;
-    KEduVocText* m_superlative;
+    QmVocText* m_comparative;
+    QmVocText* m_superlative;
 
     /// The grade of an article. The text part should not be used.
-    KEduVocText* m_articleGrade;
+    QmVocText* m_articleGrade;
 
-    KEduVocDeclension* m_declension;
+    QmVocDeclension* m_declension;
 
     // connections to other translations
     /// Synonyms for a word: sick and ill, student and pupil
-    QList< KEduVocTranslation* > m_synonyms;
+    QList< QmVocTranslation* > m_synonyms;
     /// An antonym - the opposite: hot - cold
-    QList< KEduVocTranslation* > m_antonyms;
+    QList< QmVocTranslation* > m_antonyms;
     /// List of false friends
-    QList< KEduVocTranslation* > m_falseFriends;
+    QList< QmVocTranslation* > m_falseFriends;
 };
 
-KEduVocTranslation::KEduVocTranslationPrivate::KEduVocTranslationPrivate(KEduVocExpression* parent)
+QmVocTranslation::QmVocTranslationPrivate::QmVocTranslationPrivate(QmVocExpression* parent)
 {
     m_entry = parent;
     m_wordType = 0;
@@ -92,25 +97,25 @@ KEduVocTranslation::KEduVocTranslationPrivate::KEduVocTranslationPrivate(KEduVoc
 }
 
 
-KEduVocTranslation::KEduVocTranslationPrivate::~KEduVocTranslationPrivate()
+QmVocTranslation::QmVocTranslationPrivate::~QmVocTranslationPrivate()
 {
     delete m_declension;
 }
 
-KEduVocTranslation::KEduVocTranslation(KEduVocExpression* entry) : d( new KEduVocTranslationPrivate(entry) )
+QmVocTranslation::QmVocTranslation(QmVocExpression* entry) : d( new QmVocTranslationPrivate(entry) )
 {
 }
 
 
-KEduVocTranslation::KEduVocTranslation(KEduVocExpression* entry, const QString &translation ) : d( new KEduVocTranslationPrivate(entry) )
+QmVocTranslation::QmVocTranslation(QmVocExpression* entry, const QString &translation ) : d( new QmVocTranslationPrivate(entry) )
 {
     setText(translation.simplified());
 }
 
-KEduVocTranslation::KEduVocTranslation( const KEduVocTranslation &other )
-    : KEduVocText(other),
+QmVocTranslation::QmVocTranslation( const QmVocTranslation &other )
+    : QmVocText(other),
     // set the entry to 0, the translation will be put into a copied entry by the expression copy constructor
-    d( new KEduVocTranslationPrivate(0) )
+    d( new QmVocTranslationPrivate(0) )
 {
     // beter no word type copy as this is pointer copying
     // will not work as this is not added to the word type container!
@@ -131,29 +136,29 @@ KEduVocTranslation::KEduVocTranslation( const KEduVocTranslation &other )
 //  d->m_antonyms = other.d->m_antonyms;
 //  d->m_falseFriends = other.d->m_falseFriends;
     if (other.d->m_declension) {
-        d->m_declension = new KEduVocDeclension(*other.d->m_declension);
+        d->m_declension = new QmVocDeclension(*other.d->m_declension);
     }
 }
 
-KEduVocTranslation::~KEduVocTranslation()
+QmVocTranslation::~QmVocTranslation()
 {
     setWordType(0);
     setLeitnerBox(0);
-    foreach (KEduVocTranslation *synonym, d->m_synonyms) {
+    foreach (QmVocTranslation *synonym, d->m_synonyms) {
         synonym->removeSynonym(this);
     }
-    foreach (KEduVocTranslation *antonym, d->m_antonyms) {
+    foreach (QmVocTranslation *antonym, d->m_antonyms) {
         antonym->removeAntonym(this);
     }
-    foreach (KEduVocTranslation *falseFriend, d->m_falseFriends) {
+    foreach (QmVocTranslation *falseFriend, d->m_falseFriends) {
         falseFriend->removeFalseFriend(this);
     }
     delete d;
 }
 
-bool KEduVocTranslation::operator == ( const KEduVocTranslation & translation ) const
+bool QmVocTranslation::operator == ( const QmVocTranslation & translation ) const
 {
-    return KEduVocText::operator==(translation) &&
+    return QmVocText::operator==(translation) &&
         d->m_wordType == translation.d->m_wordType &&
         d->m_leitnerBox == translation.d->m_leitnerBox &&
         d->m_comment == translation.d->m_comment &&
@@ -172,9 +177,9 @@ bool KEduVocTranslation::operator == ( const KEduVocTranslation & translation )
            /// @todo check and include declensions d->m_declension == translation.d->m_declension;
 }
 
-KEduVocTranslation & KEduVocTranslation::operator = ( const KEduVocTranslation & translation )
+QmVocTranslation & QmVocTranslation::operator = ( const QmVocTranslation & translation )
 {
-    KEduVocText::operator=(translation);
+    QmVocText::operator=(translation);
     d->m_entry = translation.d->m_entry;
 //     d->m_wordType = translation.d->m_wordType;
 //     d->m_leitnerBox = translation.d->m_leitnerBox;
@@ -192,154 +197,154 @@ KEduVocTranslation & KEduVocTranslation::operator = ( const KEduVocTranslation &
     d->m_antonyms = translation.d->m_antonyms;
     d->m_conjugations = translation.d->m_conjugations;
     if (translation.d->m_declension) {
-        d->m_declension = new KEduVocDeclension(*translation.d->m_declension);
+        d->m_declension = new QmVocDeclension(*translation.d->m_declension);
     }
 
     return *this;
 }
 
 
-QString KEduVocTranslation::comment() const
+QString QmVocTranslation::comment() const
 {
     return d->m_comment;
 }
 
 
-void KEduVocTranslation::setComment( const QString & expr )
+void QmVocTranslation::setComment( const QString & expr )
 {
     d->m_comment = expr.simplified();
 }
 
 
-void KEduVocTranslation::addFalseFriend( KEduVocTranslation* falseFriend )
+void QmVocTranslation::addFalseFriend( QmVocTranslation* falseFriend )
 {
     d->m_falseFriends.append(falseFriend);
 }
 
-void KEduVocTranslation::removeFalseFriend(KEduVocTranslation * falseFriend)
+void QmVocTranslation::removeFalseFriend(QmVocTranslation * falseFriend)
 {
     d->m_falseFriends.removeAt(d->m_falseFriends.indexOf(falseFriend));
 }
 
-QList< KEduVocTranslation* > KEduVocTranslation::falseFriends() const
+QList< QmVocTranslation* > QmVocTranslation::falseFriends() const
 {
     return d->m_falseFriends;
 }
 
 
-void KEduVocTranslation::addSynonym( KEduVocTranslation* synonym )
+void QmVocTranslation::addSynonym( QmVocTranslation* synonym )
 {
     d->m_synonyms.append(synonym);
 }
 
-void KEduVocTranslation::removeSynonym(KEduVocTranslation * synonym)
+void QmVocTranslation::removeSynonym(QmVocTranslation * synonym)
 {
     d->m_synonyms.removeAt(d->m_synonyms.indexOf(synonym));
 }
 
-QList<KEduVocTranslation*> KEduVocTranslation::synonyms() const
+QList<QmVocTranslation*> QmVocTranslation::synonyms() const
 {
     return d->m_synonyms;
 }
 
-void KEduVocTranslation::addAntonym( KEduVocTranslation* antonym )
+void QmVocTranslation::addAntonym( QmVocTranslation* antonym )
 {
     d->m_antonyms.append(antonym);
 }
 
-QList<KEduVocTranslation*> KEduVocTranslation::antonyms() const
+QList<QmVocTranslation*> QmVocTranslation::antonyms() const
 {
     return d->m_antonyms;
 }
 
-void KEduVocTranslation::removeAntonym(KEduVocTranslation * antonym)
+void QmVocTranslation::removeAntonym(QmVocTranslation * antonym)
 {
     d->m_antonyms.removeAt(d->m_antonyms.indexOf(antonym));
 }
 
-void KEduVocTranslation::setExample( const QString & expr )
+void QmVocTranslation::setExample( const QString & expr )
 {
     d->m_example = expr.simplified();
 }
 
 
-QString KEduVocTranslation::example() const
+QString QmVocTranslation::example() const
 {
     return d->m_example;
 }
 
 
-void KEduVocTranslation::setParaphrase( const QString & expr )
+void QmVocTranslation::setParaphrase( const QString & expr )
 {
     d->m_paraphrase = expr.simplified();
 }
 
 
-QString KEduVocTranslation::paraphrase() const
+QString QmVocTranslation::paraphrase() const
 {
     return d->m_paraphrase;
 }
 
 
-void KEduVocTranslation::setConjugation( const QString& tense, const KEduVocConjugation& con )
+void QmVocTranslation::setConjugation( const QString& tense, const QmVocConjugation& con )
 {
     d->m_conjugations[tense] = con;
 }
 
 
-KEduVocConjugation& KEduVocTranslation::conjugation( const QString& tense )
+QmVocConjugation& QmVocTranslation::conjugation( const QString& tense )
 {
     return d->m_conjugations[tense];
 }
 
 
-QStringList & KEduVocTranslation::multipleChoice()
+QStringList & QmVocTranslation::multipleChoice()
 {
     return d->m_multipleChoice;
 }
 
 
-QString KEduVocTranslation::pronunciation() const
+QString QmVocTranslation::pronunciation() const
 {
     return d->m_pronunciation;
 }
 
 
-void KEduVocTranslation::setPronunciation( const QString & expr )
+void QmVocTranslation::setPronunciation( const QString & expr )
 {
     d->m_pronunciation = expr.simplified();
 }
 
-QStringList KEduVocTranslation::conjugationTenses() const
+QStringList QmVocTranslation::conjugationTenses() const
 {
     return d->m_conjugations.keys();
 }
 
-QMap< QString, KEduVocConjugation > KEduVocTranslation::conjugations() const
+QMap< QString, QmVocConjugation > QmVocTranslation::conjugations() const
 {
     return d->m_conjugations;
 }
 
-void KEduVocTranslation::setConjugations(const QMap< QString, KEduVocConjugation > & conjugations)
+void QmVocTranslation::setConjugations(const QMap< QString, QmVocConjugation > & conjugations)
 {
     d->m_conjugations = conjugations;
 }
 
 /** get the sound url for this translation if it exists */
-KUrl KEduVocTranslation::soundUrl()
+QUrl QmVocTranslation::soundUrl()
 {
     return d->m_soundUrl;
 }
 
 /** set the sound url for this translation
  * @param url               url of the sound file */
-void KEduVocTranslation::setSoundUrl(const KUrl &url)
+void QmVocTranslation::setSoundUrl(const QUrl &url)
 {
     d->m_soundUrl = url;
 }
 
 /** get the image url for this translation if it exists */
-KUrl KEduVocTranslation::imageUrl()
+QUrl QmVocTranslation::imageUrl()
 {
     return d->m_imageUrl;
 }
@@ -347,12 +352,12 @@ KUrl KEduVocTranslation::imageUrl()
 /** set the image url for this translation
  * @param url               url of the image
  */
-void KEduVocTranslation::setImageUrl(const KUrl &url)
+void QmVocTranslation::setImageUrl(const QUrl &url)
 {
     d->m_imageUrl = url;
 }
 
-KEduVocWordType * KEduVocTranslation::wordType() const
+QmVocWordType * QmVocTranslation::wordType() const
 {
     if (d) {
         return d->m_wordType;
@@ -361,7 +366,7 @@ KEduVocWordType * KEduVocTranslation::wordType() const
     }
 }
 
-void KEduVocTranslation::setWordType(KEduVocWordType * wordType)
+void QmVocTranslation::setWordType(QmVocWordType * wordType)
 {
     if ( d->m_wordType ) {
         d->m_wordType->removeTranslation(this);
@@ -372,12 +377,12 @@ void KEduVocTranslation::setWordType(KEduVocWordType * wordType)
     d->m_wordType = wordType;
 }
 
-KEduVocLeitnerBox * KEduVocTranslation::leitnerBox() const
+QmVocLeitnerBox * QmVocTranslation::leitnerBox() const
 {
     return d->m_leitnerBox;
 }
 
-void KEduVocTranslation::setLeitnerBox(KEduVocLeitnerBox * leitnerBox)
+void QmVocTranslation::setLeitnerBox(QmVocLeitnerBox * leitnerBox)
 {
     if ( d->m_leitnerBox ) {
         d->m_leitnerBox->removeTranslation(this);
@@ -388,12 +393,12 @@ void KEduVocTranslation::setLeitnerBox(KEduVocLeitnerBox * leitnerBox)
     d->m_leitnerBox = leitnerBox;
 }
 
-KEduVocExpression * KEduVocTranslation::entry()
+QmVocExpression * QmVocTranslation::entry()
 {
     return d->m_entry;
 }
 
-QString KEduVocTranslation::comparative() const
+QString QmVocTranslation::comparative() const
 {
     if (d->m_comparative) {
         return d->m_comparative->text();
@@ -401,16 +406,16 @@ QString KEduVocTranslation::comparative() const
     return QString();
 }
 
-void KEduVocTranslation::setComparative(const QString & comparative)
+void QmVocTranslation::setComparative(const QString & comparative)
 {
     if (!d->m_comparative) {
-        d->m_comparative = new KEduVocText(comparative);
+        d->m_comparative = new QmVocText(comparative);
     } else {
         d->m_comparative->setText(comparative);
     }
 }
 
-QString KEduVocTranslation::superlative() const
+QString QmVocTranslation::superlative() const
 {
     if (d->m_superlative) {
         return d->m_superlative->text();
@@ -418,82 +423,82 @@ QString KEduVocTranslation::superlative() const
     return QString();
 }
 
-void KEduVocTranslation::setSuperlative(const QString & superlative)
+void QmVocTranslation::setSuperlative(const QString & superlative)
 {
     if (!d->m_superlative) {
-        d->m_superlative = new KEduVocText(superlative);
+        d->m_superlative = new QmVocText(superlative);
     } else {
         d->m_superlative->setText(superlative);
     }
 }
 
-KEduVocText KEduVocTranslation::comparativeForm() const
+QmVocText QmVocTranslation::comparativeForm() const
 {
     if (!d->m_comparative) {
-        return KEduVocText();
+        return QmVocText();
     }
-    KEduVocText t(*(d->m_comparative));
+    QmVocText t(*(d->m_comparative));
     return t;
 }
 
-void KEduVocTranslation::setComparativeForm(const KEduVocText& comparative)
+void QmVocTranslation::setComparativeForm(const QmVocText& comparative)
 {
     if (!d->m_comparative) {
-        d->m_comparative = new KEduVocText();
+        d->m_comparative = new QmVocText();
     }
     *(d->m_comparative) = comparative;
 }
 
-KEduVocText KEduVocTranslation::superlativeForm() const
+QmVocText QmVocTranslation::superlativeForm() const
 {
     if (!d->m_superlative) {
-        return KEduVocText();
+        return QmVocText();
     }
-    KEduVocText t(*d->m_superlative);
+    QmVocText t(*d->m_superlative);
     return t;
 }
 
-void KEduVocTranslation::setSuperlativeForm(const KEduVocText& superlative)
+void QmVocTranslation::setSuperlativeForm(const QmVocText& superlative)
 {
     if (!d->m_superlative) {
-        d->m_superlative = new KEduVocText();
+        d->m_superlative = new QmVocText();
     }
     *d->m_superlative = superlative;
 }
 
-KEduVocText KEduVocTranslation::article() const
+QmVocText QmVocTranslation::article() const
 {
     if (!d->m_articleGrade) {
-        return KEduVocText();
+        return QmVocText();
     }
-    KEduVocText t(*d->m_articleGrade);
+    QmVocText t(*d->m_articleGrade);
     return t;
 }
 
-void KEduVocTranslation::setArticle(const KEduVocText& article)
+void QmVocTranslation::setArticle(const QmVocText& article)
 {
     if (!d->m_articleGrade) {
-        d->m_articleGrade = new KEduVocText();
+        d->m_articleGrade = new QmVocText();
     }
     *d->m_articleGrade = article;
 }
 
-KEduVocDeclension * KEduVocTranslation::declension()
+QmVocDeclension * QmVocTranslation::declension()
 {
     return d->m_declension;
 }
 
-void KEduVocTranslation::setDeclension(KEduVocDeclension * declension)
+void QmVocTranslation::setDeclension(QmVocDeclension * declension)
 {
     // remove the old declension object
     delete d->m_declension;
     d->m_declension = declension;
 }
 
-void KEduVocTranslation::toKVTML2(QDomElement & parent)
+void QmVocTranslation::toKVTML2(QDomElement & parent)
 {
     // text and grade
-    KEduVocText::toKVTML2(parent);
+    QmVocText::toKVTML2(parent);
 
     // declension
     if (d->m_declension) {
@@ -510,26 +515,26 @@ void KEduVocTranslation::toKVTML2(QDomElement & parent)
     }
 
     // <comment>
-    KEduVocKvtml2Writer::appendTextElement( parent, KVTML_COMMENT, comment() );
+    QmVocKvtml2Writer::appendTextElement( parent, KVTML_COMMENT, comment() );
 
     // <pronunciation>
-    KEduVocKvtml2Writer::appendTextElement( parent, KVTML_PRONUNCIATION, pronunciation() );
+    QmVocKvtml2Writer::appendTextElement( parent, KVTML_PRONUNCIATION, pronunciation() );
 
     // <example>
-    KEduVocKvtml2Writer::appendTextElement( parent, KVTML_EXAMPLE, example() );
+    QmVocKvtml2Writer::appendTextElement( parent, KVTML_EXAMPLE, example() );
 
     // <paraphrase>
-    KEduVocKvtml2Writer::appendTextElement( parent, KVTML_PARAPHRASE, paraphrase() );
+    QmVocKvtml2Writer::appendTextElement( parent, KVTML_PARAPHRASE, paraphrase() );
 
     ///@todo synonyms, antonyms
     ///@todo false friends
 }
 
-void KEduVocTranslation::fromKVTML2(QDomElement & parent)
+void QmVocTranslation::fromKVTML2(QDomElement & parent)
 {
-    KEduVocText::fromKVTML2(parent);
+    QmVocText::fromKVTML2(parent);
 
-    setDeclension(KEduVocDeclension::fromKVTML2(parent));
+    setDeclension(QmVocDeclension::fromKVTML2(parent));
 
     setComment( parent.firstChildElement( KVTML_COMMENT ).text() );
 
@@ -546,7 +551,7 @@ void KEduVocTranslation::fromKVTML2(QDomElement & parent)
     while ( !conjugationElement.isNull() ) {
         QDomElement tenseElement = conjugationElement.firstChildElement( KVTML_TENSE );
         QString tense = tenseElement.text();
-        KEduVocConjugation *conjugation = KEduVocConjugation::fromKVTML2(conjugationElement);
+        QmVocConjugation *conjugation = QmVocConjugation::fromKVTML2(conjugationElement);
         setConjugation(tense, *conjugation);
         delete conjugation;
         conjugationElement = conjugationElement.nextSiblingElement( KVTML_CONJUGATION );
@@ -556,7 +561,7 @@ void KEduVocTranslation::fromKVTML2(QDomElement & parent)
     ///@todo false friends
 }
 
-void KEduVocTranslation::setEntry(KEduVocExpression * entry)
+void QmVocTranslation::setEntry(QmVocExpression * entry)
 {
     d->m_entry = entry;
 }