expression.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 SCRIPTINGEXPRESSION_H
#define SCRIPTINGEXPRESSION_H

#include <keduvocexpression.h>

#include "lesson.h"

#include <QObject>
#include <QVariantList>

namespace Scripting
{

    class Translation;

    class Expression : public QObject
    {
            Q_OBJECT
            Q_PROPERTY ( QObject * lesson READ lesson )
            Q_PROPERTY ( bool active READ isActive WRITE setActive )
//             Q_PROPERTY ( int sizeHint READ sizeHint WRITE setSizeHint)
        public:
            /* default constructor for an empty vocabulary expression
             */
            Expression ();

            /* Constructor for a vocabulary expression with one translation
             *
             * @param expression       translation
             */
            Expression ( const QString & expression );

            /*
             * Constructor for vocabulary expression with more than one translation
             * @param translations
             */
            Expression ( const QStringList & translations );

            Expression ( const Expression & other );

            /*
             * Constructor from a KEduVocExpression (doesn't exist in KEduVocExpression)
             * @param expression KEduVocExpression object
             */
            Expression ( KEduVocExpression * expression );

            ~Expression();

            KEduVocExpression * kEduVocExpression() const { return m_expression; }

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

            //Property: lesson [get method - read-only]
            QObject * lesson() const { return new Lesson ( m_expression->lesson() ); }

            /* returns flag if entry is activated for queries */
            bool isActive() const { return m_expression->isActive(); }
            /* set entry active (enabled for queries) */
            void setActive ( bool flag = true ) { m_expression->setActive ( flag ); }

            //Property: sizeHing [get/set methods] (not implemented in KEduVocExpression)
            //int sizeHint() const { return m_expression->sizeHint(); }
            //void setSizeHint( int sizeHint ) { m_expression->setSizeHint(sizeHint); }

            //for assignlable type
//             Expression & operator= ( const Expression &other );
//             bool operator== ( const Expression &other ) const;

        public slots:

            void resetGrades ( int index ) { m_expression->resetGrades ( index ); }

            //not implemented in KEduVocExpression
//             void setTranslation( int index, QObject* translation );

            void setTranslation ( int index, const QString &expression )
            {
                m_expression->setTranslation ( index,expression );
            }

            void setTranslations ( QStringList translations );

            void removeTranslation ( int index ) { m_expression->removeTranslation ( index ); }

            QObject* translation ( int index ) const;

            QVariantList translationIndices() const;

            QVariantList translations() const;

            QStringList translationTexts() const;

        private:
            KEduVocExpression* m_expression;
    };

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


}

#endif