File indexing completed on 2024-04-21 03:48:22

 /*
  * SPDX-FileCopyrightText: 2007-2008 Frederik Gladhorn <frederik.gladhorn@kdemail.net>
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "keduvoctext.h"
 
 #include "keduvockvtml2writer.h"
 #include "kvtml2defs.h"
 
 #include <QDomDocument>
 
 class KEduVocText::KEduVocTextPrivate
 {
 public:
     /// This is the word itself. The vocabulary. This is what it is all about.
     QString m_text;
 
     grade_t m_preGrade; // Before it gets to grade 1.
     grade_t m_grade;
     count_t m_totalPracticeCount;
     count_t m_badCount;
     QDateTime m_practiceDate;
     quint32 m_interval; // Interval in seconds until next training is due.
 };
 
 KEduVocText::KEduVocText(const QString &text)
     : d(new KEduVocTextPrivate)
 {
     d->m_text = text;
     resetGrades();
 }
 
 KEduVocText::KEduVocText(const KEduVocText &other)
     : d(new KEduVocTextPrivate)
 {
     d->m_text = other.d->m_text;
     setPreGrade(other.preGrade());
     setGrade(other.grade());
     setPracticeCount(other.practiceCount());
     setBadCount(other.badCount());
     setPracticeDate(other.practiceDate());
     setInterval(other.interval());
 }
 
 KEduVocText::~KEduVocText()
 {
     delete d;
 }
 
 QString KEduVocText::text() const
 {
     return d->m_text;
 }
 
 void KEduVocText::setText(const QString &expr)
 {
     d->m_text = expr.simplified();
 }
 
 void KEduVocText::resetGrades()
 {
     d->m_preGrade = KV_NORM_GRADE;
     d->m_grade = KV_NORM_GRADE;
     d->m_totalPracticeCount = 0;
     d->m_badCount = 0;
 
     const QDateTime dt = QDateTime::fromSecsSinceEpoch(0);
     d->m_practiceDate = dt;
     d->m_interval = 0;
 }
 
 grade_t KEduVocText::preGrade() const
 {
     return d->m_preGrade;
 }
 
 void KEduVocText::setPreGrade(grade_t grade)
 {
     if (grade > KV_MAX_GRADE) {
         grade = KV_MAX_GRADE;
     }
     d->m_preGrade = grade;
 }
 
 grade_t KEduVocText::grade() const
 {
     return d->m_grade;
 }
 
 void KEduVocText::setGrade(grade_t grade)
 {
     if (grade > KV_MAX_GRADE) {
         grade = KV_MAX_GRADE;
     }
     d->m_grade = grade;
 }
 
 void KEduVocText::incGrade()
 {
     setGrade(qMax<grade_t>(grade() + 1, KV_LEV1_GRADE));
 }
 
 void KEduVocText::decGrade()
 {
     if (grade() == KV_MIN_GRADE) {
         return;
     }
     setGrade(grade() - 1);
 }
 
 count_t KEduVocText::practiceCount() const
 {
     return d->m_totalPracticeCount;
 }
 
 void KEduVocText::incPracticeCount()
 {
     setPracticeCount(practiceCount() + 1);
 }
 
 void KEduVocText::incBadCount()
 {
     setBadCount(badCount() + 1);
 }
 
 void KEduVocText::setPracticeCount(count_t count)
 {
     d->m_totalPracticeCount = count;
 }
 
 count_t KEduVocText::badCount() const
 {
     return d->m_badCount;
 }
 
 void KEduVocText::setBadCount(count_t count)
 {
     d->m_badCount = count;
 }
 
 QDateTime KEduVocText::practiceDate() const
 {
     return d->m_practiceDate;
 }
 
 void KEduVocText::setPracticeDate(const QDateTime &date)
 {
     d->m_practiceDate = date;
 }
 
 quint32 KEduVocText::interval() const
 {
     return d->m_interval;
 }
 
 void KEduVocText::setInterval(quint32 interval)
 {
     d->m_interval = interval;
 }
 
 KEduVocText &KEduVocText::operator=(const KEduVocText &other)
 {
     d->m_text = other.d->m_text;
     d->m_preGrade = other.d->m_preGrade;
     d->m_grade = other.d->m_grade;
     d->m_totalPracticeCount = other.d->m_totalPracticeCount;
     d->m_badCount = other.d->m_badCount;
     d->m_practiceDate = other.d->m_practiceDate;
     d->m_interval = other.d->m_interval;
 
     return *this;
 }
 
 bool KEduVocText::operator==(const KEduVocText &other) const
 {
     return d->m_text == other.d->m_text && d->m_preGrade == other.d->m_preGrade && d->m_grade == other.d->m_grade
         && d->m_totalPracticeCount == other.d->m_totalPracticeCount && d->m_badCount == other.d->m_badCount && d->m_practiceDate == other.d->m_practiceDate
         && d->m_interval == other.d->m_interval;
 }
 
 void KEduVocText::toKVTML2(QDomElement &parent)
 {
     QDomDocument domDoc = parent.ownerDocument();
     if (d->m_text.isEmpty() && d->m_totalPracticeCount == 0) {
         return;
     }
 
     // the text
     KEduVocKvtml2Writer::appendTextElement(parent, KVTML_TEXT, text());
 
     // grades
     if (d->m_totalPracticeCount > 0) {
         QDomElement gradeElement = domDoc.createElement(KVTML_GRADE);
 
         //<pregrade>2</pregrade>
         KEduVocKvtml2Writer::appendTextElement(gradeElement, KVTML_PREGRADE, QString::number(preGrade()));
 
         //<currentgrade>2</currentgrade>
         KEduVocKvtml2Writer::appendTextElement(gradeElement, KVTML_CURRENTGRADE, QString::number(grade()));
 
         //<count>6</count>
         KEduVocKvtml2Writer::appendTextElement(gradeElement, KVTML_COUNT, QString::number(practiceCount()));
 
         //<errorcount>1</errorcount>
         KEduVocKvtml2Writer::appendTextElement(gradeElement, KVTML_ERRORCOUNT, QString::number(badCount()));
 
         //<date>949757271</date>
         KEduVocKvtml2Writer::appendTextElement(gradeElement, KVTML_DATE, practiceDate().toString(Qt::ISODate));
 
         //<interval>300</interval>
         KEduVocKvtml2Writer::appendTextElement(gradeElement, KVTML_INTERVAL, QString::number(interval()));
 
         parent.appendChild(gradeElement);
     }
 }
 
 void KEduVocText::fromKVTML2(QDomElement &parent)
 {
     setText(parent.firstChildElement(KVTML_TEXT).text());
 
     // grade element
     const QDomElement &gradeElement = parent.firstChildElement(KVTML_GRADE);
     if (!gradeElement.isNull()) {
         setPreGrade(gradeElement.firstChildElement(KVTML_PREGRADE).text().toInt());
         setGrade(gradeElement.firstChildElement(KVTML_CURRENTGRADE).text().toInt());
 
         setPracticeCount(gradeElement.firstChildElement(KVTML_COUNT).text().toInt());
 
         setBadCount(gradeElement.firstChildElement(KVTML_ERRORCOUNT).text().toInt());
 
         QString dateString = gradeElement.firstChildElement(KVTML_DATE).text();
         if (!dateString.isEmpty()) {
             QDateTime value = QDateTime::fromString(dateString, Qt::ISODate);
             setPracticeDate(value);
         }
         setInterval(gradeElement.firstChildElement(KVTML_INTERVAL).text().toInt());
     }
 }
 
 bool KEduVocText::isEmpty()
 {
     return d->m_text.isEmpty();
 }