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

**

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

#include "private/qdeclarativepathview_p_p.h"

#include <qdeclarativestate_p.h>

#include <qdeclarativeopenmetaobject_p.h>

#include <QDebug>

#include <QEvent>

#include <qlistmodelinterface_p.h>

#include <QGraphicsSceneEvent>

#include <qmath.h>

#include <math.h>

QT_BEGIN_NAMESPACE

inline qreal qmlMod(qreal x, qreal y)

{

#ifdef QT_USE_MATH_H_FLOATS

    if(sizeof(qreal) == sizeof(float))

        return fmodf(float(x), float(y));

    else

#endif

        return fmod(x, y);

}

static QDeclarativeOpenMetaObjectType *qPathViewAttachedType = 0;

QDeclarativePathViewAttached::QDeclarativePathViewAttached(QObject *parent)

: QObject(parent), m_view(0), m_onPath(false), m_isCurrent(false)

{

    if (qPathViewAttachedType) {

        m_metaobject = new QDeclarativeOpenMetaObject(this, qPathViewAttachedType);

        m_metaobject->setCached(true);

    } else {

        m_metaobject = new QDeclarativeOpenMetaObject(this);

    }

}

QDeclarativePathViewAttached::~QDeclarativePathViewAttached()

{

}

QVariant QDeclarativePathViewAttached::value(const QByteArray &name) const

{

    return m_metaobject->value(name);

}

void QDeclarativePathViewAttached::setValue(const QByteArray &name, const QVariant &val)

{

    m_metaobject->setValue(name, val);

}

QDeclarativeItem *QDeclarativePathViewPrivate::getItem(int modelIndex)

{

    Q_Q(QDeclarativePathView);

    requestedIndex = modelIndex;

    QDeclarativeItem *item = model->item(modelIndex, false);

    if (item) {

        if (!attType) {

            // pre-create one metatype to share with all attached objects

            attType = new QDeclarativeOpenMetaObjectType(&QDeclarativePathViewAttached::staticMetaObject, qmlEngine(q));

            foreach(const QString &attr, path->attributes())

                attType->createProperty(attr.toUtf8());

        }

        qPathViewAttachedType = attType;

        QDeclarativePathViewAttached *att = static_cast<QDeclarativePathViewAttached *>(qmlAttachedPropertiesObject<QDeclarativePathView>(item));

        qPathViewAttachedType = 0;

        if (att) {

            att->m_view = q;

            att->setOnPath(true);

        }

        item->setParentItem(q);

    }

    requestedIndex = -1;

    return item;

}

void QDeclarativePathViewPrivate::releaseItem(QDeclarativeItem *item)

{

    if (!item || !model)

        return;

    if (QDeclarativePathViewAttached *att = attached(item))

        att->setOnPath(false);

    model->release(item);

}

QDeclarativePathViewAttached *QDeclarativePathViewPrivate::attached(QDeclarativeItem *item)

{

    return static_cast<QDeclarativePathViewAttached *>(qmlAttachedPropertiesObject<QDeclarativePathView>(item, false));

}

void QDeclarativePathViewPrivate::clear()

{

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

        QDeclarativeItem *p = items[i];

        releaseItem(p);

    }

    items.clear();

}

void QDeclarativePathViewPrivate::updateMappedRange()

{

    if (model && pathItems != -1 && pathItems < model->count())

        mappedRange = qreal(pathItems)/model->count();

    else

        mappedRange = 1.0;

}

qreal QDeclarativePathViewPrivate::positionOfIndex(qreal index) const

{

    qreal pos = -1.0;

    if (model && index >= 0 && index < model->count()) {

        qreal start = 0.0;

        if (haveHighlightRange && highlightRangeMode != QDeclarativePathView::NoHighlightRange)

            start = highlightRangeStart;

        qreal globalPos = index + offset;

        globalPos = qmlMod(globalPos, qreal(model->count())) / model->count();

        if (pathItems != -1 && pathItems < model->count()) {

            globalPos += start * mappedRange;

            globalPos = qmlMod(globalPos, 1.0);

            if (globalPos < mappedRange)

                pos = globalPos / mappedRange;

        } else {

            pos = qmlMod(globalPos + start, 1.0);

        }

    }

    return pos;

}

void QDeclarativePathViewPrivate::createHighlight()

{

    Q_Q(QDeclarativePathView);

    if (!q->isComponentComplete())

        return;

    bool changed = false;

    if (highlightItem) {

        delete highlightItem;

        highlightItem = 0;

        changed = true;

    }

    QDeclarativeItem *item = 0;

    if (highlightComponent) {

        QDeclarativeContext *highlightContext = new QDeclarativeContext(qmlContext(q));

        QObject *nobj = highlightComponent->create(highlightContext);

        if (nobj) {

            QDeclarative_setParent_noEvent(highlightContext, nobj);

            item = qobject_cast<QDeclarativeItem *>(nobj);

            if (!item)

                delete nobj;

        } else {

            delete highlightContext;

        }

    } else {

        item = new QDeclarativeItem;

    }

    if (item) {

        QDeclarative_setParent_noEvent(item, q);

        item->setParentItem(q);

        highlightItem = item;

        changed = true;

    }

    if (changed)

        emit q->highlightItemChanged();

}

void QDeclarativePathViewPrivate::updateHighlight()

{

    Q_Q(QDeclarativePathView);

    if (!q->isComponentComplete() || !isValid())

        return;

    if (highlightItem) {

        if (haveHighlightRange && highlightRangeMode == QDeclarativePathView::StrictlyEnforceRange) {

            updateItem(highlightItem, highlightRangeStart);

        } else {

            qreal target = currentIndex;

            tl.reset(moveHighlight);

            moveHighlight.setValue(highlightPosition);

            const int duration = highlightMoveDuration;

            if (target - highlightPosition > model->count()/2) {

                highlightUp = false;

                qreal distance = model->count() - target + highlightPosition;

                tl.move(moveHighlight, 0.0, QEasingCurve(QEasingCurve::InQuad), int(duration * highlightPosition / distance));

                tl.set(moveHighlight, model->count()-0.01);

                tl.move(moveHighlight, target, QEasingCurve(QEasingCurve::OutQuad), int(duration * (model->count()-target) / distance));

            } else if (target - highlightPosition <= -model->count()/2) {

                highlightUp = true;

                qreal distance = model->count() - highlightPosition + target;

                tl.move(moveHighlight, model->count()-0.01, QEasingCurve(QEasingCurve::InQuad), int(duration * (model->count()-highlightPosition) / distance));

                tl.set(moveHighlight, 0.0);

                tl.move(moveHighlight, target, QEasingCurve(QEasingCurve::OutQuad), int(duration * target / distance));

            } else {

                highlightUp = highlightPosition - target < 0;

                tl.move(moveHighlight, target, QEasingCurve(QEasingCurve::InOutQuad), duration);

            }

        }

    }

}

void QDeclarativePathViewPrivate::setHighlightPosition(qreal pos)

{

    if (pos != highlightPosition) {

        qreal start = 0.0;

        qreal end = 1.0;

        if (haveHighlightRange && highlightRangeMode != QDeclarativePathView::NoHighlightRange) {

            start = highlightRangeStart;

            end = highlightRangeEnd;

        }

        qreal range = qreal(model->count());

        // calc normalized position of highlight relative to offset

        qreal relativeHighlight = qmlMod(pos + offset, range) / range;

        if (!highlightUp && relativeHighlight > end * mappedRange) {

            qreal diff = 1.0 - relativeHighlight;

            setOffset(offset + diff * range);

        } else if (highlightUp && relativeHighlight >= (end - start) * mappedRange) {

            qreal diff = relativeHighlight - (end - start) * mappedRange;

            setOffset(offset - diff * range - 0.00001);

        }

        highlightPosition = pos;

        qreal pathPos = positionOfIndex(pos);

        updateItem(highlightItem, pathPos);

        if (QDeclarativePathViewAttached *att = attached(highlightItem))

            att->setOnPath(pathPos != -1.0);

    }

}

void QDeclarativePathViewPrivate::updateItem(QDeclarativeItem *item, qreal percent)

{

    if (QDeclarativePathViewAttached *att = attached(item)) {

        foreach(const QString &attr, path->attributes())

            att->setValue(attr.toUtf8(), path->attributeAt(attr, percent));

    }

    QPointF pf = path->pointAt(percent);

    item->setX(qRound(pf.x() - item->width()*item->scale()/2));

    item->setY(qRound(pf.y() - item->height()*item->scale()/2));

}

void QDeclarativePathViewPrivate::regenerate()

{

    Q_Q(QDeclarativePathView);

    if (!q->isComponentComplete())

        return;

    clear();

    if (!isValid())

        return;

    firstIndex = -1;

    updateMappedRange();

    q->refill();

}

/*!

    \qmlclass PathView QDeclarativePathView

    \since 4.7

    \brief The PathView element lays out model-provided items on a path.

    \inherits Item

    The model is typically provided by a QAbstractListModel "C++ model object", but can also be created directly in QML.

    The \l delegate is instantiated for each item on the \l path.

    The items may be flicked to move them along the path.

    \snippet doc/src/snippets/declarative/pathview/pathview.qml 0

    \image pathview.gif

    Delegates are instantiated as needed and may be destroyed at any time.

    State should \e never be stored in a delegate.

    \bold Note that views do not enable \e clip automatically.  If the view

    is not clipped by another item or the screen, it will be necessary

    to set \e {clip: true} in order to have the out of view items clipped

    nicely.

    \sa Path

*/

QDeclarativePathView::QDeclarativePathView(QDeclarativeItem *parent)

  : QDeclarativeItem(*(new QDeclarativePathViewPrivate), parent)

{

    Q_D(QDeclarativePathView);

    d->init();

}

QDeclarativePathView::~QDeclarativePathView()

{

    Q_D(QDeclarativePathView);

    d->clear();

    if (d->attType)

        d->attType->release();

    if (d->ownModel)

        delete d->model;

}

/*!

    \qmlattachedproperty bool PathView::onPath

    This attached property holds whether the item is currently on the path.

    If a pathItemCount has been set, it is possible that some items may

    be instantiated, but not considered to be currently on the path.

    Usually, these items would be set invisible, for example:

    \code

    Component {

        Rectangle {

            visible: PathView.onPath

            ...

        }

    }

    \endcode

    It is attached to each instance of the delegate.

*/

/*!

    \qmlattachedproperty bool PathView::isCurrentItem

    This attached property is true if this delegate is the current item; otherwise false.

    It is attached to each instance of the delegate.

    This property may be used to adjust the appearance of the current item.

*/

/*!

    \qmlproperty model PathView::model

    This property holds the model providing data for the view.

    The model provides a set of data that is used to create the items for the view.

    For large or dynamic datasets the model is usually provided by a C++ model object.

    Models can also be created directly in XML, using the ListModel element.

    \sa {qmlmodels}{Data Models}

*/

QVariant QDeclarativePathView::model() const

{

    Q_D(const QDeclarativePathView);

    return d->modelVariant;

}

void QDeclarativePathView::setModel(const QVariant &model)

{

    Q_D(QDeclarativePathView);

    if (d->modelVariant == model)

        return;

    if (d->model) {

        disconnect(d->model, SIGNAL(itemsInserted(int,int)), this, SLOT(itemsInserted(int,int)));

        disconnect(d->model, SIGNAL(itemsRemoved(int,int)), this, SLOT(itemsRemoved(int,int)));

        disconnect(d->model, SIGNAL(itemsMoved(int,int,int)), this, SLOT(itemsMoved(int,int,int)));

        disconnect(d->model, SIGNAL(modelReset()), this, SLOT(modelReset()));

        disconnect(d->model, SIGNAL(createdItem(int, QDeclarativeItem*)), this, SLOT(createdItem(int,QDeclarativeItem*)));

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

            QDeclarativeItem *p = d->items[i];

            d->model->release(p);

        }

        d->items.clear();

    }

    d->modelVariant = model;

    QObject *object = qvariant_cast<QObject*>(model);

    QDeclarativeVisualModel *vim = 0;

    if (object && (vim = qobject_cast<QDeclarativeVisualModel *>(object))) {

        if (d->ownModel) {

            delete d->model;

            d->ownModel = false;

        }

        d->model = vim;

    } else {

        if (!d->ownModel) {

            d->model = new QDeclarativeVisualDataModel(qmlContext(this), this);

            d->ownModel = true;

        }

        if (QDeclarativeVisualDataModel *dataModel = qobject_cast<QDeclarativeVisualDataModel*>(d->model))

            dataModel->setModel(model);

    }

    if (d->model) {

        connect(d->model, SIGNAL(itemsInserted(int,int)), this, SLOT(itemsInserted(int,int)));

        connect(d->model, SIGNAL(itemsRemoved(int,int)), this, SLOT(itemsRemoved(int,int)));

        connect(d->model, SIGNAL(itemsMoved(int,int,int)), this, SLOT(itemsMoved(int,int,int)));

        connect(d->model, SIGNAL(modelReset()), this, SLOT(modelReset()));

        connect(d->model, SIGNAL(createdItem(int, QDeclarativeItem*)), this, SLOT(createdItem(int,QDeclarativeItem*)));

    }

    d->offset = qmlMod(d->offset, qreal(d->model->count()));

    if (d->offset < 0)

        d->offset = d->model->count() + d->offset;

    d->regenerate();

    d->fixOffset();

    emit countChanged();

    emit modelChanged();

}

/*!

    \qmlproperty int PathView::count

    This property holds the number of items in the model.

*/

int QDeclarativePathView::count() const

{

    Q_D(const QDeclarativePathView);

    return d->model ? d->model->count() : 0;

}

/*!

    \qmlproperty Path PathView::path

    \default

    This property holds the path used to lay out the items.

    For more information see the \l Path documentation.

*/

QDeclarativePath *QDeclarativePathView::path() const

{

    Q_D(const QDeclarativePathView);

    return d->path;

}

void QDeclarativePathView::setPath(QDeclarativePath *path)

{

    Q_D(QDeclarativePathView);

    if (d->path == path)

        return;

    if (d->path)

        disconnect(d->path, SIGNAL(changed()), this, SLOT(refill()));

    d->path = path;

    connect(d->path, SIGNAL(changed()), this, SLOT(refill()));

    if (d->isValid() && isComponentComplete()) {

        d->clear();

        if (d->attType) {

            d->attType->release();

            d->attType = 0;

        }

        d->regenerate();

    }

    emit pathChanged();

}

/*!

    \qmlproperty int PathView::currentIndex

    This property holds the index of the current item.

*/

int QDeclarativePathView::currentIndex() const

{

    Q_D(const QDeclarativePathView);

    return d->currentIndex;

}

void QDeclarativePathView::setCurrentIndex(int idx)

{

    Q_D(QDeclarativePathView);

    if (d->model && d->model->count())

        idx = qAbs(idx % d->model->count());

    if (d->model && idx != d->currentIndex) {

        if (d->model->count()) {

            int itemIndex = (d->currentIndex - d->firstIndex + d->model->count()) % d->model->count();

            if (itemIndex < d->items.count()) {

                if (QDeclarativeItem *item = d->items.at(itemIndex)) {

                    if (QDeclarativePathViewAttached *att = d->attached(item))

                        att->setIsCurrentItem(false);

                }

            }

        }

        d->currentItem = 0;

        d->moveReason = QDeclarativePathViewPrivate::SetIndex;

        d->currentIndex = idx;

        if (d->model->count()) {

            if (d->haveHighlightRange && d->highlightRangeMode == QDeclarativePathView::StrictlyEnforceRange)

                d->snapToCurrent();

            int itemIndex = (idx - d->firstIndex + d->model->count()) % d->model->count();

            if (itemIndex < d->items.count()) {

                d->currentItem = d->items.at(itemIndex);

                d->currentItem->setFocus(true);

                if (QDeclarativePathViewAttached *att = d->attached(d->currentItem))

                    att->setIsCurrentItem(true);

            }

            d->currentItemOffset = d->positionOfIndex(d->currentIndex);

            d->updateHighlight();

        }

        emit currentIndexChanged();

    }

}