exercisemodel.cpp

Go to the documentation of this file.

#include "exercisemodel.h"
#include "../Data/dataproject.h"

ExerciseModel::ExerciseModel(bool exercise, DataProject *project, QAbstractItemModel *parent) : QAbstractItemModel(parent)
{
    isTeacher = false;
    isPrintDialog = false;
    maxChapterId = 0;

    p_project = project;
    QVariantList rootData;
    if(exercise)
    {
        rootData << "Übungen";
    }
    else
    {
        rootData << "Aufgaben";
    }

    rootItem = new ExerciseItem(rootData);
    if(project)
    {
        QList<DataChapter *> chapters = project->getChapters();
        for(int i = 0; i < chapters.count(); i++)
        {
            addChapter(chapters.value(i)->name(), chapters.value(i)->id());
            QList<DataExercise *> exercises = chapters.value(i)->exercises();
            for(int j = 0; j < exercises.count(); j++)
            {
                addExercise(chapters.value(i)->name(), exercises.value(j)->name(), exercises.value(j)->id(), exercises.value(j)->status());
            }
        }
    }
}

Qt::ItemFlags ExerciseModel::flags(const QModelIndex &index) const
{
    if(!index.isValid())
    {
        return 0;
    }

    Qt::ItemFlags flags;
    if(isTeacher)
    {
        flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
    }
    else
    {
        flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
    }

    if(isPrintDialog)
    {
        flags = flags | Qt::ItemIsUserCheckable;
    }

    return flags;
}

QVariant ExerciseModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(orientation == Qt::Horizontal && role == Qt::DisplayRole)
    {
        return rootItem->data(section);
    }

    return QVariant();

}

QModelIndex ExerciseModel::index(int row, int column, const QModelIndex &parent) const
{
    if(!hasIndex(row, column, parent))
    {
         return QModelIndex();
    }

    ExerciseItem *parentItem;

    if(!parent.isValid())
    {
        parentItem = rootItem;
    }
    else
    {
        parentItem = static_cast<ExerciseItem *>(parent.internalPointer());
    }
    ExerciseItem *childItem = parentItem->child(row);
    if(childItem)
    {
        return createIndex(row, column, childItem);
    }
    else
    {
        return QModelIndex();
    }
}

QModelIndex ExerciseModel::parent(const QModelIndex &index) const
{
    if(!index.isValid())
    {
        return QModelIndex();
    }

    ExerciseItem *childItem = static_cast<ExerciseItem*>(index.internalPointer());
    ExerciseItem *parentItem = childItem->parent();

    if(parentItem == rootItem)
    {
        return QModelIndex();
    }

    // why no parentItem? constructed from PupilActions::readTask (pupilactions.cpp:35) -David
    // fix for open-close-open project segfault
    if(!parentItem)
    {
        qDebug() << "ExerciseModel::parent(): I'm missing my parentItem (NULL ptr)! anyone feeling responsible?";
        return QModelIndex();
    }

    return createIndex(parentItem->row(), 0, parentItem);
}

int ExerciseModel::rowCount(const QModelIndex &parent) const
{
    ExerciseItem *parentItem = NULL;
    if(parent.column() > 0)
    {
        return 0;
    }

    if(!parent.isValid())
    {
        parentItem = rootItem;
    }
    else
    {
        parentItem = static_cast<ExerciseItem *>(parent.internalPointer());
    }
    return parentItem->childCount();
}

int ExerciseModel::columnCount(const QModelIndex &parent) const
{
    if(parent.isValid())
    {
        return static_cast<ExerciseItem *>(parent.internalPointer())->columnCount();
    }
    else
    {
        return rootItem->columnCount();
    }
}

QVariant ExerciseModel::data(const QModelIndex &index, int role) const
{
    if(!index.isValid())
    {
        return QVariant();
    }

    if(role == Qt::DisplayRole)
    {
        ExerciseItem *item = static_cast<ExerciseItem*>(index.internalPointer());
        return item->data(index.column());
    }
    else if(role == Qt::DecorationRole)
    {
        if(!isTeacher)
        {
            ExerciseItem *item = static_cast<ExerciseItem*>(index.internalPointer());
            if(!this->index(0,0, index).isValid())
            {
                if(item->data(1).toMap().value("state").toUInt() == Correct)
                {
                    return QIcon(":misc/Apply");
                }
                else if(item->data(1).toMap().value("state").toUInt() == Wrong)
                {
                    return QIcon(":project/DeleteDocument");
                }
                else if(item->data(1).toMap().value("state").toUInt() == NotCompleted)
                {
                    return QIcon(":help/WhatsThis");
                }
            }
        }
    }
    else if(role == Qt::CheckStateRole)
    {
        if(isPrintDialog)
        {
            ExerciseItem *item = static_cast<ExerciseItem*>(index.internalPointer());
            return item->isChecked();
        }
    }
    else if(role == 32)
    {
        ExerciseItem *item = static_cast<ExerciseItem*>(index.internalPointer());
        return item->itemInfo();
    }
    else
    {
        return QVariant();
    }
    return QVariant();
}

bool ExerciseModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    bool result = false;
    if(role == Qt::EditRole)
    {
        if(!index.parent().isValid())                               // I'm a parent
        {
            ExerciseItem *item = static_cast<ExerciseItem *>(index.internalPointer());
            if(!existsChapter(value.toString()))
            {
                if((p_project->chapter(index.data(0).toString())) != NULL)
                {
                    p_project->chapter(index.data(0).toString())->setChapterName(value.toString());
                }
                replaceChapterName(item, value.toString());
            }
            else
            {
                if(item->data(0).toString() != value.toString())
                {
                    emit printError("Sie können diesen Namen nicht benutzen, da er schon existiert!");
                    removeChapter(item->data(1).toMap().value("chapterId").toUInt(), item->data(0).toString());
                }
            }
            result = true;
        }
        else                                                        //I'm a child
        {
            ExerciseItem *child = static_cast<ExerciseItem *>(index.internalPointer());
            if(!existsExercise(chapterName(child->data(1).toMap().value("chapterId").toUInt()), value.toString()))
            {
                DataChapter *chap = p_project->chapter(index.parent().data(0).toString());
                if(chap->exercise(index.data(0).toString()) != NULL)
                {
                    chap->exercise(index.data(0).toString())->setExerciseName(value.toString());
                }
                replaceExerciseName(child, value.toString());
            }
            else
            {
                if(child->data(0).toString() != value.toString())
                {
                    removeExercise(chapterById(child->data(1).toMap().value("chapterId").toUInt()), child->data(0).toString());
                    emit printError("Sie können diesen Namen nicht benutzen, da er schon existiert!");
                }
            }
            result = true;
        }
    }
    else if(role == Qt::CheckStateRole)
    {
        if(isPrintDialog)
        {
            ExerciseItem *item = static_cast<ExerciseItem *>(index.internalPointer());
            Qt::CheckState checked = static_cast<Qt::CheckState>(value.toInt());
            if(item->parent() == rootItem)
            {
                // chapter
                for(int i = 0; i < item->childCount(); i++)
                {
                    item->child(i)->setCheckState(static_cast<Qt::CheckState>(value.toInt()));
                }
            }
            item->setCheckState(checked);

            result = true;
        }
    }

    emit dataChanged(index, index);

    //drawTreeOnDebugOutput();
    return result;
}

void ExerciseModel::addChapter(QString chapterName, uint chapterId)
{
    if(!existsChapter(chapterName))
    {
        if((p_project->chapter(chapterName)) == NULL)
        {
            DataChapter *dChapter = new DataChapter();
            dChapter->setChapterName(chapterName);
            dChapter->setId(chapterId);
            p_project->addChapter(dChapter);
        }
        QVariantList list;
        QMap<QString, QVariant> data;

        data.insert("chapterId", chapterId);
        list<<chapterName;
        list<<data;
        ExerciseItem *chapter = new ExerciseItem(list, rootItem);
        rootItem->addChild(chapter);
        maxChapterId++;
    }
    reset();
    emit resetView();
}

void ExerciseModel::addExercise(QString chapterName, QString exerciseName, uint exerciseId, DataExerciseStatus status)
{
    if(!existsExercise(chapterName, exerciseName))
    {
        DataChapter *chap = p_project->chapter(chapterName);
        if((chap->exercise(exerciseName)) == NULL)
        {
            DataExercise *exercise = new DataExercise();
            exercise->setExerciseName(exerciseName);
            exercise->setExerciseId(exerciseId);
            exercise->setStatus(status);
            chap->addExercise(exercise);
        }

        ExerciseItem *item = chapterByName(chapterName);
        QVariantList list;
        QMap<QString, QVariant> data;
        data.insert("exerciseId", exerciseId);
        data.insert("chapterId", chapterID(chapterName));
        data.insert("state", status);
        list<<exerciseName;
        list<<data;
        ExerciseItem *exercise = new ExerciseItem(list, item);
        item->addChild(exercise);
        item->incrementExerciseIdByOne();
    }
    reset();
    emit resetView();
}

void ExerciseModel::addOtherExercises(uint chapterId, ExerciseItem *oldExercise)
{
    for(int i=0; i!=rootItem->childCount(); i++)
    {
        ExerciseItem *chapter = rootItem->child(i);
        if(chapter->data(1).toMap().value("chapterId").toUInt() == QVariant(chapterId).toUInt())
        {
            for(int j=0; j!= oldExercise->childCount(); j++)
            {
                ExerciseItem *item = oldExercise->child(j);
                QMap<QString, QVariant> d;
                QVariantList c;

                d.insert("exerciseId", item->data(1).toMap().value("exerciseId"));
                d.insert("chapterId", item->data(1).toMap().value("chapterId"));
                d.insert("state", item->data(1).toMap().value("state"));

                c<<item->data(0).toString();
                c<<d;

                ExerciseItem *exercise = new ExerciseItem(c, chapter);
                chapter->addChild(exercise);
                emit resetView();
            }
        }
    }
}

uint ExerciseModel::maxExerciseIdByChapterId(uint chapterId)
{
    ExerciseItem *chapter = chapterById(chapterId);
    return chapter->maxExerciseID();
}

uint ExerciseModel::maxExerciseIdByChapterName(QString chapterName)
{
    ExerciseItem *chapter = chapterByName(chapterName);
    return chapter->maxExerciseID();
}

void ExerciseModel::replaceChapterName(ExerciseItem *oldChapter, QString newChapterName)
{
    for(int i = 0; i < rootItem->childCount(); i++)
    {
        if(rootItem->child(i)->data(0).toString() == oldChapter->data(0).toString())
        {
            QVariantList list;
            QMap<QString, QVariant> data;
            data.insert("chapterId", oldChapter->data(1).toMap().value("chapterId").toUInt());
            list<<newChapterName;
            list<<data;
            ExerciseItem *item = new ExerciseItem(list, rootItem);
            rootItem->childItems.replace(i, item);
            addOtherExercises(item->data(1).toMap().value("chapterId").toUInt(), oldChapter);
        }
    }
}

void ExerciseModel::replaceExerciseName(ExerciseItem *oldExercise, QString newExerciseName)
{
    ExerciseItem *chapterItem = chapterById(oldExercise->data(1).toMap().value("chapterId").toUInt());
    for(int i = 0; i < chapterItem->childCount(); i++)
    {
        ExerciseItem * exerciseItem = chapterItem->child(i);
        if(exerciseItem->data(0).toString() == oldExercise->data(0).toString())
        {
            QVariantList list;
            QMap<QString, QVariant> data;
            data.insert("chapterId", oldExercise->data(1).toMap().value("chapterId").toString());
            data.insert("exerciseId", oldExercise->data(1).toMap().value("exerciseId").toUInt());
            data.insert("state", oldExercise->data(1).toMap().value("state").toInt());
            list<<newExerciseName;
            list<<data;
            ExerciseItem *item = new ExerciseItem(list, chapterItem);
            chapterItem->childItems.replace(i, item);
        }
    }
}

void ExerciseModel::editState(QString exerciseName, int exerciseId, DataExerciseStatus state)
{
    for(int i = 0; i != rootItem->childCount(); i++)
    {
        ExerciseItem *item = rootItem->child(i);
        if(this->existsExercise(item->data(0).toString(), exerciseName))
        {
            QVariantList list;
            QMap<QString, QVariant> data;
            data.insert("chapterId", item->data(1).toMap().value("chapterId").toUInt());
            data.insert("exerciseId", exerciseId);
            data.insert("state", state);
            list<<exerciseName;
            list<<data;
            ExerciseItem *ex = new ExerciseItem(list, item);
            item->childItems.replace(exerciseId, ex);
            emit setSelection(item->data(1).toMap().value("chapterId").toUInt(), exerciseId);
        }
    }
    emit resetView();
}

void ExerciseModel::removeChapterByName(QString chapterName)
{
    ExerciseItem *chapter = chapterByName(chapterName);
    rootItem->removeChild(chapter);
    reset();
    emit resetView();
}

void ExerciseModel::removeExerciseByName(QString chapterName, QString exerciseName, uint chapterId)
{
    if(chapterId == 0)
    {
        ExerciseItem *chapter = chapterByName(chapterName);
        removeExercise(chapter, exerciseName);
    }
    else
    {
        ExerciseItem *chapter = chapterById(chapterId);
        removeExercise(chapter, exerciseName);
    }
    reset();
    emit resetView();
}

void ExerciseModel::removeChapter(int chapterID, QString chapterName)
{
    for(int i = 0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapter = rootItem->child(i);
        if(chapter->data(1).toMap().value("chapterId").toInt() == chapterID && chapter->data(0).toString() == chapterName)
        {
            rootItem->removeChild(chapter);
        }
    }
    reset();
    emit resetView();
}

void ExerciseModel::removeExercise(ExerciseItem *chapter, QString exerciseName)
{
    for(int i = 0; i < chapter->childCount(); i++)
    {
        ExerciseItem *child = chapter->child(i);
        if(child->data(0).toString() == exerciseName)
        {
            chapter->removeChild(child);
        }
    }
    reset();
    emit resetView();
}

ExerciseItem* ExerciseModel::chapterById(uint chapterId)
{
    for(int i = 0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapter = rootItem->child(i);
        if(chapter->data(1).toMap().value("chapterId").toUInt() == chapterId)
        {
            return chapter;
        }
    }
    return 0;
}

ExerciseItem* ExerciseModel::chapterByName(QString chapterName)
{
    for(int i = 0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapter = rootItem->child(i);
        if(chapter->data(0).toString() == chapterName)
        {
            return chapter;
        }
    }
    return 0;
}

int ExerciseModel::chapterID(QString chapterName)
{
    int id = -1;
    for(int i = 0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapter = rootItem->child(i);
        if(chapter->data(0).toString() == chapterName)
        {
            id = chapter->data(1).toMap().value("chapterId").toInt();
        }
    }
    return id;
}

QString ExerciseModel::chapterName(uint chapterId)
{
    return chapterById(chapterId)->data(0).toString();
}

bool ExerciseModel::existsChapter(QString chapterName)
{
    bool found = false;
    for(int i = 0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapter = rootItem->child(i);
        if(chapter->data(0).toString() == chapterName)
        {
            found = true;
        }
    }
    return found;
}

bool ExerciseModel::existsExercise(QString chapterName, QString exerciseName)
{
    bool found = false;
    ExerciseItem *chapter = chapterByName(chapterName);
    for(int i = 0; i < chapter->childCount(); i++)
    {
        ExerciseItem *exercise = chapter->child(i);
        if(exercise->data(0).toString() == exerciseName)
        {
            found = true;
        }
    }
    return found;
}

ExerciseItem::ExerciseItem(const QVariantList &data, ExerciseItem *parent)
{
    infos = data;
    parentItem = parent;
    maxExerciseId = 0;
    checkState = Qt::Unchecked;
}

ExerciseItem* ExerciseItem::parent()
{
    return parentItem;
}

ExerciseItem *ExerciseModel::getExercise(QString chapterName, QString exerciseName) const
{
    ExerciseItem *result = NULL;

    for(int i=0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapterItem = rootItem->child(i);
        if(chapterItem->data(0).toString() == chapterName)
        {
            for(int j=0; j < chapterItem->childCount(); j++)
            {
                ExerciseItem *exerciseItem = chapterItem->child(j);
                if(exerciseItem->data(0).toString() == exerciseName)
                {
                    result = exerciseItem;
                }
            }
        }
    }
    return result;
}

void ExerciseModel::drawTreeOnDebugOutput()
{
    qDebug()<<"The ExerciseSelectionViewTree";
    qDebug()<<"INFORMATION";
    qDebug()<<"Chapter  --> chapterName, chapterId";
    qDebug()<<"Exercise --> exerciseName, exerciseId, state, chapterId";
    ExerciseItem *root = rootItem;
    for(int i = 0; i < root->childCount(); i++)
    {
        ExerciseItem *chapter = root->child(i);
        qDebug()<<chapter->data(0).toString()<<" "<<chapter->data(1).toMap().value("chapterId").toUInt();
        for(int j = 0; j < chapter->childCount(); j++)
        {
            ExerciseItem *exercise = chapter->child(j);
            qDebug()<<"   "<<exercise->data(0).toString()<<" "<<exercise->data(1).toMap().value("exerciseId").toUInt()<<" "<<exercise->data(1).toMap().value("state").toUInt()<<" "<<exercise->data(1).toMap().value("chapterId").toUInt();
        }
    }
}

ExerciseItem *ExerciseModel::getItemByName(QString name) const
{
    ExerciseItem *result = NULL;

    for(int i=0; i < rootItem->childCount(); i++)
    {
        ExerciseItem *chapterItem = rootItem->child(i);
        if(chapterItem->data(0).toString() == name)
        {
            result = chapterItem;
            break;  // stop loop
        }
        else
        {
            for(int j = 0; j < chapterItem->childCount(); j++)
            {
                ExerciseItem *exerciseItem = chapterItem->child(j);
                if(exerciseItem->data(0).toString() == name)
                {
                    result = exerciseItem;
                    break;
                }
            }
        }
    }

    return result;
}

// *** ExerciseItem
int ExerciseItem::childCount() const
{
    return this->childItems.count();
}

int ExerciseItem::columnCount() const
{
    return this->infos.count();
}

ExerciseItem *ExerciseItem::child(int row)
{
    return this->childItems.value(row);
}

QVariant ExerciseItem::data(int column) const
{
    return infos.value(column);
}

bool ExerciseItem::setData(QVariant value, int column) const
{
    bool result = false;

    if(column < this->infos.size()) // WAS: infos.count() -> see Qt Doc
    {
        // MAY RESULT IN PROBLEMS
        // concerning that infos.value returns NOT a reference...
        // the value will propably not be changed!
        // Please test!! - Peter Nirschl
        infos.value(column)=value;
        result=true;
    }
    return result;
}

int ExerciseItem::row() const
{
    if(parentItem)
    {
        return parentItem->childItems.indexOf(const_cast<ExerciseItem*>(this));
    }
    return 0;
}

void ExerciseItem::addChild(ExerciseItem *item)
{
    childItems.append(item);
}

void ExerciseItem::removeChild(ExerciseItem *item)
{
    childItems.removeAll(item);
}

int ExerciseItem::positionOfExerciseById(uint exerciseId)
{
    for(int i = 0; i < childCount(); i++)
    {
        ExerciseItem *item = child(i);
        if(item->data(1).toMap().value("exerciseId").toUInt() == exerciseId)
        {
            return i;
        }
    }
    return 0;
}

---