From: Frederik Gladhorn <gladhorn@kde.org>
Date: Sat, 1 Sep 2007 17:24:32 +0000 (+0000)
Subject: Simplify conjugation class:
X-Git-Tag: v3.94.0~96
X-Git-Url: https://git.rmz.fi/?a=commitdiff_plain;h=87d48be69122004c3dacdb0d0d613500693c528a;p=libqmvoc.git

Simplify conjugation class:
 - only consists of the entries for one language
 - tenses moved directly into translation which contains a qmap<qstring,keduvoctranslation> now.

Removed superfluous replace empty string with "".

Cleanup.
Personal pronouns much more logical this way.

Breaks reading of old conjugations (will be fixed again soon).

svn path=/trunk/KDE/kdeedu/libkdeedu/; revision=707378
---

diff --git a/keduvocdocument/keduvocconjugation.cpp b/keduvocdocument/keduvocconjugation.cpp
index 5a66254..975e903 100644
--- a/keduvocdocument/keduvocconjugation.cpp
+++ b/keduvocdocument/keduvocconjugation.cpp
@@ -29,34 +29,32 @@
 class KEduVocConjugation::Private
 {
 public:
-    struct conjug_t
-    {
-        conjug_t()
-        {
-            p3common = false;
-            s3common = false;
-        }
-
-        bool operator==(const conjug_t& other) const;
-
-        bool    p3common;
-        bool    s3common;
-        QString pers1_sing;
-        QString pers2_sing;
-        QString pers3_m_sing;
-        QString pers3_f_sing;
-        QString pers3_n_sing;
-        QString pers1_plur;
-        QString pers2_plur;
-        QString pers3_m_plur;
-        QString pers3_f_plur;
-        QString pers3_n_plur;
-    };
-
-    QMap <QString, conjug_t> m_conjugations;
+    Private();
+
+//     bool operator==(const conjug_t& other) const;
+
+    bool    p3common;
+    bool    s3common;
+    QString pers1_sing;
+    QString pers2_sing;
+    QString pers3_m_sing;
+    QString pers3_f_sing;
+    QString pers3_n_sing;
+    QString pers1_plur;
+    QString pers2_plur;
+    QString pers3_m_plur;
+    QString pers3_f_plur;
+    QString pers3_n_plur;
+
 };
 
 
+KEduVocConjugation::Private::Private()
+{
+    p3common = false;
+    s3common = false;
+}
+
 KEduVocConjugation::KEduVocConjugation()
         : d( new Private )
 {}
@@ -74,188 +72,179 @@ KEduVocConjugation::~KEduVocConjugation()
 }
 
 
-KEduVocConjugation& KEduVocConjugation::operator = ( const KEduVocConjugation& a )
+KEduVocConjugation& KEduVocConjugation::operator = ( const KEduVocConjugation& other )
 {
-    d->m_conjugations = a.d->m_conjugations;
+    d->s3common = other.d->s3common;
+    d->p3common = other.d->p3common;
+    d->pers1_sing = other.d->pers1_sing;
+    d->pers2_sing = other.d->pers2_sing;
+    d->pers3_m_sing = other.d->pers3_m_sing;
+    d->pers3_f_sing = other.d->pers3_f_sing;
+    d->pers3_n_sing = other.d->pers3_n_sing;
+    d->pers1_plur = other.d->pers1_plur;
+    d->pers2_plur = other.d->pers2_plur;
+    d->pers3_m_plur = other.d->pers3_m_plur;
+    d->pers3_f_plur = other.d->pers3_f_plur;
+    d->pers3_n_plur = other.d->pers3_n_plur;
     return *this;
 }
 
-
-bool KEduVocConjugation::operator == ( const KEduVocConjugation& a ) const
-{
-    return d->m_conjugations == a.d->m_conjugations;
-}
-
-
-int KEduVocConjugation::entryCount() const
-{
-    return d->m_conjugations.count();
-}
-
-
-bool KEduVocConjugation::pers3SingularCommon( const QString &type ) const
+bool KEduVocConjugation::operator ==(const KEduVocConjugation& other) const
 {
-    return d->m_conjugations.value(type).s3common;
+    return d->s3common == other.d->s3common &&
+        d->p3common == other.d->p3common &&
+        d->pers1_sing == other.d->pers1_sing &&
+        d->pers2_sing == other.d->pers2_sing &&
+        d->pers3_m_sing == other.d->pers3_m_sing &&
+        d->pers3_f_sing == other.d->pers3_f_sing &&
+        d->pers3_n_sing == other.d->pers3_n_sing &&
+        d->pers1_plur == other.d->pers1_plur &&
+        d->pers2_plur == other.d->pers2_plur &&
+        d->pers3_m_plur == other.d->pers3_m_plur &&
+        d->pers3_f_plur == other.d->pers3_f_plur &&
+        d->pers3_n_plur == other.d->pers3_n_plur;
 }
 
-
-bool KEduVocConjugation::pers3PluralCommon( const QString &type ) const
+bool KEduVocConjugation::pers3SingularCommon() const
 {
-    return d->m_conjugations.value(type).p3common;
+    return d->s3common;
 }
 
 
-QString KEduVocConjugation::pers1Singular( const QString &type ) const
+bool KEduVocConjugation::pers3PluralCommon() const
 {
-    return d->m_conjugations.value(type).pers1_sing;
+    return d->p3common;
 }
 
 
-QString KEduVocConjugation::pers2Singular( const QString &type ) const
+QString KEduVocConjugation::pers1Singular() const
 {
-    return d->m_conjugations.value(type).pers2_sing;
+    return d->pers1_sing;
 }
 
 
-QString KEduVocConjugation::pers3FemaleSingular( const QString &type ) const
+QString KEduVocConjugation::pers2Singular() const
 {
-    return d->m_conjugations.value(type).pers3_f_sing;
+    return d->pers2_sing;
 }
 
 
-QString KEduVocConjugation::pers3MaleSingular( const QString &type ) const
+QString KEduVocConjugation::pers3FemaleSingular() const
 {
-    return d->m_conjugations.value(type).pers3_m_sing;
+    return d->pers3_f_sing;
 }
 
 
-QString KEduVocConjugation::pers3NaturalSingular( const QString &type ) const
+QString KEduVocConjugation::pers3MaleSingular() const
 {
-    return d->m_conjugations.value(type).pers3_n_sing;
+    return d->pers3_m_sing;
 }
 
 
-QString KEduVocConjugation::pers1Plural( const QString &type ) const
+QString KEduVocConjugation::pers3NaturalSingular() const
 {
-    return d->m_conjugations.value(type).pers1_plur;
+    return d->pers3_n_sing;
 }
 
 
-QString KEduVocConjugation::pers2Plural( const QString &type ) const
+QString KEduVocConjugation::pers1Plural() const
 {
-    return d->m_conjugations.value(type).pers2_plur;
+    return d->pers1_plur;
 }
 
 
-QString KEduVocConjugation::pers3FemalePlural( const QString &type ) const
+QString KEduVocConjugation::pers2Plural() const
 {
-    return d->m_conjugations.value(type).pers3_f_plur;
+    return d->pers2_plur;
 }
 
 
-QString KEduVocConjugation::pers3MalePlural( const QString &type ) const
+QString KEduVocConjugation::pers3FemalePlural() const
 {
-    return d->m_conjugations.value(type).pers3_m_plur;
+    return d->pers3_f_plur;
 }
 
 
-QString KEduVocConjugation::pers3NaturalPlural( const QString &type ) const
+QString KEduVocConjugation::pers3MalePlural() const
 {
-    return d->m_conjugations.value(type).pers3_n_plur;
+    return d->pers3_m_plur;
 }
 
 
-void KEduVocConjugation::setPers3PluralCommon( const QString &type, bool f )
+QString KEduVocConjugation::pers3NaturalPlural() const
 {
-    d->m_conjugations[type].p3common = f;
+    return d->pers3_n_plur;
 }
 
 
-void KEduVocConjugation::setPers3SingularCommon( const QString &type, bool f )
+void KEduVocConjugation::setPers3PluralCommon( bool f )
 {
-    d->m_conjugations[type].s3common = f;
+    d->p3common = f;
 }
 
 
-void KEduVocConjugation::setPers1Singular( const QString &type, const QString &str )
+void KEduVocConjugation::setPers3SingularCommon( bool f )
 {
-    d->m_conjugations[type].pers1_sing = str;
+    d->s3common = f;
 }
 
 
-void KEduVocConjugation::setPers2Singular( const QString &type, const QString &str )
+void KEduVocConjugation::setPers1Singular( const QString &str )
 {
-    d->m_conjugations[type].pers2_sing = str;
+    d->pers1_sing = str;
 }
 
 
-void KEduVocConjugation::setPers3FemaleSingular( const QString &type, const QString &str )
+void KEduVocConjugation::setPers2Singular( const QString &str )
 {
-    d->m_conjugations[type].pers3_f_sing = str;
+    d->pers2_sing = str;
 }
 
 
-void KEduVocConjugation::setPers3MaleSingular( const QString &type, const QString &str )
+void KEduVocConjugation::setPers3FemaleSingular( const QString &str )
 {
-    d->m_conjugations[type].pers3_m_sing = str;
+    d->pers3_f_sing = str;
 }
 
 
-void KEduVocConjugation::setPers3NaturalSingular( const QString &type, const QString &str )
+void KEduVocConjugation::setPers3MaleSingular( const QString &str )
 {
-    d->m_conjugations[type].pers3_n_sing = str;
+    d->pers3_m_sing = str;
 }
 
 
-void KEduVocConjugation::setPers1Plural( const QString &type, const QString &str )
+void KEduVocConjugation::setPers3NaturalSingular( const QString &str )
 {
-    d->m_conjugations[type].pers1_plur = str;
+    d->pers3_n_sing = str;
 }
 
 
-void KEduVocConjugation::setPers2Plural( const QString &type, const QString &str )
+void KEduVocConjugation::setPers1Plural( const QString &str )
 {
-    d->m_conjugations[type].pers2_plur = str;
+    d->pers1_plur = str;
 }
 
 
-void KEduVocConjugation::setPers3FemalePlural( const QString &type, const QString &str )
+void KEduVocConjugation::setPers2Plural( const QString &str )
 {
-    d->m_conjugations[type].pers3_f_plur = str;
+    d->pers2_plur = str;
 }
 
 
-void KEduVocConjugation::setPers3MalePlural( const QString &type, const QString &str )
+void KEduVocConjugation::setPers3FemalePlural( const QString &str )
 {
-    d->m_conjugations[type].pers3_m_plur = str;
+    d->pers3_f_plur = str;
 }
 
 
-void KEduVocConjugation::setPers3NaturalPlural( const QString &type, const QString &str )
+void KEduVocConjugation::setPers3MalePlural( const QString &str )
 {
-    d->m_conjugations[type].pers3_n_plur = str;
+    d->pers3_m_plur = str;
 }
 
 
-bool KEduVocConjugation::Private::conjug_t::operator ==(const conjug_t & other) const
+void KEduVocConjugation::setPers3NaturalPlural( const QString &str )
 {
-    return s3common == other.s3common &&
-        p3common == other.p3common &&
-        pers1_sing == other.pers1_sing &&
-        pers2_sing == other.pers2_sing &&
-        pers3_m_sing == other.pers3_m_sing &&
-        pers3_f_sing == other.pers3_f_sing &&
-        pers3_n_sing == other.pers3_n_sing &&
-        pers1_plur == other.pers1_plur &&
-        pers2_plur == other.pers2_plur &&
-        pers3_m_plur == other.pers3_m_plur &&
-        pers3_f_plur == other.pers3_f_plur &&
-        pers3_n_plur == other.pers3_n_plur;
+    d->pers3_n_plur = str;
 }
 
-QStringList KEduVocConjugation::tenses() const
-{
-    return d->m_conjugations.keys();
-}
-
-
diff --git a/keduvocdocument/keduvocconjugation.h b/keduvocdocument/keduvocconjugation.h
index 122aab0..8f151f6 100644
--- a/keduvocdocument/keduvocconjugation.h
+++ b/keduvocdocument/keduvocconjugation.h
@@ -49,37 +49,33 @@ public:
 
     ~KEduVocConjugation();
 
-    int entryCount() const;
-
-    QStringList tenses() const;
-
-    QString pers1Singular( const QString &type ) const;
-    QString pers2Singular( const QString &type ) const;
-    bool    pers3SingularCommon( const QString &type ) const;
-    QString pers3FemaleSingular( const QString &type ) const;
-    QString pers3MaleSingular( const QString &type ) const;
-    QString pers3NaturalSingular( const QString &type ) const;
-
-    QString pers1Plural( const QString &type ) const;
-    QString pers2Plural( const QString &type ) const;
-    bool    pers3PluralCommon( const QString &type ) const;
-    QString pers3FemalePlural( const QString &type ) const;
-    QString pers3MalePlural( const QString &type ) const;
-    QString pers3NaturalPlural( const QString &type ) const;
-
-    void setPers1Singular( const QString &type, const QString &str );
-    void setPers2Singular( const QString &type, const QString &str );
-    void setPers3SingularCommon( const QString &type, bool f );
-    void setPers3FemaleSingular( const QString &type, const QString &str );
-    void setPers3MaleSingular( const QString &type, const QString &str );
-    void setPers3NaturalSingular( const QString &type, const QString &str );
-
-    void setPers1Plural( const QString &type, const QString &str );
-    void setPers2Plural( const QString &type, const QString &str );
-    void setPers3PluralCommon( const QString &type, bool f );
-    void setPers3FemalePlural( const QString &type, const QString &str );
-    void setPers3MalePlural( const QString &type, const QString &str );
-    void setPers3NaturalPlural( const QString &type, const QString &str );
+    QString pers1Singular( ) const;
+    QString pers2Singular( ) const;
+    bool    pers3SingularCommon( ) const;
+    QString pers3FemaleSingular( ) const;
+    QString pers3MaleSingular( ) const;
+    QString pers3NaturalSingular( ) const;
+
+    QString pers1Plural( ) const;
+    QString pers2Plural( ) const;
+    bool    pers3PluralCommon( ) const;
+    QString pers3FemalePlural( ) const;
+    QString pers3MalePlural( ) const;
+    QString pers3NaturalPlural( ) const;
+
+    void setPers1Singular( const QString &str );
+    void setPers2Singular( const QString &str );
+    void setPers3SingularCommon( bool f );
+    void setPers3FemaleSingular( const QString &str );
+    void setPers3MaleSingular( const QString &str );
+    void setPers3NaturalSingular( const QString &str );
+
+    void setPers1Plural( const QString &str );
+    void setPers2Plural( const QString &str );
+    void setPers3PluralCommon( bool f );
+    void setPers3FemalePlural( const QString &str );
+    void setPers3MalePlural( const QString &str );
+    void setPers3NaturalPlural( const QString &str );
 
     KEduVocConjugation& operator = ( const KEduVocConjugation& a );
     bool operator == ( const KEduVocConjugation& a ) const;
diff --git a/keduvocdocument/keduvockvtml2reader.cpp b/keduvocdocument/keduvockvtml2reader.cpp
index 902525b..1ad98f8 100644
--- a/keduvocdocument/keduvockvtml2reader.cpp
+++ b/keduvocdocument/keduvockvtml2reader.cpp
@@ -383,16 +383,15 @@ bool KEduVocKvtml2Reader::readTranslation( QDomElement &translationElement,
 
     // conjugations
     currentElement = translationElement.firstChildElement( KVTML_CONJUGATION );
-    KEduVocConjugation conjugation;
     while ( !currentElement.isNull() ) {
         // read any conjugations (NOTE: this will overwrite any conjugations of the same type for this
         // translation, as the type is used as the key
-        readConjugation( currentElement, conjugation );
+        QDomElement tenseElement = currentElement.firstChildElement( KVTML_TENSE );
+        QString tense = tenseElement.text();
+
+        readConjugation( currentElement, expr.translation(index).conjugation(tense) );
         currentElement = currentElement.nextSiblingElement( KVTML_CONJUGATION );
     }
-    if ( conjugation.entryCount() > 0 ) {
-        expr.translation( index ).setConjugation( conjugation );
-    }
 
     // grade elements
     currentElement = translationElement.firstChildElement( KVTML_GRADE );
@@ -545,7 +544,7 @@ bool KEduVocKvtml2Reader::readArticle( QDomElement &articleElement, int identifi
 }
 
 
-bool KEduVocKvtml2Reader::readConjugation( QDomElement &conjugElement, KEduVocConjugation &curr_conjug )
+bool KEduVocKvtml2Reader::readConjugation( QDomElement &conjugElement, KEduVocConjugation &conjugation )
 /*
  <conjugation>
   <tense>Futurepastperfekt:)</tense>
@@ -580,10 +579,7 @@ bool KEduVocKvtml2Reader::readConjugation( QDomElement &conjugElement, KEduVocCo
     QString plurthirdmale;
     QString plurthirdfemale;
     QString plurthirdneutral;
-    QString tense;
 
-    QDomElement tenseElement = conjugElement.firstChildElement( KVTML_TENSE );
-    tense = tenseElement.text();
     QDomElement currentGroup = conjugElement.firstChildElement( KVTML_SINGULAR );
     if ( !currentGroup.isNull() )
     {
@@ -645,18 +641,18 @@ bool KEduVocKvtml2Reader::readConjugation( QDomElement &conjugElement, KEduVocCo
         }
     }
 
-    curr_conjug.setPers3SingularCommon( tense, s3_common );
-    curr_conjug.setPers3PluralCommon( tense, p3_common );
-    curr_conjug.setPers1Singular( tense, singfirst );
-    curr_conjug.setPers2Singular( tense, singsecond );
-    curr_conjug.setPers3FemaleSingular( tense, singthirdfemale );
-    curr_conjug.setPers3MaleSingular( tense, singthirdmale );
-    curr_conjug.setPers3NaturalSingular( tense, singthirdneutral );
-    curr_conjug.setPers1Plural( tense, plurfirst );
-    curr_conjug.setPers2Plural( tense, plursecond );
-    curr_conjug.setPers3FemalePlural( tense, plurthirdfemale );
-    curr_conjug.setPers3MalePlural( tense, plurthirdmale );
-    curr_conjug.setPers3NaturalPlural( tense, plurthirdneutral );
+    conjugation.setPers3SingularCommon( s3_common );
+    conjugation.setPers3PluralCommon( p3_common );
+    conjugation.setPers1Singular( singfirst );
+    conjugation.setPers2Singular( singsecond );
+    conjugation.setPers3FemaleSingular( singthirdfemale );
+    conjugation.setPers3MaleSingular( singthirdmale );
+    conjugation.setPers3NaturalSingular( singthirdneutral );
+    conjugation.setPers1Plural( plurfirst );
+    conjugation.setPers2Plural( plursecond );
+    conjugation.setPers3FemalePlural( plurthirdfemale );
+    conjugation.setPers3MalePlural( plurthirdmale );
+    conjugation.setPers3NaturalPlural( plurthirdneutral );
 
     return true;
 }
diff --git a/keduvocdocument/keduvockvtml2reader.h b/keduvocdocument/keduvockvtml2reader.h
index 60587e8..1848092 100644
--- a/keduvocdocument/keduvockvtml2reader.h
+++ b/keduvocdocument/keduvockvtml2reader.h
@@ -67,7 +67,7 @@ public:
      * @param conjugElement QDomElement for the conjugation group
      * @param curr_conjug conjugation object to populate
      */
-    bool readConjugation( QDomElement &conjugElement, KEduVocConjugation &curr_conjug );
+    bool readConjugation( QDomElement &conjugElement, KEduVocConjugation &conjugation );
 
     /** read the types
      * @param typesElement QDomElement for the types group
diff --git a/keduvocdocument/keduvockvtml2writer.cpp b/keduvocdocument/keduvockvtml2writer.cpp
index 4b63599..0241b1a 100644
--- a/keduvocdocument/keduvockvtml2writer.cpp
+++ b/keduvocdocument/keduvockvtml2writer.cpp
@@ -431,13 +431,10 @@ bool KEduVocKvtml2Writer::writeTranslation( QDomElement &translationElement, KEd
     }
 
     // conjugation
-    if ( translation.conjugation().entryCount() > 0 ) {
-        KEduVocConjugation conjugation = translation.conjugation();
-        foreach ( QString tense, conjugation.tenses() ) {
-            QDomElement thisElement = m_domDoc.createElement( KVTML_CONJUGATION );
-            writeConjugation( thisElement, conjugation, tense );
-            translationElement.appendChild( thisElement );
-        }
+    foreach ( QString tense, translation.conjugationTenses() ) {
+        QDomElement thisElement = m_domDoc.createElement( KVTML_CONJUGATION );
+        writeConjugation( thisElement, translation.conjugation(tense), tense );
+        translationElement.appendChild( thisElement );
     }
 
     // comparison
@@ -503,12 +500,12 @@ bool KEduVocKvtml2Writer::writeConjugation( QDomElement &conjugationElement,
     conjugationElement.appendChild( newTextElement(KVTML_TENSE, tense) );
 
     // first singular conjugations
-    QString first = conjugation.pers1Singular( tense );
-    QString second = conjugation.pers2Singular( tense );
-    bool third_common = conjugation.pers3SingularCommon( tense );
-    QString third_male = conjugation.pers3MaleSingular( tense );
-    QString third_female = conjugation.pers3FemaleSingular( tense );
-    QString third_neutral = conjugation.pers3NaturalSingular( tense );
+    QString first = conjugation.pers1Singular();
+    QString second = conjugation.pers2Singular();
+    bool third_common = conjugation.pers3SingularCommon();
+    QString third_male = conjugation.pers3MaleSingular();
+    QString third_female = conjugation.pers3FemaleSingular();
+    QString third_neutral = conjugation.pers3NaturalSingular();
 
     if ( !first.isEmpty() || !second.isEmpty() || !third_female.isEmpty() ||
             !third_male.isEmpty() || !third_neutral.isEmpty() ) {
@@ -531,12 +528,12 @@ bool KEduVocKvtml2Writer::writeConjugation( QDomElement &conjugationElement,
     }
 
     // now for plurals
-    first = conjugation.pers1Plural( tense );
-    second = conjugation.pers2Plural( tense );
-    third_common = conjugation.pers3PluralCommon( tense );
-    third_male = conjugation.pers3MalePlural( tense );
-    third_female = conjugation.pers3FemalePlural( tense );
-    third_neutral = conjugation.pers3NaturalPlural( tense );
+    first = conjugation.pers1Plural();
+    second = conjugation.pers2Plural();
+    third_common = conjugation.pers3PluralCommon();
+    third_male = conjugation.pers3MalePlural();
+    third_female = conjugation.pers3FemalePlural();
+    third_neutral = conjugation.pers3NaturalPlural();
 
     if ( !first.isEmpty() || !second.isEmpty() || !third_female.isEmpty() ||
             !third_male.isEmpty() || !third_neutral.isEmpty() ) {
diff --git a/keduvocdocument/keduvockvtmlreader.cpp b/keduvocdocument/keduvockvtmlreader.cpp
index 6f96c94..681abed 100644
--- a/keduvocdocument/keduvockvtmlreader.cpp
+++ b/keduvocdocument/keduvockvtmlreader.cpp
@@ -132,16 +132,28 @@ bool KEduVocKvtmlReader::readBody( QDomElement &domElementParent )
 
     currentElement = domElementParent.firstChildElement( KV_CONJUG_GRP );
     if ( !currentElement.isNull() ) {
-        QList<KEduVocConjugation> conjugations;
-        result = readConjug( currentElement, conjugations );
-        if ( result ) {
-            KEduVocConjugation conjug;
-            for ( int i = 0; i< conjugations.count(); i++ ) {
-                conjug = conjugations[i];
-                m_doc->identifier(i).setPersonalPronouns( conjug );
+///@todo conjugations
+        int count = 0;
+
+        QDomElement domElementConjugChild = currentElement.firstChildElement(KV_CON_ENTRY);
+        while ( !domElementConjugChild.isNull() ) {
+            QString lang;
+            QDomAttr domAttrLang = domElementConjugChild.attributeNode( KV_LANG ); // "l"
+            // make sure, the identifier is there
+            if (!addLanguage(count, domAttrLang.value())) {
+                return false;
             }
-        } else
-            return false;
+
+            KEduVocConjugation pronouns;
+            if (! readConjugation( domElementConjugChild, pronouns ) ) {
+                return false;
+            }
+            m_doc->identifier(count).setPersonalPronouns( pronouns );
+
+            count ++;
+
+            domElementConjugChild = domElementConjugChild.nextSiblingElement( KV_CON_ENTRY );
+        }
     }
 
     // initialize the list of predefined types
@@ -342,7 +354,28 @@ bool KEduVocKvtmlReader::readArticle( QDomElement &domElementParent )
 }
 
 
-bool KEduVocKvtmlReader::readConjug( QDomElement &domElementParent, QList<KEduVocConjugation> &curr_conjug )
+bool KEduVocKvtmlReader::readTranslationConjugations( QDomElement &domElementParent, KEduVocTranslation &translation ) {
+
+    QString tense;
+
+    QDomElement domElementConjugChild = domElementParent.firstChildElement(KV_CON_ENTRY);
+    while ( !domElementConjugChild.isNull() )
+    {
+        // "n" == is the type is the tense
+        QDomAttr domAttrLang = domElementConjugChild.attributeNode( KV_CON_NAME );
+        QString oldShortTense = domAttrLang.value();
+
+        tense = m_compability.tenseFromKvtml1( oldShortTense );
+        KEduVocConjugation conjugation;
+        readConjugation(domElementConjugChild, conjugation);
+        translation.setConjugation(tense, conjugation);
+
+        domElementConjugChild = domElementConjugChild.nextSiblingElement( KV_CON_ENTRY );
+    } // while -> next tense, count++
+    return true;
+}
+
+bool KEduVocKvtmlReader::readConjugation( QDomElement &domElementParent, KEduVocConjugation& conjugation )
 /*
  <conjugation>        used in header for definiton of "prefix"
   <e l="de">          lang determines also lang order in entries !!
@@ -375,7 +408,7 @@ bool KEduVocKvtmlReader::readConjug( QDomElement &domElementParent, QList<KEduVo
  </conjugation>
 */
 {
-    QString s;
+//     QString s;
     bool p3_common;
     bool s3_common;
     QString pers1_sing;
@@ -388,110 +421,48 @@ bool KEduVocKvtmlReader::readConjug( QDomElement &domElementParent, QList<KEduVo
     QString pers3_m_plur;
     QString pers3_f_plur;
     QString pers3_n_plur;
-    QString lang;
-    QString tense; // former type
-
-    // this gets a list of keduvocconjugations, count will be the conjug number to be filled.
-    int count = 0;
 
-// reset
-    curr_conjug.clear();
-// create new empty one
-    curr_conjug.append( KEduVocConjugation() );
-
-    QDomElement domElementConjugChild = domElementParent.firstChild().toElement();
-    while ( !domElementConjugChild.isNull() )
-    {
-        if ( domElementConjugChild.tagName() == KV_CON_ENTRY ) {            // if KV_CON_ENTRY == "e" is found, we are reading a personal pronun definition.
-            // CONJ_PREFIX is defined as "--"
-            tense = CONJ_PREFIX;
-
-            //----------
-            // Attribute
-
-            QString lang;
-            QDomAttr domAttrLang = domElementConjugChild.attributeNode( KV_LANG ); // "l"
-
-            if (!addLanguage(count, domAttrLang.value())) {
-                return false;
-            }
-
-        } else if ( domElementConjugChild.tagName() == KV_CON_TYPE ) {                    // this means reading translations KV_CON_TYPE == "t"
-            //----------
-            // Attribute
-
-            // "n" == is the type is the tense
-            QDomAttr domAttrLang = domElementConjugChild.attributeNode( KV_CON_NAME );
-            QString oldShortTense = domAttrLang.value();
-
-            tense = m_compability.tenseFromKvtml1( oldShortTense );
-kDebug() << "Reading conjugation for " << tense;
-        }
-
-        pers1_sing = "";
-        pers2_sing = "";
-        pers3_m_sing = "";
-        pers3_f_sing = "";
-        pers3_n_sing = "";
-        pers1_plur = "";
-        pers2_plur = "";
-        pers3_m_plur = "";
-        pers3_f_plur = "";
-        pers3_n_plur = "";
-        p3_common = false;
-        s3_common = false;
+    p3_common = false;
+    s3_common = false;
 
         // get the individual entries for persons...
-        QDomElement domElementConjugGrandChild = domElementConjugChild.firstChild().toElement();
+        QDomElement domElementConjugGrandChild = domElementParent.firstChild().toElement();
         while ( !domElementConjugGrandChild.isNull() ) {
             if ( domElementConjugGrandChild.tagName() == KV_CON_P1S ) {
                 pers1_sing = domElementConjugGrandChild.text();
-                if ( pers1_sing.isNull() )
-                    pers1_sing = "";
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P2S ) {
                 pers2_sing = domElementConjugGrandChild.text();
-                if ( pers2_sing.isNull() )
-                    pers2_sing = "";
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P3SF ) {
                 QDomAttr domAttrCommon = domElementConjugGrandChild.attributeNode( KV_CONJ_COMMON );
                 if ( !domAttrCommon.isNull() )
                     s3_common = domAttrCommon.value().toInt();  // returns 0 if the conversion fails
-
                 pers3_f_sing = domElementConjugGrandChild.text();
-                if ( pers3_f_sing.isNull() )
-                    pers3_f_sing = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P3SM ) {
                 pers3_m_sing = domElementConjugGrandChild.text();
-                if ( pers3_m_sing.isNull() )
-                    pers3_m_sing = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P3SN ) {
                 pers3_n_sing = domElementConjugGrandChild.text();
-                if ( pers3_n_sing.isNull() )
-                    pers3_n_sing = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P1P ) {
                 pers1_plur = domElementConjugGrandChild.text();
-                if ( pers1_plur.isNull() )
-                    pers1_plur = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P2P ) {
                 pers2_plur = domElementConjugGrandChild.text();
-                if ( pers2_plur.isNull() )
-                    pers2_plur = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P3PF ) {
                 QDomAttr domAttrCommon = domElementConjugGrandChild.attributeNode( KV_CONJ_COMMON );
                 if ( !domAttrCommon.isNull() )
                     p3_common = domAttrCommon.value().toInt();  // returns 0 if the conversion fails
 
                 pers3_f_plur = domElementConjugGrandChild.text();
-                if ( pers3_f_plur.isNull() )
-                    pers3_f_plur = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P3PM ) {
                 pers3_m_plur = domElementConjugGrandChild.text();
-                if ( pers3_m_plur.isNull() )
-                    pers3_m_plur = "";
+
             } else if ( domElementConjugGrandChild.tagName() == KV_CON_P3PN ) {
                 pers3_n_plur = domElementConjugGrandChild.text();
-                if ( pers3_n_plur.isNull() )
-                    pers3_n_plur = "";
+
             } else {
                 return false;
             }
@@ -505,31 +476,21 @@ kDebug() << "Reading conjugation for " << tense;
 
 
 
-        if ( domElementConjugChild.tagName() == KV_CON_ENTRY )
-            while ( count + 1 > ( int ) curr_conjug.size() )
-                curr_conjug.append( KEduVocConjugation() );
-
-        // now set the data: [count] - number of conjug?
-        // type - the tense?
-        // finally the person
-        curr_conjug[count].setPers3SingularCommon( tense, s3_common );
-        curr_conjug[count].setPers3PluralCommon( tense, p3_common );
-        curr_conjug[count].setPers1Singular( tense, pers1_sing );
-        curr_conjug[count].setPers2Singular( tense, pers2_sing );
-        curr_conjug[count].setPers3FemaleSingular( tense, pers3_f_sing );
-        curr_conjug[count].setPers3MaleSingular( tense, pers3_m_sing );
-        curr_conjug[count].setPers3NaturalSingular( tense, pers3_n_sing );
-        curr_conjug[count].setPers1Plural( tense, pers1_plur );
-        curr_conjug[count].setPers2Plural( tense, pers2_plur );
-        curr_conjug[count].setPers3FemalePlural( tense, pers3_f_plur );
-        curr_conjug[count].setPers3MalePlural( tense, pers3_m_plur );
-        curr_conjug[count].setPers3NaturalPlural( tense, pers3_n_plur );
-
-        if ( domElementConjugChild.tagName() == KV_CON_ENTRY )
-            count++;
-
-        domElementConjugChild = domElementConjugChild.nextSibling().toElement();
-    } // while -> next tense, count++
+    // now set the data: [count] - number of conjug?
+    // type - the tense?
+    // finally the person
+    conjugation.setPers3SingularCommon( s3_common );
+    conjugation.setPers3PluralCommon( p3_common );
+    conjugation.setPers1Singular( pers1_sing );
+    conjugation.setPers2Singular( pers2_sing );
+    conjugation.setPers3FemaleSingular( pers3_f_sing );
+    conjugation.setPers3MaleSingular( pers3_m_sing );
+    conjugation.setPers3NaturalSingular( pers3_n_sing );
+    conjugation.setPers1Plural( pers1_plur );
+    conjugation.setPers2Plural( pers2_plur );
+    conjugation.setPers3FemalePlural( pers3_f_plur );
+    conjugation.setPers3MalePlural( pers3_m_plur );
+    conjugation.setPers3NaturalPlural( pers3_n_plur );
 
     return true;
 }
@@ -915,7 +876,7 @@ bool KEduVocKvtmlReader::readExpression( QDomElement &domElementParent )
     QString                   antonym;
     QSet<QString>             usage;
     QString                   paraphrase;
-    QList<KEduVocConjugation> conjug;
+
     KEduVocComparison         comparison;
     KEduVocMultipleChoice     mc;
     KEduVocExpression         expr;
@@ -1027,13 +988,6 @@ bool KEduVocKvtmlReader::readExpression( QDomElement &domElementParent )
         //---------
         // Children
 
-        currentChild = currentElement.firstChildElement( KV_CONJUG_GRP );
-        if ( !currentChild.isNull() ) {
-            conjug.clear();
-            if ( !readConjug( currentChild, conjug ) )
-                return false;
-        }
-
         currentChild = currentElement.firstChildElement( KV_COMPARISON_GRP );
         if ( !currentChild.isNull() ) {
             comparison.clear();
@@ -1049,8 +1003,6 @@ bool KEduVocKvtmlReader::readExpression( QDomElement &domElementParent )
         }
 
         textstr = currentElement.lastChild().toText().data();
-        if ( textstr.isNull() )
-            textstr = "";
 
         if ( i == 0 ) {
             expr = KEduVocExpression( textstr );
@@ -1061,14 +1013,14 @@ bool KEduVocKvtmlReader::readExpression( QDomElement &domElementParent )
             expr.setTranslation( i, textstr );
         }
 
-        if ( conjug.size() > 0 ) {
-            for ( int conjugationIndex = 0; conjugationIndex < conjug.size(); conjugationIndex++ ) {
-                expr.translation( i ).setConjugation( conjug[conjugationIndex] );
+        // better make sure, translation(i) already exists...
+        currentChild = currentElement.firstChildElement( KV_CONJUG_GRP );
+        if ( !currentChild.isNull() ) {
+            if ( !readTranslationConjugations( currentChild, expr.translation(i) ) ) {
+                return false;
             }
-            //expr.setConjugation(i, conjug[0]); ///@todo check if this is better than the above!
-
-            conjug.clear();
         }
+
         if ( !comparison.isEmpty() ) {
             expr.translation( i ).setComparison( comparison );
             comparison.clear();
diff --git a/keduvocdocument/keduvockvtmlreader.h b/keduvocdocument/keduvockvtmlreader.h
index 5d9f17b..610c097 100644
--- a/keduvocdocument/keduvockvtmlreader.h
+++ b/keduvocdocument/keduvockvtmlreader.h
@@ -56,8 +56,8 @@ public:
 
     bool readLesson( QDomElement &domElementParent );
     bool readArticle( QDomElement &domElementParent );
-    bool readConjug( QDomElement &domElementParent, QList<KEduVocConjugation> &curr_conjug );
-//     bool readOptions( QDomElement &domElementParent );
+    bool readConjugation( QDomElement &domElementParent, KEduVocConjugation &conjugation );
+    bool readTranslationConjugations( QDomElement &domElementParent, KEduVocTranslation &translation );
     bool readType( QDomElement &domElementParent );
     bool readTense( QDomElement &domElementParent );
     bool readUsage( QDomElement &domElementParent );
diff --git a/keduvocdocument/keduvockvtmlwriter.cpp b/keduvocdocument/keduvockvtmlwriter.cpp
index 9fe7b17..b7fdf99 100644
--- a/keduvocdocument/keduvockvtmlwriter.cpp
+++ b/keduvocdocument/keduvockvtmlwriter.cpp
@@ -166,10 +166,13 @@ bool KEduVocKvtmlWriter::writeDoc( KEduVocDocument *doc, const QString &generato
         else
             entype = s;
 
-        if ( entype == QM_VERB && entry->translation( 0 ).conjugation().entryCount() > 0 ) {
-            KEduVocConjugation conj = entry->translation( 0 ).conjugation();
-            if ( !writeConjugEntry( domDoc, domElementOriginal, conj ) )
-                return false;
+        if ( entype == QM_VERB ) {
+                // conjugation
+            if ( !writeConjugEntry( domDoc, domElementOriginal, entry->translation( 0 )) ) {
+                    return false;
+            }
+
+
         } else if ( entype == QM_ADJ && !entry->translation( 0 ).comparison().isEmpty() ) {
             KEduVocComparison comp = entry->translation( 0 ).comparison();
             if ( !writeComparison( domDoc, domElementOriginal, comp ) )
@@ -255,10 +258,10 @@ bool KEduVocKvtmlWriter::writeDoc( KEduVocDocument *doc, const QString &generato
             else
                 entype = s;
 
-            if ( entype == QM_VERB && entry->translation( trans ).conjugation().entryCount() > 0 ) {
-                KEduVocConjugation conj = entry->translation( trans ).conjugation();
-                if ( !writeConjugEntry( domDoc, domElementTranslation, conj ) )
+            if ( entype == QM_VERB ) {
+                if ( !writeConjugEntry( domDoc, domElementTranslation, entry->translation( trans ) ) ) {
                     return false;
+                }
             }
 
             if ( entype == QM_ADJ && !entry->translation( trans ).comparison().isEmpty() ) {
@@ -635,7 +638,7 @@ bool KEduVocKvtmlWriter::writeConjugHeader( QDomDocument &domDoc, QDomElement &d
 }
 
 
-bool KEduVocKvtmlWriter::writeConjugEntry( QDomDocument &domDoc, QDomElement &domElementParent, KEduVocConjugation &curr_conjug )
+bool KEduVocKvtmlWriter::writeConjugEntry( QDomDocument &domDoc, QDomElement &domElementParent, KEduVocTranslation &translation )
 /*
  <conjugation>    in entry for definition of tenses of (irreg.) verbs
   <t n="sipa">
@@ -655,18 +658,14 @@ bool KEduVocKvtmlWriter::writeConjugEntry( QDomDocument &domDoc, QDomElement &do
 {
 
 //     curr_conjug.cleanUp();
-    if ( curr_conjug.entryCount() == 0 ) {
-        return true;
-    }
-
     QDomElement domElementConjug = domDoc.createElement( KV_CONJUG_GRP );
 
-    foreach ( QString tense, curr_conjug.tenses() ) {
+    foreach ( QString tense, translation.conjugationTenses() ) {
         QDomElement domElementType = domDoc.createElement( KV_CON_TYPE );
 
         domElementType.setAttribute( KV_CON_NAME, m_compability.oldTense(tense) );
 
-        if ( !writeConjug( domDoc, domElementType, curr_conjug, m_compability.oldTense(tense) ) )
+        if ( !writeConjug( domDoc, domElementType, translation.conjugation(tense), m_compability.oldTense(tense) ) )
             return false;
 
         domElementConjug.appendChild( domElementType );
@@ -679,87 +678,87 @@ bool KEduVocKvtmlWriter::writeConjugEntry( QDomDocument &domDoc, QDomElement &do
 
 bool KEduVocKvtmlWriter::writeConjug( QDomDocument &domDoc, QDomElement &domElementParent, const KEduVocConjugation &curr_conjug, const QString &type )
 {
-    if ( !curr_conjug.pers1Singular( type ).isEmpty() ) {
+    if ( !curr_conjug.pers1Singular().isEmpty() ) {
         QDomElement domElementP1s = domDoc.createElement( KV_CON_P1S );
-        QDomText domTextP1s = domDoc.createTextNode( curr_conjug.pers1Singular( type ) );
+        QDomText domTextP1s = domDoc.createTextNode( curr_conjug.pers1Singular() );
 
         domElementP1s.appendChild( domTextP1s );
         domElementParent.appendChild( domElementP1s );
     }
 
-    if ( !curr_conjug.pers2Singular( type ).isEmpty() ) {
+    if ( !curr_conjug.pers2Singular().isEmpty() ) {
         QDomElement domElementP2s = domDoc.createElement( KV_CON_P2S );
-        QDomText domTextP2s = domDoc.createTextNode( curr_conjug.pers2Singular( type ) );
+        QDomText domTextP2s = domDoc.createTextNode( curr_conjug.pers2Singular() );
 
         domElementP2s.appendChild( domTextP2s );
         domElementParent.appendChild( domElementP2s );
     }
 
-    if ( !curr_conjug.pers3FemaleSingular( type ).isEmpty() || curr_conjug.pers3SingularCommon( type ) ) {
+    if ( !curr_conjug.pers3FemaleSingular().isEmpty() || curr_conjug.pers3SingularCommon() ) {
         QDomElement domElementP3sf = domDoc.createElement( KV_CON_P3SF );
-        QDomText domTextP3sf = domDoc.createTextNode( curr_conjug.pers3FemaleSingular( type ) );
+        QDomText domTextP3sf = domDoc.createTextNode( curr_conjug.pers3FemaleSingular() );
 
-        if ( curr_conjug.pers3SingularCommon( type ) )
+        if ( curr_conjug.pers3SingularCommon() )
             domElementP3sf.setAttribute( KV_CONJ_COMMON, 1 );
 
         domElementP3sf.appendChild( domTextP3sf );
         domElementParent.appendChild( domElementP3sf );
     }
 
-    if ( !curr_conjug.pers3MaleSingular( type ).isEmpty() ) {
+    if ( !curr_conjug.pers3MaleSingular().isEmpty() ) {
         QDomElement domElementP3sm = domDoc.createElement( KV_CON_P3SM );
-        QDomText domTextP3sm = domDoc.createTextNode( curr_conjug.pers3MaleSingular( type ) );
+        QDomText domTextP3sm = domDoc.createTextNode( curr_conjug.pers3MaleSingular() );
 
         domElementP3sm.appendChild( domTextP3sm );
         domElementParent.appendChild( domElementP3sm );
     }
 
-    if ( !curr_conjug.pers3NaturalSingular( type ).isEmpty() ) {
+    if ( !curr_conjug.pers3NaturalSingular().isEmpty() ) {
         QDomElement domElementP3sn = domDoc.createElement( KV_CON_P3SN );
-        QDomText domTextP3sn = domDoc.createTextNode( curr_conjug.pers3NaturalSingular( type ) );
+        QDomText domTextP3sn = domDoc.createTextNode( curr_conjug.pers3NaturalSingular() );
 
         domElementP3sn.appendChild( domTextP3sn );
         domElementParent.appendChild( domElementP3sn );
     }
 
-    if ( !curr_conjug.pers1Plural( type ).isEmpty() ) {
+    if ( !curr_conjug.pers1Plural().isEmpty() ) {
         QDomElement domElementP1p = domDoc.createElement( KV_CON_P1P );
-        QDomText domTextP1p = domDoc.createTextNode( curr_conjug.pers1Plural( type ) );
+        QDomText domTextP1p = domDoc.createTextNode( curr_conjug.pers1Plural() );
 
         domElementP1p.appendChild( domTextP1p );
         domElementParent.appendChild( domElementP1p );
     }
 
-    if ( !curr_conjug.pers2Plural( type ).isEmpty() ) {
+    if ( !curr_conjug.pers2Plural().isEmpty() ) {
         QDomElement domElementP2p = domDoc.createElement( KV_CON_P2P );
-        QDomText domTextP2p = domDoc.createTextNode( curr_conjug.pers2Plural( type ) );
+        QDomText domTextP2p = domDoc.createTextNode( curr_conjug.pers2Plural() );
 
         domElementP2p.appendChild( domTextP2p );
         domElementParent.appendChild( domElementP2p );
     }
 
-    if ( !curr_conjug.pers3FemalePlural( type ).isEmpty() || curr_conjug.pers3PluralCommon( type ) ) {
+    if ( !curr_conjug.pers3FemalePlural().isEmpty() || curr_conjug.pers3PluralCommon() ) {
         QDomElement domElementP3pf = domDoc.createElement( KV_CON_P3PF );
-        QDomText domTextP3pf = domDoc.createTextNode( curr_conjug.pers3FemalePlural( type ) );
+        QDomText domTextP3pf = domDoc.createTextNode( curr_conjug.pers3FemalePlural() );
 
-        if ( curr_conjug.pers3PluralCommon( type ) )
+        if ( curr_conjug.pers3PluralCommon() )
             domElementP3pf.setAttribute( KV_CONJ_COMMON, 1 );
 
         domElementP3pf.appendChild( domTextP3pf );
         domElementParent.appendChild( domElementP3pf );
     }
 
-    if ( !curr_conjug.pers3MalePlural( type ).isEmpty() ) {
+    if ( !curr_conjug.pers3MalePlural().isEmpty() ) {
         QDomElement domElementP3pm = domDoc.createElement( KV_CON_P3PM );
-        QDomText domTextP3pm = domDoc.createTextNode( curr_conjug.pers3MalePlural( type ) );
+        QDomText domTextP3pm = domDoc.createTextNode( curr_conjug.pers3MalePlural() );
 
         domElementP3pm.appendChild( domTextP3pm );
         domElementParent.appendChild( domElementP3pm );
     }
 
-    if ( !curr_conjug.pers3NaturalPlural( type ).isEmpty() ) {
+    if ( !curr_conjug.pers3NaturalPlural().isEmpty() ) {
         QDomElement domElementP3pn = domDoc.createElement( KV_CON_P3PN );
-        QDomText domTextP3pn = domDoc.createTextNode( curr_conjug.pers3NaturalPlural( type ) );
+        QDomText domTextP3pn = domDoc.createTextNode( curr_conjug.pers3NaturalPlural() );
 
         domElementP3pn.appendChild( domTextP3pn );
         domElementParent.appendChild( domElementP3pn );
diff --git a/keduvocdocument/keduvockvtmlwriter.h b/keduvocdocument/keduvockvtmlwriter.h
index 585316c..bf2704f 100644
--- a/keduvocdocument/keduvockvtmlwriter.h
+++ b/keduvocdocument/keduvockvtmlwriter.h
@@ -28,6 +28,7 @@
 #include "keduvocconjugation.h"
 #include "keduvocmultiplechoice.h"
 #include "keduvockvtmlcompability.h"
+#include "keduvoctranslation.h"
 
 class KEduVocDocument;
 
@@ -49,7 +50,7 @@ public:
     bool writeArticle( QDomDocument &domDoc, QDomElement &domElementParent );
     bool writeConjugHeader( QDomDocument &domDoc, QDomElement &domElementParent, QList<KEduVocConjugation> &curr_conjug );
     bool writeConjug( QDomDocument &domDoc, QDomElement &domElementParent, const KEduVocConjugation &curr_conjug, const QString &type );
-    bool writeConjugEntry( QDomDocument &domDoc, QDomElement &domElementParent, KEduVocConjugation &curr_conjug );
+    bool writeConjugEntry( QDomDocument &domDoc, QDomElement &domElementParent, KEduVocTranslation &translation  );
     bool writeComparison( QDomDocument &domDoc, QDomElement &domElementParent, const KEduVocComparison &comp );
     bool writeMultipleChoice( QDomDocument &domDoc, QDomElement &domElementParent, const KEduVocMultipleChoice &mc );
 
diff --git a/keduvocdocument/keduvoctranslation.cpp b/keduvocdocument/keduvoctranslation.cpp
index d4df09c..e1d6c18 100644
--- a/keduvocdocument/keduvoctranslation.cpp
+++ b/keduvocdocument/keduvoctranslation.cpp
@@ -52,7 +52,7 @@ public:
     QString m_pronunciation;
     QSet<QString> m_usages;
 
-    KEduVocConjugation m_conjugation;
+    QMap <QString, KEduVocConjugation> m_conjugations;
 
     KEduVocComparison m_comparison;
 
@@ -89,7 +89,7 @@ bool KEduVocTranslation::KEduVocTranslationPrivate::operator== ( const KEduVocTr
             m_example == other.m_example &&
             m_antonym == other.m_antonym &&
             m_pronunciation == other.m_pronunciation &&
-            m_conjugation == other.m_conjugation &&
+            m_conjugations == other.m_conjugations &&
             m_comparison == other.m_comparison &&
             m_multipleChoice == other.m_multipleChoice &&
             m_grades.keys() == other.m_grades.keys() &&
@@ -120,7 +120,7 @@ KEduVocTranslation::KEduVocTranslation( const KEduVocTranslation &other ) : d( n
     d->m_example = other.d->m_example;
     d->m_antonym = other.d->m_antonym;
     d->m_pronunciation = other.d->m_pronunciation;
-    d->m_conjugation = other.d->m_conjugation;
+    d->m_conjugations = other.d->m_conjugations;
     d->m_comparison = other.d->m_comparison;
     d->m_multipleChoice = other.d->m_multipleChoice;
     d->m_grades = other.d->m_grades;
@@ -228,15 +228,15 @@ QString KEduVocTranslation::antonym() const
 }
 
 
-void KEduVocTranslation::setConjugation( const KEduVocConjugation &con )
+void KEduVocTranslation::setConjugation( const QString& tense, const KEduVocConjugation& con )
 {
-    d->m_conjugation = con;
+    d->m_conjugations[tense] = con;
 }
 
 
-KEduVocConjugation KEduVocTranslation::conjugation() const
+KEduVocConjugation& KEduVocTranslation::conjugation( const QString& tense )
 {
-    return d->m_conjugation;
+    return d->m_conjugations[tense];
 }
 
 
@@ -355,3 +355,18 @@ KEduVocGrade & KEduVocTranslation::gradeFrom( int indexFrom )
     return d->m_grades[indexFrom];
 }
 
+QStringList KEduVocTranslation::conjugationTenses() const
+{
+    return d->m_conjugations.keys();
+}
+
+QMap< QString, KEduVocConjugation > KEduVocTranslation::conjugations() const
+{
+    return d->m_conjugations;
+}
+
+void KEduVocTranslation::setConjugations(const QMap< QString, KEduVocConjugation > & conjugations)
+{
+    d->m_conjugations = conjugations;
+}
+
diff --git a/keduvocdocument/keduvoctranslation.h b/keduvocdocument/keduvoctranslation.h
index 705559a..9747c97 100644
--- a/keduvocdocument/keduvoctranslation.h
+++ b/keduvocdocument/keduvoctranslation.h
@@ -181,14 +181,28 @@ public:
     */
     KEduVocGrade & gradeFrom( int indexFrom );
 
-    /** returns conjugations if available
+    /** returns a conjugation if available
     */
-    KEduVocConjugation conjugation() const;
+    KEduVocConjugation& conjugation( const QString& tense );
 
-    /** sets conjugations
-    * @param conjugation      conjugation block
+    /** adds conjugations or replaces them, if they exist.
+    * @param conjugation      conjugation
     */
-    void setConjugation( const KEduVocConjugation & conjugation );
+    void setConjugation( const QString& tense, const KEduVocConjugation & conjugation );
+
+    /**
+     * Bad, only used for tense entry page, will be deleted later. Deprecated.
+     * @param conjugation
+     */
+    void setConjugations( const QMap<QString, KEduVocConjugation>& conjugations );
+
+    QStringList conjugationTenses() const;
+
+    /**
+     * Bad, only compability. Deprecated.
+     * @return
+     */
+    QMap <QString, KEduVocConjugation> conjugations() const;
 
     /** returns comparison if available
      */