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

**

** 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)

{

    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);

        QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item));

        itemPrivate->addItemChangeListener(this, QDeclarativeItemPrivate::Geometry);

    }

    requestedIndex = -1;

    return item;

}

void QDeclarativePathViewPrivate::releaseItem(QDeclarativeItem *item)

{

    if (!item || !model)

        return;

    if (QDeclarativePathViewAttached *att = attached(item))

        att->setOnPath(false);

    QDeclarativeItemPrivate *itemPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(item));

    itemPrivate->removeItemChangeListener(this, QDeclarativeItemPrivate::Geometry);

    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()

{

    else

        mappedRange = 1.0;

}

qreal QDeclarativePathViewPrivate::positionOfIndex(qreal index) const

{

    qreal pos = -1.0;

        qreal start = 0.0;

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

            start = highlightRangeStart;

        qreal globalPos = index + offset;

            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;

                highlightUp = false;

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

                highlightUp = true;

                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;

        }

        // 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()/2));

    item->setY(qRound(pf.y() - item->height()/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

    A PathView displays data from models created from built-in QML elements like ListModel

    and XmlListModel, or custom model classes defined in C++ that inherit from

    QAbstractListModel.

    a \l delegate, which defines how the data should be displayed.  

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

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

    For example, if there is a simple list model defined in a file \c ContactModel.qml like this:

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

    This data can be represented as a PathView, like this:

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

    \image pathview.gif

    (Note the above example uses PathAttribute to scale and modify the

    opacity of the items as they rotate. This additional code can be seen in the

    PathAttribute documentation.)

    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.

*/

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 PathView PathView::view

    This attached property holds the view that manages this delegate instance.

    It is attached to each instance of the delegate.

*/

/*!

    \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.

    \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->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);

}

/*!

    \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;

}