/*

* Copyright (c) 2009 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: 

*

*/

#include "webtouchnavigation.h"

#include "qwebpage.h"

#include "qwebframe.h"

#include "qapplication.h"

#include "qwebelement.h"

#include <QGraphicsSceneMouseEvent>

#include <QTimer>

#include <qmath.h>

#include "webcontentview.h"

#include "wrtBrowserUtils.h"

#define LONG_PRESS_DURATION 500

const int KFlickSpeed = 400;

const qreal PI = 3.1415926535897932;

const qreal KAngleTolerance = 30;

const int KAnimationTimeout = 40;

const qreal KDecelerationFactor = 0.8;

const int KMilliSecond = 1000;

const int KThresholdForRightToLeftMotion = 100;  // 100 pixels

const int KThresholdForLeftToRightMotion = -100; // 100 pixels

const int XAlignVal = 10;

const int KDecelerationTimer = 125; //Decelerate only if flicked/swiped after KDecelerationTimer milli seconds after last drag event

const int KDoubleClickTimeOut = 400;

const QPoint KFocussPoint(5, 50);

const int KTouchThresholdX = 20;

const int KTouchThresholdY = 20;

const int KThreshHoldValForLink = 10;

const qreal KDeccelaration = 1000.00;

const int KDefaultViewportWidth = 980;

const int KDefaultPortraitScaleWidth = 540;

const int KKineticTimeout = 60;

const int KMinBlockWidth = 50;

static const int KStartPanDistance = 50;

static const int KWaitForClickTimeoutMS = 200;

//The amount of pixels to try to pan before pan mode unlocks

static const int KPanModeChangeDelta = 100;

namespace WRT {

/*!

    \class WebTouchNavigation

    \since cwrt 1.0

    \brief cwrt navigation.

    \sa WebNavigation, WebHtmlTabIndexedNavigation, WebCursorNavigation, WebDirectionalNavigation

*/

WebTouchNavigation::WebTouchNavigation(QWebPage* webPage,QObject* view)

: m_webPage(webPage)

, m_view(view)

, m_frame(0)

, m_scrollTimer(0)

, m_doubleClickTimer(0)

, m_pressEvent(0)

, m_releaseEvent(0)

, m_focusedBlockPt(-1, -1)

, m_ishighlighted(false)

, m_offset(0)

, m_longPressTimer(0)

, m_finalzoomfactor(0)

, m_kineticTimer(0)

, m_isPanning(false)

{

	install();

	WebContentWidget* currentView = qobject_cast<WebContentWidget*>(m_view);  

	connect(currentView, SIGNAL(BlockFocusChanged(QPoint)), this, SLOT(BlockFocusChanged(QPoint)));  

}

/*!

*/

WebTouchNavigation::~WebTouchNavigation() 

{

    disconnect(m_doubleClickTimer, SIGNAL(timeout()), this, SLOT(doubleClickTimerExpired()));    

    if (m_doubleClickTimer) {

        m_doubleClickTimer->stop();

        delete m_doubleClickTimer;

    }

    disconnect(m_scrollTimer, SIGNAL(timeout()),this,SLOT(pan()));

    delete m_scrollTimer;

    disconnect(m_kineticTimer, SIGNAL(timeout()),this,SLOT(kineticScroll()));

    delete m_kineticTimer;

    uninstall();

}

void WebTouchNavigation::install()

{

    m_view->installEventFilter(this);

}

void WebTouchNavigation::BlockFocusChanged(QPoint pt)

{

	m_focusedBlockPt = pt;

}

void WebTouchNavigation::uninstall()

{

    if (m_view)

        m_view->removeEventFilter(this);

}

bool WebTouchNavigation::eventFilter(QObject *object, QEvent *event)

{

    bool ret = false;

    if (object != m_view)

        return false;

{

        switch (event->type()) {

            case QEvent::MouseButtonPress:

                if (static_cast<QMouseEvent *>(event)->buttons() & Qt::LeftButton) {

                    mousePressEvent(static_cast<QMouseEvent *>(event)->pos());

                    return true;

                }

                break;

            case QEvent::MouseMove:

                if (static_cast<QMouseEvent *>(event)->buttons() & Qt::LeftButton) {

                    mouseMoveEvent(static_cast<QMouseEvent*>(event)->pos());

                    return true;

                }

                break;

            case QEvent::MouseButtonRelease:

                mouseReleaseEvent(static_cast<QMouseEvent*>(event)->pos());

                return true;

            case QEvent::MouseButtonDblClick:

                mouseDoubleClickEvent(static_cast<QMouseEvent*>(event)->pos());

                return true;

            case QEvent::GraphicsSceneMousePress:

                if (static_cast<QGraphicsSceneMouseEvent*>(event)->buttons() & Qt::LeftButton) {

                    mousePressEvent(static_cast<QGraphicsSceneMouseEvent*>(event)->pos().toPoint());

                    return true;

                }

            break;

            case QEvent::GraphicsSceneMouseMove:

                if (static_cast<QGraphicsSceneMouseEvent *>(event)->buttons() & Qt::LeftButton) {

                    mouseMoveEvent(static_cast<QGraphicsSceneMouseEvent*>(event)->pos().toPoint());

                    return true;

                }

            break;

            case QEvent::GraphicsSceneMouseRelease: {

                mouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent*>(event)->pos().toPoint());

                return true;

            }

            break;

            case QEvent::GraphicsSceneMouseDoubleClick:

                 mouseDoubleClickEvent(static_cast<QGraphicsSceneMouseEvent*>(event)->pos().toPoint());

                 return true;

            break;

        default:

                break;

        }

    }

    return false;

}

void WebTouchNavigation::stopScrolling()

{

	if (m_scrollTimer && m_scrollTimer->isActive()) {

	    m_scrollTimer->stop();

	    m_scrollDelta = QPoint(0,0);

	}

	if (m_kineticTimer && m_kineticTimer->isActive()) {

	    m_kineticTimer->stop();

	    m_kineticSpeed.setX(0.0);

	    m_kineticSpeed.setY(0.0);

	}

}

void WebTouchNavigation::pan()

{

	if (m_scrollDelta.x() != 0 || m_scrollDelta.y() != 0) {

            scrollCurrentFrame(-m_scrollDelta.x(), m_scrollDelta.y());

	    m_scrollDelta = QPoint(0,0);

	}

}

#define DECELERATION 0.0002 

void WebTouchNavigation::kineticScroll()

{

	qreal decelX = m_kineticSpeed.x() > 0 ? -DECELERATION : DECELERATION;

	qreal decelY = m_kineticSpeed.y() > 0 ? -DECELERATION : DECELERATION;

	qreal dx = 0;

	qreal dy = 0;

	qreal vx = 0;

	qreal vy = 0;

	m_kineticScrollTime += m_actualTime.elapsed();

	if (m_kineticSpeed.x()) {

		vx = m_kineticSpeed.x() + decelX * m_kineticScrollTime;

		if (vx * m_kineticSpeed.x() < 0) {

			dx = 0;

			vx = 0;

		}

		else {

	        dx = m_kineticScrollTime * m_kineticSpeed.x() + 

		        0.5 * decelX * m_kineticScrollTime * m_kineticScrollTime;

		}

	}

	if (m_kineticSpeed.y()) {

		vy = m_kineticSpeed.y() + decelY * m_kineticScrollTime;

		if (vy * m_kineticSpeed.y() < 0) {

			dy = 0;

			vy = 0;

		}

		else {

		    dy = m_kineticScrollTime * m_kineticSpeed.y() + 

			     0.5 * decelY * m_kineticScrollTime * m_kineticScrollTime;

		}

	}

	QPoint scrollPos = m_frame->scrollPosition();

	QPoint distPos = m_initialScrollPos + QPointF(dx, dy).toPoint();

	if (vx != 0 || vy != 0) {

            setCurrentFrameScrollPosition(distPos);

	}

	if ((vx == 0 && vy == 0) || scrollPos == m_frame->scrollPosition()) {

    	stopScrolling();

    }

}

/*!

    Scrolls QWebFrame to the given position

    \sa QWebFrame::scroll()

*/

void WebTouchNavigation::scrollFrame(const QPoint& pos)

{

    if (m_touchPosition != pos) {

        QPoint diff = m_touchPosition-pos;

        if (qAbs(diff.x()) < 10 && qAbs(diff.y()) < 10)

            return;

		else if(m_dragPoints.size() == 1) {	

			WebContentWidget* view = qobject_cast<WebContentWidget*>(m_view);  

			view->setBlockElement(QWebElement());

		}

        if(!m_isPanning) {

            qreal dy = qAbs(diff.y());

            qreal dx = qAbs(diff.x());

            if (dy > KStartPanDistance || dx > KStartPanDistance

                || m_delayedPressMoment.elapsed() > KWaitForClickTimeoutMS) {

                //get the scroll direction

                Direction scrollDir = findDirectionWithAngle(m_touchPosition,pos);

                if(scrollDir == UP || scrollDir == DOWN)

                    startPanGesture(VerticalPan);

                else if(scrollDir == LEFT || scrollDir == RIGHT)

                    startPanGesture(HorizontalPan);

                else

                    startPanGesture(RandomPan);

                m_isPanning = true;

                m_dragStartPos = pos;

            }

        }

        if (m_isPanning) {

            m_scrolled= false;

            m_frame = getNextScrollableFrame(diff);

            QPoint scrollPosition = m_frame->scrollPosition();

            if (diff.manhattanLength())

                panBy(diff);            

            m_scrolled = (scrollPosition != m_frame->scrollPosition());

            m_dragStartPos = pos;

        }

        m_touchPosition = pos;

        DragPoint dragPoint;

        dragPoint.iPoint = pos;

        dragPoint.iTime = QTime::currentTime();

        m_dragPoints.append(dragPoint);

        QTime now(QTime::currentTime());

        m_lastMoveEventTime.setHMS(now.hour(),now.minute(), now.second(), now.msec());

        while (m_dragPoints.size() > 4)

            m_dragPoints.removeFirst();

        }

}

void WebTouchNavigation::startPanGesture(PanDirection directionHint) {

    m_panDirection = directionHint;

    m_panModeResidue = QPointF(0., 0.);

}

void WebTouchNavigation::panBy(const QPointF& delta) {

    m_panModeResidue += delta;

    if (qAbs(m_panModeResidue.x()) > KPanModeChangeDelta)

        m_panDirection = HorizontalPan;

    if (qAbs(m_panModeResidue.y()) > KPanModeChangeDelta)

        m_panDirection = VerticalPan;

    if(qAbs(m_panModeResidue.x()) > KPanModeChangeDelta 

        && qAbs(m_panModeResidue.y()) > KPanModeChangeDelta)

        m_panDirection = RandomPan;

    QPointF p;

    if(m_panDirection == HorizontalPan)

        p.setX(delta.x());

    if(m_panDirection == VerticalPan)

        p.setY(delta.y());

    if(m_panDirection == RandomPan) {

        p.setX(delta.x());     

        p.setY(delta.y());

    }

    scrollCurrentFrame(p.x(),p.y());

}

void WebTouchNavigation::highlightableElement(QMouseEvent* ev) {

    m_anchorElement = getClosestAnchorElement(ev);

}

inline int xInRect(const QRect& r, int x)

{

    return std::min(std::max(x, r.x()), r.x() + r.width());

}

inline int yInRect(const QRect& r, int y)

{

    return std::min(std::max(y, r.y()), r.y() + r.height());

}

bool WebTouchNavigation::traverseNextNode(QWebElement parentNode,QWebElement& nextNode) 

{ 

    if (!parentNode.firstChild().isNull()) {

        nextNode = parentNode.firstChild();

        return true;

    }

    if (!parentNode.nextSibling().isNull()) {

        nextNode = parentNode.nextSibling();

        return true;

    }

    QWebElement n = parentNode;

    while (!n.isNull() && n.nextSibling().isNull()) 

        n = n.parent (); 

    if (!n.isNull()) {

        nextNode = n.nextSibling();

        return true;

    }

    return false; 

} 

QWebElement WebTouchNavigation::getClosestAnchorElement(QMouseEvent* ev)

{   

    QWebElement webElement;

    QWebHitTestResult htRes = getHitTestResult(ev);

    QWebElement hitElement = htRes.element();

    //check whether hit test returns a link element

    if(!htRes.linkElement().isNull()) {

        webElement = htRes.linkElement();              

		m_higlightedPos = ev->pos();

        m_ishighlighted = true;

    }

    //get the closet anchor element

    else {

		QPoint docPoint = (m_touchPosition + m_frame->scrollPosition());

        int dist = 99999999;

        QWebElement result;

        QWebElement ele = m_webPage->currentFrame()->documentElement();

        do {

            if(ele.tagName().compare("a",Qt::CaseInsensitive) == 0 ) {       

                QRect r = ele.geometry();

                if(r.contains(docPoint)) {

                    dist = 0;

                    result = ele;

                    break;

                }

                int x = xInRect(r, docPoint.x());

                int y = yInRect(r, docPoint.y());

                int d = (docPoint.x() - x) * (docPoint.x() - x) + (docPoint.y() - y) * (docPoint.y() - y);

                if (dist > d) {

                    dist = d;

                    result = ele;

                }

            }                       

        }while(traverseNextNode(ele,ele));

        WebContentWidget* view = qobject_cast<WebContentWidget*>(m_view);

		// check if we are close enough and calcualte with zoom factor.

        if (dist< (KThreshHoldValForLink/view->zoomFactor())) {

            QRect r = result.geometry();

            r.translate(2,2); 

            r.setWidth(2+2); 

            r.setHeight(2+2); 

            webElement = result;

            m_higlightedPos = QPoint(xInRect(r, docPoint.x()), yInRect(r, docPoint.y())) - m_frame->scrollPosition(); 

            m_ishighlighted = true;

            QPoint centerpt = webElement.geometry().center();

            m_offset = (docPoint.x()- centerpt.x())*(docPoint.x()- centerpt.x()) + (docPoint.y()- centerpt.y())*(docPoint.y()- centerpt.y());

        }

    }

    return webElement;

}

/*!

    Sends a mouse press event to QWebPage

*/

void WebTouchNavigation::mousePressEvent(const QPoint& pos)

{

    m_delayedPressMoment.start();

    // stop deceleration and don't send further events to engine if scroll timer is active

    if(m_scrollTimer && m_scrollTimer->isActive()) {

        m_prevPoint.setX(0);

        m_prevPoint.setY(0);

        m_scrollDistance.setX(0);

        m_scrollDistance.setY(0);

        m_lastMoveEventTime.setHMS(0,0,0,0); //H, M, S, mS

        m_scrolled = false;

        m_ishighlighted = false;

        m_higlightedPos = m_touchPosition = pos;

        m_frame = m_webPage->frameAt(pos);

        if (!m_frame)

              m_frame = m_webPage->currentFrame(); 

        m_dragPoints.clear();

        DragPoint dragPoint;

        dragPoint.iPoint = m_touchPosition;

        dragPoint.iTime = QTime::currentTime();

        m_dragPoints.append(dragPoint);

        m_offset = 0;

        m_pressEvent = new QMouseEvent(QEvent::MouseButtonPress, m_touchPosition, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

        m_scrollTimer->stop();

        return;

    }

    if (m_doubleClickTimer) {

        // If there is another click event almost on the same region 

        // as the previous click before doubleClick timeout 

        // Consider it as double click.

        if (m_doubleClickTimer->isActive() && m_pressEvent) {

            QPoint diff = m_pressEvent->pos() - pos;

            if (qAbs(diff.x()) < KTouchThresholdX && qAbs(diff.y()) < KTouchThresholdY) {           

                mouseDoubleClickEvent(pos);

                return;

            }

        }

        m_doubleClickTimer->stop();

    } else {

        m_doubleClickTimer = new QTimer(this);

        connect(m_doubleClickTimer, SIGNAL(timeout()), this, SLOT(doubleClickTimerExpired()));    

    }

    //Clear the previous press and release events.

    if (m_pressEvent) {

        delete m_pressEvent;

        m_pressEvent = NULL;

    }

    if (m_releaseEvent) {

        delete m_releaseEvent;

        m_releaseEvent = NULL;

    }

    m_doubleClickTimer->start(KDoubleClickTimeOut);

    m_pressEvent = new QMouseEvent(QEvent::MouseButtonPress, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

}

void WebTouchNavigation::handleMousePressEvent(QMouseEvent* ev)

{

    m_lastMoveEventTime.setHMS(0,0,0,0); //H, M, S, mS

    if(!m_longPressTimer){

        delete m_longPressTimer;

        m_longPressTimer = 0;

    }

    startTimer();

    m_scrolled = false;

    m_ishighlighted = false;

    m_higlightedPos = m_touchPosition = ev->pos();

    m_frame = m_webPage->frameAt(ev->pos());

    if (!m_frame)

        m_frame = m_webPage->currentFrame(); 

    m_dragPoints.clear();

    DragPoint dragPoint;

    dragPoint.iPoint = m_touchPosition;

    dragPoint.iTime = QTime::currentTime();

    m_dragPoints.append(dragPoint);

	m_offset = 0;

    highlightableElement(ev);

    getFocusedElement();