1 /*

     1 /*

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

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

     3 * All rights reserved.

     3 * All rights reserved.

     8 *

     4 *

    11 *

     8 *

    13 *

    13 *

    15 *

    17 *

    18 

    21 

    19 #include "GWebTouchNavigation.h"

    22 #include "GWebTouchNavigation.h"

    26 #include <QGraphicsSceneMouseEvent>

    29 #include <QGraphicsSceneMouseEvent>

    27 #include <QTimer>

    30 #include <QTimer>

    28 #include <qmath.h>

    31 #include <qmath.h>

    29 #include <QDebug>

    32 #include <QDebug>

    30 #include <QGraphicsView>

    33 #include <QGraphicsView>

    31 

    34 

    39 

    37 

    40 const int KFlickSpeed = 400;

    38 const int KFlickSpeed = 400;

    41 const qreal PI = 3.1415926535897932;

    39 const qreal PI = 3.1415926535897932;

    42 const qreal KAngleTolerance = 30;

    40 const qreal KAngleTolerance = 30;

    43 const int KAnimationTimeout = 40;

    41 const int KAnimationTimeout = 40;

    53 const int KTouchThresholdX = 20;

    51 const int KTouchThresholdX = 20;

    54 const int KTouchThresholdY = 20;

    52 const int KTouchThresholdY = 20;

    55 const int KPanThreshold = 2;

    53 const int KPanThreshold = 2;

    56 const int KThreshHoldValForLink = 10;

    54 const int KThreshHoldValForLink = 10;

    57 const qreal KDeccelaration = 1000.00;

    55 const qreal KDeccelaration = 1000.00;

    62 

    56 

    63 static const int KStartPanDistance = 50;

    57 static const int KStartPanDistance = 50;

    64 static const int KWaitForClickTimeoutMS = 200;

    58 static const int KWaitForClickTimeoutMS = 200;

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

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

    66 static const int KPanModeChangeDelta = 100;

    62 static const int KPanModeChangeDelta = 100;

    70 

    63 

    71 /*!

    64 /*!

    72     \class WebTouchNavigation

    65     \class WebTouchNavigation

    73     \since cwrt 1.0

    66     \since cwrt 1.0

    74     \brief cwrt navigation.

    67     \brief cwrt navigation.

    75 

    68 

    76     \sa WebNavigation, WebHtmlTabIndexedNavigation, WebCursorNavigation, WebDirectionalNavigation

    69     \sa WebNavigation, WebHtmlTabIndexedNavigation, WebCursorNavigation, WebDirectionalNavigation

    77 */

    70 */

    79 : m_webPage(webPage)

    72 : m_webPage(webPage)

    80 , m_view(view)

    73 , m_view(view)

    81 , m_frame(0)

    74 , m_frame(0)

    82 , m_doubleClickTimer(0)

    75 , m_doubleClickTimer(0)

    83 , m_pressEvent(0)

    76 , m_pressEvent(0)

    85 , m_releaseEvent(0)

    77 , m_releaseEvent(0)

    86 , m_focusedBlockPt(-1, -1)

    78 , m_focusedBlockPt(-1, -1)

    87 , m_ishighlighted(false)

    79 , m_ishighlighted(false)

    88 , m_offset(0)

    80 , m_offset(0)

    89 , m_longPressTimer(0)

    81 , m_longPressTimer(0)

    90 , m_finalzoomfactor(0)

    82 , m_finalzoomfactor(0)

    91 , m_kineticTimer(0)

    84 , m_kineticTimer(0)

    92 , m_isPanning(false)

    85 , m_isPanning(false)

    93 , m_enabled(true)

    86 , m_enabled(true)

    94 , m_isLoading(false)

    88 , m_isLoading(false)

    95 {

    93 {

    96         install();

    94         install();

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

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

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

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

   100 }

    97 }

   101 

    98 

   102 /*!

   113 /*!

   103 */

   114 */

   112     delete m_scrollTimer;

   118     delete m_scrollTimer;

   115     delete m_kineticTimer;

   119     delete m_kineticTimer;

   116     uninstall();

   121     uninstall();

   117 }

   125 }

   118 

   126 

   119 void GWebTouchNavigation::install()

   127 void GWebTouchNavigation::install()

   120 {

   128 {

   121     m_view->installEventFilter(this);

   129     m_view->installEventFilter(this);

   122 }

   130 }

   123 

   131 

   124 void GWebTouchNavigation::BlockFocusChanged(QPoint pt)

   132 void GWebTouchNavigation::BlockFocusChanged(QPoint pt)

   125 {

   133 {

   127 }

   135 }

   128 

   136 

   129 void GWebTouchNavigation::uninstall()

   137 void GWebTouchNavigation::uninstall()

   130 {

   138 {

   131     if (m_view)

   139     if (m_view)

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

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

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

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

   171                 return true;

   179                 return true;

   172             }

   180             }

   173             break;

   181             break;

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

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

   176             emit mouseEvent(QEvent::GraphicsSceneMouseRelease);

   184             emit mouseEvent(QEvent::GraphicsSceneMouseRelease);

   177             return true;

   185             return true;

   179         case QEvent::GraphicsSceneMouseDoubleClick:

   186         case QEvent::GraphicsSceneMouseDoubleClick:

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

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

   181             emit mouseEvent(QEvent::GraphicsSceneMouseDoubleClick);

   188             emit mouseEvent(QEvent::GraphicsSceneMouseDoubleClick);

   182             return true;

   189             return true;

   183             break;

   192             break;

   184         default:

   193         default:

   185             break;

   194             break;

   186     }

   195     }

   187     return false;

   196     return false;

   188 }

   197 }

   189 

   198 

   190 void GWebTouchNavigation::stopScrolling()

   199 void GWebTouchNavigation::stopScrolling()

   191 {

   200 {

   202 }

   211 }

   203 

   212 

   204 

   213 

   205 void GWebTouchNavigation::pan()

   214 void GWebTouchNavigation::pan()

   206 {

   215 {

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

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

   214 

   223 

   215 void GWebTouchNavigation::kineticScroll()

   224 void GWebTouchNavigation::kineticScroll()

   216 {

   225 {

   254             setCurrentFrameScrollPosition(distPos);

   263             setCurrentFrameScrollPosition(distPos);

   259     }

   268     }

   260 

   269 

   261 }

   270 }

   262 

   271 

   263 

   272 

   268 */

   277 */

   269 void GWebTouchNavigation::scrollFrame(const QPoint& diff)

   278 void GWebTouchNavigation::scrollFrame(const QPoint& diff)

   270 {

   279 {

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

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

   272         return;

   281         return;

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

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

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

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

   281         if (dy > KStartPanDistance || dx > KStartPanDistance

   289         if (dy > KStartPanDistance || dx > KStartPanDistance

   283             //get the scroll direction

   291             //get the scroll direction

   284             Direction scrollDir = findDirectionWithAngle(diff);

   292             Direction scrollDir = findDirectionWithAngle(diff);

   286                 startPanGesture(VerticalPan);

   294                 startPanGesture(VerticalPan);

   288                 startPanGesture(HorizontalPan);

   296                 startPanGesture(HorizontalPan);

   289             else

   297             else

   290                 startPanGesture(RandomPan);

   298                 startPanGesture(RandomPan);

   291             m_isPanning = true;

   299             m_isPanning = true;

   292         }

   300         }

   293     }

   301     }

   294 

   302 

   304 }

   312 }

   305 

   313 

   306 void GWebTouchNavigation::startPanGesture(PanDirection directionHint) {

   314 void GWebTouchNavigation::startPanGesture(PanDirection directionHint) {

   307     emit startingPanGesture((int)directionHint);

   315     emit startingPanGesture((int)directionHint);

   308     m_panDirection = directionHint;

   316     m_panDirection = directionHint;

   309     m_panModeResidue = QPointF(0., 0.);

   317     m_panModeResidue = QPointF(0., 0.);

   310 }

   318 }

   311 

   319 

   312 void GWebTouchNavigation::panBy(const QPointF& delta) {

   320 void GWebTouchNavigation::panBy(const QPointF& delta) {

   314     m_panModeResidue += delta;

   322     m_panModeResidue += delta;

   315 

   323 

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

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

   317         m_panDirection = HorizontalPan;

   325         m_panDirection = HorizontalPan;

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

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

   320         m_panDirection = VerticalPan;

   328         m_panDirection = VerticalPan;

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

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

   324         m_panDirection = RandomPan;

   332         m_panDirection = RandomPan;

   326     QPointF p;

   334     QPointF p;

   328         p.setX(delta.x());

   336         p.setX(delta.x());

   330         p.setY(delta.y());

   338         p.setY(delta.y());

   333         p.setY(delta.y());

   341         p.setY(delta.y());

   334     }

   342     }

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

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

   337 }

   345 }

   338 

   346 

   339 void GWebTouchNavigation::highlightableElement(QMouseEvent* ev) {

   347 void GWebTouchNavigation::highlightableElement(QMouseEvent* ev) {

   340     m_anchorElement = getClosestAnchorElement(ev);

   348     m_anchorElement = getClosestAnchorElement(ev);

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

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

   349 {

   357 {

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

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

   351 }

   359 }

   352 

   360 

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

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

   356         nextNode = parentNode.firstChild();

   364         nextNode = parentNode.firstChild();

   357         return true;

   365         return true;

   358     }

   366     }

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

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

   361         nextNode = parentNode.nextSibling();

   369         nextNode = parentNode.nextSibling();

   362         return true;

   370         return true;

   363     }

   371     }

   364 

   372 

   365     QWebElement n = parentNode;

   373     QWebElement n = parentNode;

   369     if (!n.isNull()) {

   377     if (!n.isNull()) {

   370         nextNode = n.nextSibling();

   378         nextNode = n.nextSibling();

   371         return true;

   379         return true;

   372     }

   380     }

   373 

   381 

   376 

   384 

   377 

   385 

   378 QWebElement GWebTouchNavigation::getClosestAnchorElement(QMouseEvent* ev)

   386 QWebElement GWebTouchNavigation::getClosestAnchorElement(QMouseEvent* ev)

   380     QWebElement webElement;

   388     QWebElement webElement;

   381     QWebHitTestResult htRes = getHitTestResult(ev);

   389     QWebHitTestResult htRes = getHitTestResult(ev);

   382     QWebElement hitElement = htRes.element();

   390     QWebElement hitElement = htRes.element();

   383     //check whether hit test returns a link element

   391     //check whether hit test returns a link element

   387         m_ishighlighted = true;

   395         m_ishighlighted = true;

   388     }

   396     }

   389     //get the closet anchor element

   397     //get the closet anchor element

   390     else {

   398     else {

   392         int dist = 99999999;

   400         int dist = 99999999;

   393         QWebElement result;

   401         QWebElement result;

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

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

   395         do {

   403         do {

   397                 QRect r = ele.geometry();

   405                 QRect r = ele.geometry();

   399                     dist = 0;

   407                     dist = 0;

   400                     result = ele;

   408                     result = ele;

   401                     break;

   409                     break;

   402                 }

   410                 }

   403 

   411 

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

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

   407                 if (dist > d) {

   415                 if (dist > d) {

   408                     dist = d;

   416                     dist = d;

   409                     result = ele;

   417                     result = ele;

   410                 }

   418                 }

   412         }while(traverseNextNode(ele,ele));

   420         }while(traverseNextNode(ele,ele));

   413 

   421 

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

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

   417             QRect r = result.geometry();

   424             QRect r = result.geometry();

   421             webElement = result;

   428             webElement = result;

   423             m_ishighlighted = true;

   430             m_ishighlighted = true;

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

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

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

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

   427         }

   434         }

   428     }

   435     }

   429     return webElement;

   436     return webElement;

   430 }

   437 }

   431 

   438 

   434 */

   441 */

   435 void GWebTouchNavigation::mousePressEvent(const QPoint& pos)

   442 void GWebTouchNavigation::mousePressEvent(const QPoint& pos)

   436 {

   443 {

   437     m_delayedPressMoment.start();

   444     m_delayedPressMoment.start();

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

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

   440         m_prevPoint.setX(0);

   447         m_prevPoint.setX(0);

   441         m_prevPoint.setY(0);

   448         m_prevPoint.setY(0);

   442         m_scrollDistance.setX(0);

   449         m_scrollDistance.setX(0);

   443         m_scrollDistance.setY(0);

   450         m_scrollDistance.setY(0);

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

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

   446         m_scrolled = false;

   453         m_scrolled = false;

   447         m_ishighlighted = false;

   454         m_ishighlighted = false;

   448         m_higlightedPos = m_touchPosition = pos;

   455         m_higlightedPos = m_touchPosition = pos;

   449         m_frame = m_webPage->frameAt(pos);

   456         m_frame = m_webPage->frameAt(pos);

   450         if (!m_frame)

   457         if (!m_frame)

   453         m_dragPoints.clear();

   460         m_dragPoints.clear();

   455         DragPoint dragPoint;

   462         DragPoint dragPoint;

   456         dragPoint.iPoint = m_touchPosition;

   463         dragPoint.iPoint = m_touchPosition;

   457         dragPoint.iTime = QTime::currentTime();

   464         dragPoint.iTime = QTime::currentTime();

   458         m_dragPoints.append(dragPoint);

   465         m_dragPoints.append(dragPoint);

   459         m_offset = 0;

   466         m_offset = 0;

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

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

   462         m_scrollTimer->stop();

   469         m_scrollTimer->stop();

   463         return;

   470         return;

   464     }

   471     }

   466     if (m_doubleClickTimer) {

   473     if (m_doubleClickTimer) {

   469         // Consider it as double click.

   476         // Consider it as double click.

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

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

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

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

   473                 mouseDoubleClickEvent(pos);

   480                 mouseDoubleClickEvent(pos);

   474                 return;

   481                 return;

   475             }

   482             }

   476         }

   483         }

   477         m_doubleClickTimer->stop();

   484         m_doubleClickTimer->stop();

   478     } else {

   485     } else {

   479         m_doubleClickTimer = new QTimer(this);

   486         m_doubleClickTimer = new QTimer(this);

   481     }

   488     }

   482 

   489 

   483     //Clear the previous press and release events.

   490     //Clear the previous press and release events.

   493 

   493 

   494     m_doubleClickTimer->start(KDoubleClickTimeOut);

   494     m_doubleClickTimer->start(KDoubleClickTimeOut);

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

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

   496 }

   498 }

   497 

   499 

   498 void GWebTouchNavigation::handleMousePressEvent(QMouseEvent* ev)

   500 void GWebTouchNavigation::handleMousePressEvent(QMouseEvent* ev)

   499 {

   501 {

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

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

   506     m_scrolled = false;

   504     m_scrolled = false;

   507     m_ishighlighted = false;

   505     m_ishighlighted = false;

   508     m_higlightedPos = m_touchPosition = ev->pos();

   506     m_higlightedPos = m_touchPosition = ev->pos();

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

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

   510     if (!m_frame)

   508     if (!m_frame)

   513     m_dragPoints.clear();

   511     m_dragPoints.clear();

   515     DragPoint dragPoint;

   513     DragPoint dragPoint;

   516     dragPoint.iPoint = m_touchPosition;

   514     dragPoint.iPoint = m_touchPosition;

   517     dragPoint.iTime = QTime::currentTime();

   515     dragPoint.iTime = QTime::currentTime();

   518     m_dragPoints.append(dragPoint);

   516     m_dragPoints.append(dragPoint);

   519 

   517 

   522     highlightableElement(ev);

   520     highlightableElement(ev);

   524 

   522 

   525     //send a mouse press

   523     //send a mouse press

   526     QMouseEvent iev(ev->type(), m_touchPosition, ev->button(), ev->buttons(), getEventModifier(m_higlightedPos));

   524     QMouseEvent iev(ev->type(), m_touchPosition, ev->button(), ev->buttons(), getEventModifier(m_higlightedPos));

   527     m_webPage->event(&iev);

   525     m_webPage->event(&iev);

   528 }

   527 }

   529 

   528 

   530 void GWebTouchNavigation::doubleClickTimerExpired()

   529 void GWebTouchNavigation::doubleClickTimerExpired()

   532     handleMousePressEvent(m_pressEvent);

   531     handleMousePressEvent(m_pressEvent);

   533 

   532 

   537     if (m_releaseEvent) {

   535     if (m_releaseEvent) {

   538         handleMouseReleaseEvent(m_releaseEvent);

   536         handleMouseReleaseEvent(m_releaseEvent);

   539 

   537 

   545         m_doubleClickTimer->stop();

   542         m_doubleClickTimer->stop();

   546 }

   543 }

   547 

   544 

   548 bool GWebTouchNavigation::canDehighlight(QMouseEvent* ev)

   545 bool GWebTouchNavigation::canDehighlight(QMouseEvent* ev)

   551     QPoint pt = ev->pos() + m_frame->scrollPosition();

   548     QPoint pt = ev->pos() + m_frame->scrollPosition();

   554         checkDehighlight = true;

   551         checkDehighlight = true;

   555     }

   552     }

   557         QRect rect = m_anchorElement.geometry();

   554         QRect rect = m_anchorElement.geometry();

   558 

   555 

   560             checkDehighlight = false;

   557             checkDehighlight = false;

   561         }

   558         }

   563             QPoint centerpt = m_anchorElement.geometry().center();

   560             QPoint centerpt = m_anchorElement.geometry().center();

   564             int newoffset = (pt.x()- centerpt.x())*(pt.x()- centerpt.x()) + (pt.y()- centerpt.y())*(pt.y()- centerpt.y());

   561             int newoffset = (pt.x()- centerpt.x())*(pt.x()- centerpt.x()) + (pt.y()- centerpt.y())*(pt.y()- centerpt.y());

   569             }

   566             }

   570             else {

   567             else {

   571                 m_offset =0;

   568                 m_offset =0;

   572                 checkDehighlight = true;

   569                 checkDehighlight = true;

   573             }

   570             }

   576             checkDehighlight = true;

   573             checkDehighlight = true;

   577         }

   574         }

   578     }

   575     }

   579     return checkDehighlight;

   576     return checkDehighlight;

   580 }

   577 }

   582 {

   579 {

   583     m_higlightedPos = QPoint(0,0);

   580     m_higlightedPos = QPoint(0,0);

   584     m_ishighlighted = false;

   581     m_ishighlighted = false;

   585     QMouseEvent iev(QEvent::MouseButtonPress,m_higlightedPos,ev->button(), ev->buttons(), ev->modifiers());

   582     QMouseEvent iev(QEvent::MouseButtonPress,m_higlightedPos,ev->button(), ev->buttons(), ev->modifiers());

   586     m_webPage->event(&iev);

   583     m_webPage->event(&iev);

   597     Scrolls the frame

   594     Scrolls the frame

   598     \sa scrollFrame()

   595     \sa scrollFrame()

   599 */

   596 */

   600 void GWebTouchNavigation::mouseMoveEvent(const QPoint& pos, const QPoint& diff)

   597 void GWebTouchNavigation::mouseMoveEvent(const QPoint& pos, const QPoint& diff)

   601 {

   598 {

   603     if (m_pressEvent){

   606     if (m_pressEvent){

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

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

   610         //send mousePressEvent

   614         //send mousePressEvent

   611         m_doubleClickTimer->stop();

   615         m_doubleClickTimer->stop();

   612         handleMousePressEvent(m_pressEvent);

   616         handleMousePressEvent(m_pressEvent);

   618     QMouseEvent tmpEv(QEvent::MouseMove, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

   620     QMouseEvent tmpEv(QEvent::MouseMove, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

   619     handleHighlightChange(&tmpEv);

   621     handleHighlightChange(&tmpEv);

   620 

   622 

   635 }

   653 }

   636 

   654 

   637 /*!

   655 /*!

   638     If WebCanvas or QWebFrame were scrolled starts the deceleration alogrithm

   656     If WebCanvas or QWebFrame were scrolled starts the deceleration alogrithm

   639     Otherwise sends the mouse release event to QWebPage

   657     Otherwise sends the mouse release event to QWebPage

   640     \sa startDeceleration()

   658     \sa startDeceleration()

   641 */

   659 */

   642 void GWebTouchNavigation::mouseReleaseEvent(const QPoint& pos)

   660 void GWebTouchNavigation::mouseReleaseEvent(const QPoint& pos)

   643 {

   661 {

   645         m_isPanning = false;

   665         m_isPanning = false;

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

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

   647         m_releaseEvent = new QMouseEvent(QEvent::MouseButtonRelease, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

   667         m_releaseEvent = new QMouseEvent(QEvent::MouseButtonRelease, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

   648         return;

   674         return;

   649     }

   675     }

   650     //mouseReleaseEvent is called in two cases. 1. Double click, 2. Mouse Drag

   676     //mouseReleaseEvent is called in two cases. 1. Double click, 2. Mouse Drag

   651     //m_releaseEvent is not null only in Mouse double click

   677     //m_releaseEvent is not null only in Mouse double click

   652     //So delete m_releaseEvent only in double click case.

   678     //So delete m_releaseEvent only in double click case.

   653     //Send release event in mouse move case

   679     //Send release event in mouse move case

   654     if (m_releaseEvent) {

   680     if (m_releaseEvent) {

   657     } else {

   682     } else {

   658         QMouseEvent tmpEv(QEvent::MouseButtonRelease, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

   683         QMouseEvent tmpEv(QEvent::MouseButtonRelease, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);

   660     }

   685     }

   661 }

   686 }

   662 Qt::KeyboardModifier GWebTouchNavigation::getEventModifier(const QPoint& pos)

   687 Qt::KeyboardModifier GWebTouchNavigation::getEventModifier(const QPoint& pos)

   663 {

   688 {

   664     QWebFrame *frame = m_webPage->frameAt(pos);

   689     QWebFrame *frame = m_webPage->frameAt(pos);

   665     if (!frame)

   690     if (!frame)

   667     QWebHitTestResult htr = frame->hitTestContent(pos);

   692     QWebHitTestResult htr = frame->hitTestContent(pos);

   668     if (htr.element().tagName().toLower().compare("select")==0  && htr.element().hasAttribute("multiple"))

   693     if (htr.element().tagName().toLower().compare("select")==0  && htr.element().hasAttribute("multiple"))

   669         return Qt::ControlModifier;

   694         return Qt::ControlModifier;

   670     return Qt::NoModifier;

   695     return Qt::NoModifier;

   671 }

   696 }

   672 

   697 

   673 void GWebTouchNavigation::handleMouseReleaseEvent(QMouseEvent* ev)

   698 void GWebTouchNavigation::handleMouseReleaseEvent(QMouseEvent* ev)

   674 {

   699 {

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

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

   676     if (!m_frame)

   701     if (!m_frame)

   682         int msecs = 0;

   707         int msecs = 0;

   683         if (!m_lastMoveEventTime.isNull()) {

   708         if (!m_lastMoveEventTime.isNull()) {

   684             //Start deceleration only if the delta since last drag event is less than threshold

   709             //Start deceleration only if the delta since last drag event is less than threshold

   685             QTime now(QTime::currentTime());

   710             QTime now(QTime::currentTime());

   686             msecs = m_lastMoveEventTime.msecsTo(now);

   711             msecs = m_lastMoveEventTime.msecsTo(now);

   687             m_lastMoveEventTime.setHMS(0,0,0,0);

   712             m_lastMoveEventTime.setHMS(0,0,0,0);

   688         }

   713         }

   689         if (msecs < KDecelerationTimer) {

   714         if (msecs < KDecelerationTimer) {

   691                 updateFlickScrollDistance();

   716                 updateFlickScrollDistance();

   692             }

   717             }

   693             else {

   718             else {

   694                 QRect enclosingRect = findEnclosingBlock(ev);

   719                 QRect enclosingRect = findEnclosingBlock(ev);

   695                 QPoint blockDocPt(enclosingRect.x(), enclosingRect.y());

   720                 QPoint blockDocPt(enclosingRect.x(), enclosingRect.y());

   699                 setNewScrollDistance(blockCanvasPoint, thresholdCheckVal);

   724                 setNewScrollDistance(blockCanvasPoint, thresholdCheckVal);

   700             }

   725             }

   701             startScrollTimer();

   726             startScrollTimer();

   702         }

   727         }

   703     } else {

   728     } else {

   705         QMouseEvent(ev->type(), m_higlightedPos, ev->button(), ev->buttons(), getEventModifier(m_higlightedPos)) :

   733         QMouseEvent(ev->type(), m_higlightedPos, ev->button(), ev->buttons(), getEventModifier(m_higlightedPos)) :

   706         QMouseEvent(QEvent::MouseButtonRelease, m_touchPosition, ev->button(), ev->buttons(), getEventModifier(m_touchPosition));

   734         QMouseEvent(QEvent::MouseButtonRelease, m_touchPosition, ev->button(), ev->buttons(), getEventModifier(m_touchPosition));

   707         m_webPage->event(&iev);

   735         m_webPage->event(&iev);

   708 #if defined __SYMBIAN32__

   737 #if defined __SYMBIAN32__

   710         if (ev->button() == Qt::LeftButton) {

   739         if (ev->button() == Qt::LeftButton) {

   711             QWebHitTestResult htr = m_frame->hitTestContent(ev->pos());

   740             QWebHitTestResult htr = m_frame->hitTestContent(ev->pos());

   712             if (htr.isContentEditable()) {

   741             if (htr.isContentEditable()) {

   713                 QEvent vkbEvent(QEvent::RequestSoftwareInputPanel);

   742                 QEvent vkbEvent(QEvent::RequestSoftwareInputPanel);

   714                 QList<QGraphicsView*> views = m_view->scene()->views();

   743                 QList<QGraphicsView*> views = m_view->scene()->views();

   721     }

   750     }

   722 }

   751 }

   723 

   752 

   724 void GWebTouchNavigation::mouseDoubleClickEvent(const QPoint& pos)

   753 void GWebTouchNavigation::mouseDoubleClickEvent(const QPoint& pos)

   725 {

   754 {

   728         return;

   757         return;

   730         m_doubleClickTimer->stop();

   759         m_doubleClickTimer->stop();

   731 

   760 

   732     //If the page is already scrolling(because of a previous doubletap)

   761     //If the page is already scrolling(because of a previous doubletap)

   733     //we need to stop the timer before we start scrolling the new block again.

   762     //we need to stop the timer before we start scrolling the new block again.

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

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

   738     handleDoubleClickEvent(&tmpEv);

   767     handleDoubleClickEvent(&tmpEv);

   739 }

   768 }

   740 

   769 

   741 void GWebTouchNavigation::handleDoubleClickEvent(QMouseEvent* ev)

   770 void GWebTouchNavigation::handleDoubleClickEvent(QMouseEvent* ev)

   742 {

   771 {

   743     QPoint imageFocusPoint;

   775     QPoint imageFocusPoint;

   744     QWebHitTestResult hitTest = getHitTestResult(ev);

   776     QWebHitTestResult hitTest = getHitTestResult(ev);

   746     QWebElement block = hitTest.element();

   778     QWebElement block = hitTest.element();

   747 

   779 

   748     if (block.tagName() != "IMG" && (block.styleProperty(QString("background-image"),QWebElement::InlineStyle) == ""))

   780     if (block.tagName() != "IMG" && (block.styleProperty(QString("background-image"),QWebElement::InlineStyle) == ""))

   749         block = hitTest.enclosingBlockElement();

   781         block = hitTest.enclosingBlockElement();

   750 

   782 

   751     QWebFrame* frame = m_webPage->frameAt(ev->pos());

   783     QWebFrame* frame = m_webPage->frameAt(ev->pos());

   752     m_frame = (frame) ? frame : m_webPage->mainFrame();

   784     m_frame = (frame) ? frame : m_webPage->mainFrame();

   754     QRect enclosingRect = block.geometry();

   786     QRect enclosingRect = block.geometry();

   768         m_finalzoomfactor = 0;

   799         m_finalzoomfactor = 0;

   771             m_finalzoomfactor   = (qreal) (m_webPage->viewportSize().width() - 10) * m_view->zoomFactor();

   802             m_finalzoomfactor   = (qreal) (m_webPage->viewportSize().width() - 10) * m_view->zoomFactor();

   779             int boundW = block.geometry().width() * factor/m_view->zoomFactor();

   810             int boundW = block.geometry().width() * factor/m_view->zoomFactor();

   780             int boundH = block.geometry().height() * factor/m_view->zoomFactor();

   811             int boundH = block.geometry().height() * factor/m_view->zoomFactor();

   792                 factor = factorh * m_view->zoomFactor();

   823                 factor = factorh * m_view->zoomFactor();

   794                 factor = factorw * m_view->zoomFactor();

   825                 factor = factorw * m_view->zoomFactor();

   796                 factor = ((factorh < factorw) ? factorh : factorw) * m_view->zoomFactor();

   827                 factor = ((factorh < factorw) ? factorh : factorw) * m_view->zoomFactor();

   808         if (m_finalzoomfactor != m_view->zoomFactor()) {

   839         if (m_finalzoomfactor != m_view->zoomFactor()) {

   831             QSize viewSize = m_webPage->viewportSize();

   862             QSize viewSize = m_webPage->viewportSize();

   832             QSize contentSize = m_frame->contentsSize();

   863             QSize contentSize = m_frame->contentsSize();

   833             QPoint documentViewPoint = QPoint(viewSize.width(),viewSize.height()) + m_frame->scrollPosition();

   864             QPoint documentViewPoint = QPoint(viewSize.width(),viewSize.height()) + m_frame->scrollPosition();

   851 

   882 

   852             m_focusedBlockPt = QPoint(block.geometry().x(), block.geometry().y());

   883             m_focusedBlockPt = QPoint(block.geometry().x(), block.geometry().y());

   853             m_scrollDistance.setX(m_focusedBlockPt.x() - docFocusPoint.x());

   884             m_scrollDistance.setX(m_focusedBlockPt.x() - docFocusPoint.x());

   854             m_scrollDistance.setY(m_focusedBlockPt.y() - docFocusPoint.y());

   885             m_scrollDistance.setY(m_focusedBlockPt.y() - docFocusPoint.y());

   855 

   886 

   856             QPoint scrollableDistance(0, 0);

   887             QPoint scrollableDistance(0, 0);

   857             QPoint viewStartPoint = QPoint(0,0) + m_frame->scrollPosition();

   888             QPoint viewStartPoint = QPoint(0,0) + m_frame->scrollPosition();

   871                 //m_scrollDistance.x() >= 0 means scroll from right to left

   902                 //m_scrollDistance.x() >= 0 means scroll from right to left

   874                 //m_scrollDistance.x() < 0 means scroll from left to right

   905                 //m_scrollDistance.x() < 0 means scroll from left to right

   877              } else

   908              } else

   878                 m_focusedBlockPt.setX(docFocusPoint.x());

   909                 m_focusedBlockPt.setX(docFocusPoint.x());

   879 

   910 

   885             }

   916             }

   886             else

   917             else

   889             m_focusedBlockPt = m_focusedBlockPt - m_frame->scrollPosition();

   920             m_focusedBlockPt = m_focusedBlockPt - m_frame->scrollPosition();

   890             startScrollTimer();

   921             startScrollTimer();

   891         }

   922         }

   895 

   932 

   896 /*!

   933 /*!

   897     Returns the next scrollable frame in the frame tree give the x,y position

   934     Returns the next scrollable frame in the frame tree give the x,y position

   898 */

   935 */

   899 QWebFrame* GWebTouchNavigation::getNextScrollableFrame(const QPoint& pos)

   936 QWebFrame* GWebTouchNavigation::getNextScrollableFrame(const QPoint& pos)

   926 Starts the timer for scrolling smoothly to the destination location .

   963 Starts the timer for scrolling smoothly to the destination location .

   927 The timer will do the decelaration while scrolling

   964 The timer will do the decelaration while scrolling

   928 */

   965 */

   929 void GWebTouchNavigation::startScrollTimer()

   966 void GWebTouchNavigation::startScrollTimer()

   930 {

   967 {

   932         m_scrollTimer = new QTimer(this);

   969         m_scrollTimer = new QTimer(this);

   933         connect(m_scrollTimer,SIGNAL(timeout()),this,SLOT(scrollToEdge()));

   970         connect(m_scrollTimer,SIGNAL(timeout()),this,SLOT(scrollToEdge()));

   934     }

   971     }

   935     m_scrollTimer->stop();

   972     m_scrollTimer->stop();

   936     m_scrollTimer->start(KAnimationTimeout);

   973     m_scrollTimer->start(KAnimationTimeout);

   939 /*

   976 /*

   940 Update the scroll distance for flick gesture. Update the scroll distance upto the edge of the page

   977 Update the scroll distance for flick gesture. Update the scroll distance upto the edge of the page

   941 */

   978 */

   942 void GWebTouchNavigation::updateFlickScrollDistance()

   979 void GWebTouchNavigation::updateFlickScrollDistance()

   943 {

   980 {

   960     {

   997     {

   962                     m_scrollDistance.setX(0);

   999                     m_scrollDistance.setX(0);

   967                     break;

  1004                     break;

   968         case UP :

  1005         case UP :

   969                     m_scrollDistance.setX(0);

  1006                     m_scrollDistance.setX(0);

   972                     break;

  1009                     break;

   973         case RIGHT:

  1010         case RIGHT:

   974                     m_scrollDistance.setX(-(m_scrollDistance.x()));

  1011                     m_scrollDistance.setX(-(m_scrollDistance.x()));

   977                     m_scrollDistance.setY(0);

  1014                     m_scrollDistance.setY(0);

   978                     break;

  1015                     break;

   984         case BOTTOMRIGHT:

  1021         case BOTTOMRIGHT:

   985                     m_scrollDistance.setX(-(m_scrollDistance.x()));

  1022                     m_scrollDistance.setX(-(m_scrollDistance.x()));

   998                     break;

  1035                     break;

   999         case TOPLEFT:

  1036         case TOPLEFT:

  1005         case TOPRIGHT:

  1042         case TOPRIGHT:

  1006                     m_scrollDistance.setX(-(m_scrollDistance.x()));

  1043                     m_scrollDistance.setX(-(m_scrollDistance.x()));

  1011                     break;

  1048                     break;

  1012     }

  1050     }

  1013 }

  1051 }

  1014 

  1052 

  1015 /*

  1053 /*

  1016 Distinguishes b/w swipe and flick

  1054 Distinguishes b/w swipe and flick

  1017 */

  1055 */

  1019 {

  1057 {

  1020     bool flick = false;

  1058     bool flick = false;

  1021     QPoint moveSpeed = speed();

  1059     QPoint moveSpeed = speed();

  1022     int xSpeed = moveSpeed.x();

  1060     int xSpeed = moveSpeed.x();

  1023     int ySpeed = moveSpeed.y();

  1061     int ySpeed = moveSpeed.y();

  1026              qAbs(ySpeed) > KFlickSpeed);

  1064              qAbs(ySpeed) > KFlickSpeed);

  1028     return flick;

  1066     return flick;

  1029 }

  1067 }

  1030 

  1068 

  1031 /*

  1069 /*

  1032 Calculates the speed of te scroll along x-axis and y-axis

  1070 Calculates the speed of te scroll along x-axis and y-axis

  1033 */

  1071 */

  1035 {

  1073 {

  1036     // Speed is only evaluated at the end of the swipe

  1074     // Speed is only evaluated at the end of the swipe

  1037     QPoint dragSpeed(0,0);

  1075     QPoint dragSpeed(0,0);

  1038     qreal time =  dragTime() / KMilliSecond;

  1076     qreal time =  dragTime() / KMilliSecond;

  1039     if (time > 0) {

  1077     if (time > 0) {

  1063 /*

  1101 /*

  1064 Finds the time difference b/w the first and last dragpoint

  1102 Finds the time difference b/w the first and last dragpoint

  1065 */

  1103 */

  1066 qreal GWebTouchNavigation::dragTime() const

  1104 qreal GWebTouchNavigation::dragTime() const

  1067 {

  1105 {

  1069         return 0.0;

  1107         return 0.0;

  1070     else

  1108     else

  1071         return  m_dragPoints[0].iTime.msecsTo(m_dragPoints[m_dragPoints.size()-1].iTime);

  1109         return  m_dragPoints[0].iTime.msecsTo(m_dragPoints[m_dragPoints.size()-1].iTime);

  1072 }

  1110 }

  1073 

  1111 

  1074 /*!

  1112 /*!

  1075 Find the flick direction with respect to angle of flick

  1113 Find the flick direction with respect to angle of flick

  1076 */

  1114 */

  1080     int xDelta = -diff.x();

  1118     int xDelta = -diff.x();

  1081     int yDelta = -diff.y();

  1119     int yDelta = -diff.y();

  1082 

  1120 

  1083     qreal angle = findAngle(xDelta, yDelta);

  1121     qreal angle = findAngle(xDelta, yDelta);

  1085          direction = DOWN;

  1123          direction = DOWN;

  1086      }

  1124      }

  1088         direction = LEFT;

  1126         direction = LEFT;

  1089     }

  1127     }

  1091         direction = UP;

  1129         direction = UP;

  1092     }

  1130     }

  1094         direction = RIGHT;

  1132         direction = RIGHT;

  1095     }

  1133     }

  1097         direction = BOTTOMRIGHT;

  1135         direction = BOTTOMRIGHT;

  1098     }

  1136     }

  1100         direction = BOTTOMLEFT;

  1138         direction = BOTTOMLEFT;

  1101     }

  1139     }

  1103         direction = TOPLEFT;

  1141         direction = TOPLEFT;

  1104     }

  1142     }

  1106         direction = TOPRIGHT;

  1144         direction = TOPRIGHT;

  1107     }

  1145     }

  1108 

  1147 

  1109     return direction;

  1148     return direction;

  1110 }

  1149 }

  1111 

  1150 

  1112 /*

  1151 /*

  1123 qreal GWebTouchNavigation::findAngle(const int& xDelta,const int& yDelta)

  1162 qreal GWebTouchNavigation::findAngle(const int& xDelta,const int& yDelta)

  1124 {

  1163 {

  1125     qreal angle = 0;

  1164     qreal angle = 0;

  1126     qreal hypotenuse = qSqrt(xDelta*xDelta + yDelta*yDelta);

  1165     qreal hypotenuse = qSqrt(xDelta*xDelta + yDelta*yDelta);

  1127 

  1166 

  1129         angle = qAcos(xDelta / hypotenuse);

  1168         angle = qAcos(xDelta / hypotenuse);

  1130 

  1169 

  1132             angle = (2 * PI) - angle;

  1171             angle = (2 * PI) - angle;

  1133         }

  1172         }

  1134     }

  1173     }

  1135 

  1174 

  1136     return (angle * 180) / PI;

  1175     return (angle * 180) / PI;

  1137 }

  1176 }

  1138 

  1177 

  1142 }

  1181 }

  1143 

  1182 

  1144 /*

  1183 /*

  1146 */

  1185 */

  1147 QRect GWebTouchNavigation::findEnclosingBlock(QMouseEvent* ev)

  1186 QRect GWebTouchNavigation::findEnclosingBlock(QMouseEvent* ev)

  1148 {

  1187 {

  1149     QWebHitTestResult htr = getHitTestResult(ev);

  1188     QWebHitTestResult htr = getHitTestResult(ev);

  1150     QRect rect = htr.enclosingBlockElement().geometry();

  1189     QRect rect = htr.enclosingBlockElement().geometry();

  1162     QWebHitTestResult htr = frame->hitTestContent(pt);

  1201     QWebHitTestResult htr = frame->hitTestContent(pt);

  1163     return htr;

  1202     return htr;

  1164 }

  1203 }

  1165 

  1204 

  1166 /*

  1205 /*

  1168 */

  1207 */

  1169 void GWebTouchNavigation::calculateActualScrollDistance()

  1208 void GWebTouchNavigation::calculateActualScrollDistance()

  1170 {

  1209 {

  1171     m_actualScrollDistance.setX(0);

  1210     m_actualScrollDistance.setX(0);

  1172     m_actualScrollDistance.setY(0);

  1211     m_actualScrollDistance.setY(0);

  1178     }

  1217     }

  1179 }

  1218 }

  1180 

  1219 

  1181 /*

  1220 /*

  1182 In the case of slow swipe, if the destination location lies within the threshold area, then

  1221 In the case of slow swipe, if the destination location lies within the threshold area, then

  1184 new scroll distance

  1223 new scroll distance

  1185 */

  1224 */

  1186 void GWebTouchNavigation::setNewScrollDistance(QPoint blockCanvasPoint, int thresholdCheckVal)

  1225 void GWebTouchNavigation::setNewScrollDistance(QPoint blockCanvasPoint, int thresholdCheckVal)

  1187 {

  1226 {

  1188     m_scrollDistance.setX(m_actualScrollDistance.x());

  1227     m_scrollDistance.setX(m_actualScrollDistance.x());

  1189     m_scrollDistance.setY(m_actualScrollDistance.y());

  1228     m_scrollDistance.setY(m_actualScrollDistance.y());

  1191         //Checks whether the block falls within the threshold after right to left swipe

  1230         //Checks whether the block falls within the threshold after right to left swipe

  1193             //if the block is within the threshold range already and the user tries

  1232             //if the block is within the threshold range already and the user tries

  1194             //to swipe from left to right , then let it move to right. Dont try to

  1233             //to swipe from left to right , then let it move to right. Dont try to

  1195             //snap to the left edge .

  1234             //snap to the left edge .

  1197                 m_scrollDistance.setX(blockCanvasPoint.x() - XAlignVal);

  1236                 m_scrollDistance.setX(blockCanvasPoint.x() - XAlignVal);

  1198             }

  1237             }

  1199         }

  1238         }

  1200     }

  1239     }

  1201     else {

  1240     else {

  1202         //Checks whether the block falls within the threshold after left to right swipe

  1241         //Checks whether the block falls within the threshold after left to right swipe

  1204             //if the block is within the threshold range already and the user tries

  1243             //if the block is within the threshold range already and the user tries

  1205             //to swipe from right to left , then let it move to left. Dont try to

  1244             //to swipe from right to left , then let it move to left. Dont try to

  1206             //snap to the left edge .

  1245             //snap to the left edge .

  1207             if (m_actualScrollDistance.x() < 0) {

  1246             if (m_actualScrollDistance.x() < 0) {

  1208                 m_scrollDistance.setX(blockCanvasPoint.x() - XAlignVal);

  1247                 m_scrollDistance.setX(blockCanvasPoint.x() - XAlignVal);

  1209             }