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

**

** 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 "hbstyleoption_p.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 = 16.0;

static const int INITIAL_SCROLLBAR_HIDE_TIMEOUT = 4000;

static const int PAGE_CHANGE_DURATION = 170;

//keep this half of swapbuffer time so that we dont end up doing too many updates

static const int ANIMATION_INTERVAL = 8;

static const int FRAMEUPDATE_THRESHOLD = 32;

}

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

        mScrollTimerId(0),

        mScrollElapsedTime(),

        mTargetAnimationInProgress(false),

        mElapsedTimeInAnimation(0.0),

        mOverallTimeToTarget(0.0),

        mTargetDelta(QPointF(0,0)),

        mAnimationInitialPosition (QPointF(0,0)),

        mAnimationShape (0),

        mScrollBarHideTimerId(0),

        mFrictionEnabled(true),

        mResetAlignment(true),

        mClampingStyle(HbScrollArea::BounceBackClamping),

        mScrollingStyle(HbScrollArea::PanWithFollowOn),

        mLayoutDirection(Qt::LeftToRight),

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

        mContinuationIndicators(false),

        mEmitPositionChangedSignal(false),

        mClearCachedRect (true),

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

{    

    delete mAnimationShape;

}

void HbScrollAreaPrivate::init()

{

    Q_Q( HbScrollArea );

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

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

    q->setFlag(QGraphicsItem::ItemHasNoContents, 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);

#if QT_VERSION >= 0x040700

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

#else

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

#endif

    q->grabGesture(Qt::TapGesture);

}

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

}

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

            }

        }

        bool scrolled = currentPosition != newPosition;

        if (scrolled) {

            setContentPosition(-newPosition);

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

                updateScrollBar(Qt::Horizontal);

            }

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

                updateScrollBar(Qt::Vertical);

            }

        }

        // if animating stopScrolling will be called from _q_animateScrollTimeout

        if (!mIsAnimating) {

            stopScrolling();

        }

        // must return here, otherwise mIsScrolling will be false

        // below and scrollingStarted will be emitted

        return scrolled;

    } else {

        mBoundaryReached = false;

    }

    setContentPosition(-newPosition);

    //Its important to setcontents position first as thats used in updateScrollbar.displayScrollbar calls

    //updateScrollbar internally.Other wise we need to update scrollbars twice with different positions.

    if (!mIsScrolling) {

        if (mAbleToScrollX || mAbleToScrollY) {

            mIsScrolling = true;

            emit q->scrollingStarted();

        }

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

            displayScrollBar(Qt::Horizontal);

        }

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

            displayScrollBar(Qt::Vertical);

        }

        stopScrollbarHideTimer();

    }

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

        updateScrollBar(Qt::Horizontal);

    }

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

        updateScrollBar(Qt::Vertical);

    }

        //if we are here than content position has changed.i.e delta is not zero or

    //we havent reached the boundaries.

    return true;

}

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

        return;

    if (mScrollTimerId == 0) {

        Q_Q( HbScrollArea );

        mScrollTimerId = q->startTimer(ANIMATION_INTERVAL);

        //make sure we where able to start the timer

        if (mScrollTimerId != 0) {

            mScrollElapsedTime.restart();

            mIsAnimating = true;

        }

        resetFrameVariables();

    }

}

void HbScrollAreaPrivate::stopScrolling()

{

    Q_Q( HbScrollArea );

    if (mHorizontalScrollBarPolicy == HbScrollArea::ScrollBarAutoHide ||

        mVerticalScrollBarPolicy == HbScrollArea::ScrollBarAutoHide) {

        startScrollbarHideTimer();

    }

    if (mIsScrolling) {

        if (mScrollFeedbackOngoing) {

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

            mScrollFeedbackOngoing = false;

        }

        mBoundaryReached = false;

        mIsScrolling = false;

        emit q->scrollingEnded();

    }

}

void HbScrollAreaPrivate::stopAnimating()

{

    if (mIsAnimating) {

        Q_Q( HbScrollArea );

        q->killTimer(mScrollTimerId);

        mScrollTimerId = 0;

        mIsAnimating = false;

        stopScrolling();

    }

}

void HbScrollAreaPrivate::startScrollbarHideTimer()

{

    if (mScrollBarHideTimerId == 0){

        Q_Q( HbScrollArea );

        mScrollBarHideTimerId = q->startTimer(INITIAL_SCROLLBAR_HIDE_TIMEOUT);

    }

}

void HbScrollAreaPrivate::stopScrollbarHideTimer()

{

    if (mScrollBarHideTimerId != 0) {

        Q_Q( HbScrollArea );

        q->killTimer(mScrollBarHideTimerId);

        mScrollBarHideTimerId = 0;

    }

}

void HbScrollAreaPrivate::reStartScrollbarHideTimer()

{

  stopScrollbarHideTimer();

  startScrollbarHideTimer();

}

void HbScrollAreaPrivate::resetFrameVariables()

{

    mUnderFramCount = 0;

    mOverFramCount = 0;

}

qreal HbScrollAreaPrivate::timeDifferenceBetweenFrame(qreal difference)

{

    if (difference<MAX_TIMEDIF_FOR_SIMULATION) {

        mOverFramCount = 0;

        mUnderFramCount++;

        if(mUnderFramCount > FRAMEUPDATE_THRESHOLD ) {

            mUnderFramCount = FRAMEUPDATE_THRESHOLD;

            //To have smooth velocity during scrolling avg the ideal time with the

            //actual frame time.

            return qCeil((difference+MAX_TIMEDIF_FOR_SIMULATION)/2);

        }

        else {

            return MAX_TIMEDIF_FOR_SIMULATION;

        }

    } else if (difference>FRAMEUPDATE_THRESHOLD) {

        mUnderFramCount = 0;

        mOverFramCount++;

        if(mOverFramCount > FRAMEUPDATE_THRESHOLD) {

            mOverFramCount = FRAMEUPDATE_THRESHOLD;

            //To have smooth velocity during scrolling avg the ideal time with the

            //actual frame time.

                return qCeil((qreal(difference)+MAX_TIMEDIF_FOR_SIMULATION)/2);

        }

        else {

            return MAX_TIMEDIF_FOR_SIMULATION;

        }

    }

    mUnderFramCount = 0;

    mOverFramCount = 0;

    return MAX_TIMEDIF_FOR_SIMULATION;

}

/*

 * animateScrollTimeout() is a private slot function called during

 * follow-on scroll animation

 */

void HbScrollAreaPrivate::_q_animateScrollTimeout()

{

    Q_Q( HbScrollArea );

    qreal timeDifference(mScrollElapsedTime.elapsed());

    // if no time has elapsed, just return

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

    if (qIsNull(timeDifference)) {

        return;

    }

    timeDifference = timeDifferenceBetweenFrame(timeDifference);

    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 {

        qreal simulationStepInTime;

        QPointF overAllDist(0,0);

        QPointF currentPosition(-mContents->pos());

        bool stopVerticalAnimation(false);

        bool stopHorizontalAnimation(false);

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

        // are made in varying framerates.