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