FdViewCoa.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 "FdViewCoa.hpp"
#include "../FdMainWindow.hpp"
#include "../FdSubWindow.hpp"
#include "../../data/FdModelCoa.hpp"
#include "../../data/FdItemCoa.hpp"

FdViewCoa::FdViewCoa(FdSubWindow *parent) :
    QTreeView(0), mSubwindow(parent)
{
    mModel = mSubwindow->coa();
    setModel(mModel);

    setSelectionBehavior(QAbstractItemView::SelectRows);
    setSelectionMode(QAbstractItemView::ExtendedSelection);
    setDragDropMode(QAbstractItemView::InternalMove);
    setDragEnabled(true);
    setAcceptDrops(true);
    setDropIndicatorShown(true);
    setAlternatingRowColors(true);

    QSettings settings;
    settings.beginGroup("ViewCoa");
    setColumnWidth(CoaId, settings.value("id", 100).toInt());
    setColumnWidth(CoaLabel, settings.value("label", 500).toInt());
    setColumnWidth(CoaBalanceSheet, settings.value("balanceSheet", 110).toInt());
    setColumnWidth(CoaSigns, settings.value("signs", 40).toInt());
    setColumnWidth(CoaInitial, settings.value("initial", 90).toInt());
    settings.endGroup();
    header()->setResizeMode(CoaBalance, QHeaderView::Stretch);
    header()->setDefaultAlignment(Qt::AlignCenter);

    mDelegate = new FdDelegateCoa(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 FdViewCoa::mouseReleaseEvent(QMouseEvent* event)
{
    if (event->button() == Qt::LeftButton && !(indexAt(event->pos()).isValid()))
        setCurrentIndex(QModelIndex());

    QTreeView::mouseReleaseEvent(event);
}

QModelIndex FdViewCoa::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
{
    QModelIndex index = currentIndex();
    if(index.isValid())
    {
        FdItemCoa_p item;
        if(cursorAction == QAbstractItemView::MoveNext)
        {
            item = mModel->item(index);

            if(index.column() == CoaLabel && item->type() == AccountType)
                return model()->index(index.row(), index.column()+2, index.parent());
            else if(index.column() == CoaLabel && item->type() == CategoryType) {}
            else if(index.column() != CoaInitial)
                return model()->index(index.row(), index.column()+1, index.parent());

            return model()->index(index.row(), CoaId, index.parent());
        }
        else if(cursorAction == QAbstractItemView::MovePrevious)
        {
            item = mModel->item(index);

            if(index.column() == CoaSigns)
                return model()->index(index.row(), index.column()-2, index.parent());
            else if(index.column() != CoaId)
                 return model()->index(index.row(), index.column()-1, index.parent());

            if(item->type() == AccountType)
                return model()->index(index.row(), CoaInitial, index.parent());
            else if(item->type() == CategoryType)
                return model()->index(index.row(), CoaLabel, index.parent());
        }
        else if(cursorAction == QAbstractItemView::MovePageUp)
        {
            item = mModel->item(index);
            if(item->parent()->type() != RootType)
                return mModel->index(item->parent());
            else
                return index;
        }
        else if(cursorAction == QAbstractItemView::MovePageDown)
        {
            item = mModel->item(index);
            if(item->childrenCount())
                return mModel->index(item->child(0));
            else
                return index;
        }
    }

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

void FdViewCoa::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));
}

int FdViewCoa::print(QPrinter &printer, QPainter &painter, const QRect &area, QRect& remainingArea)
{
    QFont font = painter.font();
    // This controls accounts font size
    font.setPointSize(12);
    int rowHeight = 250;

    int pageNumber = print(printer,
                           painter,
                           area,
                           remainingArea,
                           font,
                           rowHeight,
                           200,
                           0.6*area.width(),
                           0.2*area.width(),
                           mModel->getRootItem());


    remainingArea.setRect(area.x(), remainingArea.y()+2*rowHeight, area.width(), remainingArea.height()-2*rowHeight);
    return pageNumber;
}

int FdViewCoa::print(QPrinter &printer, QPainter &painter, const QRect &area, QRect &remainingArea, QFont font, int rowHeight, int tabulation, int widthLabel, int widthAmount, FdItemCoa_p parent, int pageNumber, int level)
{
    QRect rect;
    FdItemCoa_p item;
    int x;
    int rows;
    QString text;

    for(int i = 0; i < parent->childrenCount(); ++i)
    {
        item = parent->child(i);
        rows = item->childrenCount();
        x = 0;

        if((pageNumber || level) && rows*rowHeight > remainingArea.height() && rows*rowHeight < area.height())
            remainingArea.setHeight(0);

        if(remainingArea.height() < rowHeight)
        {
            remainingArea = area;

            if(pageNumber)
                printer.newPage();
            else
                FdSubWindow::printTitle(painter, remainingArea, tr("Chart of accounts", "Chart of accounts printed page title."));

//            painter.drawRect(area);

            ++pageNumber;
            mSubwindow->printHeaderFooter(printer, painter, tr("Chart of accounts", "Chart of accounts printed pages footer."), pageNumber);

            x += remainingArea.x()+widthLabel;
            rect.setRect(x, remainingArea.y(), widthAmount, rowHeight);
            painter.drawText(rect, Qt::AlignRight, tr("Previous year", "Chart of accounts printed pages column header."));
            x += widthAmount;
            rect.setRect(x, remainingArea.y(), widthAmount, rowHeight);
            painter.drawText(rect, Qt::AlignRight, tr("Current year", "Chart of accounts printed pages column header."));

            remainingArea.setRect(remainingArea.x(), remainingArea.y()+rowHeight, remainingArea.width(), remainingArea.height()-rowHeight);
        }

        if(item->type() == CategoryType)
        {
            remainingArea.setRect(remainingArea.x(), remainingArea.y()+rowHeight, remainingArea.width(), remainingArea.height()-rowHeight);
            font.setBold(true);
        }
        else
            font.setBold(false);

        painter.setFont(font);

        x = remainingArea.x()+level*tabulation;
        rect.setRect(x, remainingArea.y(), widthLabel, rowHeight);
        text = item->displayLabel();
        painter.drawText(rect, Qt::AlignLeft, text);

        x -= level*tabulation;
        x += widthLabel;
        rect.setRect(x, remainingArea.y(), widthAmount, rowHeight);
        if(item->onBalanceSheet())
        {
            if(item->initialBalance() < 0)
                painter.setPen(Qt::red);

            text = mDelegate->displayText(item->initialBalance());
            painter.drawText(rect, Qt::AlignRight, text);
        }
        else if(item->previousBalance())
        {
            if(item->previousBalance() < 0)
                painter.setPen(Qt::red);

            text = mDelegate->displayText(item->previousBalance());
            painter.drawText(rect, Qt::AlignRight, text);
        }
        painter.setPen(Qt::black);

        x += widthAmount;
        rect.setRect(x, remainingArea.y(), widthAmount, rowHeight);
        if(item->balance() < 0)
            painter.setPen(Qt::red);
        text = mDelegate->displayText(item->balance());
        painter.drawText(rect, Qt::AlignRight, text);
        painter.setPen(Qt::black);

        remainingArea.setRect(remainingArea.x(), remainingArea.y()+rowHeight, remainingArea.width(), remainingArea.height()-rowHeight);

        if(item->children().size())
            pageNumber = print(printer,
                               painter,
                               area,
                               remainingArea,
                               font,
                               rowHeight,
                               tabulation,
                               widthLabel,
                               widthAmount,
                               item,
                               pageNumber,
                               level+1);
    }
    return pageNumber;
}

QModelIndexList FdViewCoa::selectedItems() const
{
    QModelIndexList selected = selectedIndexes();
    QModelIndexList indexes;
    for(int i = 0; i < selected.size(); ++i)
    {
        if(selected[i].column() == 0)
            indexes << selected[i];
    }

    for(int i = 0; i < indexes.size(); ++i)
    {
        QModelIndex index = indexes[i];
        while(index.parent() != QModelIndex())
        {
            if(indexes.contains(index.parent()))
            {
                indexes.removeAt(i);
                --i;
                break;
            }
            index = index.parent();
        }
    }

    return indexes;
}

void FdViewCoa::writeSettings()
{
    QSettings settings;
    settings.beginGroup("ViewCoa");
    settings.setValue("id", columnWidth(CoaId));
    settings.setValue("label", columnWidth(CoaLabel));
    settings.setValue("balanceSheet", columnWidth(CoaBalanceSheet));
    settings.setValue("signs", columnWidth(CoaSigns));
    settings.setValue("initial", columnWidth(CoaInitial));
    settings.endGroup();
}

void FdViewCoa::edit(const QModelIndex &index)
{
    setCurrentIndex(index);
    QTreeView::edit(index);
}

void FdViewCoa::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
{
    if(!state())
        setCurrentIndex(bottomRight);
    QTreeView::dataChanged(topLeft, bottomRight);
}

void FdViewCoa::setCurrentIndex(const QModelIndex &index)
{
    clearSelection();
    QTreeView::setCurrentIndex(index);
}

void FdViewCoa::currentChanged(const QModelIndex &current, const QModelIndex &previous)
{
    mainWindow->enableRemoveAction(mModel->isRemovable(current));

    if(mModel->item(current)->type() == AccountType)
        mainWindow->enableShowAccountAction(true);
    else
        mainWindow->enableShowAccountAction(false);

    QTreeView::currentChanged(current, previous);
}

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

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

void FdViewCoa::searchTimeout()
{
    mSearchResults = mModel->itemByPartialText(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 FdViewCoa::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."));
}

FdDelegateCoa::FdDelegateCoa(FdModelCoa *model) : QStyledItemDelegate(0), mModel(model)
{
}

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

QString FdDelegateCoa::displayText(const QVariant &value, const QLocale &locale) const
{
    if(value.type() == QVariant::Double)
        return QLocale::system().toString(value.toDouble(), 'f', 2);
//        QString balance = value.toString();
//        QRegExp decimal("[.]");
//        QRegExp one_decimal("[.]\\d$");
//        if(!balance.contains(decimal))
//            balance.append(".00");
//        else if(balance.contains(one_decimal))
//            balance.append("0");

//        return balance;

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

void FdDelegateCoa::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    QStyleOptionViewItem viewOption(option);
    FdItemCoa_p item = mModel->item(index);

    if(item->type() == CategoryType)
        viewOption.font.setBold(true);

    if((index.column() == CoaInitial && item->initialBalance() < 0) || (index.column() == CoaBalance && item->balance() < 0))
        viewOption.palette.setColor(QPalette::Text, Qt::red);

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

QWidget* FdDelegateCoa::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
{
    if(index.column() == CoaSigns)
    {
        QComboBox* box = new QComboBox(parent);
        box->addItem("+-", PlusMinus);
        box->addItem("-+", MinusPlus);
        QVariant value = mModel->item(index)->signature();
        box->setCurrentIndex(box->findData(value));
        return box;
    }

    return QStyledItemDelegate::createEditor(parent, option, index);
}

void FdDelegateCoa::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
{
    if(index.column() == CoaSigns)
    {
        QComboBox* box = static_cast<QComboBox*>(editor);
        QVariant value = box->itemData(box->currentIndex());
        model->setData(index, value, Qt::EditRole);
    }
    else
        QStyledItemDelegate::setModelData(editor, model, index);
}