userrequirementsmodel.cpp

#include "userrequirementsmodel.h"
#include <domain/task.h>
#include <domain/tasktype.h>
#include <domain/usertype.h>

#include <limits>

#include <QDebug>

using namespace control;

UserRequirementsModel::UserRequirementsModel(domain::Task* task) :
                                            DomainModel(0), task(task),
                                            taskType(task->taskType())
{
}

UserRequirementsModel::UserRequirementsModel(domain::TaskType* taskType) :
                                             DomainModel(0), task(0),
                                             taskType(taskType)
{
}

int UserRequirementsModel::rowCount(const QModelIndex& parent) const
{
    if (!parent.isValid())
        return taskType->userRequirements().size();

    return 0;
}

int UserRequirementsModel::columnCount(const QModelIndex& parent) const
{
    if (!parent.isValid())
        return LastColumn;

    return 0;
}

QVariant UserRequirementsModel::headerData(int section,
                                           Qt::Orientation orientation,
                                           int role) const
{
    if (role == Qt::DisplayRole && orientation == Qt::Horizontal)
    {
        switch (section)
        {
            case Type:       return "User type";
            case Min:        return "Minimum";
            case Max:        return "Maximum";
            case NbAccepted: return "# accepted";
        }
    }

    return QVariant();
}

QVariant UserRequirementsModel::data(const QModelIndex& index, int role) const
{
    if (index.parent().isValid())
        return QVariant();

    domain::Requirement* req = taskType->userRequirements()[index.row()];

    int nbAccepted;

    if (task != 0)
        nbAccepted = task->nbAcceptedInvitations(static_cast<domain::UserType*>(req->type));
    else
        nbAccepted = -1;

    if (role == Qt::DisplayRole)
    {
        switch (index.column())
        {
            case Type:
                return req->type->name();
            case Min:
                return req->min;
            case Max:
                if (req->max == std::numeric_limits<unsigned>::max())
                    return QChar(0x221E);
                else
                    return req->max;
            case NbAccepted:
                return nbAccepted < 0 ? "/" : QString::number(nbAccepted);
        }
    }
    else if (role == Qt::ToolTipRole && task != 0)
    {
        QString toolTip("Requirement of task %1 for a user of type \"%2\"\n");
        if (nbAccepted >= 0)
        {
            double perc;
            if (req->min == 0)
                perc = 100.0;
            else
                perc = qMin(100.0, nbAccepted / req->min * 100.0);

            toolTip += QString("%1% completed").arg(perc);
        }

        return toolTip.arg(task->id()).arg(req->type->name());
    }

    return QVariant();
}

---