/*

* 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 "qmath.h"

#include "qpainter.h"

#include "qwebpage.h"

#include "qwebview.h"

#include "qwebframe.h"

#include "qwebelement.h"

#include "webdirectionalnavigation.h"

namespace WRT {

const int KInitialSize = 20;

const int KNormalScrollRange = 40;

const int KFullStep = 14;

const double KMaxDistance = 1000000;

/*!

    \class WebDirectionalNavigation

    \since cwrt 1.0

    \brief cwrt navigation.

    \sa WebNavigation, WebTouchNavigation, WebCursorNavigation, WebHtmlTabIndexedNavigation

*/

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

    m_webPage(webPage)

,   m_view(view)

{

    install();

}

WebDirectionalNavigation::~WebDirectionalNavigation()

{

    uninstall();

}

void WebDirectionalNavigation::install()

{

    m_view->installEventFilter(this);

    //initiallayoutCompleted();

}

void WebDirectionalNavigation::uninstall()

{

    if (m_view)

        m_view->removeEventFilter(this);

}

void WebDirectionalNavigation::initiallayoutCompleted()

{

    m_webElement = m_webPage->currentFrame()->findFirstElement(QString("a,input,select,textarea,object"));

    if (!m_webElement.isNull()) {

        m_webElement.setFocus();

        m_focusPoint = m_webElement.geometry().topLeft();

        setCurrentFrameScrollPosition(m_focusPoint);

    }

}

double WebDirectionalNavigation::calculateElementDistance(int direction, const QRect& possibleRect) 

{

    // Roughly based on this algorithm http://www.w3.org/TR/WICD/#nav-distance-fkt 

    // Deviates in that the overlap is not calculated. Instead, if there is any overlap

    // selection is restricted to x or y direction only. This helps for differnt size elments

    // all lying on the same plane, but might mess up backtracking the naviation path.

    QRect focusedRect(0,0,1,1);

    if (!m_webElement.isNull())

        focusedRect = QRect(m_webElement.geometry());

    //calculate the next focuspoint

    switch (direction) {

    case Qt::Key_Up:

        if (m_focusPoint.x() < focusedRect.x())

            m_focusPoint.setX(focusedRect.x());

        else if (m_focusPoint.x() > focusedRect.right())

            m_focusPoint.setX(focusedRect.right());

        m_focusPoint.setY(focusedRect.y());

        break;

    case Qt::Key_Down:

        if (m_focusPoint.x() < focusedRect.x())

            m_focusPoint.setX(focusedRect.x());

        else if (m_focusPoint.x() > focusedRect.right())

            m_focusPoint.setX(focusedRect.right());

        m_focusPoint.setY(focusedRect.bottom());

        break;

    case Qt::Key_Right:

        m_focusPoint.setX(focusedRect.right());

        if (m_focusPoint.y() < focusedRect.y())

            m_focusPoint.setY(focusedRect.y());

        else if (m_focusPoint.y() > focusedRect.bottom())

            m_focusPoint.setY(focusedRect.bottom());

        break;

    case Qt::Key_Left:

        m_focusPoint.setX(focusedRect.x());

        if (m_focusPoint.y() < focusedRect.y())

            m_focusPoint.setY(focusedRect.y());

        else if (m_focusPoint.y() > focusedRect.bottom())

            m_focusPoint.setY(focusedRect.bottom());

        break;

    }

    // Make sure the rectangle falls within the search area

    if (direction == Qt::Key_Up && possibleRect.bottom() > m_focusPoint.y()

        || direction == Qt::Key_Down && possibleRect.y() < m_focusPoint.y()

        || direction == Qt::Key_Right && possibleRect.x() < m_focusPoint.x()

        || direction == Qt::Key_Left && possibleRect.right() > m_focusPoint.x())

        return KMaxDistance;

    // The absolute distance (dx or dy) on the navigation axis between the opposing edges of the currently focused

    // element and each of the candidates.

    double distanceX = 0;

    double distanceY = 0;

    if (direction == Qt::Key_Up) {

        // adjust the x distance based on the closest edge

        if (m_focusPoint.x() < possibleRect.x()) 

            distanceX = possibleRect.x() - m_focusPoint.x();

        else if (m_focusPoint.x() > possibleRect.right())

            distanceX = m_focusPoint.x() - possibleRect.right();

       distanceY = m_focusPoint.y() - possibleRect.bottom();

    } else if (direction == Qt::Key_Down) {

        // adjust the x distance based on the closest edge

        if (m_focusPoint.x() < possibleRect.x()) 

            distanceX = possibleRect.x() - m_focusPoint.x();

        else if (m_focusPoint.x() > possibleRect.right())

            distanceX = m_focusPoint.x() - possibleRect.right();

        distanceY = possibleRect.y() - m_focusPoint.y();

    } else if (direction == Qt::Key_Right) {

        distanceX = possibleRect.x() - m_focusPoint.x();

        // adjust the y distance based on the closest edge

        if (m_focusPoint.y() < possibleRect.y())

            distanceY = possibleRect.y() - m_focusPoint.y();

        else if (m_focusPoint.y() > possibleRect.bottom())

            distanceY = m_focusPoint.y() - possibleRect.bottom();

    } else if (direction == Qt::Key_Left) {

        distanceX = m_focusPoint.x() - possibleRect.right();

        // adjust the y distance based on the closest edge

        if (m_focusPoint.y() < possibleRect.y()) 

            distanceY = possibleRect.y() - m_focusPoint.y();

        else if (m_focusPoint.y() > possibleRect.bottom())

            distanceY = m_focusPoint.y() - possibleRect.bottom();

    }

    // The absolute distance on the axis orthogonal to the navigation axis between

    // the opposing edges of currently focused element and each of candidates

    double displacement = 0;

    // The euclidean distance

    double euclideanDist = sqrt(distanceX * distanceX + distanceY * distanceY);

    // Area of the document to search

    QRect searchRect(m_webPage->currentFrame()->scrollPosition(),m_webPage->viewportSize());

    if (direction == Qt::Key_Up || direction == Qt::Key_Down) {

        // if the rectangles are on the same plane set the euclideanDist to zero to favor this navigation

        if ((possibleRect.x() == focusedRect.x())

            || (possibleRect.right() > focusedRect.x() && possibleRect.right() < focusedRect.right())

            || (possibleRect.x() > focusedRect.x() && possibleRect.x() < focusedRect.right())

            || (possibleRect.x() > focusedRect.x() && possibleRect.right() < focusedRect.right())

            || (possibleRect.x() < focusedRect.x() && possibleRect.right() > focusedRect.right())) {

            euclideanDist = 0;

            distanceX = 0;

        } else {

            // displacement is added for being orthogonally far from the current rectangle.

            if (possibleRect.x() > focusedRect.right())

                displacement = possibleRect.x() - focusedRect.right();

            if (possibleRect.right() < focusedRect.x())

                displacement = focusedRect.x() - possibleRect.right();

            // This is a little sketchy, but if the rectangles are all 

            // touching set the displacment to 1 so rects on the same plane win

            if (displacement == 0)

                displacement = 1;

            // if the focus is within the view limit the diagonal search by half the search rectangle

            if (searchRect.intersects(focusedRect) && (displacement > (searchRect.width()/2)))

                return KMaxDistance;

        }

    } else if (direction == Qt::Key_Left || direction == Qt::Key_Right) {

        // if the rectangles are on the same plane set the euclideanDist to zero to favor this navigation

        if ((possibleRect.y() == focusedRect.y())

            || (possibleRect.bottom() > focusedRect.y() && possibleRect.bottom() < focusedRect.bottom())

            || (possibleRect.y() > focusedRect.y() && possibleRect.y() < focusedRect.bottom())

            || (possibleRect.y() > focusedRect.y() && possibleRect.bottom() < focusedRect.bottom())

            || (possibleRect.y() < focusedRect.y() && possibleRect.bottom() > focusedRect.bottom())) {

           euclideanDist = 0;

           distanceY = 0; 

        } else {

            // displacement is added for being orthogonally far from the current rectangle.

            if (possibleRect.y() > focusedRect.bottom())

                displacement = possibleRect.y() - focusedRect.bottom();

            if (possibleRect.bottom() < focusedRect.y())

                displacement = focusedRect.y() - possibleRect.bottom();

            // This is a little sketchy, but if the rectangles are all 

            // touching set the displacment to 1 so rects on the same plane win

            if (displacement == 0) 

                displacement = 1;

            //  if the focus is within the view limit the diagonal search by half the search rectangle

            if (searchRect.intersects(focusedRect) && (displacement > (searchRect.height()/2)))

                return KMaxDistance; 

        }

    }

    return euclideanDist + distanceX + distanceY + 2 * (displacement);

}

bool WebDirectionalNavigation::nextElementInDirection(int direction)

{

    double bestDistance = KMaxDistance;

    QWebElement bestElement;

#if QT_VERSION < 0x040600

    QList<QWebElement> elementList = m_webPage->currentFrame()->findAllElements(QString("a,input,select,textarea,object"));

#else

    QList<QWebElement> elementList = m_webPage->currentFrame()->findAllElements(QString("a,input,select,textarea,object")).toList();

#endif

    QList<QWebElement>::iterator it;

    for (it = elementList.begin(); it != elementList.end(); it++) {

        QWebElement el(*it);

        QRect nRect(el.geometry());

        if (nRect.isValid()) {

            if (QRect(m_webPage->currentFrame()->scrollPosition(),m_webPage->viewportSize()).intersects(nRect)) {

                double distance = calculateElementDistance (direction, nRect);

                if (bestDistance > distance) {

                    bestDistance = distance;

                    bestElement = el;

                }

            }

        }

    }

    if (!bestElement.isNull() && bestElement != m_webElement) {

        m_webElement.setStyleProperty("outline", m_webElementStyle);    	  

        m_webElement = bestElement;

        m_webElement.setFocus();

        m_webElementStyle = m_webElement.styleProperty("outline", QWebElement::ComputedStyle);

        m_webElement.setStyleProperty("outline", "3px ridge rgb(140,140,255)");             

        scrollFrame(direction);

        return true;

    }

    scrollFrameOneDirection (direction, KNormalScrollRange);

    return false;

}

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

{

    if (object == m_view) {

        switch (event->type()) {

            case QEvent::KeyPress: {

                QKeyEvent* ev = static_cast<QKeyEvent*>(event);

                if (ev->key() == Qt::Key_Up || ev->key() == Qt::Key_Down 

                || ev->key() == Qt::Key_Left || ev->key() == Qt::Key_Right )

                    {

                    return true;

                    }

                if (ev->key() ==  Qt::Key_Select )

                    {

                    QKeyEvent rockerEnterEvent(QEvent::KeyPress, Qt::Key_Enter, Qt::NoModifier);

                    m_webPage->event(&rockerEnterEvent); 

                    return true; 

                    }                

            }

            break; 

            case QEvent::KeyRelease: {

                QKeyEvent* ev = static_cast<QKeyEvent*>(event);

                if (ev->key() == Qt::Key_Up || ev->key() == Qt::Key_Down 

                || ev->key() == Qt::Key_Left || ev->key() == Qt::Key_Right ) 

                    {

                    nextElementInDirection(ev->key());    

                    return true;

                    }

                if (ev->key() == Qt::Key_Select )

                    {

                    QKeyEvent rockerEnterEvent(QEvent::KeyPress, Qt::Key_Enter, Qt::NoModifier);

                    m_webPage->event(&rockerEnterEvent); 

                    return true; 

                    }

            }

            break;

            default: 

                return false; 

            break; 

        } // end of switch statement 

    }  // end of if statement 

    return false;

}

void WebDirectionalNavigation::scrollFrame(int direction)

{

    int xadjust = m_webPage->viewportSize().width()/5;

    int yadjust = m_webPage->viewportSize().height()/5;

    switch (direction) {

        case Qt::Key_Left: {

            int distanceX =  xadjust - m_webElement.geometry().x();

            if (distanceX > 0)

                scrollCurrentFrame(-distanceX,0);

        }

        break;

        case Qt::Key_Right: {

            int distanceX = m_webElement.geometry().right() - m_webPage->viewportSize().width()-xadjust;

            if (distanceX > 0)

                scrollCurrentFrame(distanceX,0);

        }

        break;

        case Qt::Key_Up: {

            int distanceY = yadjust - m_webElement.geometry().y();

            if (distanceY > 0)

                scrollCurrentFrame(0,-distanceY);

        }

        break;

        case Qt::Key_Down: {

            int distanceY = m_webElement.geometry().bottom() - m_webPage->viewportSize().height()-yadjust;

            if (distanceY > 0)

                scrollCurrentFrame(0,distanceY);

        }

        break;

    }

}

void WebDirectionalNavigation::scrollFrameOneDirection (int direction, int distance)

{

    int dx = 0;

    int dy = 0;

    switch (direction) {

        case Qt::Key_Up: {

            dy = -distance;

        }

        break;

        case Qt::Key_Down: {

            dy = +distance;

        }

        break;

        case Qt::Key_Left: {

            dx = -distance;

        }

        break;

        case Qt::Key_Right: {

            dx = distance;

        }

        break;

        default:

        break;

    }

    scrollCurrentFrame(dx, dy);

}

void WebDirectionalNavigation::scrollCurrentFrame (int dx, int dy)

{

    QPoint scrollPosition = m_webPage->currentFrame()->scrollPosition();

    m_webPage->currentFrame()->scroll(dx, dy);

    /* emit pageScrollPositionZero singal if it's mainFrame scrolling or scroll to top*/

    if (m_webPage->currentFrame() == m_webPage->mainFrame()) {

        if (scrollPosition.y() == 0 || m_webPage->currentFrame()->scrollPosition().y() == 0) {

            emit pageScrollPositionZero();

        }

    }

}

void WebDirectionalNavigation::setCurrentFrameScrollPosition (QPoint& pos)

{

    QPoint scrollPosition = m_webPage->currentFrame()->scrollPosition();

    m_webPage->currentFrame()->setScrollPosition(pos);

    /* emit pageScrollPositionZero singal if it's mainFrame scrolling or scroll to top*/

    if (m_webPage->currentFrame() == m_webPage->mainFrame()) {

        if (scrollPosition.y() == 0 || m_webPage->currentFrame()->scrollPosition().y() == 0) {

            emit pageScrollPositionZero();

        }

    }

}

}