/*

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

* All rights reserved.

*

*

*

*

*/

#include "GWebTouchNavigation.h"

#include "GWebContentViewWidget.h"

#include "GWebContentView.h"

#include <QGraphicsSceneMouseEvent>

#include <QTimer>

#include <qmath.h>

#include <QDebug>

#include <QGraphicsView>

#include "wrtBrowserUtils.h"

#include "ChromeWidget.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 KPanThreshold = 2;

const int KThreshHoldValForLink = 10;

const qreal KDeccelaration = 1000.00;

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

/*!

    \class WebTouchNavigation

    \since cwrt 1.0

    \brief cwrt navigation.

    \sa WebNavigation, WebHtmlTabIndexedNavigation, WebCursorNavigation, WebDirectionalNavigation

*/

: 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_kineticTimer(0)

, m_isPanning(false)

, m_enabled(true)

, m_isLoading(false)

{

        install();

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

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

}

/*!

*/

{

    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 GWebTouchNavigation::install()

{

    m_view->installEventFilter(this);

}

void GWebTouchNavigation::BlockFocusChanged(QPoint 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;

            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;

            break;

        default:

            break;

    }

    return false;

}

void GWebTouchNavigation::stopScrolling()

{

}

void GWebTouchNavigation::pan()

{

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

}

void GWebTouchNavigation::kineticScroll()

{

            setCurrentFrameScrollPosition(distPos);

    }

}

/*!

    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;

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

                startPanGesture(VerticalPan);

                startPanGesture(HorizontalPan);

            else

                startPanGesture(RandomPan);

            m_isPanning = true;

        }

    }

}

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;

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

        m_panDirection = RandomPan;

    QPointF p;

        p.setX(delta.x());

        p.setY(delta.y());

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

}

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

        nextNode = parentNode.firstChild();

        return true;

    }

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

        nextNode = parentNode.nextSibling();

        return true;

    }

    QWebElement n = parentNode;

    if (!n.isNull()) {

        nextNode = n.nextSibling();

        return true;

    }

QWebElement GWebTouchNavigation::getClosestAnchorElement(QMouseEvent* ev)

    QWebElement webElement;

    QWebHitTestResult htRes = getHitTestResult(ev);

    QWebElement hitElement = htRes.element();

    //check whether hit test returns a link element

        m_ishighlighted = true;

    }

    //get the closet anchor element

    else {

        int dist = 99999999;

        QWebElement result;

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

        do {

                QRect r = ele.geometry();

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

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

            QRect r = result.geometry();

            webElement = result;

            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

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

        // Consider it as double click.

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

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

                mouseDoubleClickEvent(pos);

                return;

            }

        }

        m_doubleClickTimer->stop();

    } else {

        m_doubleClickTimer = new QTimer(this);

    }

    //Clear the previous press and release events.

    m_doubleClickTimer->start(KDoubleClickTimeOut);

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