/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:  CalenDayContentScrollArea implementation.
 *
 */

// System includes
#include <QGraphicsLinearLayout>
#include <QGesture>

#include <HbInstance>
#include <HbSwipeGesture>

// User includes
#include "calendaycontentscrollarea.h"
#include "calendayutils.h"

// Constants
/*!
 Default timeout for scrolling between days [ms]
 */
const int KCalenScrollDaysTimeout = 600;

/*!
 Value [%] defines how long (depending on content area width) should horizontal
 pan gesture be to change day to previous/next.
 If the gesture is shorter - current view is not changed.
 */
const int KCalenHScrollMoveParam = 30;  //!< Percentage

/*!
 Value [degree] defines the max. angle of swipe gesture which should change day.
 */
const qreal KCalenSwipeAngle = 30;


/*!
 \class CalenDayContentScrollArea
 \brief Scrollable container class for content widgets.
 
 It handles horizontal scrolling and swipe or pan gestures.
 */

/*!
 \brief Constructor
 
 Configures scroll area settings and resets internal stares of widget.
 Gets the width of device.
 
 \param parent The parent of scroll area widget
 */
CalenDayContentScrollArea::CalenDayContentScrollArea(QGraphicsItem *parent) :
    HbScrollArea(parent), mPanDayDirection(ECalenPanNotSet), mIsMoving(false),
    mMoveDirection(ECalenScrollNoDayChange)
{ 
#ifdef CALENDAYVIEW_PANNING_ENABLED
    grabGesture(Qt::PanGesture);
    ungrabGesture(Qt::SwipeGesture);
#else
    grabGesture(Qt::SwipeGesture);
    ungrabGesture(Qt::PanGesture);
#endif

    // Get the width of content area and orientation of screen
    mContentWidth = CalenDayUtils::instance()->contentWidth();
    mOrientation = CalenDayUtils::instance()->orientation();
    
    // Fix the width of scroll area
    setMinimumWidth(mContentWidth);
    setMaximumWidth(mContentWidth);

    // Connect to main window's orientationChanged SIGNAL to handle orientation
    // switching
    connect(CalenDayUtils::instance()->mainWindow(), 
        SIGNAL(orientationChanged(Qt::Orientation)), this,
        SLOT(orientationChanged(Qt::Orientation)));
}

/*!
 \brief Destructor
 */
CalenDayContentScrollArea::~CalenDayContentScrollArea()
{
}

/*!
 \brief Scrolls to middle widget.
 
 Scrolling to middle widget is done if needed.
 Resets internal pan direction flag.
 */
void CalenDayContentScrollArea::scrollToMiddleWidget()
{
    QPointF currentPosition = contentWidget()->pos();
    QPointF destPosition = QPointF(mContentWidth, currentPosition.y());

    // Scroll only when x position is wrong
    if (currentPosition.x() != destPosition.x()) {
        scrollContentsTo(QPointF(mContentWidth, currentPosition.y()), 0);
    }

    // Reset pan direction flag and scrolling flag
    mPanDayDirection = ECalenPanNotSet;
}

/*!
 \brief Scrolls the view by the amount indicated by "delta".
 
 Checks the direction of pan gesture and promotes leading direction.
 
 \param delta Move offset
 \return Returns TRUE if the view was able to scroll, FALSE otherwise
 */
bool CalenDayContentScrollArea::scrollByAmount(const QPointF &delta)
{
    QPointF newDelta(delta);
    if (mPanDayDirection == ECalenPanVertical) {
        newDelta.setX(0);
    }
    else
        if (mPanDayDirection == ECalenPanHorizontal) {
            newDelta.setY(0);
        }
        else {
            // Pan direction not set
        }

    return HbScrollArea::scrollByAmount(newDelta);
}

/*!
 \brief Handles pan gesture event (horizontal) or swipe gesture. 
 
 Ignores vertical pan gestures.
 
 \param event Gesture event to be handled
 */
void CalenDayContentScrollArea::gestureEvent(QGestureEvent *event)
{
#ifdef CALENDAYVIEW_PANNING_ENABLED
    // Process a pan gesture event
    if (QPanGesture *panGesture = qobject_cast<QPanGesture*> (event->gesture(
        Qt::PanGesture))) {

        // Checks pan gesture direction
        checkPanDirection(panGesture);

        // Put the gesture forward before working with finished gesture
        HbScrollArea::gestureEvent(event);

        // If gesture is finished move the scroll area to next or previous 
        // widget or resume to gesture start point
        if (panGesture->state() == Qt::GestureFinished) {
            // Pan direction should be reseted when scrolling ends

            // Gets the offset of pan gesture.
            QPointF offset = panGesture->offset();

            // Note: in horizontal orientation x should is treaten as Y, y as X.
            QPointF movement;
            if (mOrientation == Qt::Vertical) {
                movement = offset;
            }
            else {
                movement.setX(offset.y());
                movement.setY(offset.x());
            }

            // Gesture was long enough for place movement
            if (qAbs(movement.x()) > (KCalenHScrollMoveParam * mContentWidth / 100)) {
                if (movement.x() < 0) {
                    mMoveDirection = ECalenScrollToNext;
                    moveTo(QPointF((-mStartPosition.x() + mContentWidth),
                        -mStartPosition.y()), KCalenScrollDaysTimeout);
                }
                else {
                    mMoveDirection = ECalenScrollToPrev;
                    moveTo(QPointF(-mStartPosition.x() - mContentWidth,
                        -mStartPosition.y()), KCalenScrollDaysTimeout);
                }
            }
            // Gesture was short one, reset to gesture start point
            else {
                qreal startPos = mStartPosition.x();
                bool isNegative = false;
                if (startPos < 0) {
                    isNegative = true;
                }
                startPos = qAbs(startPos);
                qreal normalizeValue = mContentWidth / 2;

                while (startPos > normalizeValue) {
                    normalizeValue += mContentWidth;
                }

                if (isNegative) {
                    mStartPosition.setX(-(normalizeValue - (mContentWidth / 2)));
                }
                else {
                    mStartPosition.setX(normalizeValue - (mContentWidth / 2));
                }

                mMoveDirection = ECalenScrollNoDayChange;
                moveTo(-mStartPosition, KCalenScrollDaysTimeout);
            }
        }
    }
    else {
        HbScrollArea::gestureEvent(event);
    }
#else
    // Let the content scroll area ignore pan gestures
    if (QPanGesture *panGesture = qobject_cast<QPanGesture *> (event->gesture(
                Qt::PanGesture))) {
        // do nothing with pan gesture
    }

    if (HbSwipeGesture *swipeGesture =
        qobject_cast<HbSwipeGesture *> (event->gesture(Qt::SwipeGesture))) {
        if (swipeGesture->state() == Qt::GestureStarted) {
            mStartPosition = contentWidget()->pos();
            
            qreal swipeAngle = swipeGesture->sceneSwipeAngle();
            if (isHorizontalSwipe(swipeAngle)) {
                if (QSwipeGesture::Left == 
                    swipeGesture->sceneHorizontalDirection()) {
                    mMoveDirection = ECalenScrollToNext;
                    moveTo(QPointF((-mStartPosition.x() + mContentWidth),
                            -mStartPosition.y()), KCalenScrollDaysTimeout);
                }
                else if (QSwipeGesture::Right == 
                    swipeGesture->sceneHorizontalDirection()) {
                    mMoveDirection = ECalenScrollToPrev;
                    moveTo(QPointF(-mStartPosition.x() - mContentWidth,
                            -mStartPosition.y()), KCalenScrollDaysTimeout);
                }
            }
        }
    }
#endif
}

/*!
 \brief Filters pan gesture events.
 
 Filters events if this object has been installed as an event filter for
 the watched object. Handles horizontal pan gestures (ignores vertical).
 When moving scroll area all gesture events are blocked.
 
 \param obj Watched object
 \param event Event to be filtered
 \return Returns TRUE if event was handled. FALSE otherwise.
 */
bool CalenDayContentScrollArea::eventFilter(QObject *obj, QEvent *event)
{
    Q_UNUSED(obj);

    bool handled = false;

    // Check if we get a gesture event
    if (event->type() == QEvent::Gesture) {

        // Blocks handling of gesture events if scrolling started by 
        // pan gesture is in progress
        if (mIsMoving) {
            handled = true;
        }
        else {
            QGestureEvent* gesture = static_cast<QGestureEvent*> (event);

            // Check if we get a pan gesture
            QPanGesture *panGesture = qobject_cast<QPanGesture*> (
                gesture->gesture(Qt::PanGesture));
            if (panGesture) {
                checkPanDirection(panGesture);
                if (mPanDayDirection == ECalenPanHorizontal) {
                    gestureEvent(gesture);
                    handled = true;
                }
            }
        }
    }

    return handled;
}

/*!
 \brief Overriden event handler.
 
 Handles events:
 - gesture/focus events blocked when horizontal scrolling is in progress
 - layout request event - scrolls to middle widget if current position is wrong
 
 \param e Event to be handled
 \return Returns TRUE if event was handled. FALSE otherwise.
 */
bool CalenDayContentScrollArea::event(QEvent *e)
{
    bool result = false;

    // Blocks base class handler for certain events if scrolling started
    // by pan gesture is in progress
    if (mIsMoving && (e->type() == QEvent::Gesture || e->type()
        == QEvent::GestureOverride || e->type() == QEvent::FocusOut
        || e->type() == QEvent::FocusIn)) {
        result = true;
    }
    if (!result) {
        // Call base class handler
        result = HbScrollArea::event(e);
        
        // Scroll to middle widget when layout request
        if (e->type() == QEvent::LayoutRequest) {
            scrollToMiddleWidget();
        }  
    }

    return result;
}

/*!
 \brief Checks the direction of pan gesture.
 
 Changes the scrolling style according to movement direction, 
 stores the orientation of the pan gesture.
 Function is used when switching widgets by panning gesture is enabled.
 
 \param panGesture Pan gesture event
 */
void CalenDayContentScrollArea::checkPanDirection(QPanGesture *panGesture)
{
    // Gets the offset of pan gesture.
    QPointF offset = panGesture->offset();

    // Note: in horizontal orientation x should is treaten as Y, y as X.
    QPointF movement;
    if (mOrientation == Qt::Vertical) {
        movement = offset;
    }
    else {
        movement.setX(offset.y());
        movement.setY(offset.x());
    }

    // If gesture is started check leading movement direction
    if (panGesture->state() == Qt::GestureStarted) {
        if (qAbs(movement.x()) < qAbs(movement.y())) {
            mPanDayDirection = ECalenPanVertical;
        }
        else {
            mStartPosition = contentWidget()->pos();
            mPanDayDirection = ECalenPanHorizontal;
        }
    }
}

/*!
 \brief Scrolls the contents to the newPosition in a given time.
 
 Sets the flag to indicate that scrolling is in progress. Use this function
 for scrolling with timeout > 0 to block gesture and focus events during
 scroll area movement.
 
 \param newPosition Destination position
 \param time Time of scroll movement
 */
void CalenDayContentScrollArea::moveTo(const QPointF &newPosition, int time)
{
    // Connect to scrollingEnded SIGNAL to get feedback when scrolling ends
    connect(this, SIGNAL(scrollingEnded()), this, SLOT(moveFinished()));
    
    // Scroll the content to new position and set isMoving flag
    scrollContentsTo(newPosition, time);
    mIsMoving = true;
    
    // Emit signal that moving has just started
    if (mMoveDirection != ECalenScrollNoDayChange) {
        emit scrollAreaMoveStarted(mMoveDirection);
    }
}

/*!
 \brief isHorizontalSwipe
 
 \return TRUE if horizontal swipe was recognized (angle in specific range)
 */
bool CalenDayContentScrollArea::isHorizontalSwipe(qreal angle) const
{
    bool isHSwipe = false;
    if ((angle < KCalenSwipeAngle) || 
        ((angle > 180 - KCalenSwipeAngle) && (angle < 180 + KCalenSwipeAngle)) ||
        (angle > 360 - KCalenSwipeAngle)) {
        isHSwipe = true;
    }
    
    return isHSwipe;
}

/*!
 \brief Slot which is called when moving of scroll area is finished.
 
 Resets internal isMoving flag.
 */
void CalenDayContentScrollArea::moveFinished()
{
    // Disconnect from signal, move is finished now
    disconnect(this, SIGNAL(scrollingEnded()), this, SLOT(moveFinished()));
    mIsMoving = false;
    
    // Emit signal that moving has just finished and reset direction
    if (mMoveDirection != ECalenScrollNoDayChange) {
        emit scrollAreaMoveFinished(mMoveDirection);
        mMoveDirection = ECalenScrollNoDayChange;
    }
}

/*!
 \brief Slot which is called whenever the orientation of the device changes.
 
 Stores screen width and orientation in private members.
 
 \param orientation Current device orientation
 */
void CalenDayContentScrollArea::orientationChanged(Qt::Orientation orientation)
{
    // Update the width of content area
    mContentWidth = CalenDayUtils::instance()->contentWidth();
    mOrientation = orientation;

    // Fix the width of scroll area
    setMinimumWidth(mContentWidth);
    setMaximumWidth(mContentWidth);

    scrollToMiddleWidget();

    // Reset flag related to moving
    mPanDayDirection = ECalenPanNotSet;
    mMoveDirection = ECalenScrollNoDayChange;
    mIsMoving = false;
}

// End of File