1 /*

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

     3 * All rights reserved.

     4 *

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

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

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

     8 *

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

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

    11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12 * GNU Lesser General Public License for more details.

    13 *

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

    15 * along with this program.  If not,

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

    17 *

    18 * Description:

    19 *

    20 */

    21 

    22 #include "ScrollableWebContentView.h"

    23 

    24 #include "Gestures/GestureRecognizer.h"

    25 #include "Kinetics/KineticScroller.h"

    26 #include "ScrollableViewBase.h"

    27 #include "ViewportMetaDataParser.h"

    28 #include "WebContentAnimationItem.h"

    29 

    30 #include <QApplication>

    31 #include <QGraphicsScene>

    32 #include <QGraphicsSceneMouseEvent>

    33 #include <QGraphicsWebView>

    34 #include <QWebElement>

    35 #include <QWebHitTestResult>

    36 

    37 //Kinetic scroll constants

    38 static const int ScrollsPerSecond = 30;

    39 static const int MinimumScrollVelocity = 10;

    40 static const qreal AxisLockThreshold = .8;

    41 

    42 

    43 //Zooming constants

    44 static const int ZoomAnimationDuration = 300;   //ms. Zooming transition duration

    45 static const qreal ZoomStep = .5;               //Incremental zoom step

    46 const int TileUpdateEnableDelay = 500;         //Wait duration before tiling updates are enabled.

    47 

    48 namespace GVA {

    49 

    50 ScrollableWebContentView::ScrollableWebContentView(WebContentAnimationItem* webAnimationItem, QGraphicsItem* parent)

    51     : ScrollableViewBase(parent)

    52     , m_gestureRecognizer(this)

    53 {

    54     m_viewportMetaData = new ViewportMetaData();

    55 

    56     //Kinetic scroller settings

    57     //Sets the number of scrolls (frames) per second to sps.

    58     m_kineticScroller->setScrollsPerSecond(ScrollsPerSecond);

    59     //For elastic scroll in page edges

    60     m_kineticScroller->setOvershootPolicy(KineticScroller::OvershootWhenScrollable);

    61 

    62     //Gesture settings

    63     //For detecting scroll direction

    64     m_gestureRecognizer.setAxisLockThreshold(AxisLockThreshold);

    65     //To enable touch and drag scrolling

    66     m_gestureRecognizer.setMinimumVelocity(MinimumScrollVelocity);

    67 

    68     setWidget(webAnimationItem);

    69     //FIX ME : Revisit this code. Duplicate info sharing!

    70     webAnimationItem->setViewportMetaData(m_viewportMetaData);

    71 

    72 

    73     m_tileUpdateEnableTimer.setSingleShot(true);

    74     connect(&m_tileUpdateEnableTimer, SIGNAL(timeout()), webAnimationItem, SLOT(enableContentUpdates()));

    75 

    76     //Setup zooming animator

    77     m_zoomAnimator = new QPropertyAnimation(webAnimationItem, "geometry");

    78     m_zoomAnimator->setDuration(ZoomAnimationDuration);

    79     connect(m_zoomAnimator, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), this, SLOT(zoomAnimationStateChanged(QAbstractAnimation::State,QAbstractAnimation::State)));

    80 }

    81 

    82 ScrollableWebContentView::~ScrollableWebContentView()

    83 {

    84     delete m_viewportMetaData;

    85     delete m_kineticScroller;

    86 

    87     if(m_zoomAnimator) {

    88         m_zoomAnimator->stop();

    89         delete m_zoomAnimator;

    90     }

    91 }

    92 

    93 WebContentAnimationItem* ScrollableWebContentView::viewportWidget() const

    94 {

    95     return qobject_cast<WebContentAnimationItem*>(scrollWidget());

    96 }

    97 

    98 void ScrollableWebContentView::zoomToScreenCenter(bool zoomIn)

    99 {

   100     //If viewport metadata has user scalable false.

   101     //Do not zoom.

   102     if (!m_viewportMetaData->m_userScalable)

   103         return;

   104 

   105     qreal scale = 1;

   106     scale += ZoomStep;

   107 

   108     if (!zoomIn)

   109         scale = 1/scale;

   110 

   111     qreal curScale =  viewportWidget()->zoomScale();

   112 

   113     if (zoomIn && (curScale * scale > m_viewportMetaData->m_maximumScale))

   114         scale = m_viewportMetaData->m_maximumScale / curScale;

   115     else if (!zoomIn && (curScale * scale < m_viewportMetaData->m_minimumScale))

   116         scale = m_viewportMetaData->m_minimumScale / curScale;

   117 

   118     if(scale == 1.)

   119         return;

   120 

   121     //Screen center

   122     QPointF scrCenter(size().width()/2, size().height()/2);

   123     //Map screen center to document

   124     QPointF docPoint(viewportWidget()->mapFromScene(scrCenter));

   125     //Maintain that spot in the same point on the viewport

   126     QPointF docPointInScr(viewportWidget()->mapToParent(docPoint));

   127     startZoomAnimToItemHotspot(docPoint, docPointInScr, scale);

   128 }

   129 

   130 ZoomMetaData ScrollableWebContentView::currentPageInfo()

   131 {

   132     ZoomMetaData data;

   133 

   134     data.initialScale = m_viewportMetaData->m_initialScale;

   135     data.minScale = m_viewportMetaData->m_minimumScale;

   136     data.maxScale = m_viewportMetaData->m_maximumScale;

   137     data.userScalable = m_viewportMetaData->m_userScalable;

   138     data.m_specifiedWidth = m_viewportMetaData->m_specifiedData.m_width;

   139     data.m_specifiedHeight= m_viewportMetaData->m_specifiedData.m_height;

   140 

   141     data.rect = viewportWidget()->geometry();

   142     data.scale = viewportWidget()->zoomScale();

   143     data.webViewSize = viewportWidget()->webView()->geometry();

   144     data.viewportSize = size();

   145 

   146     return data;

   147 }

   148 

   149 void ScrollableWebContentView::setCurrentPageInfo(ZoomMetaData data)

   150 {

   151     m_viewportMetaData->m_initialScale = data.initialScale;

   152     m_viewportMetaData->m_minimumScale = data.minScale;

   153     m_viewportMetaData->m_maximumScale = data.maxScale;

   154     m_viewportMetaData->m_userScalable = data.userScalable;

   155     m_viewportMetaData->m_specifiedData.m_width = data.m_specifiedWidth;

   156     m_viewportMetaData->m_specifiedData.m_height = data.m_specifiedHeight;

   157     m_viewportMetaData->m_isValid = true;

   158 

   159     m_viewportMetaData->m_width = data.webViewSize.width();

   160     m_viewportMetaData->m_height = data.webViewSize.height();

   161 

   162     viewportWidget()->webView()->setGeometry(data.webViewSize);

   163     viewportWidget()->setZoomScale(data.scale, true);

   164     viewportWidget()->setGeometry(data.rect);

   165 

   166     if (data.viewportSize.width() != size().width())

   167         adjustViewportSize(data.viewportSize, size());

   168 }

   169 

   170 ZoomMetaData ScrollableWebContentView::defaultZoomData()

   171 {

   172     ZoomMetaData data;

   173 

   174     data.initialScale = m_viewportMetaData->m_initialScale;

   175     data.minScale = m_viewportMetaData->m_minimumScale;

   176     data.maxScale = m_viewportMetaData->m_maximumScale;

   177     data.userScalable = m_viewportMetaData->m_userScalable;

   178 

   179     data.scale = 1.0;

   180     data.rect = QRectF();

   181     data.webViewSize = QRectF();

   182     data.viewportSize = QSizeF();

   183 

   184     return data;

   185 }

   186 

   187 void ScrollableWebContentView::updatePreferredContentSize()

   188 {

   189     viewportWidget()->updatePreferredContentSize(QSize(m_viewportMetaData->m_width

   190                                                        , m_viewportMetaData->m_height));

   191 }

   192 

   193 void ScrollableWebContentView::setSuperPage()

   194 {

   195     m_viewportMetaData->m_initialScale = 1.;

   196     m_viewportMetaData->m_minimumScale = 1.;

   197     m_viewportMetaData->m_maximumScale = 1.;

   198     m_viewportMetaData->m_specifiedData.m_width = "device-width";

   199     m_viewportMetaData->m_specifiedData.m_height = "device-height";

   200     m_viewportMetaData->m_userScalable = false;

   201 

   202     QSize contentSize = viewportWidget()->contentsSize();

   203     QRect webViewRect(0, 0, size().width(), contentSize.height());

   204     viewportWidget()->webView()->setGeometry(webViewRect);

   205     viewportWidget()->setZoomScale(1., true);

   206     viewportWidget()->setGeometry(webViewRect);

   207 

   208     m_viewportMetaData->m_width = size().width();

   209     m_viewportMetaData->m_height = size().height();

   210     m_viewportMetaData->m_isValid = true;

   211 

   212     updatePreferredContentSize();

   213 }

   214 

   215 void ScrollableWebContentView::reset()

   216 {

   217     // TODO: INVESTIGATE: In the case of multiple windows loading pages simultaneously, it is possible

   218     // to be calling this slot on a signal from a frame that is not

   219     // the frame of the page saved here. It might be better to use 'sender' instead of

   220     // page->mainFrame() to get the metaData so that we use the meta data of the corresponding

   221     // frame

   222 

   223     QWebPage* page = viewportWidget()->webView()->page();

   224     if (!page)

   225         return;

   226 

   227     //Initialize viewport metadata

   228     m_viewportMetaData->reset();

   229 

   230     QWebFrame* frame = page->mainFrame();

   231     QMap<QString, QString> metaData = frame->metaData();

   232     QString viewportTag = metaData.value("viewport");

   233 

   234     QRect clientRect = geometry().toAlignedRect();

   235     ViewportMetaDataParser parser(clientRect);

   236     *m_viewportMetaData = parser.parse(viewportTag);

   237 

   238     updatePreferredContentSize();

   239     setViewportWidgetGeometry(QRectF(QPointF(),

   240                                      QSize(m_viewportMetaData->m_width, m_viewportMetaData->m_height)

   241                                      * m_viewportMetaData->m_initialScale));

   242 }

   243 

   244 void ScrollableWebContentView::contentsSizeChanged(const QSize& newContentSize)

   245 {

   246     QRect clientRect = geometry().toAlignedRect();

   247     m_viewportMetaData->updateViewportData(newContentSize, clientRect);

   248     viewportWidget()->resize(QSize(m_viewportMetaData->m_width, m_viewportMetaData->m_height)

   249                              * m_viewportMetaData->m_initialScale);

   250 }

   251 

   252 void ScrollableWebContentView::pageLoadFinished(bool ok)

   253 {

   254     Q_UNUSED(ok);

   255     QSize contentSize = viewportWidget()->contentsSize();

   256     QRect clientRect = geometry().toAlignedRect();

   257     m_viewportMetaData->updateViewportData(contentSize, clientRect);

   258 

   259     viewportWidget()->resize(QSize(m_viewportMetaData->m_width, m_viewportMetaData->m_height)

   260                              * m_viewportMetaData->m_initialScale);

   261     viewportWidget()->setZoomScale(m_viewportMetaData->m_initialScale, true);

   262 }

   263 

   264 bool ScrollableWebContentView::sceneEventFilter(QGraphicsItem* item, QEvent* event)

   265 {

   266     Q_UNUSED(item);

   267 

   268     bool handled = false;

   269     if (!isVisible())

   270         return handled;

   271 

   272     //Pass all events to recognizer

   273     handled  = m_gestureRecognizer.mouseEventFilter(static_cast<QGraphicsSceneMouseEvent *>(event));

   274     return handled;

   275 }

   276 

   277 void ScrollableWebContentView::handleGesture(GestureEvent* gestureEvent)

   278 {

   279     switch (gestureEvent->type()) {

   280     case GestureEvent::Touch:

   281         handlePress(gestureEvent);

   282         break;

   283     case GestureEvent::Release:

   284         handleRelease(gestureEvent);

   285         break;

   286     case GestureEvent::Pan:

   287         handlePan(gestureEvent);

   288         break;

   289     case GestureEvent::Flick:

   290         handleFlick(gestureEvent);

   291         break;

   292     case GestureEvent::DoubleTap:

   293         handleDoubleTap(gestureEvent);

   294         break;

   295     case GestureEvent::LongTap:

   296         handleLongTap(gestureEvent);

   297         break;

   298     default:

   299         break;

   300     }

   301 

   302 }

   303 

   304 void ScrollableWebContentView::handlePress(GestureEvent* gestureEvent)

   305 {

   306     m_kineticScroller->stop();

   307     QPointF pos = gestureEvent->position();

   308     sendEventToWebKit(QEvent::GraphicsSceneMousePress, pos);

   309 }

   310 

   311 void ScrollableWebContentView::handleRelease(GestureEvent* gestureEvent)

   312 {

   313     //Cache release event to send on release

   314     QPointF pos = gestureEvent->position();

   315     sendEventToWebKit(QEvent::GraphicsSceneMouseRelease, pos);

   316 }

   317 

   318 void ScrollableWebContentView::handleDoubleTap(GestureEvent* gestureEvent)

   319 {

   320     if (!m_viewportMetaData->m_userScalable)

   321         return;

   322 

   323     QRectF target;

   324     WebContentAnimationItem* webViewProxy = viewportWidget();

   325 

   326     // Contentview center is the focus hotspot

   327     QPointF viewTargetHotspot(size().width() / 2, size().height() / 2);

   328 

   329     //Get the focussable element rect from current touch position

   330     QPointF touchPoint = webViewProxy->mapFromScene(gestureEvent->position());

   331     QRectF zoomRect = webViewProxy->findZoomableRectForPoint(touchPoint);

   332 

   333     if (!zoomRect.isValid()) {

   334         //FIX ME: Add an event ignore animation

   335         return;

   336     }

   337 

   338     // target is the center of the identified rect x-wise

   339     // y-wise it's the place user touched

   340     QPointF hotspot(zoomRect.center().x(), touchPoint.y());

   341     qreal scale = size().width() / zoomRect.size().width();

   342     startZoomAnimToItemHotspot(hotspot, viewTargetHotspot, scale, zoomRect);

   343 }

   344 

   345 void ScrollableWebContentView::handlePan(GestureEvent* gestureEvent)

   346 {

   347     QPoint scrollPos = ScrollableViewBase::scrollPosition();

   348     m_kineticScroller->doPan(gestureEvent->delta());

   349     QPoint delta;

   350     delta.setX(-gestureEvent->delta().x());

   351     delta.setY(-gestureEvent->delta().y());

   352     emit viewScrolled(scrollPos, delta);

   353 }

   354 

   355 void ScrollableWebContentView::handleFlick(GestureEvent* gestureEvent)

   356 {

   357     QPoint scrollPos = ScrollableViewBase::scrollPosition();

   358     m_kineticScroller->doFlick(gestureEvent->velocity());

   359 }

   360 

   361 void ScrollableWebContentView::handleLongTap(GestureEvent* gestureEvent)

   362 {

   363     QWebPage* page = viewportWidget()->webView()->page();

   364     QPointF contextPt = viewportWidget()->webView()->mapFromScene(gestureEvent->position());

   365     QWebHitTestResult result = page->currentFrame()->hitTestContent(contextPt.toPoint());

   366 

   367     //Notify context menu observers

   368     emit contextEventObject(&result);

   369 }

   370 

   371 void ScrollableWebContentView::setViewportWidgetGeometry(const QRectF& r)

   372 {

   373     ScrollableViewBase::setScrollWidgetGeometry(r);

   374 }

   375 

   376 void ScrollableWebContentView::startZoomAnimToItemHotspot(const QPointF& hotspot, const QPointF& viewTargetHotspot, qreal scale,  QRectF target)

   377 {

   378     WebContentAnimationItem* animWidget = viewportWidget();

   379 

   380     QPointF newHotspot = hotspot * scale;

   381     QPointF newViewportOrigon = newHotspot - viewTargetHotspot;

   382     QRectF zoomedRect(-newViewportOrigon, animWidget->size() * scale);

   383 

   384     QRectF temp = adjustScrollWidgetRect(zoomedRect);

   385     qreal diff = qAbs(scrollWidget()->geometry().y() - temp.y());

   386 

   387     //FIX ME : Seperate the logic for centerzoom and block-focus zoom

   388     if (qFuzzyCompare(scrollWidget()->geometry().topLeft().x(), temp.topLeft().x())

   389         && qFuzzyCompare(scrollWidget()->geometry().width(), temp.width())

   390         && qFuzzyCompare(scrollWidget()->geometry().height(), temp.height())

   391         && !target.isEmpty() && (diff <= target.height())) {

   392 

   393             scale = size().width() / animWidget->size().width();

   394             newHotspot = QPointF(0, -animWidget->pos().y()) * scale;

   395             newViewportOrigon = newHotspot - viewTargetHotspot;

   396             zoomedRect = QRectF(-newViewportOrigon, animWidget->size() * scale);

   397     }

   398 

   399     startZoomAnimation(zoomedRect);

   400 }

   401 

   402 bool ScrollableWebContentView::isZoomedIn() const

   403 {

   404     return size().width() < viewportWidget()->size().width();

   405 }

   406 

   407 void ScrollableWebContentView::stateChanged(KineticScrollable::State oldState

   408                                             , KineticScrollable::State newState)

   409 {

   410     ScrollableViewBase::stateChanged(oldState, newState);

   411 

   412     if (newState == KineticScrollable::Pushing) {

   413         m_tileUpdateEnableTimer.stop();

   414         viewportWidget()->disableContentUpdates();

   415     }

   416     else if (newState == KineticScrollable::AutoScrolling) {

   417         m_tileUpdateEnableTimer.stop();

   418         viewportWidget()->disableContentUpdates();

   419     }

   420     else if (newState == KineticScrollable::Inactive) {

   421         m_tileUpdateEnableTimer.start(TileUpdateEnableDelay);

   422     }

   423 }

   424 

   425 void ScrollableWebContentView::startZoomAnimation(const QRectF& destRect)

   426 {

   427     QAbstractAnimation::State animState = m_zoomAnimator->state();

   428     if (animState == QAbstractAnimation::Running)

   429         return;

   430 

   431     m_zoomAnimator->setStartValue(scrollWidget()->geometry());

   432     m_animationEndRect = adjustScrollWidgetRect(destRect);

   433     m_zoomAnimator->setEndValue(m_animationEndRect);

   434     m_zoomAnimator->start();

   435 }

   436 

   437 void ScrollableWebContentView::stopZoomAnimation()

   438 {

   439     m_animationEndRect = QRectF();

   440     m_zoomAnimator->stop();

   441 }

   442 

   443 void ScrollableWebContentView::updateZoomEndRect()

   444 {

   445     if (m_animationEndRect.isValid())

   446         scrollWidget()->setGeometry(m_animationEndRect);

   447 }

   448 

   449 void ScrollableWebContentView::zoomAnimationStateChanged(QAbstractAnimation::State newState,QAbstractAnimation::State)

   450 {

   451     switch (newState) {

   452     case QAbstractAnimation::Stopped:

   453         updateZoomEndRect();

   454         break;

   455     default:

   456         break;

   457     }

   458 }

   459 

   460 void ScrollableWebContentView::resizeEvent(QGraphicsSceneResizeEvent* event)

   461 {

   462     QGraphicsWidget::resizeEvent(event);

   463 

   464     //Ignore resize when chrome is being still setup

   465     if (!event->oldSize().width())

   466         return;

   467 

   468     adjustViewportSize(event->oldSize(), event->newSize());

   469 }

   470 

   471 void ScrollableWebContentView::adjustViewportSize(QSizeF oldSize, QSizeF newSize)

   472 {

   473     //FIX ME : Check this

   474     if (m_viewportMetaData->m_isValid) {

   475 

   476         QRect clientRect = geometry().toAlignedRect();

   477         if (m_viewportMetaData->isLayoutNeeded())  {

   478             m_viewportMetaData->orientationChanged(clientRect);

   479             updatePreferredContentSize();

   480             return;

   481         } else

   482             m_viewportMetaData->updateViewportData(viewportWidget()->contentsSize(), clientRect);

   483     }

   484 

   485     qreal scale = newSize.width() / oldSize.width();

   486     QPointF middleLeft(0, oldSize.height()/2);

   487     QPointF docPoint(viewportWidget()->mapFromScene(middleLeft));

   488 

   489     QPointF resizedMiddleLeft(0, newSize.height()/2);

   490     QPointF resizedDocPoint(viewportWidget()->mapFromScene(resizedMiddleLeft));

   491     QPointF docPointInScr(viewportWidget()->mapToParent(resizedDocPoint));

   492 

   493     //FIX ME : Should be handled with only following function call

   494     //Since its not working, work-around is added. Plz fix it

   495     //startZoomAnimToItemHotspot(docPoint, docPointInScr, scale);

   496 

   497     QPointF newHotspot = docPoint * scale;

   498     QPointF newViewportOrigon = newHotspot - docPointInScr;

   499     QRectF zoomedRect(-newViewportOrigon,  viewportWidget()->size() * scale);

   500     QRectF adjustRect = adjustScrollWidgetRect(zoomedRect);

   501 

   502     setScrollWidgetGeometry(zoomedRect);

   503 }

   504 

   505 void ScrollableWebContentView::sendEventToWebKit(QEvent::Type type, QPointF& scenPos)

   506 {

   507     //Setup event and send it to webkit

   508     QGraphicsSceneMouseEvent event(type);

   509     event.setScenePos(scenPos);

   510     event.setPos(viewportWidget()->webView()->mapFromScene(event.scenePos()));

   511     event.setButton(Qt::LeftButton);

   512     event.setButtons(Qt::LeftButton);

   513     event.setModifiers(Qt::NoModifier);

   514 

   515     viewportWidget()->webView()->page()->event(&event);

   516 }

   517 

   518 } //namespace GVA