keduvoctranslation.cpp

/*
 * Vocabulary Expression Translation for KDE Edu
 * SPDX-FileCopyrightText: 2007-2010 Frederik Gladhorn <gladhorn@kde.org>
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "keduvoctranslation.h"
 
#include "keduvocdeclension.h"
#include "keduvockvtml2writer.h"
#include "keduvocleitnerbox.h"
#include "keduvocwordtype.h"
#include "kvtml2defs.h"
 
class KEduVocTranslation::KEduVocTranslationPrivate
{
public:
    KEduVocTranslationPrivate(KEduVocExpression *parent);
 
    ~KEduVocTranslationPrivate();
 
    KEduVocExpression *m_entry;
 
    /// Type of a word noun, verb, adjective etc
    KEduVocWordType *m_wordType;
 
    /// Leitner box of the translation.
    KEduVocLeitnerBox *m_leitnerBox;
 
    /// A comment giving additional information.
    QString m_comment;
    /// A hint, to make guessing the word easier.
    QString m_hint;
    /// Paraphrase
    QString m_paraphrase;
    /// An example
    QString m_example;
    /// Pronunciation
    QString m_pronunciation;
    /// Image url
    QUrl m_imageUrl;
    /// Sound url
    QUrl m_soundUrl;
 
    /// When creating multiple choice tests, these are possible answers. (otherwise other words are added randomly)
    QStringList m_multipleChoice;
 
    /// Conjugations of a word (I go, you go, he goes... boring in english)
    QMap<QString, KEduVocConjugation> m_conjugations;
 
    /// The comparison forms of adjectives and adverbs: (fast), faster, fastest
    KEduVocText *m_comparative;
    KEduVocText *m_superlative;
 
    /// The grade of an article. The text part should not be used.
    KEduVocText *m_articleGrade;
 
    KEduVocDeclension *m_declension;
 
    // connections to other translations
    /// Synonyms for a word: sick and ill, student and pupil
    QList<KEduVocTranslation *> m_synonyms;
    /// An antonym - the opposite: hot - cold
    QList<KEduVocTranslation *> m_antonyms;
    /// List of false friends
    QList<KEduVocTranslation *> m_falseFriends;
};
 
KEduVocTranslation::KEduVocTranslationPrivate::KEduVocTranslationPrivate(KEduVocExpression *parent)
{
    m_entry = parent;
    m_wordType = nullptr;
    m_leitnerBox = nullptr;
    m_declension = nullptr;
 
    m_comparative = nullptr;
    m_superlative = nullptr;
    m_articleGrade = nullptr;
}
 
KEduVocTranslation::KEduVocTranslationPrivate::~KEduVocTranslationPrivate()
{
    delete m_declension;
}
 
KEduVocTranslation::KEduVocTranslation(KEduVocExpression *entry)
    : d(new KEduVocTranslationPrivate(entry))
{
}
 
KEduVocTranslation::KEduVocTranslation(KEduVocExpression *entry, const QString &translation)
    : d(new KEduVocTranslationPrivate(entry))
{
    setText(translation.simplified());
}
 
KEduVocTranslation::KEduVocTranslation(const KEduVocTranslation &other)
    : KEduVocText(other)
    ,
    // set the entry to 0, the translation will be put into a copied entry by the expression copy constructor
    d(new KEduVocTranslationPrivate(nullptr))
{
    // better no word type copy as this is pointer copying
    // will not work as this is not added to the word type container!
    //  d->m_wordType = other.d->m_wordType;
    //  d->m_leitnerBox = translation.d->m_leitnerBox;
    d->m_comment = other.d->m_comment;
    d->m_paraphrase = other.d->m_paraphrase;
    d->m_example = other.d->m_example;
    d->m_pronunciation = other.d->m_pronunciation;
    d->m_conjugations = other.d->m_conjugations;
    d->m_comparative = other.d->m_comparative;
    d->m_superlative = other.d->m_superlative;
    d->m_multipleChoice = other.d->m_multipleChoice;
    d->m_imageUrl = other.d->m_imageUrl;
    d->m_soundUrl = other.d->m_soundUrl;
    //  no copies of the following for now. we don't know enough to also add this as synonym/etc
    //  d->m_synonyms = other.d->m_synonyms;
    //  d->m_antonyms = other.d->m_antonyms;
    //  d->m_falseFriends = other.d->m_falseFriends;
    if (other.d->m_declension) {
        d->m_declension = new KEduVocDeclension(*other.d->m_declension);
    }
}
 
KEduVocTranslation::~KEduVocTranslation()
{
    setWordType(nullptr);
    setLeitnerBox(nullptr);
    foreach (KEduVocTranslation *synonym, d->m_synonyms) {
        synonym->removeSynonym(this);
    }
    foreach (KEduVocTranslation *antonym, d->m_antonyms) {
        antonym->removeAntonym(this);
    }
    foreach (KEduVocTranslation *falseFriend, d->m_falseFriends) {
        falseFriend->removeFalseFriend(this);
    }
    delete d;
}
 
bool KEduVocTranslation::operator==(const KEduVocTranslation &translation) const
{
    return KEduVocText::operator==(translation) && d->m_wordType == translation.d->m_wordType && d->m_leitnerBox == translation.d->m_leitnerBox
        && d->m_comment == translation.d->m_comment && d->m_paraphrase == translation.d->m_paraphrase && d->m_example == translation.d->m_example
        && d->m_pronunciation == translation.d->m_pronunciation && d->m_imageUrl == translation.d->m_imageUrl && d->m_soundUrl == translation.d->m_soundUrl
        && d->m_comparative == translation.d->m_comparative && d->m_superlative == translation.d->m_superlative
        && d->m_multipleChoice == translation.d->m_multipleChoice && d->m_synonyms == translation.d->m_synonyms && d->m_antonyms == translation.d->m_antonyms
        && d->m_falseFriends == translation.d->m_falseFriends && d->m_conjugations == translation.d->m_conjugations;
    /// @todo check and include declensions d->m_declension == translation.d->m_declension;
}
 
KEduVocTranslation &KEduVocTranslation::operator=(const KEduVocTranslation &translation)
{
    KEduVocText::operator=(translation);
    d->m_entry = translation.d->m_entry;
    //     d->m_wordType = translation.d->m_wordType;
    //     d->m_leitnerBox = translation.d->m_leitnerBox;
    d->m_comment = translation.d->m_comment;
    d->m_paraphrase = translation.d->m_paraphrase;
    d->m_example = translation.d->m_example;
    d->m_pronunciation = translation.d->m_pronunciation;
    d->m_imageUrl = translation.d->m_imageUrl;
    d->m_soundUrl = translation.d->m_soundUrl;
    d->m_comparative = translation.d->m_comparative;
    d->m_superlative = translation.d->m_superlative;
    d->m_multipleChoice = translation.d->m_multipleChoice;
    d->m_falseFriends = translation.d->m_falseFriends;
    d->m_synonyms = translation.d->m_synonyms;
    d->m_antonyms = translation.d->m_antonyms;
    d->m_conjugations = translation.d->m_conjugations;
    if (translation.d->m_declension) {
        d->m_declension = new KEduVocDeclension(*translation.d->m_declension);
    }
 
    return *this;
}
 
QString KEduVocTranslation::comment() const
{
    return d->m_comment;
}
 
void KEduVocTranslation::setComment(const QString &expr)
{
    d->m_comment = expr.simplified();
}
 
void KEduVocTranslation::addFalseFriend(KEduVocTranslation *falseFriend)
{
    d->m_falseFriends.append(falseFriend);
}
 
void KEduVocTranslation::removeFalseFriend(KEduVocTranslation *falseFriend)
{
    d->m_falseFriends.removeAt(d->m_falseFriends.indexOf(falseFriend));
}
 
QList<KEduVocTranslation *> KEduVocTranslation::falseFriends() const
{
    return d->m_falseFriends;
}
 
void KEduVocTranslation::addSynonym(KEduVocTranslation *synonym)
{
    d->m_synonyms.append(synonym);
}
 
void KEduVocTranslation::removeSynonym(KEduVocTranslation *synonym)
{
    d->m_synonyms.removeAt(d->m_synonyms.indexOf(synonym));
}
 
QList<KEduVocTranslation *> KEduVocTranslation::synonyms() const
{
    return d->m_synonyms;
}
 
void KEduVocTranslation::addAntonym(KEduVocTranslation *antonym)
{
    d->m_antonyms.append(antonym);
}
 
QList<KEduVocTranslation *> KEduVocTranslation::antonyms() const
{
    return d->m_antonyms;
}
 
void KEduVocTranslation::removeAntonym(KEduVocTranslation *antonym)
{
    d->m_antonyms.removeAt(d->m_antonyms.indexOf(antonym));
}
 
void KEduVocTranslation::setExample(const QString &expr)
{
    d->m_example = expr.simplified();
}
 
QString KEduVocTranslation::example() const
{
    return d->m_example;
}
 
void KEduVocTranslation::setParaphrase(const QString &expr)
{
    d->m_paraphrase = expr.simplified();
}
 
QString KEduVocTranslation::paraphrase() const
{
    return d->m_paraphrase;
}
 
void KEduVocTranslation::setConjugation(const QString &tense, const KEduVocConjugation &con)
{
    d->m_conjugations[tense] = con;
}
 
KEduVocConjugation &KEduVocTranslation::conjugation(const QString &tense)
{
    return d->m_conjugations[tense];
}
 
KEduVocConjugation KEduVocTranslation::getConjugation(const QString &tense) const
{
    if (d->m_conjugations.contains(tense)) {
        return d->m_conjugations[tense];
    }
    return KEduVocConjugation();
}
 
QStringList &KEduVocTranslation::multipleChoice()
{
    return d->m_multipleChoice;
}
 
QStringList KEduVocTranslation::getMultipleChoice() const
{
    return d->m_multipleChoice;
}
 
void KEduVocTranslation::setMultipleChoice(const QStringList &choices)
{
    d->m_multipleChoice = choices;
}
 
QString KEduVocTranslation::pronunciation() const
{
    return d->m_pronunciation;
}
 
void KEduVocTranslation::setPronunciation(const QString &expr)
{
    d->m_pronunciation = expr.simplified();
}
 
QStringList KEduVocTranslation::conjugationTenses() const
{
    return d->m_conjugations.keys();
}
 
QMap<QString, KEduVocConjugation> KEduVocTranslation::conjugations() const
{
    return d->m_conjugations;
}
 
void KEduVocTranslation::setConjugations(const QMap<QString, KEduVocConjugation> &conjugations)
{
    d->m_conjugations = conjugations;
}
 
/** get the sound url for this translation if it exists */
QUrl KEduVocTranslation::soundUrl()
{
    return d->m_soundUrl;
}
 
/** set the sound url for this translation
 * @param url               url of the sound file */
void KEduVocTranslation::setSoundUrl(const QUrl &url)
{
    d->m_soundUrl = url;
}
 
/** get the image url for this translation if it exists */
QUrl KEduVocTranslation::imageUrl()
{
    return d->m_imageUrl;
}
 
/** set the image url for this translation
 * @param url               url of the image
 */
void KEduVocTranslation::setImageUrl(const QUrl &url)
{
    d->m_imageUrl = url;
}
 
KEduVocWordType *KEduVocTranslation::wordType() const
{
    if (d) {
        return d->m_wordType;
    } else {
        return nullptr;
    }
}
 
void KEduVocTranslation::setWordType(KEduVocWordType *wordType)
{
    if (d->m_wordType) {
        d->m_wordType->removeTranslation(this);
    }
    if (wordType) {
        wordType->addTranslation(this);
    }
    d->m_wordType = wordType;
}
 
KEduVocLeitnerBox *KEduVocTranslation::leitnerBox() const
{
    return d->m_leitnerBox;
}
 
void KEduVocTranslation::setLeitnerBox(KEduVocLeitnerBox *leitnerBox)
{
    if (d->m_leitnerBox) {
        d->m_leitnerBox->removeTranslation(this);
    }
    if (leitnerBox) {
        leitnerBox->addTranslation(this);
    }
    d->m_leitnerBox = leitnerBox;
}
 
KEduVocExpression *KEduVocTranslation::entry()
{
    return d->m_entry;
}
 
QString KEduVocTranslation::comparative() const
{
    if (d->m_comparative) {
        return d->m_comparative->text();
    }
    return QString();
}
 
void KEduVocTranslation::setComparative(const QString &comparative)
{
    if (!d->m_comparative) {
        d->m_comparative = new KEduVocText(comparative);
    } else {
        d->m_comparative->setText(comparative);
    }
}
 
QString KEduVocTranslation::superlative() const
{
    if (d->m_superlative) {
        return d->m_superlative->text();
    }
    return QString();
}
 
void KEduVocTranslation::setSuperlative(const QString &superlative)
{
    if (!d->m_superlative) {
        d->m_superlative = new KEduVocText(superlative);
    } else {
        d->m_superlative->setText(superlative);
    }
}
 
KEduVocText KEduVocTranslation::comparativeForm() const
{
    if (!d->m_comparative) {
        return KEduVocText();
    }
    KEduVocText t(*(d->m_comparative));
    return t;
}
 
void KEduVocTranslation::setComparativeForm(const KEduVocText &comparative)
{
    if (!d->m_comparative) {
        d->m_comparative = new KEduVocText();
    }
    *(d->m_comparative) = comparative;
}
 
KEduVocText KEduVocTranslation::superlativeForm() const
{
    if (!d->m_superlative) {
        return KEduVocText();
    }
    KEduVocText t(*d->m_superlative);
    return t;
}
 
void KEduVocTranslation::setSuperlativeForm(const KEduVocText &superlative)
{
    if (!d->m_superlative) {
        d->m_superlative = new KEduVocText();
    }
    *d->m_superlative = superlative;
}
 
KEduVocText KEduVocTranslation::article() const
{
    if (!d->m_articleGrade) {
        return KEduVocText();
    }
    KEduVocText t(*d->m_articleGrade);
    return t;
}
 
void KEduVocTranslation::setArticle(const KEduVocText &article)
{
    if (!d->m_articleGrade) {
        d->m_articleGrade = new KEduVocText();
    }
    *d->m_articleGrade = article;
}
 
KEduVocDeclension *KEduVocTranslation::declension()
{
    return d->m_declension;
}
 
void KEduVocTranslation::setDeclension(KEduVocDeclension *declension)
{
    // remove the old declension object
    delete d->m_declension;
    d->m_declension = declension;
}
 
void KEduVocTranslation::toKVTML2(QDomElement &parent)
{
    // text and grade
    KEduVocText::toKVTML2(parent);
 
    // declension
    if (d->m_declension) {
        d->m_declension->toKVTML2(parent);
    }
 
    // conjugation
    foreach (const QString &tense, conjugationTenses()) {
        QDomElement conjugationElement = parent.ownerDocument().createElement(KVTML_CONJUGATION);
        getConjugation(tense).toKVTML2(conjugationElement, tense);
        if (conjugationElement.hasChildNodes()) {
            parent.appendChild(conjugationElement);
        }
    }
 
    // <comment>
    KEduVocKvtml2Writer::appendTextElement(parent, KVTML_COMMENT, comment());
 
    // <pronunciation>
    KEduVocKvtml2Writer::appendTextElement(parent, KVTML_PRONUNCIATION, pronunciation());
 
    // <example>
    KEduVocKvtml2Writer::appendTextElement(parent, KVTML_EXAMPLE, example());
 
    // <paraphrase>
    KEduVocKvtml2Writer::appendTextElement(parent, KVTML_PARAPHRASE, paraphrase());
 
    ///@todo synonyms, antonyms
    ///@todo false friends
}
 
void KEduVocTranslation::fromKVTML2(QDomElement &parent)
{
    KEduVocText::fromKVTML2(parent);
 
    setDeclension(KEduVocDeclension::fromKVTML2(parent));
 
    setComment(parent.firstChildElement(KVTML_COMMENT).text());
 
    setPronunciation(parent.firstChildElement(KVTML_PRONUNCIATION).text());
 
    //<example></example>
    setExample(parent.firstChildElement(KVTML_EXAMPLE).text());
 
    //<paraphrase></paraphrase>
    setParaphrase(parent.firstChildElement(KVTML_PARAPHRASE).text());
 
    // conjugations
    QDomElement conjugationElement = parent.firstChildElement(KVTML_CONJUGATION);
    while (!conjugationElement.isNull()) {
        QDomElement tenseElement = conjugationElement.firstChildElement(KVTML_TENSE);
        QString tense = tenseElement.text();
        KEduVocConjugation *conjugation = KEduVocConjugation::fromKVTML2(conjugationElement);
        setConjugation(tense, *conjugation);
        delete conjugation;
        conjugationElement = conjugationElement.nextSiblingElement(KVTML_CONJUGATION);
    }
 
    ///@todo synonyms, antonym
    ///@todo false friends
}
 
void KEduVocTranslation::setEntry(KEduVocExpression *entry)
{
    d->m_entry = entry;
}