adapt qmvoccontainer.cpp for querymee

diff --git a/qmvoccontainer.cpp b/qmvoccontainer.cpp
index ded54104b631cdc50500a2d390807c132f492193..904a3f8e037b21e0c8a2aeffd9f7f46a1449801c 100644 (file)
--- a/qmvoccontainer.cpp
+++ b/qmvoccontainer.cpp
@@ -1,7 +1,12 @@
+/***************************************************************************
+*   this file is from kdeedu project. Filename: keduvoccontainer.cpp
+***************************************************************************/
+
 /***************************************************************************
 
     Copyright 2007 Jeremy Whiting <jpwhiting@kde.org>
     Copyright 2007 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
+    Copyright 2010, 2012 Reto Zingg <g.d0b3rm4n@gmail.com>
 
  ***************************************************************************/
 
@@ -14,15 +19,16 @@
  *                                                                         *
  ***************************************************************************/
 
-#include "keduvoccontainer.h"
+#include "qmvoccontainer.h"
 
-#include "keduvocexpression.h"
+#include "qmvocexpression.h"
 
-#include <KDebug>
+// #include <KDebug>
 #include <QList>
+#include <QtDebug>
 
 /** private class to store information about a lesson */
-class KEduVocContainer::Private
+class QmVocContainer::Private
 {
 public:
     ~Private();
@@ -32,24 +38,24 @@ public:
     bool m_inPractice;
 
     // other lessons in the tree
-    KEduVocContainer *m_parentContainer;
-    QList < KEduVocContainer * > m_childContainers;
+    QmVocContainer *m_parentContainer;
+    QList < QmVocContainer * > m_childContainers;
 
     EnumContainerType m_type;
 
-    QList < KEduVocExpression* > m_childLessonEntries;
+    QList < QmVocExpression* > m_childLessonEntries;
     bool m_childLessonEntriesValid;
 
     /// Image url
-    KUrl m_imageUrl;
+    QUrl m_imageUrl;
 };
 
-KEduVocContainer::Private::~Private()
+QmVocContainer::Private::~Private()
 {
     qDeleteAll(m_childContainers);
 }
 
-KEduVocContainer::KEduVocContainer(const QString& name, EnumContainerType type, KEduVocContainer *parent)
+QmVocContainer::QmVocContainer(const QString& name, EnumContainerType type, QmVocContainer *parent)
         : d( new Private )
 {
     d->m_parentContainer = parent;
@@ -59,7 +65,7 @@ KEduVocContainer::KEduVocContainer(const QString& name, EnumContainerType type,
     d->m_childLessonEntriesValid = false;
 }
 
-KEduVocContainer::KEduVocContainer( const KEduVocContainer &other )
+QmVocContainer::QmVocContainer( const QmVocContainer &other )
         : d( new Private )
 {
     d->m_name = other.d->m_name;
@@ -69,12 +75,12 @@ KEduVocContainer::KEduVocContainer( const KEduVocContainer &other )
     d->m_childLessonEntriesValid = false;
 }
 
-KEduVocContainer::~KEduVocContainer()
+QmVocContainer::~QmVocContainer()
 {
     delete d;
 }
 
-void KEduVocContainer::appendChildContainer(KEduVocContainer * child)
+void QmVocContainer::appendChildContainer(QmVocContainer * child)
 {
     d->m_childContainers.append(child);
     child->d->m_parentContainer = this;
@@ -82,20 +88,20 @@ void KEduVocContainer::appendChildContainer(KEduVocContainer * child)
     invalidateChildLessonEntries();
 }
 
-KEduVocContainer * KEduVocContainer::childContainer(int row)
+QmVocContainer * QmVocContainer::childContainer(int row)
 {
     return d->m_childContainers.value(row);
 }
 
 
-KEduVocContainer * KEduVocContainer::childContainer(const QString & name)
+QmVocContainer * QmVocContainer::childContainer(const QString & name)
 {
     if (d->m_name == name) {
         return this;
     }
 
-    foreach (KEduVocContainer *container, d->m_childContainers) {
-        KEduVocContainer *found = container->childContainer(name);
+    foreach (QmVocContainer *container, d->m_childContainers) {
+        QmVocContainer *found = container->childContainer(name);
         if (found) {
             return found;
         }
@@ -104,43 +110,43 @@ KEduVocContainer * KEduVocContainer::childContainer(const QString & name)
 }
 
 
-void KEduVocContainer::deleteChildContainer(int row)
+void QmVocContainer::deleteChildContainer(int row)
 {
-    kDebug() << "Delete of container - check entry deletion!";
+    qDebug() << "Delete of container - check entry deletion!";
     delete d->m_childContainers.takeAt(row);
 
     invalidateChildLessonEntries();
 }
 
-void KEduVocContainer::removeChildContainer(int row)
+void QmVocContainer::removeChildContainer(int row)
 {
     d->m_childContainers.removeAt(row);
     invalidateChildLessonEntries();
 }
 
 
-int KEduVocContainer::childContainerCount() const
+int QmVocContainer::childContainerCount() const
 {
     return d->m_childContainers.count();
 }
 
-int KEduVocContainer::row() const
+int QmVocContainer::row() const
 {
     if (d->m_parentContainer) {
-        return d->m_parentContainer->d->m_childContainers.indexOf(const_cast<KEduVocContainer*>(this));
+        return d->m_parentContainer->d->m_childContainers.indexOf(const_cast<QmVocContainer*>(this));
     }
     return 0;
 }
 
 
-KEduVocContainer& KEduVocContainer::operator= ( const KEduVocContainer &other )
+QmVocContainer& QmVocContainer::operator= ( const QmVocContainer &other )
 {
     d->m_name = other.d->m_name;
     d->m_inPractice = other.d->m_inPractice;
     return *this;
 }
 
-bool KEduVocContainer::operator==(const KEduVocContainer &other)
+bool QmVocContainer::operator==(const QmVocContainer &other)
 {
     return  d->m_name == other.d->m_name &&
             d->m_inPractice == other.d->m_inPractice
@@ -148,38 +154,38 @@ bool KEduVocContainer::operator==(const KEduVocContainer &other)
             ;
 }
 
-void KEduVocContainer::setName( const QString &name )
+void QmVocContainer::setName( const QString &name )
 {
     d->m_name = name;
 }
 
-QString KEduVocContainer::name()
+QString QmVocContainer::name()
 {
     return d->m_name;
 }
 
-bool KEduVocContainer::inPractice()
+bool QmVocContainer::inPractice()
 {
     return d->m_inPractice;
 }
 
-void KEduVocContainer::setInPractice(bool inPractice)
+void QmVocContainer::setInPractice(bool inPractice)
 {
     d->m_inPractice = inPractice;
 }
 
-void KEduVocContainer::removeTranslation(int translation)
+void QmVocContainer::removeTranslation(int translation)
 {
-    foreach(KEduVocContainer *childContainer, d->m_childContainers) {
+    foreach(QmVocContainer *childContainer, d->m_childContainers) {
         childContainer->removeTranslation(translation);
     }
 
-    foreach(KEduVocExpression *entry, entries() ) {
+    foreach(QmVocExpression *entry, entries() ) {
         entry->removeTranslation( translation );
     }
 }
 
-QList< KEduVocExpression * > KEduVocContainer::entriesRecursive()
+QList< QmVocExpression * > QmVocContainer::entriesRecursive()
 {
     if (!d->m_childLessonEntriesValid) {
         updateChildLessonEntries();
@@ -187,38 +193,38 @@ QList< KEduVocExpression * > KEduVocContainer::entriesRecursive()
     return d->m_childLessonEntries;
 }
 
-QList< KEduVocContainer * > KEduVocContainer::childContainers()
+QList< QmVocContainer * > QmVocContainer::childContainers()
 {
     return d->m_childContainers;
 }
 
-KEduVocContainer * KEduVocContainer::parent()
+QmVocContainer * QmVocContainer::parent()
 {
     return d->m_parentContainer;
 }
 
-void KEduVocContainer::setContainerType(KEduVocContainer::EnumContainerType type)
+void QmVocContainer::setContainerType(QmVocContainer::EnumContainerType type)
 {
     d->m_type = type;
 }
 
-KEduVocContainer::EnumContainerType KEduVocContainer::containerType()
+QmVocContainer::EnumContainerType QmVocContainer::containerType()
 {
     return d->m_type;
 }
 
 
-KUrl KEduVocContainer::imageUrl()
+QUrl QmVocContainer::imageUrl()
 {
     return d->m_imageUrl;
 }
 
-void KEduVocContainer::setImageUrl(const KUrl &url)
+void QmVocContainer::setImageUrl(const QUrl &url)
 {
     d->m_imageUrl = url;
 }
 
-void KEduVocContainer::insertChildContainer(int row, KEduVocContainer * child)
+void QmVocContainer::insertChildContainer(int row, QmVocContainer * child)
 {
     d->m_childContainers.insert(row, child);
     child->d->m_parentContainer = this;
@@ -226,19 +232,19 @@ void KEduVocContainer::insertChildContainer(int row, KEduVocContainer * child)
     invalidateChildLessonEntries();
 }
 
-void KEduVocContainer::updateChildLessonEntries()
+void QmVocContainer::updateChildLessonEntries()
 {
-    QList < KEduVocExpression* > entriesRecursive = entries();
+    QList < QmVocExpression* > entriesRecursive = entries();
 
-    foreach(KEduVocContainer *childContainer, d->m_childContainers)
-        foreach(KEduVocExpression * expr, childContainer->entries(Recursive))
+    foreach(QmVocContainer *childContainer, d->m_childContainers)
+        foreach(QmVocExpression * expr, childContainer->entries(Recursive))
             entriesRecursive.append(expr);
 
     d->m_childLessonEntries = entriesRecursive;
     d->m_childLessonEntriesValid = true;
 }
 
-void KEduVocContainer::invalidateChildLessonEntries()
+void QmVocContainer::invalidateChildLessonEntries()
 {
     d->m_childLessonEntriesValid = false;
     // propagate to parent
@@ -247,21 +253,21 @@ void KEduVocContainer::invalidateChildLessonEntries()
     }
 }
 
-double KEduVocContainer::averageGrade(int translation, EnumEntriesRecursive recursive)
+double QmVocContainer::averageGrade(int translation, EnumEntriesRecursive recursive)
 {
     // grades range from 0..7 right now
     int sum = 0;
-    foreach (KEduVocExpression *entry, entries(recursive)) {
+    foreach (QmVocExpression *entry, entries(recursive)) {
         sum += entry->translation(translation)->grade();
     }
     // make that a percentage
     return (sum * 100.0/7.0)/entryCount(recursive);
 }
 
-int KEduVocContainer::expressionsOfGrade(int translation, grade_t grade, EnumEntriesRecursive recursive)
+int QmVocContainer::expressionsOfGrade(int translation, grade_t grade, EnumEntriesRecursive recursive)
 {
     int sum = 0;
-    foreach (KEduVocExpression *entry, entries(recursive)) {
+    foreach (QmVocExpression *entry, entries(recursive)) {
         if (entry->translation(translation)->grade() == grade) {
             sum++;
         }
@@ -269,9 +275,9 @@ int KEduVocContainer::expressionsOfGrade(int translation, grade_t grade, EnumEnt
     return sum;
 }
 
-void KEduVocContainer::resetGrades(int translation, EnumEntriesRecursive recursive)
+void QmVocContainer::resetGrades(int translation, EnumEntriesRecursive recursive)
 {
-    foreach (KEduVocExpression *entry, entries(recursive)) {
+    foreach (QmVocExpression *entry, entries(recursive)) {
         entry->resetGrades(translation);
     }
 }