ESGRAF48/source/ResultWidget/ResultModel.cpp

#include "ResultModel.h"

#include "PluralPR.h"
#include "GenusPR.h"
#include "VerbEndPR.h"
#include "AkkusativPR.h"
#include "DativPR.h"
#include "V2PR.h"
#include "SvkPR.h"
#include "PassivPR.h"
#include "GenitivPR.h"

#include "PrintableModel.h"

#include <QDebug>

ResultModel::ResultModel(QObject* parent)
    : QAbstractTableModel(parent)
{
    m_results = {{"V2", "SVK", "VE", "Passiv", "Genus", "Akkusativ", "Dativ", "Genitiv", "Plural"}};
    m_results = {{"V2", "SVK", "VE", "Genus", "Akkusativ", "Dativ", "Plural", "Passiv", "Genitiv"}};
}

int ResultModel::rowCount(const QModelIndex& parent) const
{
    return 4;
}

int ResultModel::columnCount(const QModelIndex& parent) const
{
    return 9;
}

QVariant ResultModel::data(const QModelIndex& index, int role) const
{
    if (role == Qt::DisplayRole && index.column() < m_results.size())
    {
        switch (index.row())
        {
            case 0:
            {
                auto points = m_results[index.column()].points();
                if (points != 0)
                {
                    return static_cast<uint>(points);
                }
                break;
            }
            case 1:
            {
                auto pr = m_results[index.column()].pr();
                if (pr >= 84)
                {
                    return static_cast<uint>(pr);
                }
                break;
            }
            case 2:
            {
                auto pr = m_results[index.column()].pr();
                if (pr < 84 && pr > 16)
                {
                    return static_cast<uint>(pr);
                }
                break;
            }
            case 3:
            {
                auto pr = m_results[index.column()].pr();
                if (pr <= 16)
                {
                    return static_cast<uint>(pr);
                }
                break;
            }
            default:
                break;
        };

        return "-";
    }

    return {};
}

QVariant ResultModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole)
    {
        return {};
    }

    switch (orientation)
    {
        case Qt::Horizontal:
            if (m_results.size() > section)
            {
                return m_results[section].name();
            }
        case Qt::Vertical:
            switch (section)
            {
                case 0:
                    return "RP";
                case 1:
                    return ">= PR 84";
                case 2:
                    return "< PR 84";
                case 3:
                    return "<= PR 16";
                default:
                    return {};
            }
        default:
            return {};
    }
}

void ResultModel::setAge(const Age& age)
{
    m_age = age;
    emit dataChanged(index(1, 0), index(4, 8));
}

void ResultModel::setPluralResult(unsigned int points)
{
    if (m_results[6].points() != points)
    {
        m_results[6].setPoints(points);
        m_results[6].setPR(PluralPR().lookup(m_age, points));
        emit dataChanged(index(0, 6), index(4, 6));
    }
}

void ResultModel::setGenusResult(unsigned int points)
{
    if (m_results[3].points() != points)
    {
        m_results[3].setPoints(points);
        m_results[3].setPR(GenusPR().lookup(m_age, points));
        emit dataChanged(index(0, 3), index(4, 3));
    }
}

void ResultModel::setVerbEndResult(unsigned int points)
{
    if (m_results[2].points() != points)
    {
        m_results[2].setPoints(points);
        m_results[2].setPR(VerbEndPR().lookup(m_age, points));
        emit dataChanged(index(0, 2), index(4, 2));
    }
}

void ResultModel::setAkkusativResult(unsigned int points)
{
    if (m_results[4].points() != points)
    {
        m_results[4].setPoints(points);
        m_results[4].setPR(AkkusativPR().lookup(m_age, points));
        emit dataChanged(index(0, 4), index(4, 4));
    }
}

void ResultModel::setDativResult(unsigned int points)
{
    if (m_results[5].points() != points)
    {
        m_results[5].setPoints(points);
        m_results[5].setPR(DativPR().lookup(m_age, points));
        emit dataChanged(index(0, 5), index(4, 5));
    }
}

void ResultModel::setV2Result(unsigned int points)
{
    if (m_results[0].points() != points)
    {
        m_results[0].setPoints(points);
        m_results[0].setPR(V2PR().lookup(m_age, points));
        emit dataChanged(index(0, 0), index(4, 0));
    }
}

void ResultModel::setSvkResult(unsigned int points)
{
    if (m_results[1].points() != points)
    {
        m_results[1].setPoints(points);
        m_results[1].setPR(SvkPR().lookup(m_age, points));
        emit dataChanged(index(0, 1), index(4, 1));
    }
}

void ResultModel::setPassivResult(unsigned int points)
{
    if (m_results[7].points() != points)
    {
        m_results[7].setPoints(points);
        m_results[7].setPR(PassivPR().lookup(m_age, points));
        emit dataChanged(index(0, 7), index(4, 7));
    }
}

void ResultModel::setGenitivResult(unsigned int points)
{
    if (m_results[8].points() != points)
    {
        m_results[8].setPoints(points);
        m_results[8].setPR(GenitivPR().lookup(m_age, points));
        emit dataChanged(index(0, 8), index(4, 8));
    }
}

void ResultModel::printTo(QPainter& painter) const
{
    PrintableModel::drawHeader2(painter, "Prozentränge (PR)");

    painter.setFont(PrintableModel::tableFont());
    painter.setPen(PrintableModel::tablePen());

    auto width = painter.device()->width();
    auto height = 1.5 * painter.fontMetrics().lineSpacing();

    double cellWidth = width / (m_results.size() + 1);
    double rowHeight = 2 * height;

    double x = 0;
    double y = 0;

    PrintableModel::drawTextSquare(painter, {x, y + 0 * rowHeight, cellWidth, rowHeight}, "");
    PrintableModel::drawTextSquare(painter, {x, y + 1 * rowHeight, cellWidth, rowHeight},
                                   u8"\u2265 PR 84");
    PrintableModel::drawTextSquare(painter, {x, y + 2 * rowHeight, cellWidth, rowHeight},
                                   "< PR 84");

    PrintableModel::drawGreySquare(painter, {x, y + 3 * rowHeight, cellWidth, rowHeight});
    PrintableModel::drawTextSquare(painter, {x, y + 3 * rowHeight, cellWidth, rowHeight},
                                   u8"\u2264 PR 16");

    x += cellWidth;
    for (const auto& result : m_results)
    {
        PrintableModel::drawTextSquare(painter, {x, y + 0 * rowHeight, cellWidth, rowHeight},
                                       result.name());
        const auto pr = result.pr();

        PrintableModel::drawTextSquare(painter, {x, y + 1 * rowHeight, cellWidth, rowHeight},
                                       pr >= 84 ? QString::number(pr) : "-");
        PrintableModel::drawTextSquare(painter, {x, y + 2 * rowHeight, cellWidth, rowHeight},
                                       pr < 84 && pr > 16 ? QString::number(pr) : "-");

        PrintableModel::drawGreySquare(painter, {x, y + 3 * rowHeight, cellWidth, rowHeight});
        PrintableModel::drawTextSquare(painter, {x, y + 3 * rowHeight, cellWidth, rowHeight},
                                       pr <= 16 ? QString::number(pr) : "-");

        x += cellWidth;
    }
}