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

**

** 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 QtDeclarative 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 "private/qdeclarativelistview_p.h"

#include "private/qdeclarativeflickable_p_p.h"

#include "private/qdeclarativevisualitemmodel_p.h"

#include "private/qdeclarativesmoothedanimation_p_p.h"

#include <qdeclarativeexpression.h>

#include <qdeclarativeengine.h>

#include <qdeclarativeguard_p.h>

#include <qdeclarativeinfo.h>

#include <qlistmodelinterface_p.h>

#include <qmath.h>

#include <QKeyEvent>

QT_BEGIN_NAMESPACE

void QDeclarativeViewSection::setProperty(const QString &property)

{

    if (property != m_property) {

        m_property = property;

    }

}

void QDeclarativeViewSection::setCriteria(QDeclarativeViewSection::SectionCriteria criteria)

{

    if (criteria != m_criteria) {

        m_criteria = criteria;

    }

}

void QDeclarativeViewSection::setDelegate(QDeclarativeComponent *delegate)

{

    if (delegate != m_delegate) {

        m_delegate = delegate;

        emit delegateChanged();

    }

}

QString QDeclarativeViewSection::sectionString(const QString &value)

{

    if (m_criteria == FirstCharacter)

        return value.isEmpty() ? QString() : value.at(0);

    else

        return value;

}

//----------------------------------------------------------------------------

class FxListItem

{

public:

    FxListItem(QDeclarativeItem *i, QDeclarativeListView *v) : item(i), section(0), view(v) {

        attached = static_cast<QDeclarativeListViewAttached*>(qmlAttachedPropertiesObject<QDeclarativeListView>(item));

        if (attached)

    }

    ~FxListItem() {}

    qreal position() const {

        if (section)

            return (view->orientation() == QDeclarativeListView::Vertical ? section->y() : section->x());

        else

            return (view->orientation() == QDeclarativeListView::Vertical ? item->y() : item->x());

    }

    qreal size() const {

        if (section)

        else

            return (view->orientation() == QDeclarativeListView::Vertical ? item->height() : item->width());

    }

    qreal endPosition() const {

        return (view->orientation() == QDeclarativeListView::Vertical

                                        ? item->y() + (item->height() > 0 ? item->height() : 1)

                                        : item->x() + (item->width() > 0 ? item->width() : 1)) - 1;

    }

    void setPosition(qreal pos) {

        if (view->orientation() == QDeclarativeListView::Vertical) {

            if (section) {

                section->setY(pos);

                pos += section->height();

            }

            item->setY(pos);

        } else {

            if (section) {

                section->setX(pos);

                pos += section->width();

            }

            item->setX(pos);

        }

    }

    bool contains(int x, int y) const {

        return (x >= item->x() && x < item->x() + item->width() &&

                y >= item->y() && y < item->y() + item->height());

    }

    QDeclarativeItem *item;

    QDeclarativeItem *section;

    QDeclarativeListView *view;

    QDeclarativeListViewAttached *attached;

    int index;

};

//----------------------------------------------------------------------------

class QDeclarativeListViewPrivate : public QDeclarativeFlickablePrivate

{

    Q_DECLARE_PUBLIC(QDeclarativeListView)

public:

    QDeclarativeListViewPrivate()

        : currentItem(0), orient(QDeclarativeListView::Vertical)

        , visiblePos(0), visibleIndex(0)

        , averageSize(100.0), currentIndex(-1), requestedIndex(-1)

        , itemCount(0), highlightRangeStart(0), highlightRangeEnd(0)

        , highlightComponent(0), highlight(0), trackedItem(0)

        , moveReason(Other), buffer(0), highlightPosAnimator(0), highlightSizeAnimator(0)

        , sectionCriteria(0), spacing(0.0)

        , highlightMoveSpeed(400), highlightMoveDuration(-1)

        , highlightResizeSpeed(400), highlightResizeDuration(-1), highlightRange(QDeclarativeListView::NoHighlightRange)

        , snapMode(QDeclarativeListView::NoSnap), overshootDist(0.0)

        , footerComponent(0), footer(0), headerComponent(0), header(0)

        , bufferMode(BufferBefore | BufferAfter)

        , ownModel(false), wrap(false), autoHighlight(true), haveHighlightRange(false)

        , correctFlick(false), inFlickCorrection(false), lazyRelease(false)

        , deferredRelease(false), layoutScheduled(false), minExtentDirty(true), maxExtentDirty(true)

    {}

    void init();

    void clear();

    FxListItem *createItem(int modelIndex);

    void releaseItem(FxListItem *item);

    FxListItem *visibleItem(int modelIndex) const {

        if (modelIndex >= visibleIndex && modelIndex < visibleIndex + visibleItems.count()) {

            for (int i = modelIndex - visibleIndex; i < visibleItems.count(); ++i) {

                FxListItem *item = visibleItems.at(i);

                if (item->index == modelIndex)

                    return item;

            }

        }

        return 0;

    }

    FxListItem *firstVisibleItem() const {

        const qreal pos = position();

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

            FxListItem *item = visibleItems.at(i);

            if (item->index != -1 && item->endPosition() > pos)

                return item;

        }

        return visibleItems.count() ? visibleItems.first() : 0;

    }

    FxListItem *nextVisibleItem() const {

        const qreal pos = position();

        bool foundFirst = false;

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

            FxListItem *item = visibleItems.at(i);

            if (item->index != -1) {

                if (foundFirst)

                    return item;

                else if (item->position() < pos && item->endPosition() > pos)

                    foundFirst = true;

            }

        }

        return 0;

    }

    qreal position() const {

        Q_Q(const QDeclarativeListView);

        return orient == QDeclarativeListView::Vertical ? q->contentY() : q->contentX();

    }

    void setPosition(qreal pos) {

        Q_Q(QDeclarativeListView);

        if (orient == QDeclarativeListView::Vertical)

            q->QDeclarativeFlickable::setContentY(pos);

        else

            q->QDeclarativeFlickable::setContentX(pos);

    }

    qreal size() const {

        Q_Q(const QDeclarativeListView);

        return orient == QDeclarativeListView::Vertical ? q->height() : q->width();

    }

    qreal startPosition() const {

        qreal pos = 0;

        if (!visibleItems.isEmpty()) {

            pos = (*visibleItems.constBegin())->position();

            if (visibleIndex > 0)

                pos -= visibleIndex * (averageSize + spacing);

        }

        return pos;

    }

    qreal endPosition() const {

        qreal pos = 0;

        if (!visibleItems.isEmpty()) {

            int invisibleCount = visibleItems.count() - visibleIndex;

            for (int i = visibleItems.count()-1; i >= 0; --i) {

                if (visibleItems.at(i)->index != -1) {

                    invisibleCount = model->count() - visibleItems.at(i)->index - 1;

                    break;

                }

            }

            pos = (*(--visibleItems.constEnd()))->endPosition() + invisibleCount * (averageSize + spacing);

        }

        return pos;

    }

    qreal positionAt(int modelIndex) const {

        if (FxListItem *item = visibleItem(modelIndex))

            return item->position();

        if (!visibleItems.isEmpty()) {

            if (modelIndex < visibleIndex) {

                int count = visibleIndex - modelIndex;

            } else {

                int idx = visibleItems.count() - 1;

                while (idx >= 0 && visibleItems.at(idx)->index == -1)

                    --idx;

                if (idx < 0)

                    idx = visibleIndex;

                else

                    idx = visibleItems.at(idx)->index;

                int count = modelIndex - idx - 1;

                return (*(--visibleItems.constEnd()))->endPosition() + spacing + count * (averageSize + spacing) + 1;

            }

        }

        return 0;

    }

    qreal endPositionAt(int modelIndex) const {

        if (FxListItem *item = visibleItem(modelIndex))

            return item->endPosition();

        if (!visibleItems.isEmpty()) {

            if (modelIndex < visibleIndex) {

                int count = visibleIndex - modelIndex;

                return (*visibleItems.constBegin())->position() - (count - 1) * (averageSize + spacing) - spacing - 1;

            } else {

                int idx = visibleItems.count() - 1;

                while (idx >= 0 && visibleItems.at(idx)->index == -1)

                    --idx;

                if (idx < 0)

                    idx = visibleIndex;

                else

                    idx = visibleItems.at(idx)->index;

                int count = modelIndex - idx - 1;

                return (*(--visibleItems.constEnd()))->endPosition() + count * (averageSize + spacing);

            }

        }

        return 0;

    }

    QString sectionAt(int modelIndex) {

        if (FxListItem *item = visibleItem(modelIndex))

            return item->attached->section();

        QString section;

        if (sectionCriteria) {

            QString propValue = model->stringValue(modelIndex, sectionCriteria->property());

            section = sectionCriteria->sectionString(propValue);

        }

        return section;

    }

    bool isValid() const {

        return model && model->count() && model->isValid();

    }

    int snapIndex() {

        int index = currentIndex;

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

            FxListItem *item = visibleItems[i];

            if (item->index == -1)

                continue;

            qreal itemTop = item->position();

            if (itemTop >= highlight->position()-item->size()/2 && itemTop < highlight->position()+item->size()/2)

                return item->index;

        }

        return index;

    }

    qreal snapPosAt(qreal pos) {

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

            FxListItem *item = visibleItems[i];

            if (item->index == -1)

                continue;

            qreal itemTop = item->position();

            if (itemTop+item->size()/2 >= pos && itemTop <= pos)

                return item->position();

        }

        if (visibleItems.count()) {

            qreal firstPos = visibleItems.first()->position();

            qreal endPos = visibleItems.last()->position();

            if (pos < firstPos) {

                return firstPos - qRound((firstPos - pos) / averageSize) * averageSize;

            } else if (pos > endPos)

                return endPos + qRound((pos - endPos) / averageSize) * averageSize;

        }

        return qRound((pos - startPosition()) / averageSize) * averageSize + startPosition();

    }

    FxListItem *snapItemAt(qreal pos) {

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

            FxListItem *item = visibleItems[i];

            if (item->index == -1)

                continue;

            qreal itemTop = item->position();

            if (item->index == model->count()-1 || (itemTop+item->size()/2 >= pos))

                return item;

        }

        if (visibleItems.count() && visibleItems.first()->position() <= pos)

            return visibleItems.first();

        return 0;

    }

    int lastVisibleIndex() const {

        int lastIndex = -1;

        for (int i = visibleItems.count()-1; i >= 0; --i) {

            FxListItem *listItem = visibleItems.at(i);

            if (listItem->index != -1) {

                lastIndex = listItem->index;

                break;

            }

        }

        return lastIndex;

    }

    // map a model index to visibleItems index.

    // These may differ if removed items are still present in the visible list,

    // e.g. doing a removal animation

    int mapFromModel(int modelIndex) const {

        if (modelIndex < visibleIndex || modelIndex >= visibleIndex + visibleItems.count())

            return -1;

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

            FxListItem *listItem = visibleItems.at(i);

            if (listItem->index == modelIndex)

                return i + visibleIndex;

            if (listItem->index > modelIndex)

                return -1;

        }

        return -1; // Not in visibleList

    }

    bool mapRangeFromModel(int &index, int &count) const {

        if (index + count < visibleIndex)

            return false;

        int lastIndex = -1;

        for (int i = visibleItems.count()-1; i >= 0; --i) {

            FxListItem *listItem = visibleItems.at(i);

            if (listItem->index != -1) {

                lastIndex = listItem->index;

                break;

            }

        }

        if (index > lastIndex)

            return false;

        int last = qMin(index + count - 1, lastIndex);

        index = qMax(index, visibleIndex);

        count = last - index + 1;

        return true;

    }

    void updateViewport() {

        Q_Q(QDeclarativeListView);

        if (orient == QDeclarativeListView::Vertical) {

            q->setContentHeight(endPosition() - startPosition() + 1);

        } else {

            q->setContentWidth(endPosition() - startPosition() + 1);

        }

    }

    void itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) {

        Q_Q(QDeclarativeListView);

        QDeclarativeFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);

        if (item != contentItem && (!highlight || item != highlight->item)) {

            if ((orient == QDeclarativeListView::Vertical && newGeometry.height() != oldGeometry.height())

                || (orient == QDeclarativeListView::Horizontal && newGeometry.width() != oldGeometry.width())) {

                scheduleLayout();

            }

        }

        if ((header && header->item == item) || (footer && footer->item == item)) {

            updateHeader();

            updateFooter();

        }

        if (currentItem && currentItem->item == item)

            updateHighlight();

        if (trackedItem && trackedItem->item == item)

            q->trackedPositionChanged();

    }

    // for debugging only

    void checkVisible() const {

        int skip = 0;

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

            FxListItem *listItem = visibleItems.at(i);

            if (listItem->index == -1) {

                ++skip;

            } else if (listItem->index != visibleIndex + i - skip) {

                qFatal("index %d %d %d", visibleIndex, i, listItem->index);

            }

        }

    }

    void refill(qreal from, qreal to, bool doBuffer = false);

    void scheduleLayout();

    void layout();

    void updateUnrequestedIndexes();

    void updateUnrequestedPositions();

    void updateTrackedItem();

    void createHighlight();

    void updateHighlight();

    void createSection(FxListItem *);

    void updateSections();

    void updateCurrentSection();

    void updateCurrent(int);

    void updateAverage();

    void updateHeader();

    void updateFooter();

    void fixupPosition();

    virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);

    virtual void flick(QDeclarativeFlickablePrivate::AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,

                        QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity);

    QDeclarativeGuard<QDeclarativeVisualModel> model;

    QVariant modelVariant;

    QList<FxListItem*> visibleItems;

    QHash<QDeclarativeItem*,int> unrequestedItems;

    FxListItem *currentItem;

    QDeclarativeListView::Orientation orient;

    qreal visiblePos;

    int visibleIndex;

    qreal averageSize;

    int currentIndex;

    int requestedIndex;

    int itemCount;

    qreal highlightRangeStart;

    qreal highlightRangeEnd;

    QDeclarativeComponent *highlightComponent;

    FxListItem *highlight;

    FxListItem *trackedItem;

    enum MovementReason { Other, SetIndex, Mouse };

    MovementReason moveReason;

    int buffer;

    QSmoothedAnimation *highlightPosAnimator;

    QSmoothedAnimation *highlightSizeAnimator;

    QDeclarativeViewSection *sectionCriteria;

    QString currentSection;

    static const int sectionCacheSize = 4;

    QDeclarativeItem *sectionCache[sectionCacheSize];

    qreal spacing;

    qreal highlightMoveSpeed;

    int highlightMoveDuration;

    qreal highlightResizeSpeed;