translation.h

Go to the documentation of this file.

/***************************************************************************

    Copyright 2008 Avgoustinos Kadis <avgoustinos.kadis@kdemail.net>

 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef SCRIPTINGSCRIPTOBJECTTRANSLATION_H
#define SCRIPTINGSCRIPTOBJECTTRANSLATION_H

#include <keduvocdeclension.h>
#include <keduvocconjugation.h>

#include "keduvoctranslation.h"
#include "keduvocwordtype.h"
#include "expression.h"
#include "text.h"

#include <QObject>

namespace Scripting
{

class Translation : public Text
{
    Q_OBJECT
    Q_PROPERTY(QString pronunciation READ pronunciation WRITE setPronunciation)
    Q_PROPERTY(QString comment READ comment WRITE setComment)
    Q_PROPERTY(QString example READ example WRITE setExample)
    Q_PROPERTY(QString paraphrase READ paraphrase WRITE setParaphrase)
//             Q_PROPERTY ( QString antonym READ antonym WRITE setAntonym )
//             Q_PROPERTY ( QString irregularPlural READ irregularPlural WRITE setIrregularPlural )
    Q_PROPERTY(QString comparative READ comparative WRITE setComparative)
    Q_PROPERTY(QString superlative READ superlative WRITE setSuperlative)
    Q_PROPERTY(QString soundUrl READ soundUrl WRITE setSoundUrl)
    Q_PROPERTY(QString imageUrl READ soundUrl WRITE setImageUrl)
public:
    /*
     * Default constructor for an empty translation.
     */
    Translation(Expression * entry);

    /*
     * Constructor
     * @param translation is used as translation
     */
    Translation(Expression * entry, const QString & translation);

    /*
     * Constructor from KEduVocTranslation (not used by scripts)
     * @param translation KEduVocTranslation to initialize Scripting::Translation
     */
    Translation(KEduVocTranslation * translation);

    ~Translation();

    KEduVocTranslation* kEduVocTranslation() {
        return m_translation;
    }

    template <class T, class S>
    QVariantList toVariantList(QList<T*> objList) const;

//             static QMap<QString,KEduVocConjugation::ConjugationNumber> & getConjNumberMap ();

//             static QMap<QString,KEduVocConjugation::ConjugationPerson> & getConjPersonMap ();

    /* returns the pronunciation of this translation */
    QString pronunciation() const {
        return m_translation->pronunciation();
    }
    /* sets the pronunciation of this expression */
    void setPronunciation(const QString & expression) {
        m_translation->setPronunciation(expression);
    }

    /* returns the translation commment */
    QString comment() const {
        return m_translation->comment();
    }
    /* sets the translation commment */
    void setComment(const QString & expr) {
        m_translation->setComment(expr);
    }

    /* returns example of this expression
    * @return                 example or "" if no string available
    */
    QString example() const {
        return m_translation->example();
    }

    /* sets example of this expression */
    void setExample(const QString & expression) {
        m_translation->setExample(expression);
    }

    /* sets paraphrase of this expression
    * @param expression       paraphrase of this index
    */
    void setParaphrase(const QString & expression) {
        m_translation->setParaphrase(expression);
    }

    /* returns paraphrase of this expression
    * @return                 paraphrase or "" if no string available
    */
    QString paraphrase() const {
        return m_translation->paraphrase();
    }

    /* sets antonym this expression
    * @param expression       antonym of this index
    */
//             void setAntonym ( const QString & expression ) { m_translation->setAntonym ( expression ); }

    /* returns antonym of this expression
    * @return                 antonym or "" if no string available
    */
//             QString antonym() const { return m_translation->antonym(); }

    /*
     * Set a irregular plural form.
     * @param plural plural of the word
     */
//             void setIrregularPlural ( const QString& plural ) { m_translation->setIrregularPlural( plural ); }

    /*
     * Get a irregular plural form.
     * @return plural of the word
     */
//             QString irregularPlural() const { return m_translation->irregularPlural(); }

    /* sets the word type of this expression
    * @param type             type of this expression ("" = none)
    */
    void setWordType(KEduVocWordType* wordType) {
        m_translation->setWordType(wordType);
    }

    /* returns the leitner box of this translation
     * @return the box
     */
//             KEduVocLeitnerBox* leitnerBox() const;

    /* sets the leitner box of this translation
     * @param leitnerBox the box
     */
//             void setLeitnerBox ( KEduVocLeitnerBox* leitnerBox );

    /*
     * Bad, only used for tense entry page, will be deleted later. Deprecated.
     * @param conjugation
     */
//             void setConjugations ( const QMap<QString, KEduVocConjugation>& conjugations );



    /*
     * Bad, only compatibility. Deprecated.
     * @return
     */
//             QMap <QString, KEduVocConjugation> conjugations() const;

    /*
     * Comparison forms of adjectives/adverbs.
     */
    QString comparative() const {
        return m_translation->comparative();
    }
    void setComparative(const QString& comparative) {
        m_translation->setComparative(comparative);
    }
    QString superlative() const {
        return m_translation->superlative();
    }
    void setSuperlative(const QString& superlative) {
        m_translation->setSuperlative(superlative);
    }

    /* sets multiple choice
     * @param mc               multiple choice block
      */
//@note commented out in keduvoctranslation.h
//     void setMultipleChoice( const QStringList &mc );

    /* get the sound url for this translation if it exists */
    QString soundUrl() {
        return m_translation->soundUrl().path();
    }

    /* set the sound url for this translation
     * @param url               url of the sound file */
    void setSoundUrl(const QString &url) {
        m_translation->setSoundUrl(url);
    }

    /* get the image url for this translation if it exists */
    QString imageUrl() {
        return m_translation->soundUrl().path();
    }

    /* set the image url for this translation
     * @param url               url of the image
     */
    void setImageUrl(const QString &url) {
        m_translation->setImageUrl(url);
    }

    /*
     * Equal operator to assing a translation to another one.
     * @param translation translation to be copied
     * @return reference to the new translation
     */
//             KEduVocTranslation& operator= ( const KEduVocTranslation &translation );

    /*
     * Compare two translations, including word type etc.
     * @param translation
     * @return true if equal
     */
//             bool operator== ( const KEduVocTranslation &translation ) const;

//             void fromKVTML2 ( QDomElement& parent );
//             void toKVTML2 ( QDomElement& parent );
public slots:
    void addFalseFriend(Translation* falseFriend) {
        m_translation->addFalseFriend(falseFriend->kEduVocTranslation());
    }

    void removeFalseFriend(Translation* falseFriend) {
        m_translation->removeFalseFriend(falseFriend->kEduVocTranslation());
    }

    void addSynonym(Translation* synonym) {
        m_translation->addSynonym(synonym->kEduVocTranslation());
    }

    void removeSynonym(Translation* synonym) {
        m_translation->removeSynonym(synonym->kEduVocTranslation());
    }

    void addAntonym(Translation* antonym) {
        m_translation->addAntonym(antonym->kEduVocTranslation());
    }

    void removeAntonym(Translation* antonym) {
        m_translation->removeAntonym(antonym->kEduVocTranslation());
    }

    QVariantList falseFriends() const {
        return toVariantList<KEduVocTranslation, Translation> (m_translation->falseFriends());
    }

    QVariantList synonyms() const {
        return toVariantList<KEduVocTranslation, Translation> (m_translation->synonyms());
    }

    QVariantList antonyms() const {
        return toVariantList<KEduVocTranslation, Translation> (m_translation->antonyms());
    }

    QString wordType() const;

    QStringList multipleChoice() {
        return m_translation->multipleChoice();
    }

    QStringList conjugationTenses() const {
        return m_translation->conjugationTenses();
    }

    void setConjugationText(const QString& conjugation, const QString& tense, const KEduVocWordFlags& flags);

    void setConjugation(QObject * conjugation, const QString& tense, const KEduVocWordFlags& flags);


    QObject * conjugation(const QString & tense, const KEduVocWordFlags& flags);

    QStringList conjugationTexts(const QString& tense);

    QStringList conjugationTexts(const QString& tense, const KEduVocWordFlags& flags);


    /*
     * Returns a pointer to the declension object of this translation.
     * Returns 0 if no declension object exists!
     * @return the declension
     */
//             KEduVocDeclension* declension();
//weird bug with QMap with this function
//             QObject * declension(KEduVocWordFlag::DeclensionNumber number, KEduVocWordFlag::DeclensionCase decCase);

    /*
     * Set a new declension for a translation
     * @param declension
     */
//             void setDeclension ( KEduVocDeclension* declension );
//             void setDeclension(const QString& declension, KEduVocWordFlag::DeclensionNumber number, KEduVocWordFlag::DeclensionCase decCase);



private:
    KEduVocTranslation * m_translation;

};

//Template functions should not be separated from their definition (must be in the header file)
template <class T, class S>
QVariantList Translation::toVariantList(QList<T*> objList) const
{
    QVariantList list;
    foreach(T * t, objList) {
        QObject * obj = new S(t);
        list.push_back(qVariantFromValue(obj));
    }
    return list;
}


}

#endif