adapt qmvocwordtype.cpp for querymee

diff --git a/qmvocwordtype.cpp b/qmvocwordtype.cpp
index 8539baddf408148c0cbe8047db98527bb61b3b97..d485a4af3e72962f2a716a835dca42863d478dcc 100644 (file)
--- a/qmvocwordtype.cpp
+++ b/qmvocwordtype.cpp
@@ -1,7 +1,12 @@
+/***************************************************************************
+*   this file is from kdeedu project. Filename: keduvocwordtype.cpp
+***************************************************************************/
+
 /***************************************************************************
 
     Copyright 2007 Jeremy Whiting <jpwhiting@kde.org>
     Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+    Copyright (C) 2010, 2012 Reto Zingg <g.d0b3rm4n@gmail.com>
 
  ***************************************************************************/
 
@@ -14,36 +19,36 @@
  *                                                                         *
  ***************************************************************************/
 
-#include "keduvocwordtype.h"
+#include "qmvocwordtype.h"
 
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
 
 #include <QtCore/QList>
 #include <QtCore/QSet>
 
-class KEduVocWordType::Private
+class QmVocWordType::Private
 {
 public:
     // bitvector of word type flags
-    KEduVocWordFlags m_flags;
-    QList<KEduVocExpression*> m_expressions;
+    QmVocWordFlags m_flags;
+    QList<QmVocExpression*> m_expressions;
     // list of translations
-    QList<KEduVocTranslation*> m_translations;
+    QList<QmVocTranslation*> m_translations;
 };
 
-KEduVocWordType::KEduVocWordType(const QString& name, KEduVocWordType *parent)
-        : KEduVocContainer(name, WordType, parent), d( new Private )
+QmVocWordType::QmVocWordType(const QString& name, QmVocWordType *parent)
+        : QmVocContainer(name, WordType, parent), d( new Private )
 {}
 
-KEduVocWordType::~KEduVocWordType()
+QmVocWordType::~QmVocWordType()
 {
-    foreach(KEduVocTranslation* translation, d->m_translations) {
+    foreach(QmVocTranslation* translation, d->m_translations) {
         translation->setWordType(0);
     }
     delete d;
 }
 
-QList<KEduVocExpression*> KEduVocWordType::entries(EnumEntriesRecursive recursive)
+QList<QmVocExpression*> QmVocWordType::entries(EnumEntriesRecursive recursive)
 {
     if (recursive == Recursive) {
         return entriesRecursive();
@@ -52,7 +57,7 @@ QList<KEduVocExpression*> KEduVocWordType::entries(EnumEntriesRecursive recursiv
     return d->m_expressions;
 }
 
-int KEduVocWordType::entryCount(EnumEntriesRecursive recursive)
+int QmVocWordType::entryCount(EnumEntriesRecursive recursive)
 {
     if (recursive == Recursive) {
         return entriesRecursive().count();
@@ -60,7 +65,7 @@ int KEduVocWordType::entryCount(EnumEntriesRecursive recursive)
     return d->m_expressions.count();
 }
 
-void KEduVocWordType::addTranslation(KEduVocTranslation* translation)
+void QmVocWordType::addTranslation(QmVocTranslation* translation)
 {
     // add to expression - if not already there because another translation of the same word is there.
     bool found = false;
@@ -77,7 +82,7 @@ void KEduVocWordType::addTranslation(KEduVocTranslation* translation)
     invalidateChildLessonEntries();
 }
 
-void KEduVocWordType::removeTranslation(KEduVocTranslation* translation)
+void QmVocWordType::removeTranslation(QmVocTranslation* translation)
 {
     d->m_translations.removeAt( d->m_translations.indexOf(translation) );
 
@@ -104,13 +109,13 @@ void KEduVocWordType::removeTranslation(KEduVocTranslation* translation)
     invalidateChildLessonEntries();
 }
 
-KEduVocTranslation * KEduVocWordType::translation(int row)
+QmVocTranslation * QmVocWordType::translation(int row)
 {
 
     return d->m_translations.value(row);
 }
 
-KEduVocExpression * KEduVocWordType::entry(int row, EnumEntriesRecursive recursive)
+QmVocExpression * QmVocWordType::entry(int row, EnumEntriesRecursive recursive)
 {
     if (recursive == Recursive) {
         return entriesRecursive().value(row);
@@ -118,23 +123,23 @@ KEduVocExpression * KEduVocWordType::entry(int row, EnumEntriesRecursive recursi
     return entries().value(row);
 }
 
-KEduVocWordFlags KEduVocWordType::wordType() const
+QmVocWordFlags QmVocWordType::wordType() const
 {
     return d->m_flags;
 }
 
-void KEduVocWordType::setWordType(KEduVocWordFlags flags)
+void QmVocWordType::setWordType(QmVocWordFlags flags)
 {
     d->m_flags = flags;
 }
 
-KEduVocWordType* KEduVocWordType::childOfType(const KEduVocWordFlags& flags)
+QmVocWordType* QmVocWordType::childOfType(const QmVocWordFlags& flags)
 {
     if(d->m_flags == flags) {
         return this;
     }
-    foreach(KEduVocContainer* child, childContainers()) {
-        KEduVocWordType* result = static_cast<KEduVocWordType*>(child)->childOfType(flags);
+    foreach(QmVocContainer* child, childContainers()) {
+        QmVocWordType* result = static_cast<QmVocWordType*>(child)->childOfType(flags);
         if(result) {
             return result;
         }