File indexing completed on 2024-04-14 03:46:39

 /*
  * Vocabulary Expression for KDE Edu
  * SPDX-FileCopyrightText: 1999-2001 Ewald Arnold <kvoctrain@ewald-arnold.de>
  * SPDX-FileCopyrightText: 2005-2007 Peter Hedlund <peter.hedlund@kdemail.net>
  * SPDX-FileCopyrightText: 2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "keduvocexpression.h"
 
 #include <QMap>
 
 class KEduVocExpression::KEduVocExpressionPrivate
 {
 public:
     KEduVocExpressionPrivate()
     {
         m_active = true;
         m_lesson = nullptr;
     }
     ~KEduVocExpressionPrivate();
 
     KEduVocExpressionPrivate(const KEduVocExpressionPrivate &other);
     KEduVocExpressionPrivate &operator=(const KEduVocExpressionPrivate &other);
 
     bool operator==(const KEduVocExpressionPrivate &p) const;
 
     KEduVocLesson *m_lesson;
     bool m_active;
 
     QMap<int, KEduVocTranslation *> m_translations;
 };
 
 KEduVocExpression::KEduVocExpressionPrivate::~KEduVocExpressionPrivate()
 {
     QMap<int, KEduVocTranslation *> translations = m_translations;
     // empty the translations map, otherwise removal from word type will try to access them again when they don't exist any more
     m_translations.clear();
     qDeleteAll(translations);
 }
 
 KEduVocExpression::KEduVocExpressionPrivate::KEduVocExpressionPrivate(const KEduVocExpressionPrivate &other)
 {
     m_active = other.m_active;
     m_lesson = nullptr;
 }
 
 KEduVocExpression::KEduVocExpressionPrivate &KEduVocExpression::KEduVocExpressionPrivate::operator=(const KEduVocExpressionPrivate &other)
 {
     m_active = other.m_active;
     m_lesson = nullptr;
 
     return *this;
 }
 
 bool KEduVocExpression::KEduVocExpressionPrivate::operator==(const KEduVocExpression::KEduVocExpressionPrivate &p) const
 {
     return m_translations == p.m_translations && m_lesson == p.m_lesson && m_active == p.m_active;
 }
 
 KEduVocExpression::KEduVocExpression()
     : d(new KEduVocExpressionPrivate)
 {
 }
 
 KEduVocExpression::KEduVocExpression(const QString &expression)
     : d(new KEduVocExpressionPrivate)
 {
     setTranslation(0, expression.simplified());
 }
 
 KEduVocExpression::KEduVocExpression(const QStringList &translations)
     : d(new KEduVocExpressionPrivate)
 {
     foreach (const QString &translation, translations) {
         setTranslation(d->m_translations.count(), translation);
     }
 }
 
 KEduVocExpression::KEduVocExpression(const KEduVocExpression &other)
     : d(new KEduVocExpressionPrivate(*other.d))
 {
     foreach (int key, other.d->m_translations.keys()) {
         d->m_translations[key] = new KEduVocTranslation(*other.d->m_translations.value(key));
         d->m_translations[key]->setEntry(this);
     }
 }
 
 KEduVocExpression &KEduVocExpression::operator=(const KEduVocExpression &other)
 {
     *d = *other.d;
     foreach (int key, other.d->m_translations.keys()) {
         d->m_translations[key] = new KEduVocTranslation(*other.d->m_translations.value(key));
         d->m_translations[key]->setEntry(this);
     }
     return *this;
 }
 
 KEduVocExpression::~KEduVocExpression()
 {
     setLesson(nullptr);
     delete d;
 }
 
 void KEduVocExpression::removeTranslation(int index)
 {
     int count = d->m_translations.count();
 
     // remove the index we delete
     delete d->m_translations.take(index);
 
     // shift all other indexes, +1 for the deleted
     for (int j = index; j < count - 1; j++) {
         d->m_translations[j] = d->m_translations.take(j + 1);
     }
 }
 
 void KEduVocExpression::setTranslation(int index, const QString &expr)
 {
     if (index < 0) {
         return;
     }
 
     if (!d->m_translations.contains(index)) {
         d->m_translations[index] = new KEduVocTranslation(this);
     }
     d->m_translations[index]->setText(expr.simplified());
 }
 
 KEduVocLesson *KEduVocExpression::lesson() const
 {
     return d->m_lesson;
 }
 
 bool KEduVocExpression::isActive() const
 {
     return d->m_active;
 }
 
 void KEduVocExpression::setActive(bool flag)
 {
     d->m_active = flag;
 }
 
 void KEduVocExpression::resetGrades(int index)
 {
     if (index == -1) { // clear grades for all languages
         foreach (KEduVocTranslation *trans, d->m_translations) {
             trans->resetGrades();
         }
         return;
     }
 
     // only language index
     if (d->m_translations.contains(index)) {
         d->m_translations[index]->resetGrades();
     }
 }
 
 bool KEduVocExpression::operator==(const KEduVocExpression &expression) const
 {
     return (*d == *expression.d);
 }
 
 KEduVocTranslation *KEduVocExpression::translation(int index)
 {
     if (translationIndices().contains(index)) {
         return d->m_translations[index];
     }
     d->m_translations[index] = new KEduVocTranslation(this);
     return d->m_translations[index];
 }
 
 KEduVocTranslation *KEduVocExpression::translation(int index) const
 {
     if (d->m_translations.contains(index)) {
         return nullptr;
     }
     return d->m_translations[index];
 }
 
 QList<int> KEduVocExpression::translationIndices() const
 {
     return d->m_translations.keys();
 }
 
 void KEduVocExpression::setLesson(KEduVocLesson *l)
 {
     if (d->m_lesson) {
         d->m_lesson->removeEntry(this);
     }
     d->m_lesson = l;
 }