/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not,

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include "GWebTouchNavigation.h"

#include "wrtBrowserUtils.h"

#include <QWebPage>

#include <QWebFrame>

#include <QApplication>

#include <QWebElement>

#include <QGraphicsSceneMouseEvent>

#include <QTimer>

#include <qmath.h>

#include <QDebug>

#include <QGraphicsView>

namespace GVA {

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 KPanThreshold = 2;

const int KThreshHoldValForLink = 10;

const qreal KDeccelaration = 1000.00;

static const int KStartPanDistance = 50;

static const int KWaitForClickTimeoutMS = 200;

static const int KLongPressDuration = 1000;

static const int KLongPressThreshold = 30;

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

static const int KPanModeChangeDelta = 100;

/*!

    \class WebTouchNavigation

    \since cwrt 1.0

    \brief cwrt navigation.

    \sa WebNavigation, WebHtmlTabIndexedNavigation, WebCursorNavigation, WebDirectionalNavigation

*/

GWebTouchNavigation::GWebTouchNavigation(QWebPage* webPage, QGraphicsWebView* view)

: m_webPage(webPage)

, m_view(view)

, m_frame(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_scrollTimer(0)

, m_kineticTimer(0)

, m_isPanning(false)

, m_enabled(true)

, m_textSelected(false)

, m_isLoading(false)

, m_contentHeight(0)

, m_isContextEvent(false)

, m_wantSlideViewCalls(true)

, m_doubleClickEnabled(true)

{

        install();

        connect(m_webPage, SIGNAL(loadStarted()), this, SLOT(onLoadStarted()));

        connect(m_webPage, SIGNAL(loadFinished(bool)), this, SLOT(onLoadFinished(bool)));

}

inline void GWebTouchNavigation::cancelPressEvent() {

    if (m_pressEvent) {

        delete m_pressEvent;

        m_pressEvent = 0;

    }

}

inline void GWebTouchNavigation::cancelReleaseEvent() {

    if (m_releaseEvent) {

        delete m_releaseEvent;

        m_releaseEvent = 0;

    }

}

/*!

*/

GWebTouchNavigation::~GWebTouchNavigation()

{

    delete m_doubleClickTimer;

    delete m_scrollTimer;

    delete m_kineticTimer;

    delete m_longPressTimer;

    uninstall();

    cancelPressEvent();

    cancelReleaseEvent();

}

void GWebTouchNavigation::install()

{

    m_view->installEventFilter(this);

}

void GWebTouchNavigation::BlockFocusChanged(QPoint pt)

{

    m_focusedBlockPt = pt;

}

void GWebTouchNavigation::uninstall()

{

    if (m_view)

        m_view->removeEventFilter(this);

}

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

{

    if (object != m_view || !enabled())

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

                QPoint diff = m_touchPosition - static_cast<QMouseEvent*>(event)->globalPos();

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

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

                emit mouseEvent(QEvent::GraphicsSceneMousePress);

                return true;

            }

            break;

        case QEvent::GraphicsSceneMouseMove:

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

                QPoint diff = static_cast<QGraphicsSceneMouseEvent*>(event)->lastScenePos().toPoint() - static_cast<QGraphicsSceneMouseEvent*>(event)->scenePos().toPoint();

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

                return true;

            }

            break;

        case QEvent::GraphicsSceneMouseRelease:

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

            emit mouseEvent(QEvent::GraphicsSceneMouseRelease);

            return true;

        case QEvent::GraphicsSceneMouseDoubleClick:

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

            emit mouseEvent(QEvent::GraphicsSceneMouseDoubleClick);

            return true;

        case QEvent::GraphicsSceneContextMenu:

            contextMenuEvent();

            break;

        default:

            break;

    }

    return false;

}

void GWebTouchNavigation::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 GWebTouchNavigation::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 GWebTouchNavigation::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 GWebTouchNavigation::scrollFrame(const QPoint& diff)

{

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

        return;

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

        setViewBlockElement(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(diff);

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

                startPanGesture(VerticalPan);

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

                startPanGesture(HorizontalPan);

            else

                startPanGesture(RandomPan);

            m_isPanning = true;

        }

    }

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

    }

}

void GWebTouchNavigation::startPanGesture(PanDirection directionHint) {

    emit startingPanGesture((int)directionHint);

    m_panDirection = directionHint;

    m_panModeResidue = QPointF(0., 0.);

}

void GWebTouchNavigation::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 GWebTouchNavigation::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 GWebTouchNavigation::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 GWebTouchNavigation::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));

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

        if (dist< (KThreshHoldValForLink/m_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 GWebTouchNavigation::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, getEventModifier(m_touchPosition));

        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.

    cancelPressEvent();

    cancelReleaseEvent();

    m_doubleClickTimer->start(KDoubleClickTimeOut);

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

    m_longPressPosition = pos;

    startLongPressTimer();

}

void GWebTouchNavigation::handleMousePressEvent(QMouseEvent* ev)

{

    if (!ev) return;

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

    m_scrolled = false;

    m_ishighlighted = false;

    m_higlightedPos = m_touchPosition = ev->pos();

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

    if (!m_frame)