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

**

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

#include "private/qdeclarativeflickable_p_p.h"

#include <qdeclarativeinfo.h>

#include <QGraphicsSceneMouseEvent>

#include <QPointer>

#include <QTimer>

QT_BEGIN_NAMESPACE

// FlickThreshold determines how far the "mouse" must have moved

// before we perform a flick.

static const int FlickThreshold = 20;

// Really slow flicks can be annoying.

static const int minimumFlickVelocity = 200;

QDeclarativeFlickableVisibleArea::QDeclarativeFlickableVisibleArea(QDeclarativeFlickable *parent)

    : QObject(parent), flickable(parent), m_xPosition(0.), m_widthRatio(0.)

    , m_yPosition(0.), m_heightRatio(0.)

{

}

qreal QDeclarativeFlickableVisibleArea::widthRatio() const

{

    return m_widthRatio;

}

qreal QDeclarativeFlickableVisibleArea::xPosition() const

{

    return m_xPosition;

}

qreal QDeclarativeFlickableVisibleArea::heightRatio() const

{

    return m_heightRatio;

}

qreal QDeclarativeFlickableVisibleArea::yPosition() const

{

    return m_yPosition;

}

void QDeclarativeFlickableVisibleArea::updateVisible()

{

    QDeclarativeFlickablePrivate *p = static_cast<QDeclarativeFlickablePrivate *>(QGraphicsItemPrivate::get(flickable));

    bool pageChange = false;

    // Vertical

    const qreal viewheight = flickable->height();

    const qreal maxyextent = -flickable->maxYExtent() + flickable->minYExtent();

    qreal pagePos = (-p->vData.move.value() + flickable->minYExtent()) / (maxyextent + viewheight);

    qreal pageSize = viewheight / (maxyextent + viewheight);

    if (pageSize != m_heightRatio) {

        m_heightRatio = pageSize;

        pageChange = true;

    }

    if (pagePos != m_yPosition) {

        m_yPosition = pagePos;

        pageChange = true;

    }

    // Horizontal

    const qreal viewwidth = flickable->width();

    const qreal maxxextent = -flickable->maxXExtent() + flickable->minXExtent();

    pagePos = (-p->hData.move.value() + flickable->minXExtent()) / (maxxextent + viewwidth);

    pageSize = viewwidth / (maxxextent + viewwidth);

    if (pageSize != m_widthRatio) {

        m_widthRatio = pageSize;

        pageChange = true;

    }

    if (pagePos != m_xPosition) {

        m_xPosition = pagePos;

        pageChange = true;

    }

    if (pageChange)

        emit pageChanged();

}

QDeclarativeFlickablePrivate::QDeclarativeFlickablePrivate()

  : contentItem(new QDeclarativeItem)

    , hData(this, &QDeclarativeFlickablePrivate::setRoundedViewportX)

    , vData(this, &QDeclarativeFlickablePrivate::setRoundedViewportY)

    , flickingHorizontally(false), flickingVertically(false)

    , hMoved(false), vMoved(false)

    , movingHorizontally(false), movingVertically(false)

    , stealMouse(false), pressed(false)

    , interactive(true), deceleration(500), maxVelocity(2000), reportedVelocitySmoothing(100)

    , delayedPressEvent(0), delayedPressTarget(0), pressDelay(0), fixupDuration(600)

    , vTime(0), visibleArea(0)

    , flickableDirection(QDeclarativeFlickable::AutoFlickDirection)

    , boundsBehavior(QDeclarativeFlickable::DragAndOvershootBounds)

{

}

void QDeclarativeFlickablePrivate::init()

{

    Q_Q(QDeclarativeFlickable);

    QDeclarative_setParent_noEvent(contentItem, q);

    contentItem->setParentItem(q);

    static int timelineUpdatedIdx = -1;

    static int timelineCompletedIdx = -1;

    static int flickableTickedIdx = -1;

    static int flickableMovementEndingIdx = -1;

    if (timelineUpdatedIdx == -1) {

        timelineUpdatedIdx = QDeclarativeTimeLine::staticMetaObject.indexOfSignal("updated()");

        timelineCompletedIdx = QDeclarativeTimeLine::staticMetaObject.indexOfSignal("completed()");

        flickableTickedIdx = QDeclarativeFlickable::staticMetaObject.indexOfSlot("ticked()");

        flickableMovementEndingIdx = QDeclarativeFlickable::staticMetaObject.indexOfSlot("movementEnding()");

    }

    QMetaObject::connect(&timeline, timelineUpdatedIdx,

                         q, flickableTickedIdx, Qt::DirectConnection);

    QMetaObject::connect(&timeline, timelineCompletedIdx,

                         q, flickableMovementEndingIdx, Qt::DirectConnection);

    q->setAcceptedMouseButtons(Qt::LeftButton);

    q->setFiltersChildEvents(true);

    QDeclarativeItemPrivate *viewportPrivate = static_cast<QDeclarativeItemPrivate*>(QGraphicsItemPrivate::get(contentItem));

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

    lastPosTime.invalidate();

}

/*

    Returns the amount to overshoot by given a velocity.

    Will be roughly in range 0 - size/4

*/

qreal QDeclarativeFlickablePrivate::overShootDistance(qreal velocity, qreal size)

{

    if (maxVelocity <= 0)

        return 0.0;

    velocity = qAbs(velocity);

    if (velocity > maxVelocity)

        velocity = maxVelocity;

    qreal dist = size / 4 * velocity / maxVelocity;

    return dist;

}

void QDeclarativeFlickablePrivate::itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeom, const QRectF &oldGeom)

{

    Q_Q(QDeclarativeFlickable);

    if (item == contentItem) {

        if (newGeom.x() != oldGeom.x())

            emit q->contentXChanged();

        if (newGeom.y() != oldGeom.y())

            emit q->contentYChanged();

    }

}

void QDeclarativeFlickablePrivate::flickX(qreal velocity)

{

    Q_Q(QDeclarativeFlickable);

    flick(hData, q->minXExtent(), q->maxXExtent(), q->width(), fixupX_callback, velocity);

}

void QDeclarativeFlickablePrivate::flickY(qreal velocity)

{

    Q_Q(QDeclarativeFlickable);

    flick(vData, q->minYExtent(), q->maxYExtent(), q->height(), fixupY_callback, velocity);

}

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

                                         QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity)

{

    Q_Q(QDeclarativeFlickable);

    qreal maxDistance = -1;

    bool overShoot = boundsBehavior == QDeclarativeFlickable::DragAndOvershootBounds;

    // -ve velocity means list is moving up

    if (velocity > 0) {

        if (data.move.value() < minExtent)

            maxDistance = qAbs(minExtent - data.move.value() + (overShoot?overShootDistance(velocity,vSize):0));

        data.flickTarget = minExtent;

    } else {

        if (data.move.value() > maxExtent)

            maxDistance = qAbs(maxExtent - data.move.value()) + (overShoot?overShootDistance(velocity,vSize):0);

        data.flickTarget = maxExtent;

    }

    if (maxDistance > 0) {

        qreal v = velocity;

        if (maxVelocity != -1 && maxVelocity < qAbs(v)) {

            if (v < 0)

                v = -maxVelocity;

            else

                v = maxVelocity;

        }

        timeline.reset(data.move);

        timeline.accel(data.move, v, deceleration, maxDistance);

        timeline.callback(QDeclarativeTimeLineCallback(&data.move, fixupCallback, this));

        if (!flickingHorizontally && q->xflick()) {

            flickingHorizontally = true;

            emit q->flickingChanged();

            emit q->flickingHorizontallyChanged();

            if (!flickingVertically)

                emit q->flickStarted();

        }

        if (!flickingVertically && q->yflick()) {

            flickingVertically = true;

            emit q->flickingChanged();

            emit q->flickingVerticallyChanged();

            if (!flickingHorizontally)

                emit q->flickStarted();

        }

    } else {

        timeline.reset(data.move);

        fixup(data, minExtent, maxExtent);

    }

}

void QDeclarativeFlickablePrivate::fixupY_callback(void *data)

{

    ((QDeclarativeFlickablePrivate *)data)->fixupY();

}

void QDeclarativeFlickablePrivate::fixupX_callback(void *data)

{

    ((QDeclarativeFlickablePrivate *)data)->fixupX();

}

void QDeclarativeFlickablePrivate::fixupX()

{

    Q_Q(QDeclarativeFlickable);

    fixup(hData, q->minXExtent(), q->maxXExtent());

}

void QDeclarativeFlickablePrivate::fixupY()

{

    Q_Q(QDeclarativeFlickable);

    fixup(vData, q->minYExtent(), q->maxYExtent());

}

void QDeclarativeFlickablePrivate::fixup(AxisData &data, qreal minExtent, qreal maxExtent)

{

    Q_Q(QDeclarativeFlickable);

    if (data.move.value() > minExtent || maxExtent > minExtent) {

        timeline.reset(data.move);

        if (data.move.value() != minExtent) {

            if (fixupDuration) {

                qreal dist = minExtent - data.move;

                timeline.move(data.move, minExtent - dist/2, QEasingCurve(QEasingCurve::InQuad), fixupDuration/4);

                timeline.move(data.move, minExtent, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);

            } else {

                data.move.setValue(minExtent);

                q->viewportMoved();

            }

        }

    } else if (data.move.value() < maxExtent) {

        timeline.reset(data.move);

        if (fixupDuration) {

            qreal dist = maxExtent - data.move;

            timeline.move(data.move, maxExtent - dist/2, QEasingCurve(QEasingCurve::InQuad), fixupDuration/4);

            timeline.move(data.move, maxExtent, QEasingCurve(QEasingCurve::OutExpo), 3*fixupDuration/4);

        } else {

            data.move.setValue(maxExtent);

            q->viewportMoved();

        }

    }

    vTime = timeline.time();

}

void QDeclarativeFlickablePrivate::updateBeginningEnd()

{

    Q_Q(QDeclarativeFlickable);

    bool atBoundaryChange = false;

    // Vertical

    const int maxyextent = int(-q->maxYExtent());

    const qreal ypos = -vData.move.value();

    bool atBeginning = (ypos <= -q->minYExtent());

    bool atEnd = (maxyextent <= ypos);

    if (atBeginning != vData.atBeginning) {

        vData.atBeginning = atBeginning;

        atBoundaryChange = true;

    }

    if (atEnd != vData.atEnd) {

        vData.atEnd = atEnd;

        atBoundaryChange = true;

    }

    // Horizontal

    const int maxxextent = int(-q->maxXExtent());

    const qreal xpos = -hData.move.value();

    atBeginning = (xpos <= -q->minXExtent());

    atEnd = (maxxextent <= xpos);

    if (atBeginning != hData.atBeginning) {

        hData.atBeginning = atBeginning;

        atBoundaryChange = true;

    }

    if (atEnd != hData.atEnd) {

        hData.atEnd = atEnd;

        atBoundaryChange = true;

    }

    if (atBoundaryChange)

        emit q->isAtBoundaryChanged();

    if (visibleArea)

        visibleArea->updateVisible();

}

/*!

    \qmlclass Flickable QDeclarativeFlickable

    \since 4.7

    \brief The Flickable item provides a surface that can be "flicked".

    \inherits Item

    Flickable places its children on a surface that can be dragged and flicked.

    \code

    import Qt 4.7

    Flickable {

        width: 200; height: 200

        contentWidth: image.width; contentHeight: image.height

        Image { id: image; source: "bigImage.png" }

    }

    \endcode

    \image flickable.gif

    Flickable does not automatically clip its contents. If

    it is not full-screen it is likely that \l {Item::clip}{clip} should be set

    to \c true.

    \note Due to an implementation detail, items placed inside a Flickable cannot anchor to it by

    \c id. Use \c parent instead.

*/

/*!

    \qmlsignal Flickable::onMovementStarted()

    This handler is called when the view begins moving due to user

    interaction.

*/

/*!

    \qmlsignal Flickable::onMovementEnded()

    This handler is called when the view stops moving due to user

    interaction.  If a flick was generated, this handler will

    be triggered once the flick stops.  If a flick was not

    generated, the handler will be triggered when the

    user stops dragging - i.e. a mouse or touch release.

*/

/*!

    \qmlsignal Flickable::onFlickStarted()

    This handler is called when the view is flicked.  A flick

    starts from the point that the mouse or touch is released,

    while still in motion.

*/

/*!

    \qmlsignal Flickable::onFlickEnded()

    This handler is called when the view stops moving due to a flick.

*/

/*!

    \qmlproperty real Flickable::visibleArea.xPosition

    \qmlproperty real Flickable::visibleArea.widthRatio

    \qmlproperty real Flickable::visibleArea.yPosition

    \qmlproperty real Flickable::visibleArea.heightRatio

    These properties describe the position and size of the currently viewed area.

    The size is defined as the percentage of the full view currently visible,

    scaled to 0.0 - 1.0.  The page position is usually in the range 0.0 (beginning) to

    1.0 minus size ratio (end), i.e. \c yPosition is in the range 0.0 to 1.0-\c heightRatio.

    However, it is possible for the contents to be dragged outside of the normal

    range, resulting in the page positions also being outside the normal range.

    These properties are typically used to draw a scrollbar. For example:

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

    \dots 8

    \snippet doc/src/snippets/declarative/flickableScrollbar.qml 1

    \sa {declarative/ui-components/scrollbar}{scrollbar example}

*/

QDeclarativeFlickable::QDeclarativeFlickable(QDeclarativeItem *parent)

  : QDeclarativeItem(*(new QDeclarativeFlickablePrivate), parent)

{

    Q_D(QDeclarativeFlickable);

    d->init();

}

QDeclarativeFlickable::QDeclarativeFlickable(QDeclarativeFlickablePrivate &dd, QDeclarativeItem *parent)

  : QDeclarativeItem(dd, parent)

{

    Q_D(QDeclarativeFlickable);

    d->init();

}

QDeclarativeFlickable::~QDeclarativeFlickable()

{

}

/*!

    \qmlproperty int Flickable::contentX

    \qmlproperty int Flickable::contentY

    These properties hold the surface coordinate currently at the top-left

    corner of the Flickable. For example, if you flick an image up 100 pixels,

    \c contentY will be 100.

*/

qreal QDeclarativeFlickable::contentX() const

{

    Q_D(const QDeclarativeFlickable);

    return -d->hData.move.value();

}

void QDeclarativeFlickable::setContentX(qreal pos)

{

    Q_D(QDeclarativeFlickable);

    pos = qRound(pos);

    d->timeline.reset(d->hData.move);

    d->vTime = d->timeline.time();

    if (-pos != d->hData.move.value()) {

        d->hData.move.setValue(-pos);

        viewportMoved();

    }

}

qreal QDeclarativeFlickable::contentY() const

{

    Q_D(const QDeclarativeFlickable);

    return -d->vData.move.value();

}

void QDeclarativeFlickable::setContentY(qreal pos)

{

    Q_D(QDeclarativeFlickable);

    pos = qRound(pos);

    d->timeline.reset(d->vData.move);

    d->vTime = d->timeline.time();

    if (-pos != d->vData.move.value()) {

        d->vData.move.setValue(-pos);

        viewportMoved();

    }

}

/*!

    \qmlproperty bool Flickable::interactive

    This property holds whether the user can interact with the Flickable. A user

    cannot drag or flick a Flickable that is not interactive.

    This property is useful for temporarily disabling flicking. This allows

    special interaction with Flickable's children: for example, you might want to

    freeze a flickable map while scrolling through a pop-up dialog that is a child of the Flickable.

*/

bool QDeclarativeFlickable::isInteractive() const

{

    Q_D(const QDeclarativeFlickable);

    return d->interactive;

}

void QDeclarativeFlickable::setInteractive(bool interactive)

{

    Q_D(QDeclarativeFlickable);

    if (interactive != d->interactive) {

        d->interactive = interactive;

        if (!interactive && (d->flickingHorizontally || d->flickingVertically)) {

            d->timeline.clear();

            d->vTime = d->timeline.time();

            d->flickingHorizontally = false;

            d->flickingVertically = false;

            emit flickingChanged();

            emit flickingHorizontallyChanged();

            emit flickingVerticallyChanged();

            emit flickEnded();

        }

        emit interactiveChanged();

    }

}

/*!

    \qmlproperty real Flickable::horizontalVelocity

    \qmlproperty real Flickable::verticalVelocity