lesson.cpp

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.                                   *
 *                                                                         *
 ***************************************************************************/
#include "lesson.h"
#include "expression.h"

#include <keduvocexpression.h>

#include <KDebug>

namespace Scripting
{
Lesson::Lesson(KEduVocLesson * lesson)
    : Container(lesson), m_lesson(lesson)
{
}

Lesson::Lesson(KEduVocContainer * container)
{
    m_lesson = static_cast<KEduVocLesson*>(container);
    m_container = m_lesson;
}

Lesson::Lesson(const QString& name)
{
    m_lesson = new KEduVocLesson(name);
    m_container = m_lesson;
}


Lesson::~Lesson()
{
}

QList<KEduVocLesson*>  flattenLessons(KEduVocLesson * rootLesson)
{
    QList<KEduVocLesson*> lessonsList;
    foreach(KEduVocContainer * child, rootLesson->childContainers()) {
        lessonsList << static_cast<KEduVocLesson*>(child);
        lessonsList += flattenLessons(static_cast<KEduVocLesson*>(child));
    }
    return lessonsList;
}


QVariantList Lesson::childLessons(bool recursive)
{
    if (recursive)
        return toVariantList<KEduVocLesson, Lesson> (flattenLessons(m_lesson));
    return toVariantList<KEduVocContainer, Lesson> (m_lesson->childContainers());
}

QVariantList Lesson::entries(bool recursive) const
{
    return toVariantList<KEduVocExpression, Expression> (m_lesson->entries(boolToEnum(recursive)));
}

void Lesson::setEntries(QVariantList entries)
{
    clearEntries();

    foreach(const QVariant & ventry, entries) {
        QObject * obj = qvariant_cast<QObject*> (ventry);
        Expression * entry = dynamic_cast<Expression*>(obj);
        if (entry)
            m_lesson->appendEntry(entry->kEduVocExpression());
//                 kDebug() << entry->translationTexts();
    }
}

QObject * Lesson::entry(int row, bool recursive)
{
    return new Expression(m_lesson->entry(row, boolToEnum(recursive)));
}

int Lesson::entryCount(bool recursive)
{
    return m_lesson->entryCount(boolToEnum(recursive));
}

void Lesson::appendEntry(Expression * entry)
{
    m_lesson->appendEntry(entry->kEduVocExpression());
}

void Lesson::insertEntry(int index, Expression * entry)
{
    m_lesson->insertEntry(index, entry->kEduVocExpression());
}

void Lesson::removeEntry(QObject * entry)
{
    Expression * e = dynamic_cast<Expression*>(entry);
    if (e) {
        m_lesson->removeEntry(e->kEduVocExpression());
    } else {
        kDebug() << "The entry given does not exist";
    }
}

void Lesson::clearEntries()
{
    int N = m_lesson->entryCount(KEduVocLesson::NotRecursive);
    for (int i = 0; i < N; i++)
        m_lesson->removeEntry(m_lesson->entry(0, KEduVocLesson::NotRecursive));
}


QObject* Lesson::newEntry()
{
    return new Expression();
}

//     QObject* Lesson::newEntry ( const QString & expression )
//     {
//         return new Expression ( expression );
//     }

QObject* Lesson::newEntry(QStringList translations)
{
    return new Expression(translations);
}

void Lesson::appendNewEntry(QStringList translations)
{
    KEduVocExpression * expr = new KEduVocExpression(translations);
    m_lesson->appendEntry(expr);
}

QObject * Lesson::findChildLesson(const QString& name)
{
    KEduVocContainer * container = findContainer(name);
    if (container)
        return new Lesson(container);
    kDebug() << "not found";
    return 0;
}

}