• Skip to content
• Skip to link menu

KDE 4.4 API Reference

• KDE API Reference
• kdeedu

• Sitemap
• Contact Us

 

parley

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

parley

Skip menu "parley"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members
• Related Pages

kdeedu

Skip menu "kdeedu"

•     lib
• kalzium
• kanagram
• kig
•   lib
• klettres
• kstars
• libkdeedu
•   keduvocdocument
• marble
• parley
•   stepcore

Generated for kdeedu by doxygen 1.5.9-20090814
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal