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

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbscrollarea_p.h"

#include "hbscrollarea.h"

#include "hbinstance.h"

#include "hbpangesture.h"

#include <hbscrollbar_p.h>

#include <hbscrollbar.h>

#include <hbwidgetfeedback.h>

#include <QGraphicsSceneMouseEvent>

#include <qmath.h>

#include <QVariantAnimation>

#include <QGesture>

#include <QDebug>

// These constants control parameters of the inertia and bounce back animations and

// have been selected heuristically to produce good results.  They

// likely do not need to be controlled programatically, so they are just defined

// here.

namespace

{

// Factor that is used to convert flick to pixels per ms

static const qreal SCROLLSPEED_FACTOR = 0.0004;

// With this it's possible to have increased initial speed when

// inertia is enabled

static const qreal INERTIA_SPEEDFACTOR = 2.5;

static const qreal MAX_SCROLLSPEED_PER_MILLISECOND = 3.0; // per millisecond

static const qreal MIN_SPEED_PER_MILLISECOND = 0.005;

static const qreal SPRING_STRENGTH = 0.0013;

static const qreal SPRING_DAMPING_FACTOR = 0.33;

// Friction factor applied to the speed if inertia is enabled

static const qreal FRICTION_PER_MILLISECOND = 0.003;

const qreal MAX_TIMEDIF_FOR_SIMULATION = 30.0;

static const int INITIAL_SCROLLBAR_HIDE_TIMEOUT = 4000;

static const int SCROLLBAR_HIDE_TIMEOUT = 2000;

static const int PAGE_CHANGE_DURATION = 170;

static const int ANIMATION_INTERVAL = 10;

}

HbScrollAreaPrivate::HbScrollAreaPrivate() :

        mScrollFeedbackOngoing(false),

        mBoundaryReached(false),

        mContents(0), mScrollDirections(Qt::Vertical),        

        mHorizontalScrollBar(0),

        mVerticalScrollBar(0),

        mVerticalScrollBarPolicy(HbScrollArea::ScrollBarAutoHide),

        mHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAutoHide),

        mAbleToScrollX(false),

        mAbleToScrollY(false),

        mIsScrolling(false),

        mIsAnimating(false),

        mScrollSpeed (QPointF (0,0)),

        mScrollTimer(0),

        mScrollElapsedTime(),

        mLastElapsedTime(0.0),

        mTargetAnimationInProgress(false),

        mElapsedTimeInAnimation(0.0),

        mOverallTimeToTarget(0.0),

        mTargetDelta(QPointF(0,0)),

        mAnimationInitialPosition (QPointF(0,0)),

        mAnimationShape (0),

        mScrollBarHideTimer(0),

        mFrictionEnabled(true),

        mResetAlignment(true),

        mClampingStyle(HbScrollArea::BounceBackClamping),

        mScrollingStyle(HbScrollArea::PanWithFollowOn),

        mEventPositionQueueSize(10),

        mEventPositionQueueLastIndex(0),

        mEventPositionQueueIsFull(false),

        mLayoutDirection(Qt::LeftToRight),

        mAlignment(Qt::AlignLeft | Qt::AlignTop),

        mContinuationIndicators(false),

        continuationIndicatorTopItem(0),

        continuationIndicatorBottomItem(0),

        continuationIndicatorLeftItem(0),

        continuationIndicatorRightItem(0),

        // These values can be tweaked with the private access from Fute application

        mSpeedFactor ( SCROLLSPEED_FACTOR ),

        mInertiaSpeedFactor ( INERTIA_SPEEDFACTOR ),

        mMaxScrollSpeed ( MAX_SCROLLSPEED_PER_MILLISECOND ),

        mSpringStrength ( SPRING_STRENGTH ),

        mSpringDampingFactor ( SPRING_DAMPING_FACTOR ),

        mFrictionPerMilliSecond ( FRICTION_PER_MILLISECOND ),

        mMultiFlickEnabled (false )

{

}

HbScrollAreaPrivate::~HbScrollAreaPrivate()

{    

}

void HbScrollAreaPrivate::init()

{

    Q_Q( HbScrollArea );

    mScrollTimer.setParent(q);

    mScrollBarHideTimer.setParent(q);

    mScrollBarHideTimer.setSingleShot(true);

    q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    q->setFlag( QGraphicsItem::ItemClipsChildrenToShape, true );

    q->setFocusPolicy(Qt::StrongFocus);

    // Scrollbar is created when it is shown for the first time.

    mVerticalScrollBar = new HbScrollBar(Qt::Vertical, q);

    HbStyle::setItemName(mVerticalScrollBar, "scrollbar-vertical");

    // make sure the scrollbar is on top

    mVerticalScrollBar->setZValue(q->zValue() + 1);

    mVerticalScrollBar->setVisible(false);

    // Scrollbar is created when it is shown for the first time.

    mHorizontalScrollBar = new HbScrollBar(Qt::Horizontal, q);

    HbStyle::setItemName(mHorizontalScrollBar, "scrollbar-horizontal");

    mHorizontalScrollBar->setVisible(false);

    // make sure the scrollbar is on top

    mHorizontalScrollBar->setZValue(q->zValue() + 1);

}

void HbScrollAreaPrivate::doLazyInit()

{

    Q_Q( HbScrollArea );

    QObject::connect(mVerticalScrollBar, SIGNAL(valueChanged(qreal, Qt::Orientation)), q, SLOT(_q_thumbPositionChanged(qreal, Qt::Orientation)));

    QObject::connect(mVerticalScrollBar, SIGNAL(valueChangeRequested(qreal, Qt::Orientation)), q, SLOT(_q_groovePressed(qreal, Qt::Orientation)));

    QObject::connect(&HbScrollBarPrivate::d_ptr(mVerticalScrollBar)->core, SIGNAL(handlePressed()), q, SLOT(_q_thumbPressed()));

    QObject::connect(&HbScrollBarPrivate::d_ptr(mVerticalScrollBar)->core, SIGNAL(handleReleased()), q, SLOT(_q_thumbReleased()));

    QObject::connect(&HbScrollBarPrivate::d_ptr(mHorizontalScrollBar)->core, SIGNAL(handlePressed()), q, SLOT(_q_thumbPressed()));

    QObject::connect(&HbScrollBarPrivate::d_ptr(mHorizontalScrollBar)->core, SIGNAL(handleReleased()), q, SLOT(_q_thumbReleased()));

    QObject::connect(mHorizontalScrollBar, SIGNAL(valueChanged(qreal, Qt::Orientation)), q, SLOT(_q_thumbPositionChanged(qreal, Qt::Orientation)));

    QObject::connect(mHorizontalScrollBar, SIGNAL(valueChangeRequested(qreal, Qt::Orientation)), q, SLOT(_q_groovePressed(qreal, Qt::Orientation)));

    QObject::connect(&(mScrollTimer), SIGNAL(timeout()), q, SLOT(_q_animateScrollTimeout()));

    QObject::connect(&(mScrollBarHideTimer), SIGNAL(timeout()), q, SLOT(_q_hideScrollBars()));

    q->grabGesture(Qt::PanGesture, Qt::ReceivePartialGestures);

    q->grabGesture(Qt::TapGesture);

}

void HbScrollAreaPrivate::replaceScrollBar(Qt::Orientation orientation, HbScrollBar *scrollBar)

{

    Q_Q(HbScrollArea);

    if (orientation == Qt::Horizontal && scrollBar != mHorizontalScrollBar) {

        delete mHorizontalScrollBar;

        mHorizontalScrollBar = scrollBar;

    } else if (orientation == Qt::Vertical && scrollBar != mVerticalScrollBar) {

        delete mVerticalScrollBar;

        mVerticalScrollBar = scrollBar;

    } else {

        return;

    }

    scrollBar->setParentItem(q);

    // make sure the scrollbar is on top

    scrollBar->setZValue(q->zValue() + 1);

    prepareScrollBars();

    QObject::connect(scrollBar, SIGNAL(valueChanged(qreal, Qt::Orientation)), q, SLOT(_q_thumbPositionChanged(qreal, Qt::Orientation)));

}

void HbScrollAreaPrivate::changeLayoutDirection(

        Qt::LayoutDirection aNewDirection)

{

    Q_Q(HbScrollArea);

    mLayoutDirection = aNewDirection;

    Qt::Alignment currentAlignment = mAlignment;

    if ((mAlignment & Qt::AlignLeft) | (mAlignment & Qt::AlignRight)) {

        currentAlignment ^= Qt::AlignLeft;

        currentAlignment ^= Qt::AlignRight;        

    }

    q->setAlignment(currentAlignment);

}

bool HbScrollAreaPrivate::scrollByAmount(const QPointF& delta)

{

    Q_Q( HbScrollArea );

    if ( mContents == 0 ||

         ( qIsNull(qAbs( delta.x() )) && qIsNull(qAbs( delta.y() ) ) ) )

        return false;

    QPointF currentPosition = -mContents->pos();

    QPointF newPosition = currentPosition;

    qreal newXPosition;

    qreal newYPosition;

    bool scrollingHitBoundary(false);

    if (mAbleToScrollX) {

        newXPosition = currentPosition.x() + delta.x();

        if (mClampingStyle == HbScrollArea::StrictClamping) {

            if ( newXPosition < leftBoundary () ) {

                newXPosition = leftBoundary();

                mScrollSpeed.setX( 0.0 );

                scrollingHitBoundary = true;

            } else if ( newXPosition > rightBoundary() ) {

                newXPosition = rightBoundary();

                mScrollSpeed.setX( 0.0 );

                scrollingHitBoundary = true;

            }

        }

        newPosition.setX(newXPosition);

    }

    if (mAbleToScrollY) {

        newYPosition = currentPosition.y() + delta.y();

        if (mClampingStyle == HbScrollArea::StrictClamping) {

            if ( newYPosition < topBoundary () ) {

                newYPosition = topBoundary();

                mScrollSpeed.setY( 0.0 );

                scrollingHitBoundary = true;

            } else if ( newYPosition > bottomBoundary() ) {

                newYPosition = bottomBoundary();

                mScrollSpeed.setY( 0.0 );

                scrollingHitBoundary = true;

            }

        }

        newPosition.setY(newYPosition);

    }

    if (mContinuationIndicators) {

        updateIndicators(newPosition);

    }

    if (scrollingHitBoundary) {

        if (!mBoundaryReached) {

            mBoundaryReached = true;

            if (mScrollFeedbackOngoing) {

                HbWidgetFeedback::triggered(q, Hb::InstantBoundaryReached);

            }

        }

    } else {

        mBoundaryReached = false;

    }

    if (!mIsScrolling) {

        mIsScrolling = true;

        emit q->scrollingStarted();

        if (mAbleToScrollX && mHorizontalScrollBarPolicy == HbScrollArea::ScrollBarAutoHide) {

            displayScrollBar(Qt::Horizontal);

        }

        if (mAbleToScrollY && mVerticalScrollBarPolicy == HbScrollArea::ScrollBarAutoHide) {

            displayScrollBar(Qt::Vertical);

        }

    }  

    setContentPosition(-newPosition);

    if (mAbleToScrollX && mHorizontalScrollBar->isVisible()) {

        updateScrollBar(Qt::Horizontal);

    }

    if (mAbleToScrollY && mVerticalScrollBar->isVisible()) {

        updateScrollBar(Qt::Vertical);

    }

    bool positionChanged = currentPosition != newPosition;

    if (positionChanged && mScrollBarHideTimer.isActive()) {

        mScrollBarHideTimer.stop();

    }

    return (positionChanged);

}

void HbScrollAreaPrivate::animateScroll(QPointF speed)

{

    if (mContents == 0)

        return;

    if (mTargetAnimationInProgress) {

        mTargetAnimationInProgress = false;

    }

    mScrollPosition = -mContents->pos();

    if ( mFrictionEnabled ) {

        speed.rx() *= mInertiaSpeedFactor;

        speed.ry() *= mInertiaSpeedFactor;

    }

    speed.rx() = qBound ( -mMaxScrollSpeed, speed.rx(), mMaxScrollSpeed );

    speed.ry() = qBound ( -mMaxScrollSpeed, speed.ry(), mMaxScrollSpeed );

    if ( !mMultiFlickEnabled ) {

        // normal behavior:

        mScrollSpeed = speed;

    } else {

        // Prototype multiflick behavior:

        if ( ( mScrollSpeed.x() < 0.0 && speed.x() < 0.0 ) ||

             ( mScrollSpeed.x() > 0.0 && speed.x() > 0.0 ) ) {

            mScrollSpeed.rx() += speed.x();

        } else {

            mScrollSpeed.setX( speed.x() );

        }

        if ( ( mScrollSpeed.y() < 0.0 && speed.y() < 0.0 )  ||

             ( mScrollSpeed.y() > 0.0 && speed.y() > 0.0 ) ) {

            mScrollSpeed.ry() += speed.y();

        } else {

            mScrollSpeed.setY( speed.y() );

        }

    }

    startAnimating();

}

void HbScrollAreaPrivate::startAnimating()

{

    // Launch the animation timer

    if (!mScrollTimer.isActive()) {

        mScrollElapsedTime.restart();

        mLastElapsedTime = 0.0;

        mScrollTimer.start(ANIMATION_INTERVAL);

        mIsAnimating = true;

    }

}

void HbScrollAreaPrivate::stopScrolling()

{

    Q_Q( HbScrollArea );

    if (mHorizontalScrollBarPolicy == HbScrollArea::ScrollBarAutoHide ||

        mVerticalScrollBarPolicy == HbScrollArea::ScrollBarAutoHide) {

        mScrollBarHideTimer.start(SCROLLBAR_HIDE_TIMEOUT);

    }

    if (mIsScrolling) {

        if (mScrollFeedbackOngoing) {

            HbWidgetFeedback::continuousStopped(q, Hb::ContinuousScrolled);

            mScrollFeedbackOngoing = false;

        }

        mBoundaryReached = false;

        mIsScrolling = false;

        emit q->scrollingEnded();

    }

}

void HbScrollAreaPrivate::stopAnimating()

{

    mScrollTimer.stop();

    mIsAnimating = false;

    stopScrolling();

}

/*

 * animateScrollTimeout() is a private slot function called during

 * follow-on scroll animation

 */

void HbScrollAreaPrivate::_q_animateScrollTimeout()

{

    Q_Q( HbScrollArea );

    qreal elapsedTime = qreal(mScrollElapsedTime.elapsed());

    qreal timeDifference = elapsedTime - mLastElapsedTime;

    // if no time has elapsed, just return

    // this sometimes happens if the timer accuracy is not that great

    if (qIsNull(timeDifference)) {

        return;

    }

    mLastElapsedTime = elapsedTime;

    if ( mTargetAnimationInProgress ) {

        mElapsedTimeInAnimation += timeDifference;

        qreal progressFactor = mAnimationShape->valueForProgress(qMin ( qreal(1.0), mElapsedTimeInAnimation / mOverallTimeToTarget));

        QPointF newPosition = mAnimationInitialPosition + mTargetDelta * progressFactor;

        q->scrollByAmount( newPosition + mContents->pos() );

        if ( mElapsedTimeInAnimation >= mOverallTimeToTarget ){

            mTargetAnimationInProgress = false;

        }

    } else {

        // calculations are split so that the same amount of simulation steps

        // are made in varying framerates.

        do {

            qreal simulationStepInTime = qMin ( MAX_TIMEDIF_FOR_SIMULATION, timeDifference);

            // Calculate new velocity to horizontal movement

            mScrollSpeed.setX( calculateVelocity ( simulationStepInTime,

                                                   mScrollSpeed.x(),

                                                   -mContents->pos().x(),

                                                   leftBoundary(),

                                                   rightBoundary() ) );

            // Calculate new velocity to vertical movement

            mScrollSpeed.setY( calculateVelocity ( simulationStepInTime,

                                                   mScrollSpeed.y(),

                                                   -mContents->pos().y(),

                                                   topBoundary(),

                                                   bottomBoundary() ) );

            QPointF overAllDist = mScrollSpeed * simulationStepInTime;

            bool stopVerticalAnimation = false;

            if ( qAbs( mScrollSpeed.y() ) < MIN_SPEED_PER_MILLISECOND ) {

                stopVerticalAnimation = clampToBoundaries ( overAllDist.ry(), -mContents->pos().y(), topBoundary(), bottomBoundary() );

            }

            bool stopHorizontalAnimation = false;

            if ( qAbs( mScrollSpeed.x() ) < MIN_SPEED_PER_MILLISECOND ) {

                stopHorizontalAnimation = clampToBoundaries ( overAllDist.rx(), -mContents->pos().x(), leftBoundary(), rightBoundary() );

            }

            q->scrollByAmount ( -overAllDist );

            if ( ( !mAbleToScrollY || stopVerticalAnimation ) &&

                 ( !mAbleToScrollX || stopHorizontalAnimation ) ) {

                stopAnimating();

                break;

            }

            timeDifference -= MAX_TIMEDIF_FOR_SIMULATION;

        } while ( timeDifference > MAX_TIMEDIF_FOR_SIMULATION );

    }

    if ( mContents->pos() != -mScrollPosition && mIsAnimating) {

        // Feedback from panning is started in HbScrollArea::panGesture method,

        // feedback from flick is started here

        HbWidgetFeedback::continuousTriggered(q, Hb::ContinuousScrolled, mContents->pos() + mScrollPosition);

        mScrollFeedbackOngoing = true;

    }

}

qreal HbScrollAreaPrivate::calculateVelocity ( qreal timeDifference, qreal curVelocity, qreal pos, qreal min, qreal max )

    {

    Q_Q( HbScrollArea );

    qreal ret(curVelocity);

    qreal overShoot(0.0);

    if ( pos < min ) {

        overShoot = min - pos;

    } else if ( pos > max ) {

        overShoot = max - pos;

    }

    if ( !qIsNull(overShoot)&& !mBoundaryReached) {

        HbWidgetFeedback::triggered(q, Hb::InstantBoundaryReached);

        mBoundaryReached = true;

    }

    if ( !qIsNull(overShoot) && mClampingStyle == HbScrollArea::BounceBackClamping ){

        ret -= mSpringStrength * overShoot - ( mSpringDampingFactor * -curVelocity );

    } else if ( mFrictionEnabled ) {

        // Apply friction if enabled

        ret *= 1.0 - ( mFrictionPerMilliSecond * timeDifference );

        if ( qAbs ( ret ) < MIN_SPEED_PER_MILLISECOND ) {

            ret = 0.0;

        }

    }

    return ret;

}

bool HbScrollAreaPrivate::clampToBoundaries ( qreal& deltaRef, qreal pos, qreal min, qreal max )

{

    bool ret = false;

    qreal clampToValue(0.0);

    if ( pos < min ) {

        clampToValue = pos - min;

    } else if ( pos > max ) {

        clampToValue = pos - max;

    }

    if ( qAbs( clampToValue ) < 1.0 ) {

        deltaRef = clampToValue;

        ret = true;

    }

    return ret;

}

void HbScrollAreaPrivate::addPositionToQueue(const QPointF& position,

        qreal timestamp, bool isRelative)

{

    // queue up the event

    // if isRelative is true, there should have already been an event entered in the queue

    if (isRelative) {

        int prevIndex = (mEventPositionQueueLastIndex + mEventPositionQueueSize

                - 1) % mEventPositionQueueSize;