Cleanup

svn path=/trunk/KDE/kdeedu/libkdeedu/; revision=637816

diff --git a/kdeeducore/keduvocgrammar.cpp b/kdeeducore/keduvocgrammar.cpp
index d90f8d82cb6a2dcb53efcd6d7f4cbbeb559f7c42..e3b2c623c73762c8fa8b963685e6aefb42d5ef68 100644 (file)
--- a/kdeeducore/keduvocgrammar.cpp
+++ b/kdeeducore/keduvocgrammar.cpp
@@ -4,11 +4,11 @@
 
     -----------------------------------------------------------------------
 
-    begin         : Sat Nov 27 09:50:53 MET 1999
+    begin     : Sat Nov 27 09:50:53 MET 1999
 
-    copyright     : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
-                    (C) 2001 The KDE-EDU team
-                    (C) 2004-2005 Peter Hedlund <peter.hedlund@kdemail.net>
+    copyright : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
+                (C) 2001 The KDE-EDU team
+                (C) 2004, 2005, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
 
     -----------------------------------------------------------------------
 
@@ -47,23 +47,17 @@ QStringList KEduVocConjugation::userTenses;
 
 //================================================================
 
-KEduVocComparison::KEduVocComparison (
-           const QString &l1,
-           const QString &l2,
-           const QString &l3
-          )
+KEduVocComparison::KEduVocComparison(const QString &l1, const QString &l2, const QString &l3)
 {
-  setL1 (l1);
-  setL2 (l2);
-  setL3 (l3);
+  setL1(l1);
+  setL2(l2);
+  setL3(l3);
 }
 
 
 bool KEduVocComparison::isEmpty() const
 {
-  return   ls1.simplified().isEmpty()
-        && ls2.simplified().isEmpty()
-        && ls3.simplified().isEmpty();
+  return   ls1.simplified().isEmpty() && ls2.simplified().isEmpty() && ls3.simplified().isEmpty();
 }
 
 
@@ -74,23 +68,19 @@ void KEduVocComparison::clear()
   ls3 = "";
 }
 
-bool KEduVocComparison::operator ==( const KEduVocComparison& a ) const
+bool KEduVocComparison::operator ==(const KEduVocComparison& a) const
 {
-       if ( ls1 == a.l1() && ls2 == a.l2() && ls3 == a.l3() )
-               return true;
-       else
-               return false;
+  if (ls1 == a.l1() && ls2 == a.l2() && ls3 == a.l3())
+    return true;
+  else
+  return false;
 }
 
 
 //=================================================================
 
 
-KEduVocArticle::KEduVocArticle
-          (const QString &fem_def, const QString &fem_indef,
-           const QString &mal_def, const QString &mal_indef,
-           const QString &nat_def, const QString &nat_indef
-          )
+KEduVocArticle::KEduVocArticle(const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &nat_def, const QString &nat_indef)
 {
   setFemale  (fem_def, fem_indef);
   setMale    (mal_def, mal_indef);
@@ -144,20 +134,20 @@ void KEduVocArticle::natural(QString &def, QString &indef) const
 //==============================================================
 
 
-bool KEduVocConjugation::operator ==( const KEduVocConjugation& a ) const
+bool KEduVocConjugation::operator ==(const KEduVocConjugation& a) const
 {
-       return verbName == a.getVerbName();
+  return verbName == a.getVerbName();
 }
 
 
 const QString& KEduVocConjugation::getVerbName() const
 {
-       return verbName;
+  return verbName;
 }
 
 int KEduVocConjugation::numEntries() const
 {
-  return conjugations.size();
+  return conjugations.count();
 }
 
 
@@ -169,10 +159,10 @@ QList<KEduVocTenseRelation> KEduVocConjugation::getRelation ()
     vec.append(KEduVocTenseRelation(names[i].abbrev, i18n(names[i].name)));
   }
 
-  for (int i = 0; i < userTenses.size(); i++) {
+  for (int i = 0; i < userTenses.count(); i++) {
     QString s;
-    s.setNum(i+1);
-    s.insert(0, UL_USER_TENSE);
+    s.setNum(i + 1);
+    s.prepend(UL_USER_TENSE);
     vec.append(KEduVocTenseRelation(s, userTenses[i]));
   }
 
@@ -180,26 +170,26 @@ QList<KEduVocTenseRelation> KEduVocConjugation::getRelation ()
 }
 
 
-void KEduVocConjugation::setTenseNames (const QStringList& names)
+void KEduVocConjugation::setTenseNames(const QStringList& names)
 {
   userTenses = names;
 }
 
 
-QString KEduVocConjugation::getName (const QString &abbrev)
+QString KEduVocConjugation::getName(const QString &abbrev)
 {
   if (abbrev.length() >= 2 && QString(abbrev[0]) == QString(UL_USER_TENSE)) {
     QString s = abbrev;
     s.remove(0, 1);
     int i = s.toInt() - 1;
 
-    if (i < (int) userTenses.size() )
+    if (i < userTenses.count() )
       return userTenses[i];
     else
       return "";
   }
   else {
-    for (int i = 0; i < (int) numInternalNames(); i++)
+    for (int i = 0; i < numInternalNames(); i++)
       if (names[i].abbrev == abbrev) {
         return i18n(names[i].name);
       }
@@ -209,30 +199,28 @@ QString KEduVocConjugation::getName (const QString &abbrev)
 }
 
 
-QString KEduVocConjugation::getName (int idx)
+QString KEduVocConjugation::getName(int idx)
 {
-  if (idx < numInternalNames() )
+  if (idx < numInternalNames())
     return i18n(names[idx].name);
-
   else if (idx < numTenses() )
     return userTenses[idx-numInternalNames()];
-
   else
     return "";
 }
 
 
-QString KEduVocConjugation::getAbbrev (const QString &name)
+QString KEduVocConjugation::getAbbrev(const QString &name)
 {
-  for (int i = 0; i < (int) userTenses.size(); i++)
+  for (int i = 0; i < userTenses.count(); i++)
     if (userTenses[i] == name) {
       QString s;
-      s.setNum(i+1);
-      s.insert(0, UL_USER_TENSE);
+      s.setNum(i + 1);
+      s.prepend(UL_USER_TENSE);
       return s;
     }
 
-  for (int i = 0; i < (int) numInternalNames(); i++)
+  for (int i = 0; i < numInternalNames(); i++)
     if (names[i].name == name)
       return names[i].abbrev;
 
@@ -240,15 +228,15 @@ QString KEduVocConjugation::getAbbrev (const QString &name)
 }
 
 
-QString KEduVocConjugation::getAbbrev (int idx)
+QString KEduVocConjugation::getAbbrev(int idx)
 {
   if (idx < numInternalNames() )
     return names[idx].abbrev;
 
   else if (idx < numTenses() ) {
     QString s;
-    s.setNum(idx-numInternalNames()+1);
-    s.insert(0, UL_USER_TENSE);
+    s.setNum(idx - numInternalNames() + 1);
+    s.prepend(UL_USER_TENSE);
     return s;
   }
 
@@ -265,31 +253,31 @@ int KEduVocConjugation::numInternalNames()
 
 int KEduVocConjugation::numTenses()
 {
-  return numInternalNames()+userTenses.size();
+  return numInternalNames() + userTenses.size();
 }
 
 
-QString KEduVocConjugation::getType (int idx)
+QString KEduVocConjugation::getType(int idx)
 {
-  if (idx >= (int) conjugations.size() )
+  if (idx >= conjugations.count())
     return "";
 
   return conjugations[idx].type;
 }
 
 
-void KEduVocConjugation::setType (int idx, const QString & type)
+void KEduVocConjugation::setType(int idx, const QString & type)
 {
-  if (idx >= (int) conjugations.size() )
+  if (idx >= (int) conjugations.size())
     return;
 
   conjugations[idx].type = type;
 }
 
 
-void KEduVocConjugation::cleanUp ()
+void KEduVocConjugation::cleanUp()
 {
-  for (int i = (int)conjugations.size()-1; i >= 0; i--) {
+  for (int i = conjugations.count() - 1; i >= 0; i--) {
     const conjug_t *ctp = &conjugations[i];
     if (   ctp->pers1_sing.simplified().isEmpty()
         && ctp->pers2_sing.simplified().isEmpty()
@@ -302,14 +290,14 @@ void KEduVocConjugation::cleanUp ()
         && ctp->pers3_f_plur.simplified().isEmpty()
         && ctp->pers3_n_plur.simplified().isEmpty()
        )
-     conjugations.removeAt( i );
+     conjugations.removeAt(i);
   }
 }
 
 
-bool KEduVocConjugation::isEmpty (int idx)
+bool KEduVocConjugation::isEmpty(int idx)
 {
-  if (idx < (int) conjugations.size()) {
+  if (idx < conjugations.count()) {
     const conjug_t *ctp = &conjugations[idx];
     return ctp->pers1_sing.simplified().isEmpty()
         && ctp->pers2_sing.simplified().isEmpty()
@@ -345,71 +333,61 @@ bool KEduVocConjugation::pers3PluralCommon(const QString &type) const
 }
 
 
-QString KEduVocConjugation::pers1Singular
-  (const QString &type) const
+QString KEduVocConjugation::pers1Singular(const QString &type) const
 {
   _GET_CON_(pers1_sing, type, "");
 }
 
 
-QString KEduVocConjugation::pers2Singular
-  (const QString &type) const
+QString KEduVocConjugation::pers2Singular(const QString &type) const
 {
   _GET_CON_(pers2_sing, type, "");
 }
 
 
-QString KEduVocConjugation::pers3FemaleSingular
-  (const QString &type) const
+QString KEduVocConjugation::pers3FemaleSingular(const QString &type) const
 {
   _GET_CON_(pers3_f_sing, type, "");
 }
 
 
-QString KEduVocConjugation::pers3MaleSingular
-  (const QString &type) const
+QString KEduVocConjugation::pers3MaleSingular(const QString &type) const
 {
   _GET_CON_(pers3_m_sing, type, "");
 }
 
 
-QString KEduVocConjugation::pers3NaturalSingular
-  (const QString &type) const
+QString KEduVocConjugation::pers3NaturalSingular(const QString &type) const
 {
   _GET_CON_(pers3_n_sing, type, "");
 }
 
 
-QString KEduVocConjugation::pers1Plural
-  (const QString &type) const
+QString KEduVocConjugation::pers1Plural(const QString &type) const
 {
   _GET_CON_(pers1_plur, type, "");
 }
 
 
-QString KEduVocConjugation::pers2Plural
-  (const QString &type) const
+QString KEduVocConjugation::pers2Plural(const QString &type) const
 {
   _GET_CON_(pers2_plur, type, "");
 }
 
 
-QString KEduVocConjugation::pers3FemalePlural
-  (const QString &type) const
+QString KEduVocConjugation::pers3FemalePlural(const QString &type) const
 {
   _GET_CON_(pers3_f_plur, type, "");
 }
 
 
-QString KEduVocConjugation::pers3MalePlural
-  (const QString &type) const
+QString KEduVocConjugation::pers3MalePlural(const QString &type) const
 {
   _GET_CON_(pers3_m_plur, type, "");
 }
 
 
-QString KEduVocConjugation::pers3NaturalPlural
-  (const QString &type) const
+QString KEduVocConjugation::pers3NaturalPlural(const QString &type) const
 {
   _GET_CON_(pers3_n_plur, type, "");
 }
@@ -442,74 +420,63 @@ void KEduVocConjugation::setPers3SingularCommon(const QString &type, bool f)
 }
 
 
-void KEduVocConjugation::setPers1Singular
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers1Singular(const QString &type, const QString &str)
 {
   _SET_CON_(pers1_sing, type, str);
 }
 
 
-void KEduVocConjugation::setPers2Singular
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers2Singular(const QString &type, const QString &str)
 {
   _SET_CON_(pers2_sing, type, str);
 }
 
 
-void KEduVocConjugation::setPers3FemaleSingular
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers3FemaleSingular(const QString &type, const QString &str)
 {
   _SET_CON_(pers3_f_sing, type, str);
 }
 
 
-void KEduVocConjugation::setPers3MaleSingular
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers3MaleSingular(const QString &type, const QString &str)
 {
   _SET_CON_(pers3_m_sing, type, str);
 }
 
 
-void KEduVocConjugation::setPers3NaturalSingular
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers3NaturalSingular(const QString &type, const QString &str)
 {
   _SET_CON_(pers3_n_sing, type, str);
 }
 
 
-void KEduVocConjugation::setPers1Plural
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers1Plural(const QString &type, const QString &str)
 {
   _SET_CON_(pers1_plur, type, str);
 }
 
 
-void KEduVocConjugation::setPers2Plural
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers2Plural(const QString &type, const QString &str)
 {
   _SET_CON_(pers2_plur, type, str);
 }
 
 
-void KEduVocConjugation::setPers3FemalePlural
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers3FemalePlural(const QString &type, const QString &str)
 {
   _SET_CON_(pers3_f_plur, type, str);
 }
 
 
-void KEduVocConjugation::setPers3MalePlural
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers3MalePlural(const QString &type, const QString &str)
 {
   _SET_CON_(pers3_m_plur, type, str);
 }
 
 
-void KEduVocConjugation::setPers3NaturalPlural
-  (const QString &type, const QString &str)
+void KEduVocConjugation::setPers3NaturalPlural(const QString &type, const QString &str)
 {
   _SET_CON_(pers3_n_plur, type, str);
 }
 
 #undef _SET_CON_
-

diff --git a/kdeeducore/keduvocgrammar.h b/kdeeducore/keduvocgrammar.h
index f7d167f29205b095c633cf6f995253634e788f78..699542498dd508a109733f2bced338f2ad2075a1 100644 (file)
--- a/kdeeducore/keduvocgrammar.h
+++ b/kdeeducore/keduvocgrammar.h
@@ -4,11 +4,11 @@
 
     -----------------------------------------------------------------------
 
-    begin          : Sat Nov 27 09:50:53 MET 1999
+    begin        : Sat Nov 27 09:50:53 MET 1999
 
-    copyright      : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
-                     (C) 2001 The KDE-EDU team
-                     (C) 2005 Peter Hedlund <peter.hedlund@kdemail.net>
+    copyright    : (C) 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
+                   (C) 2001 The KDE-EDU team
+                   (C) 2005, 2007 Peter Hedlund <peter.hedlund@kdemail.net>
 
     -----------------------------------------------------------------------
 
@@ -23,7 +23,6 @@
  *                                                                         *
  ***************************************************************************/
 
-
 #ifndef grammarmanager_included
 #define grammarmanager_included
 
@@ -56,7 +55,6 @@
 
 class KDEEDUCORE_EXPORT KEduVocArticle
 {
-
 public:
 
   /**
@@ -73,45 +71,45 @@ public:
    * @param nat_def reference to a QString with the definite neutral article
    * @param nat_indef reference to a QString with the indefinite neutral article
    */
-  KEduVocArticle ( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef,
-               const QString &nat_def, const QString &nat_indef );
+  KEduVocArticle( const QString &fem_def, const QString &fem_indef, const QString &mal_def, const QString &mal_indef, const QString &nat_def, const QString &nat_indef );
 
   /**
    * Sets the female articles
    * @param def const reference to a QString with the definite female article
    * @param indef const reference to a QString with the indefinite female article
    */
-  void setFemale  (const QString &def, const QString &indef);
+  void setFemale(const QString &def, const QString &indef);
 
   /**
    * Sets the male articles
    * @param def const reference to a QString with the definite male article
    * @param indef const reference to a QString with the indefinite male article
    */
-  void setMale    (const QString &def, const QString &indef);
+  void setMale(const QString &def, const QString &indef);
 
   /**
    * Sets the neutral articles
    * @param def const reference to a QString with the definite neutral article
    * @param indef const reference to a QString with the indefinite neutral article
    */
-  void setNatural (const QString &def, const QString &indef);
+  void setNatural(const QString &def, const QString &indef);
 
   void female  (QString &def, QString &indef) const;
   void male    (QString &def, QString &indef) const;
   void natural (QString &def, QString &indef) const;
 
-protected:
-
-  QString fem_def, fem_indef,
-          mal_def, mal_indef,
-          nat_def, nat_indef;
+private:
+  QString fem_def;
+  QString fem_indef;
+  QString mal_def;
+  QString mal_indef;
+  QString nat_def;
+  QString nat_indef;
 };
 
 
 class KDEEDUCORE_EXPORT KEduVocComparison
 {
-
 public:
 
   /**
@@ -125,24 +123,25 @@ public:
    * @param l2
    * @param l3
    */
-  KEduVocComparison ( const QString &l1, const QString &l2, const QString &l3 );
+  KEduVocComparison(const QString &l1, const QString &l2, const QString &l3);
 
-  void setL1 (const QString &s) { ls1 = s; }
-  void setL2 (const QString &s) { ls2 = s; }
-  void setL3 (const QString &s) { ls3 = s; }
+  void setL1(const QString &s) { ls1 = s; }
+  void setL2(const QString &s) { ls2 = s; }
+  void setL3(const QString &s) { ls3 = s; }
 
-  QString l1 () const { return ls1; }
-  QString l2 () const { return ls2; }
-  QString l3 () const { return ls3; }
+  QString l1() const { return ls1; }
+  QString l2() const { return ls2; }
+  QString l3() const { return ls3; }
 
   bool isEmpty() const;
   void clear();
 
-  bool operator == ( const KEduVocComparison& a ) const;
-
-protected:
+  bool operator == (const KEduVocComparison& a) const;
 
-  QString  ls1, ls2, ls3;
+private:
+  QString ls1;
+  QString ls2;
+  QString ls3;
 };
 
 
@@ -155,9 +154,9 @@ public:
   inline QString shortStr() const { return shortId; }
   inline QString longStr()  const { return longId;  }
 
-protected:
-
-  QString  shortId, longId;
+private:
+  QString shortId;
+  QString longId;
 };
 
 /**
@@ -165,13 +164,12 @@ protected:
  */
 class KDEEDUCORE_EXPORT KEduVocConjugation
 {
-
 public:
 
   /**
    * The constructor
    */
-  KEduVocConjugation () {}
+  KEduVocConjugation() {}
 
   /**
    * @return
@@ -181,26 +179,26 @@ public:
   /**
    * @return 
    */
-  static QList<KEduVocTenseRelation> getRelation ();
+  static QList<KEduVocTenseRelation> getRelation();
 
   /**
    * @param names
    */
-  static void setTenseNames (const QStringList& names);
+  static void setTenseNames(const QStringList& names);
 
-  static QString getName (const QString &abbrev);
-  static QString getName (int index);
-  static QString getAbbrev (const QString &name);
-  static QString getAbbrev (int index);
+  static QString getName(const QString &abbrev);
+  static QString getName(int index);
+  static QString getAbbrev(const QString &name);
+  static QString getAbbrev(int index);
   static int numInternalNames();
   static int numTenses();
 
   const QString& getVerbName() const;
-  
-  QString getType (int index);
-  void setType (int index, const QString & type);
+
+  QString getType(int index);
+  void setType(int index, const QString & type);
   void cleanUp();
-  bool isEmpty (int idx);
+  bool isEmpty(int idx);
 
   QString pers1Singular(const QString &type) const;
   QString pers2Singular(const QString &type) const;
@@ -230,18 +228,18 @@ public:
   void setPers3MalePlural(const QString &type, const QString &str);
   void setPers3NaturalPlural(const QString &type, const QString &str);
 
-  bool operator == ( const KEduVocConjugation& a ) const;
+  bool operator == (const KEduVocConjugation& a) const;
 
 private:
-  QString verbName;    // added to have something to compare in operator ==, assumes that there is always only one
-                       // KEduVocConjugation per verb
+  QString verbName; // added to have something to compare in operator ==, assumes that there is always only one
+                    // KEduVocConjugation per verb
 
   struct conjug_name_t
   {
     const char *abbrev;
     const char *name;
   };
-  
+
   struct conjug_t
   {
      conjug_t() {
@@ -250,28 +248,25 @@ private:
      }
 
      QString type;
-     bool    p3common,
-             s3common;
-     QString 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;
+     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;
   };
 
-protected:
   typedef QList<conjug_t> conjug_tList;
   conjug_tList conjugations;
 
-  static conjug_name_t names [];
+  static conjug_name_t names[];
   static QStringList userTenses;
 };
 
-
 #endif // grammarmanager_included
-