FdModelResults.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 "FdModelResults.hpp"
#include "FdItemResults.hpp"
#include "FdCommandsResults.hpp"
#include "FdModelCoa.hpp"
#include "FdItemCoa.hpp"
#include "../gui/FdSubWindow.hpp"


FdModelResults::FdModelResults(FdSubWindow* parent) : QAbstractTableModel(0), mSubwindow(parent)
{
    init();
}

FdModelResults::FdModelResults(FdSubWindow *parent, QDomElement &results) : QAbstractTableModel(0), mSubwindow(parent)
{
    mResults = QList<FdItemResults_p>();
    QDomElement calculation = results.firstChildElement();
    while(!calculation.isNull())
    {
        mResults << FdItemResults::pointer(calculation);
        calculation = calculation.nextSiblingElement();
    }

    init();
}

FdModelResults::FdModelResults(FdSubWindow *parent, const FdModelResults *model) : QAbstractTableModel(0), mSubwindow(parent)
{
    mResults = QList<FdItemResults_p>();
    for(int i = 0; i < model->items().size(); ++i)
        mResults << FdItemResults::pointer(model->items()[i]);

    init();
}

void FdModelResults::init()
{
    setSupportedDragActions(Qt::MoveAction);
    mStack = new QUndoStack();
    connect(mStack, SIGNAL(cleanChanged(bool)), mSubwindow, SLOT(cleanStateChanged(bool)));
}

QVariant FdModelResults::data(FdItemResults_p calculation, ResultsColumn column) const
{
    switch(column)
    {
    case ResultsId: return calculation->id();
    case ResultsLabel: return calculation->label();
    case ResultsCalculation: return calculation->calculation();
    case ResultsResult:
        if(!calculation->isEmpty())
            return calculation->result();
        else
            return "";
    }

    return QVariant();
}

QVariant FdModelResults::data(const QModelIndex &index, int role) const
{
    if(!index.isValid())
        return QVariant();
    if(role == Qt::TextAlignmentRole && index.column() == ResultsResult)
        return Qt::AlignRight;
    if(role == ValidityRole)
        return isValid(mResults[index.row()]->calculation());
    if(role != Qt::DisplayRole && role != Qt::EditRole)
        return QVariant();

    return data(mResults[index.row()], ResultsColumn(index.column()));
}

void FdModelResults::setData(FdItemResults_p calculation, ResultsColumn column, const QVariant &value)
{
    int row = mResults.indexOf(calculation);
    switch(column)
    {
    case ResultsId:
        calculation->setId(value.toString());
        break;
    case ResultsLabel:
        calculation->setLabel(value.toString());
        break;
    case ResultsCalculation:
        calculation->setCalculation(value.toString());
        break;
    }

    emit(dataChanged(index(row, column), index(row, column)));
}

bool FdModelResults::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if(!index.isValid() || role != Qt::EditRole)
        return false;

    if(value == data(index, Qt::DisplayRole))
        return true;

    int column = index.column();
    switch(column)
    {
    case ResultsId:
        if(idExists(value.toString()))
            return false;
        break;
    case ResultsCalculation:
        break;
    }

    FdItemResults_p calculation = mResults.at(index.row());
    mStack->push(new FdResultsSetData(this, calculation, ResultsColumn(column), value));
    return true;
}

QVariant FdModelResults::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(role == Qt::DisplayRole)
    {
        if (orientation == Qt::Horizontal)
        {
            switch(section)
            {
            case ResultsId: return tr("Id", "Results page column header.");
            case ResultsLabel: return tr("Label", "Results page column header.");
            case ResultsCalculation: return tr("Calculation", "Results page column header.");
            case ResultsResult: return tr("Result", "Results page column header.");
            }
        }
        else
            return section+1;
    }

    return QVariant();
}

Qt::ItemFlags FdModelResults::flags(const QModelIndex &index) const
{
    Qt::ItemFlags flags;
    if(index.isValid())
    {
        flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
        if(index.column() != ResultsResult)
            flags |= Qt::ItemIsEditable;
    }

    return flags;
}

Qt::DropActions FdModelResults::supportedDropActions() const
{
    return Qt::MoveAction;
}

QStringList FdModelResults::mimeTypes() const
{
    return QStringList() << "application/freedebks";
}

QMimeData* FdModelResults::mimeData(const QModelIndexList &indexes) const
{
    QMimeData* mimeData = new QMimeData();
    QByteArray encodedData;
    QDataStream stream(&encodedData, QIODevice::WriteOnly);

    for(int i = 0; i < indexes.size(); ++i)
    {
        if(indexes[i].column() == 0)
            stream << indexes[i].row();
    }

    mimeData->setData("application/freedebks", encodedData);
    return mimeData;
}

bool FdModelResults::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
    if(action != Qt::MoveAction)
        return false;

    QByteArray encodedData = data->data("application/freedebks");
    QDataStream stream(&encodedData, QIODevice::ReadOnly);
    QList<int> rows;
    row = parent.row();
    int j;

    while(!stream.atEnd())
    {
        j = 0;
        stream >> row;
        for(int i = 0; i < rows.size(); i++)
            if(row > rows[i])
                ++j;

        rows.insert(j, row);
    }

    mStack->push(new FdResultsDragDrop(this, rows, parent.row()));
    return true;
}

bool FdModelResults::removeRows(int row, int count, const QModelIndex &parent)
{
    beginRemoveRows(parent, row, row+count-1);
    for(int i = 0; i < count; ++i)
    {
        mResults.removeAt(row);
    }
    endRemoveRows();
    return true;
}

int FdModelResults::rowCount(const QModelIndex &parent) const
{
    return mResults.size();
}

int FdModelResults::columnCount(const QModelIndex &parent) const
{
    return ResultsColumnCount;
}

void FdModelResults::insertCalculation(FdItemResults_p calculation, int row)
{
    insertCalculations(QList<FdItemResults_p>() << calculation, row);
}

void FdModelResults::insertCalculations(QList<FdItemResults_p> calculations, int row)
{
    int count = calculations.size();
    beginInsertRows(QModelIndex(), row, row+count-1);
    for(int i = 0; i < count; ++i)
    {
        mResults.insert(row+i, calculations[i]);
    }
    endInsertRows();
}

void FdModelResults::removeCalculation(FdItemResults_p calculation)
{
    removeCalculations(QList<FdItemResults_p>() << calculation);
}

void FdModelResults::removeCalculations(QList<FdItemResults_p> calculations)
{
    for(int i = 0; i < calculations.size(); ++i)
        removeRow(mResults.indexOf(calculations[i]));
}

QAction* FdModelResults::redo()
{
    return mStack->createRedoAction(this);
}

QAction* FdModelResults::undo()
{
    return mStack->createUndoAction(this);
}

bool FdModelResults::idExists(QString id) const
{
    if(mSubwindow->coa()->idExists(id) || !item(id).isNull())
        return true;

    return false;
}

FdItemResults_p FdModelResults::item(QString id) const
{
    for(int i = 0; i < mResults.size(); ++i)
    {
        if(mResults[i]->id() == id)
            return mResults[i];
    }

    return FdItemResults_p(0);
}

FdItemResults_p FdModelResults::item(int row) const
{
    return mResults[row];
}

QList<FdItemResults_p> FdModelResults::items() const
{
    return mResults;
}

QModelIndexList FdModelResults::entryByPartialText(QString text) const
{
    QModelIndexList results;
    for(int i = 0; i < rowCount(); ++i)
    {
        if(mResults[i]->label().contains(text, Qt::CaseInsensitive))
            results << index(i, 0);
    }
    return results;
}

bool FdModelResults::isValid(QString calculation) const
{
    QRegExp symbols("[-+*/()\"]");
    int p = 0;
    QString term;
    QString symbol;

    while(calculation.size())
    {
        p = calculation.indexOf(symbols);

        if(p != -1)
        {
            symbol = calculation[p];

            if(p == 0 && symbol == "\"")
            {
                calculation = calculation.mid(1);
                p = calculation.indexOf("\"");
                if(p == -1)
                    return false;
                else
                {
                    term = calculation.left(p);
                    FdItemCoa_p itemCoa = mSubwindow->coa()->itemById(term);
                    FdItemResults_p itemResults = this->item(term);
                    if(itemCoa.isNull() && itemResults.isNull())
                        return false;
                }
            }
            else if(p && !calculation.left(p).toDouble())
                return false;

            calculation = calculation.mid(p+1);
        }
        else if(!calculation.toDouble())
            return false;
        else
            calculation = "";
    }

    return true;
}

double FdModelResults::parse(QString calculation) const
{
    QStack<QString> postfix = FdModelResults::infixToPostfix(calculation);
    QStack<double> stack;
    QString e;
    double opL = 0;
    double opR = 0;
    QRegExp operators("[-+*/]");

    while(!postfix.isEmpty())
    {
        e = postfix.front();
        postfix.pop_front();
        if(e.size() == 1 && e.contains(operators))
        {
            opR = stack.pop();
            opL = stack.pop();

            if(e == "+")
                stack.push(opL+opR);
            else if(e == "-")
                stack.push(opL-opR);
            else if(e == "*")
                stack.push(opL*opR);
            else if(e == "/")
                stack.push(opL/opR);
        }
        else
            stack.push(parseItem(e));
    }

    return stack.pop();

}

double FdModelResults::parseItem(QString element) const
{
    int i = 0;
    QString e = element.at(0);

    if(e == "\"")
    {
        i = element.indexOf("\"", 1);
        if(i == -1)
            return 0;
        else
        {
             element = element.mid(1, i-1);
             FdItemCoa_p itemCoa = mSubwindow->coa()->itemById(element);
             FdItemResults_p itemResults = this->item(element);
             if(!itemCoa.isNull())
                 return itemCoa->balance();
             else if(!itemResults.isNull())
                 return itemResults->result();
             else
                 return 0;
        }
    }
    else
        return element.toDouble();
}

QDomElement FdModelResults::toXml(QDomDocument &document) const
{
    QDomElement results = document.createElement("Results");
    for(int i = 0; i < mResults.size(); ++i)
    {
        if(!mResults[i]->isEmpty())
        {
            QDomElement calculation = mResults[i]->toXml(document);
            results.appendChild(calculation);
        }
    }

    mStack->setClean();
    return results;
}

QModelIndex FdModelResults::addCalculation(const QModelIndex &selected)
{
    int row;
    if(selected.isValid())
        row = selected.row()+1;
    else
        row = rowCount();

    // Choses a new id
    QString base = "R";
    QString id;
    int i = 0;
    do
    {
        id = base+QString::number(i);
        ++i;
    }
    while(idExists(id));

    struct locationResults location;
    location.item = FdItemResults_p(new FdItemResults(id));
    location.row = row;

    mStack->push(new FdResultsAdd(this, location));
    return index(row, ResultsId);
}

void FdModelResults::removeSelected(const QList<int> &rows)
{
    if(rows.size())
        mStack->push(new FdResultsRemove(this, rows));
}

void FdModelResults::recomputeResults()
{
    for(int i = 0; i < mResults.size(); ++i)
    {
        if(!mResults[i]->isEmpty())
            mResults[i]->setResult(parse(mResults[i]->calculation()));
    }
    emit(dataChanged(index(0,0), index(rowCount()-1, columnCount()-1)));
}

QStack<QString> FdModelResults::infixToPostfix(QString expr)
{
    QRegExp operators("[-+*/]");
    QRegExp symbols("[-+*/()]");
    QStack<QString> stack;
    QStack<QString> postfix; // This will be a stack containing the postfix expression upside down.
    QString e;
    bool prevOp = true; // Is true if the previous element was an operator (or a "("). Helps treating negative numbers.
    int i = 0;

    while(expr.size())
    {
        // indexOf() returns -1 if no symbols were found.
        if(prevOp && QString(expr.at(0)) == "-")
        {
            if(QString(expr.at(1)) == "(")
                expr.insert(1, "1");
            i = expr.indexOf(symbols,1);
        }
        else
            i = expr.indexOf(symbols);

        if(i)
        {
            postfix.push(expr.left(i));
            expr = expr.mid(i);
            if(i == -1)
                break;
            if(QString(expr.at(0)) == "(")
                expr.prepend("*");
            prevOp=false;
        }

        e = expr.at(0);

        if(e == "-" && prevOp)
        {
            i = expr.indexOf(symbols,1);
            postfix.push(expr.left(i));
            expr = expr.mid(i);
            prevOp=false;
            e = expr.at(0);
        }

        if(e == "(")
        {
            stack.push("(");
            prevOp=true;
        }

        if(e == ")")
        {
            while(stack.top() != "(")
                postfix.push(stack.pop());

            stack.pop();
        }

        if(e.contains(operators))
        {
            if(stack.isEmpty())
                stack.push(e);
            else
            {
                while(!stack.isEmpty() && FdModelResults::opPriority(stack.top()) >= FdModelResults::opPriority(e))
                    postfix.push(stack.pop());

                stack.push(e);
            }
            prevOp=true;
        }

        expr.remove(0,1);
    }

    while(!stack.isEmpty())
        postfix.push(stack.pop());

    return postfix;
}


int FdModelResults::opPriority(QString op)
{
    if(op == "+" || op == "-")
        return 1;
    else if(op == "*" || op == "/")
        return 2;
    else
        return 0;

}