/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qtablewidget.h"

#ifndef QT_NO_TABLEWIDGET

#include <qitemdelegate.h>

#include <qpainter.h>

#include <private/qtablewidget_p.h>

QT_BEGIN_NAMESPACE

QTableModel::QTableModel(int rows, int columns, QTableWidget *parent)

    : QAbstractTableModel(parent),

      prototype(0),

      tableItems(rows * columns, 0),

      verticalHeaderItems(rows, 0),

      horizontalHeaderItems(columns, 0)

{}

QTableModel::~QTableModel()

{

    clear();

    delete prototype;

}

bool QTableModel::insertRows(int row, int count, const QModelIndex &)

{

    if (count < 1 || row < 0 || row > verticalHeaderItems.count())

        return false;

    beginInsertRows(QModelIndex(), row, row + count - 1);

    int rc = verticalHeaderItems.count();

    int cc = horizontalHeaderItems.count();

    verticalHeaderItems.insert(row, count, 0);

    if (rc == 0)

        tableItems.resize(cc * count);

    else

        tableItems.insert(tableIndex(row, 0), cc * count, 0);

    endInsertRows();

    return true;

}

bool QTableModel::insertColumns(int column, int count, const QModelIndex &)

{

    if (count < 1 || column < 0 || column > horizontalHeaderItems.count())

        return false;

    beginInsertColumns(QModelIndex(), column, column + count - 1);

    int rc = verticalHeaderItems.count();

    int cc = horizontalHeaderItems.count();

    horizontalHeaderItems.insert(column, count, 0);

    if (cc == 0)

        tableItems.resize(rc * count);

    else

        for (int row = 0; row < rc; ++row)

            tableItems.insert(tableIndex(row, column), count, 0);

    endInsertColumns();

    return true;

}

bool QTableModel::removeRows(int row, int count, const QModelIndex &)

{

    if (count < 1 || row < 0 || row + count > verticalHeaderItems.count())

        return false;

    beginRemoveRows(QModelIndex(), row, row + count - 1);

    int i = tableIndex(row, 0);

    int n = count * columnCount();

    QTableWidgetItem *oldItem = 0;

    for (int j = i; j < n + i; ++j) {

        oldItem = tableItems.at(j);

        if (oldItem)

            oldItem->view = 0;

        delete oldItem;

    }

    tableItems.remove(qMax(i, 0), n);

    for (int v = row; v < row + count; ++v) {

        oldItem = verticalHeaderItems.at(v);

        if (oldItem)

            oldItem->view = 0;

        delete oldItem;

    }

    verticalHeaderItems.remove(row, count);

    endRemoveRows();

    return true;

}

bool QTableModel::removeColumns(int column, int count, const QModelIndex &)

{

    if (count < 1 || column < 0 || column + count >  horizontalHeaderItems.count())

        return false;

    beginRemoveColumns(QModelIndex(), column, column + count - 1);

    QTableWidgetItem *oldItem = 0;

    for (int row = rowCount() - 1; row >= 0; --row) {

        int i = tableIndex(row, column);

        for (int j = i; j < i + count; ++j) {

            oldItem = tableItems.at(j);

            if (oldItem)

                oldItem->view = 0;

            delete oldItem;

        }

        tableItems.remove(i, count);

    }

    for (int h=column; h<column+count; ++h) {

        oldItem = horizontalHeaderItems.at(h);

        if (oldItem)

            oldItem->view = 0;

        delete oldItem;

    }

    horizontalHeaderItems.remove(column, count);

    endRemoveColumns();

    return true;

}

void QTableModel::setItem(int row, int column, QTableWidgetItem *item)

{

    int i = tableIndex(row, column);

    if (i < 0 || i >= tableItems.count())

        return;

    QTableWidgetItem *oldItem = tableItems.at(i);

    if (item == oldItem)

        return;

    // remove old

    if (oldItem)

        oldItem->view = 0;

    delete tableItems.at(i);

    QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

    // set new

    if (item)

        item->d->id = i;

    tableItems[i] = item;

    if (view && view->isSortingEnabled()

        && view->horizontalHeader()->sortIndicatorSection() == column) {

        // sorted insertion

        Qt::SortOrder order = view->horizontalHeader()->sortIndicatorOrder();

        QVector<QTableWidgetItem*> colItems = columnItems(column);

        if (row < colItems.count())

            colItems.remove(row);

        int sortedRow;

        if (item == 0) {

            // move to after all non-0 (sortable) items

            sortedRow = colItems.count();

        } else {

            QVector<QTableWidgetItem*>::iterator it;

            it = sortedInsertionIterator(colItems.begin(), colItems.end(), order, item);

            sortedRow = qMax((int)(it - colItems.begin()), 0);

        }

        if (sortedRow != row) {

            emit layoutAboutToBeChanged();

            // move the items @ row to sortedRow

            int cc = columnCount();

            QVector<QTableWidgetItem*> rowItems(cc);

            for (int j = 0; j < cc; ++j)

                rowItems[j] = tableItems.at(tableIndex(row, j));

            tableItems.remove(tableIndex(row, 0), cc);

            tableItems.insert(tableIndex(sortedRow, 0), cc, 0);

            for (int j = 0; j < cc; ++j)

                tableItems[tableIndex(sortedRow, j)] = rowItems.at(j);

            QTableWidgetItem *header = verticalHeaderItems.at(row);

            verticalHeaderItems.remove(row);

            verticalHeaderItems.insert(sortedRow, header);

            // update persistent indexes

            QModelIndexList oldPersistentIndexes = persistentIndexList();

            QModelIndexList newPersistentIndexes = oldPersistentIndexes;

            updateRowIndexes(newPersistentIndexes, row, sortedRow);

            changePersistentIndexList(oldPersistentIndexes,

                                      newPersistentIndexes);

            emit layoutChanged();

            return;

        }

    }

    QModelIndex idx = QAbstractTableModel::index(row, column);

    emit dataChanged(idx, idx);

}

QTableWidgetItem *QTableModel::takeItem(int row, int column)

{

    long i = tableIndex(row, column);

    QTableWidgetItem *itm = tableItems.value(i);

    if (itm) {

        itm->view = 0;

        itm->d->id = -1;

        tableItems[i] = 0;

        QModelIndex ind = index(itm);

        emit dataChanged(ind, ind);

    }

    return itm;

}

QTableWidgetItem *QTableModel::item(int row, int column) const

{

    return tableItems.value(tableIndex(row, column));

}

QTableWidgetItem *QTableModel::item(const QModelIndex &index) const

{

    if (!isValid(index))

        return 0;

    return tableItems.at(tableIndex(index.row(), index.column()));

}

void QTableModel::removeItem(QTableWidgetItem *item)

{

    int i = tableItems.indexOf(item);

    if (i != -1) {

        tableItems[i] = 0;

        QModelIndex idx = index(item);

        emit dataChanged(idx, idx);

        return;

    }

    i = verticalHeaderItems.indexOf(item);

    if (i != -1) {

        verticalHeaderItems[i] = 0;

        emit headerDataChanged(Qt::Vertical, i, i);

        return;

    }

    i = horizontalHeaderItems.indexOf(item);

    if (i != -1) {

        horizontalHeaderItems[i] = 0;

        emit headerDataChanged(Qt::Horizontal, i, i);

        return;

    }

}

void QTableModel::setHorizontalHeaderItem(int section, QTableWidgetItem *item)

{

    if (section < 0 || section >= horizontalHeaderItems.count())

        return;

    QTableWidgetItem *oldItem = horizontalHeaderItems.at(section);

    if (item == oldItem)

        return;

    if (oldItem)

        oldItem->view = 0;

    delete oldItem;

    QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

    if (item) {

        item->view = view;

        item->itemFlags = Qt::ItemFlags(int(item->itemFlags)|ItemIsHeaderItem);

    }

    horizontalHeaderItems[section] = item;

    emit headerDataChanged(Qt::Horizontal, section, section);

}

void QTableModel::setVerticalHeaderItem(int section, QTableWidgetItem *item)

{

    if (section < 0 || section >= verticalHeaderItems.count())

        return;

    QTableWidgetItem *oldItem = verticalHeaderItems.at(section);

    if (item == oldItem)

        return;

    if (oldItem)

        oldItem->view = 0;

    delete oldItem;

    QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

    if (item) {

        item->view = view;

        item->itemFlags = Qt::ItemFlags(int(item->itemFlags)|ItemIsHeaderItem);

    }

    verticalHeaderItems[section] = item;

    emit headerDataChanged(Qt::Vertical, section, section);

}

QTableWidgetItem *QTableModel::takeHorizontalHeaderItem(int section)

{

    if (section < 0 || section >= horizontalHeaderItems.count())

        return 0;

    QTableWidgetItem *itm = horizontalHeaderItems.at(section);

    if (itm) {

        itm->view = 0;

        itm->itemFlags &= ~ItemIsHeaderItem;

        horizontalHeaderItems[section] = 0;

    }

    return itm;

}

QTableWidgetItem *QTableModel::takeVerticalHeaderItem(int section)

{

    if (section < 0 || section >= verticalHeaderItems.count())

        return 0;

    QTableWidgetItem *itm = verticalHeaderItems.at(section);

    if (itm) {

        itm->view = 0;

        itm->itemFlags &= ~ItemIsHeaderItem;

        verticalHeaderItems[section] = 0;

    }

    return itm;

}

QTableWidgetItem *QTableModel::horizontalHeaderItem(int section)

{

    return horizontalHeaderItems.value(section);

}

QTableWidgetItem *QTableModel::verticalHeaderItem(int section)

{

    return verticalHeaderItems.value(section);

}

QModelIndex QTableModel::index(const QTableWidgetItem *item) const

{

    if (!item)

        return QModelIndex();

    int i = -1;

    const int id = item->d->id;

    if (id >= 0 && id < tableItems.count() && tableItems.at(id) == item) {

        i = id;

    } else { // we need to search for the item

        i = tableItems.indexOf(const_cast<QTableWidgetItem*>(item));

        if (i == -1) // not found

            return QModelIndex();

    }

    int row = i / columnCount();

    int col = i % columnCount();

    return QAbstractTableModel::index(row, col);

}

void QTableModel::setRowCount(int rows)

{

    int rc = verticalHeaderItems.count();

    if (rows < 0 || rc == rows)

        return;

    if (rc < rows)

        insertRows(qMax(rc, 0), rows - rc);

    else

        removeRows(qMax(rows, 0), rc - rows);

}

void QTableModel::setColumnCount(int columns)

{

    int cc = horizontalHeaderItems.count();

    if (columns < 0 || cc == columns)

        return;

    if (cc < columns)

        insertColumns(qMax(cc, 0), columns - cc);

    else

        removeColumns(qMax(columns, 0), cc - columns);

}

int QTableModel::rowCount(const QModelIndex &parent) const

{

    return parent.isValid() ? 0 : verticalHeaderItems.count();

}

int QTableModel::columnCount(const QModelIndex &parent) const

{

    return parent.isValid() ? 0 : horizontalHeaderItems.count();

}

QVariant QTableModel::data(const QModelIndex &index, int role) const

{

    QTableWidgetItem *itm = item(index);

    if (itm)

        return itm->data(role);

    return QVariant();

}

bool QTableModel::setData(const QModelIndex &index, const QVariant &value, int role)

{

    if (!index.isValid())

        return false;

    QTableWidgetItem *itm = item(index);

    if (itm) {

        itm->setData(role, value);

        return true;

    }

    // don't create dummy table items for empty values

    if (!value.isValid())

        return false;

    QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

    if (!view)

        return false;

    itm = createItem();

    itm->setData(role, value);

    view->setItem(index.row(), index.column(), itm);

    return true;

}

QMap<int, QVariant> QTableModel::itemData(const QModelIndex &index) const

{

    QMap<int, QVariant> roles;

    QTableWidgetItem *itm = item(index);

    if (itm) {

        for (int i = 0; i < itm->values.count(); ++i) {

            roles.insert(itm->values.at(i).role,

                         itm->values.at(i).value);

        }

    }

    return roles;

}

// reimplemented to ensure that only one dataChanged() signal is emitted

bool QTableModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)

{

    if (!index.isValid())

        return false;

    QTableWidget *view = qobject_cast<QTableWidget*>(QObject::parent());

    QTableWidgetItem *itm = item(index);

    if (itm) {

        itm->view = 0; // prohibits item from calling itemChanged()

        bool changed = false;

        for (QMap<int, QVariant>::ConstIterator it = roles.constBegin(); it != roles.constEnd(); ++it) {

            if (itm->data(it.key()) != it.value()) {

                itm->setData(it.key(), it.value());

                changed = true;

            }

        }

        itm->view = view;

        if (changed)

            itemChanged(itm);

        return true;

    }

    if (!view)

        return false;

    itm = createItem();

    for (QMap<int, QVariant>::ConstIterator it = roles.constBegin(); it != roles.constEnd(); ++it)

        itm->setData(it.key(), it.value());

    view->setItem(index.row(), index.column(), itm);

    return true;

}

Qt::ItemFlags QTableModel::flags(const QModelIndex &index) const

{

    if (!index.isValid())

        return Qt::ItemIsDropEnabled;

    if (QTableWidgetItem *itm = item(index))

        return itm->flags();

    return (Qt::ItemIsEditable

            |Qt::ItemIsSelectable

            |Qt::ItemIsUserCheckable

            |Qt::ItemIsEnabled

            |Qt::ItemIsDragEnabled

            |Qt::ItemIsDropEnabled);

}

void QTableModel::sort(int column, Qt::SortOrder order)

{

    QVector<QPair<QTableWidgetItem*, int> > sortable;

    QVector<int> unsortable;

    sortable.reserve(rowCount());

    unsortable.reserve(rowCount());

    for (int row = 0; row < rowCount(); ++row) {

        if (QTableWidgetItem *itm = item(row, column))

            sortable.append(QPair<QTableWidgetItem*,int>(itm, row));

        else

            unsortable.append(row);

    }

    LessThan compare = (order == Qt::AscendingOrder ? &itemLessThan : &itemGreaterThan);

    qStableSort(sortable.begin(), sortable.end(), compare);

    QVector<QTableWidgetItem*> sorted_table(tableItems.count());

    QModelIndexList from;

    QModelIndexList to;

    for (int i = 0; i < rowCount(); ++i) {

        int r = (i < sortable.count()

                 ? sortable.at(i).second

                 : unsortable.at(i - sortable.count()));

        for (int c = 0; c < columnCount(); ++c) {

            sorted_table[tableIndex(i, c)] = item(r, c);

            from.append(createIndex(r, c, 0));

            to.append(createIndex(i, c, 0));

        }

    }

    emit layoutAboutToBeChanged();