FdViewResults.cpp

Go to the documentation of this file.

// --------------------------------------------------------------------
// Copyright © 2011-2013 Mathieu Schopfer
//
// This file is part of FreeDebks.
//
// FreeDebks 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 3 of the License, or
// (at your option) any later version.
//
// FreeDebks is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with FreeDebks.  If not, see <http://www.gnu.org/licenses/>.
// --------------------------------------------------------------------

#include "FdViewResults.hpp"
#include "../../data/FdModelResults.hpp"
#include "../../data/FdItemResults.hpp"
#include "../FdSubWindow.hpp"
#include "../FdMainWindow.hpp"

FdViewResults::FdViewResults(FdSubWindow *parent) :
        QTableView(0), mSubwindow(parent)
{
    mModel = mSubwindow->results();
    setModel(mModel);

    setSelectionBehavior(QAbstractItemView::SelectRows);
    setSelectionMode(QAbstractItemView::ExtendedSelection);
    setDragDropMode(QAbstractItemView::InternalMove);
    setDragEnabled(true);
    setAcceptDrops(true);
    setDropIndicatorShown(true);
    setEditTriggers(DoubleClicked | EditKeyPressed);
    QHeaderView* header = verticalHeader();
    header->setDefaultSectionSize(16);
    setVerticalHeader(header);

    setAlternatingRowColors(true);

    QSettings settings;
    settings.beginGroup("ViewResults");
    setColumnWidth(ResultsId, settings.value("id", 50).toInt());
    setColumnWidth(ResultsLabel, settings.value("label", 300).toInt());
    setColumnWidth(ResultsCalculation, settings.value("calculation", 500).toInt());
    settings.endGroup();
    horizontalHeader()->setResizeMode(ResultsResult, QHeaderView::Stretch);

    mDelegate = new FdDelegateResults(mModel);
    setItemDelegate(mDelegate);

    setContextMenuPolicy(Qt::CustomContextMenu);
    connect(this, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(contextMenu(const QPoint&)));

    mSearchTimer = new QTimer();
    mSearchTimer->setInterval(qApp->keyboardInputInterval());
    mSearchTimer->setSingleShot(true);
    connect(mSearchTimer, SIGNAL(timeout()), this, SLOT(searchTimeout()));
}

void FdViewResults::mouseReleaseEvent(QMouseEvent* event)
{
    if(event->button() == Qt::LeftButton && !(indexAt(event->pos()).isValid()))
        setCurrentIndex(QModelIndex());

    QList<int> rows = selectedRows();
    if(rows.size() == 0)
    {

    }
    else if(rows.size() == 1)
    {

    }
    else
    {

    }

    QTableView::mouseReleaseEvent(event);
}

QModelIndex FdViewResults::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
{
    if(cursorAction == QAbstractItemView::MoveNext)
    {
        QModelIndex index = currentIndex();
        if(index.column() == ResultsCalculation)
        {
            if(index.row() == model()->rowCount()-1)
                return mModel->addCalculation(QModelIndex());
            else
                return mModel->index(index.row()+1, ResultsId);
        }
    }
    else if(cursorAction == QAbstractItemView::MovePrevious)
    {
        QModelIndex index = currentIndex();
        if(index.column() == ResultsId)
        {
            if(index.row())
                return mModel->index(index.row()-1, ResultsCalculation);
            else
                return index;
        }

    }
    else if(cursorAction == QAbstractItemView::MoveHome && modifiers == Qt::ControlModifier)
    {
        clearSelection();
        setCurrentIndex(mModel->index(0, 0));
    }
    else if(cursorAction == QAbstractItemView::MoveEnd && modifiers == Qt::ControlModifier)
    {
        clearSelection();
        setCurrentIndex(mModel->index(mModel->rowCount()-1, ResultsColumnCount-1));
    }


    return QTableView::moveCursor(cursorAction, modifiers);
}

void FdViewResults::keyboardSearch(const QString &search)
{
    mSearchTimer->start();
    mSearchText.append(search);
    mainWindow->setDockText(tr("Searched string : %1", "Text displayed in the dock widget while keyboardsearching in views. The argument is the user input string to search.").arg(mSearchText));
}

void FdViewResults::print(QPrinter &printer, QPainter &painter, const QRect &area, QRect& remainingArea, FdSubWindow *subwindow, int startPage)
{
    const int rows = model()->rowCount();

    int pageNumber = 0;
    bool titlePrinted = false;
    bool headerPrinted = false;

    struct tableElement labelHeader;
    labelHeader.width = 0.6*area.width();
    labelHeader.text = tr("Label", "Results printed pages column header.");
    labelHeader.alignement = Qt::AlignLeft;
    labelHeader.color = Qt::black;

    struct tableElement previousHeader;
    previousHeader.width = 0.2*area.width();
    previousHeader.text = tr("Previous year", "Results printed pages column header.");
    previousHeader.alignement = Qt::AlignRight;
    previousHeader.color = Qt::black;

    struct tableElement resultHeader;
    resultHeader.width = 0.2*area.width();
    resultHeader.text = tr("Result", "Results printed pages column header.");
    resultHeader.alignement = Qt::AlignRight;
    resultHeader.color = Qt::black;

    QList<tableElement*> header;
    header << &labelHeader << &previousHeader << &resultHeader;

    struct tableElement label = labelHeader;
    struct tableElement previous = previousHeader;
    struct tableElement result = resultHeader;

    QList<tableElement*> row;
    row << &label << &previous << &result;

    FdItemResults_p item;

    int neededHeight = 1200 + rows*185;

    if(neededHeight > remainingArea.height() && neededHeight < 0.75*area.height())
        remainingArea.setHeight(0);

    for(int i = 0; i < rows; ++i)
    {
        item = mModel->item(i);

        if(remainingArea.height() == 0)
        {
            printer.newPage();
            ++pageNumber;
            remainingArea = area;
            subwindow->printHeaderFooter(printer, painter, tr("Results"), pageNumber+startPage);
            headerPrinted = false;
        }

        if(!titlePrinted)
        {
            FdSubWindow::printTitle(painter, remainingArea, tr("Results"));
            titlePrinted = true;
        }
        if(!headerPrinted)
        {
            FdSubWindow::printColumnsHeader(painter, remainingArea, header);
            headerPrinted = true;
        }

//            painter.drawRect(area);

        label.text = item->id()+" "+item->label();
        previous.text = mDelegate->displayText(item->previousResult());
        result.text = mDelegate->displayText(item->result());
        if(result.text.toDouble() < 0)
            result.color = Qt::red;
        else
            result.color = Qt::black;

        FdSubWindow::printTableRow(painter, remainingArea, row);
    }
}

QList<int> FdViewResults::selectedRows() const
{
    QModelIndexList indexes = selectedIndexes();
    QList<int> rows;
    for(int i = 0; i < indexes.size(); ++i)
    {
        if(indexes[i].column() == 0)
            rows << indexes[i].row();
    }
    return rows;
}

void FdViewResults::writeSettings()
{
    QSettings settings;
    settings.beginGroup("ViewResults");
    settings.setValue("id", columnWidth(ResultsId));
    settings.setValue("label", columnWidth(ResultsLabel));
    settings.setValue("calculation", columnWidth(ResultsCalculation));
    settings.endGroup();
}

void FdViewResults::edit(const QModelIndex &index)
{
    setCurrentIndex(index);
    QTableView::edit(index);
}

void FdViewResults::setCurrentIndex(const QModelIndex &index)
{
    clearSelection();
    QTableView::setCurrentIndex(index);
}

void FdViewResults::currentChanged(const QModelIndex &current, const QModelIndex &previous)
{
    mainWindow->enableRemoveAction(current.isValid());

    QTableView::currentChanged(current, previous);
}

void FdViewResults::contextMenu(const QPoint &position)
{
    QModelIndex index = currentIndex();
    QMenu* menu = new QMenu();

    if(index.isValid())
    {
        menu->addActions(mainWindow->getContextMenuActionsEdit());
        menu->addSeparator();
    }
    menu->addActions(mainWindow->getContextMenuActionsResults());
    menu->exec(mapToGlobal(position));
}

void FdViewResults::searchTimeout()
{
    mSearchResults = mModel->entryByPartialText(mSearchText);
    if(mSearchResults.size())
    {
        mCurrentResult = -1;
        nextSearchResult();
    }
    else
        mainWindow->setDockText(tr("Sorry, no matches found.", "No matches found when searching item by text."));

    mSearchText = QString();
}

void FdViewResults::nextSearchResult()
{
    if(mSearchResults.size())
    {
        if(mCurrentResult < mSearchResults.size() - 1)
        {
            ++ mCurrentResult;
            setCurrentIndex(mSearchResults[mCurrentResult]);
        }
        else
        {
            mCurrentResult = -1;
            nextSearchResult();
        }
    }
    else
        mainWindow->setDockText(tr("Sorry, no matches found.", "No matches found when searching item by text."));
}

FdDelegateResults::FdDelegateResults(FdModelResults *model) :
    QStyledItemDelegate(0), mModel(model)
{
}

QString FdDelegateResults::displayText(const QVariant &value) const
{
    return displayText(value, QLocale::system());
}

QString FdDelegateResults::displayText(const QVariant &value, const QLocale &locale) const
{
    if(value.type() == QVariant::Double)
        return QLocale::system().toString(value.toDouble(), 'f', 2);

    return QStyledItemDelegate::displayText(value, locale);
}

void FdDelegateResults::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    FdItemResults_p item = mModel->item(index.row());
    QStyleOptionViewItem viewOption(option);

    if(!mModel->data(index, ValidityRole).toBool())
        viewOption.palette.setColor(QPalette::Highlight, Qt::red);

    if(index.column() == ResultsResult && item->result() < 0)
        viewOption.palette.setColor(QPalette::Text, Qt::red);

    QStyledItemDelegate::paint(painter, viewOption, index);
}