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

**

** 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 "qlistwidget.h"

#ifndef QT_NO_LISTWIDGET

#include <qitemdelegate.h>

#include <private/qlistview_p.h>

#include <private/qwidgetitemdata_p.h>

#include <private/qlistwidget_p.h>

QT_BEGIN_NAMESPACE

// workaround for VC++ 6.0 linker bug (?)

typedef bool(*LessThan)(const QPair<QListWidgetItem*,int>&,const QPair<QListWidgetItem*,int>&);

class QListWidgetMimeData : public QMimeData

{

    Q_OBJECT

public:

    QList<QListWidgetItem*> items;

};

QT_BEGIN_INCLUDE_NAMESPACE

#include "qlistwidget.moc"

QT_END_INCLUDE_NAMESPACE

QListModel::QListModel(QListWidget *parent)

    : QAbstractListModel(parent)

{

}

QListModel::~QListModel()

{

    clear();

}

void QListModel::clear()

{

    for (int i = 0; i < items.count(); ++i) {

        if (items.at(i)) {

            items.at(i)->d->theid = -1;

            items.at(i)->view = 0;

            delete items.at(i);

        }

    }

    items.clear();

    reset();

}

QListWidgetItem *QListModel::at(int row) const

{

    return items.value(row);

}

void QListModel::remove(QListWidgetItem *item)

{

    if (!item)

        return;

    int row = items.indexOf(item); // ### use index(item) - it's faster

    Q_ASSERT(row != -1);

    beginRemoveRows(QModelIndex(), row, row);

    items.at(row)->d->theid = -1;

    items.at(row)->view = 0;

    items.removeAt(row);

    endRemoveRows();

}

void QListModel::insert(int row, QListWidgetItem *item)

{

    if (!item)

        return;

    item->view = qobject_cast<QListWidget*>(QObject::parent());

    if (item->view && item->view->isSortingEnabled()) {

        // sorted insertion

        QList<QListWidgetItem*>::iterator it;

        it = sortedInsertionIterator(items.begin(), items.end(),

                                     item->view->sortOrder(), item);

        row = qMax(it - items.begin(), 0);

    } else {

        if (row < 0)

            row = 0;

        else if (row > items.count())

            row = items.count();

    }

    beginInsertRows(QModelIndex(), row, row);

    items.insert(row, item);

    item->d->theid = row;

    endInsertRows();

}

void QListModel::insert(int row, const QStringList &labels)

{

    const int count = labels.count();

    if (count <= 0)

        return;

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

    if (view && view->isSortingEnabled()) {

        // sorted insertion

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

            QListWidgetItem *item = new QListWidgetItem(labels.at(i));

            insert(row, item);

        }

    } else {

        if (row < 0)

            row = 0;

        else if (row > items.count())

            row = items.count();

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

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

            QListWidgetItem *item = new QListWidgetItem(labels.at(i));

            item->d->theid = row;

            item->view = qobject_cast<QListWidget*>(QObject::parent());

            items.insert(row++, item);

        }

        endInsertRows();

    }

}

QListWidgetItem *QListModel::take(int row)

{

    if (row < 0 || row >= items.count())

        return 0;

    beginRemoveRows(QModelIndex(), row, row);

    items.at(row)->d->theid = -1;

    items.at(row)->view = 0;

    QListWidgetItem *item = items.takeAt(row);

    endRemoveRows();

    return item;

}

void QListModel::move(int srcRow, int dstRow)

{

    if (srcRow == dstRow

        || srcRow < 0 || srcRow >= items.count()

        || dstRow < 0 || dstRow > items.count())

        return;

    if (!beginMoveRows(QModelIndex(), srcRow, srcRow, QModelIndex(), dstRow))

        return;

    if (srcRow < dstRow)

        --dstRow;

    items.move(srcRow, dstRow);

    endMoveRows();

}

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

{

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

}

QModelIndex QListModel::index(QListWidgetItem *item) const

{

    if (!item || !item->view || static_cast<const QListModel *>(item->view->model()) != this

        || items.isEmpty())

        return QModelIndex();

    int row;

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

    if (theid >= 0 && theid < items.count() && items.at(theid) == item) {

        row = theid;

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

        row = items.lastIndexOf(item);  // lastIndexOf is an optimization in favor of indexOf

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

            return QModelIndex();

        item->d->theid = row;

    }

    return createIndex(row, 0, item);

}

QModelIndex QListModel::index(int row, int column, const QModelIndex &parent) const

{

    if (hasIndex(row, column, parent))

        return createIndex(row, column, items.at(row));

    return QModelIndex();

}

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

{

    if (!index.isValid() || index.row() >= items.count())

        return QVariant();

    return items.at(index.row())->data(role);

}

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

{

    if (!index.isValid() || index.row() >= items.count())

        return false;

    items.at(index.row())->setData(role, value);

    return true;

}

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

{

    QMap<int, QVariant> roles;

    if (!index.isValid() || index.row() >= items.count())

        return roles;

    QListWidgetItem *itm = items.at(index.row());

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

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

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

    }

    return roles;

}

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

{

    if (count < 1 || row < 0 || row > rowCount() || parent.isValid())

        return false;

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

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

    QListWidgetItem *itm = 0;

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

        itm = new QListWidgetItem;

        itm->view = view;

        itm->d->theid = r;

        items.insert(r, itm);

    }

    endInsertRows();

    return true;

}

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

{

    if (count < 1 || row < 0 || (row + count) > rowCount() || parent.isValid())

        return false;

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

    QListWidgetItem *itm = 0;

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

        itm = items.takeAt(row);

        itm->view = 0;

        itm->d->theid = -1;

        delete itm;

    }

    endRemoveRows();

    return true;

}

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

{

    if (!index.isValid() || index.row() >= items.count() || index.model() != this)

        return Qt::ItemIsDropEnabled; // we allow drops outside the items

    return items.at(index.row())->flags();

}

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

{

    if (column != 0)

        return;

    emit layoutAboutToBeChanged();

    QVector < QPair<QListWidgetItem*,int> > sorting(items.count());

    for (int i = 0; i < items.count(); ++i) {

        QListWidgetItem *item = items.at(i);

        sorting[i].first = item;

        sorting[i].second = i;

    }

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

    qSort(sorting.begin(), sorting.end(), compare);

    QModelIndexList fromIndexes;

    QModelIndexList toIndexes;

    for (int r = 0; r < sorting.count(); ++r) {

        QListWidgetItem *item = sorting.at(r).first;

        toIndexes.append(createIndex(r, 0, item));

        fromIndexes.append(createIndex(sorting.at(r).second, 0, sorting.at(r).first));

        items[r] = sorting.at(r).first;

    }

    changePersistentIndexList(fromIndexes, toIndexes);

    emit layoutChanged();

}

/**

 * This function assumes that all items in the model except the items that are between

 * (inclusive) start and end are sorted.

 * With these assumptions, this function can ensure that the model is sorted in a

 * much more efficient way than doing a naive 'sort everything'.

 * (provided that the range is relatively small compared to the total number of items)

 */

void QListModel::ensureSorted(int column, Qt::SortOrder order, int start, int end)

{

    if (column != 0)

        return;

    int count = end - start + 1;

    QVector < QPair<QListWidgetItem*,int> > sorting(count);

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

        sorting[i].first = items.at(start + i);

        sorting[i].second = start + i;

    }

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

    qSort(sorting.begin(), sorting.end(), compare);

    QModelIndexList oldPersistentIndexes = persistentIndexList();

    QModelIndexList newPersistentIndexes = oldPersistentIndexes;

    QList<QListWidgetItem*> tmp = items;

    QList<QListWidgetItem*>::iterator lit = tmp.begin();

    bool changed = false;

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

        int oldRow = sorting.at(i).second;

        QListWidgetItem *item = tmp.takeAt(oldRow);

        lit = sortedInsertionIterator(lit, tmp.end(), order, item);

        int newRow = qMax(lit - tmp.begin(), 0);

        lit = tmp.insert(lit, item);

        if (newRow != oldRow) {

            changed = true;

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

                int otherRow = sorting.at(j).second;

                if (oldRow < otherRow && newRow >= otherRow)

                    --sorting[j].second;

                else if (oldRow > otherRow && newRow <= otherRow)

                    ++sorting[j].second;

            }

            for (int k = 0; k < newPersistentIndexes.count(); ++k) {

                QModelIndex pi = newPersistentIndexes.at(k);

                int oldPersistentRow = pi.row();

                int newPersistentRow = oldPersistentRow;

                if (oldPersistentRow == oldRow)

                    newPersistentRow = newRow;

                else if (oldRow < oldPersistentRow && newRow >= oldPersistentRow)

                    newPersistentRow = oldPersistentRow - 1;

                else if (oldRow > oldPersistentRow && newRow <= oldPersistentRow)

                    newPersistentRow = oldPersistentRow + 1;

                if (newPersistentRow != oldPersistentRow)

                    newPersistentIndexes[k] = createIndex(newPersistentRow,

                                                          pi.column(), pi.internalPointer());

            }

        }

    }

    if (changed) {

        emit layoutAboutToBeChanged();

        items = tmp;

        changePersistentIndexList(oldPersistentIndexes, newPersistentIndexes);

        emit layoutChanged();

    }

}

bool QListModel::itemLessThan(const QPair<QListWidgetItem*,int> &left,

                              const QPair<QListWidgetItem*,int> &right)

{

    return (*left.first) < (*right.first);

}

bool QListModel::itemGreaterThan(const QPair<QListWidgetItem*,int> &left,

                                 const QPair<QListWidgetItem*,int> &right)

{

    return (*right.first) < (*left.first);

}

QList<QListWidgetItem*>::iterator QListModel::sortedInsertionIterator(

    const QList<QListWidgetItem*>::iterator &begin,

    const QList<QListWidgetItem*>::iterator &end,

    Qt::SortOrder order, QListWidgetItem *item)

{

    if (order == Qt::AscendingOrder)

        return qLowerBound(begin, end, item, QListModelLessThan());

    return qLowerBound(begin, end, item, QListModelGreaterThan());

}

void QListModel::itemChanged(QListWidgetItem *item)

{

    QModelIndex idx = index(item);

    emit dataChanged(idx, idx);

}

QStringList QListModel::mimeTypes() const

{

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

    return view->mimeTypes();

}

QMimeData *QListModel::internalMimeData()  const

{

    return QAbstractItemModel::mimeData(cachedIndexes);

}

QMimeData *QListModel::mimeData(const QModelIndexList &indexes) const

{

    QList<QListWidgetItem*> itemlist;

    for (int i = 0; i < indexes.count(); ++i)

        itemlist << at(indexes.at(i).row());

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

    cachedIndexes = indexes;

    QMimeData *mimeData = view->mimeData(itemlist);

    cachedIndexes.clear();

    return mimeData;

}

#ifndef QT_NO_DRAGANDDROP

bool QListModel::dropMimeData(const QMimeData *data, Qt::DropAction action,

                              int row, int column, const QModelIndex &index)

{

    Q_UNUSED(column);

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

    if (index.isValid())

        row = index.row();

    else if (row == -1)

        row = items.count();

    return view->dropMimeData(row, data, action);

}

Qt::DropActions QListModel::supportedDropActions() const

{

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

    return view->supportedDropActions();

}

#endif // QT_NO_DRAGANDDROP

/*!

    \class QListWidgetItem

    \brief The QListWidgetItem class provides an item for use with the

    QListWidget item view class.

    \ingroup model-view

    A QListWidgetItem represents a single item in a QListWidget. Each item can

    hold several pieces of information, and will display them appropriately.

    The item view convenience classes use a classic item-based interface rather

    than a pure model/view approach. For a more flexible list view widget,

    consider using the QListView class with a standard model.

    List items can be inserted automatically into a list, when they are

    constructed, by specifying the list widget:

    \snippet doc/src/snippets/qlistwidget-using/mainwindow.cpp 2

    Alternatively, list items can also be created without a parent widget, and

    later inserted into a list using QListWidget::insertItem().

    List items are typically used to display text() and an icon(). These are

    set with the setText() and setIcon() functions. The appearance of the text

    can be customized with setFont(), setForeground(), and setBackground().

    Text in list items can be aligned using the setTextAlignment() function.

    Tooltips, status tips and "What's This?" help can be added to list items

    with setToolTip(), setStatusTip(), and setWhatsThis().

    By default, items are enabled, selectable, checkable, and can be the source

    of drag and drop operations.

    Each item's flags can be changed by calling setFlags() with the appropriate

    value (see Qt::ItemFlags). Checkable items can be checked, unchecked and

    partially checked with the setCheckState() function. The corresponding

    checkState() function indicates the item's current check state.

    The isHidden() function can be used to determine whether the item is

    hidden. To hide an item, use setHidden().

    \section1 Subclassing

    When subclassing QListWidgetItem to provide custom items, it is possible to

    define new types for them enabling them to be distinguished from standard

    items. For subclasses that require this feature, ensure that you call the

    base class constructor with a new type value equal to or greater than

    \l UserType, within \e your constructor.

    \sa QListWidget, {Model/View Programming}, QTreeWidgetItem, QTableWidgetItem

*/

/*!

    \enum QListWidgetItem::ItemType

    This enum describes the types that are used to describe list widget items.

    \value Type     The default type for list widget items.

    \value UserType The minimum value for custom types. Values below UserType are

                    reserved by Qt.

    You can define new user types in QListWidgetItem subclasses to ensure that

    custom items are treated specially.

    \sa type()

*/

/*!

    \fn int QListWidgetItem::type() const