flickcharm.cpp Example File

 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the demos of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 ** contained in the Technology Preview License Agreement accompanying
 ** this package.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL included in the
 ** packaging of this file.  Please review the following information to
 ** ensure the GNU Lesser General Public License version 2.1 requirements
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights.  These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at [email protected].
 **
 **
 **
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "flickcharm.h"

 #include <QAbstractScrollArea>
 #include <QApplication>
 #include <QBasicTimer>
 #include <QEvent>
 #include <QHash>
 #include <QList>
 #include <QMouseEvent>
 #include <QScrollBar>
 #include <QTime>
 #include <QWebFrame>
 #include <QWebView>

 #include <QDebug>

 const int fingerAccuracyThreshold = 3;

 struct FlickData {
     typedef enum {
         Steady, // Interaction without scrolling
         ManualScroll, // Scrolling manually with the finger on the screen
         AutoScroll, // Scrolling automatically
         AutoScrollAcceleration // Scrolling automatically but a finger is on the screen
     } State;
     State state;
     QWidget *widget;
     QPoint pressPos;
     QPoint lastPos;
     QPoint speed;
     QTime speedTimer;
     QList<QEvent*> ignored;
     QTime accelerationTimer;
     bool lastPosValid:1;
     bool waitingAcceleration:1;

     FlickData()
         : lastPosValid(false)
         , waitingAcceleration(false)
     {}

     void resetSpeed()
     {
         speed = QPoint();
         lastPosValid = false;
     }
     void updateSpeed(const QPoint &newPosition)
     {
         if (lastPosValid) {
             const int timeElapsed = speedTimer.elapsed();
             if (timeElapsed) {
                 const QPoint newPixelDiff = (newPosition - lastPos);
                 const QPoint pixelsPerSecond = newPixelDiff * (1000 / timeElapsed);
                 // fingers are inacurates, we ignore small changes to avoid stopping the autoscroll because
                 // of a small horizontal offset when scrolling vertically
                 const int newSpeedY = (qAbs(pixelsPerSecond.y()) > fingerAccuracyThreshold) ? pixelsPerSecond.y() : 0;
                 const int newSpeedX = (qAbs(pixelsPerSecond.x()) > fingerAccuracyThreshold) ? pixelsPerSecond.x() : 0;
                 if (state == AutoScrollAcceleration) {
                     const int max = 4000; // px by seconds
                     const int oldSpeedY = speed.y();
                     const int oldSpeedX = speed.x();
                     if ((oldSpeedY <= 0 && newSpeedY <= 0) ||  (oldSpeedY >= 0 && newSpeedY >= 0)
                         && (oldSpeedX <= 0 && newSpeedX <= 0) ||  (oldSpeedX >= 0 && newSpeedX >= 0)) {
                         speed.setY(qBound(-max, (oldSpeedY + (newSpeedY / 4)), max));
                         speed.setX(qBound(-max, (oldSpeedX + (newSpeedX / 4)), max));
                     } else {
                         speed = QPoint();
                     }
                 } else {
                     const int max = 2500; // px by seconds
                     // we average the speed to avoid strange effects with the last delta
                     if (!speed.isNull()) {
                         speed.setX(qBound(-max, (speed.x() / 4) + (newSpeedX * 3 / 4), max));
                         speed.setY(qBound(-max, (speed.y() / 4) + (newSpeedY * 3 / 4), max));
                     } else {
                         speed = QPoint(newSpeedX, newSpeedY);
                     }
                 }
             }
         } else {
             lastPosValid = true;
         }
         speedTimer.start();
         lastPos = newPosition;
     }

     // scroll by dx, dy
     // return true if the widget was scrolled
     bool scrollWidget(const int dx, const int dy)
     {
         QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
         if (scrollArea) {
             const int x = scrollArea->horizontalScrollBar()->value();
             const int y = scrollArea->verticalScrollBar()->value();
             scrollArea->horizontalScrollBar()->setValue(x - dx);
             scrollArea->verticalScrollBar()->setValue(y - dy);
             return (scrollArea->horizontalScrollBar()->value() != x
                     || scrollArea->verticalScrollBar()->value() != y);
         }

         QWebView *webView = qobject_cast<QWebView*>(widget);
         if (webView) {
             QWebFrame *frame = webView->page()->mainFrame();
             const QPoint position = frame->scrollPosition();
             frame->setScrollPosition(position - QPoint(dx, dy));
             return frame->scrollPosition() != position;
         }
         return false;
     }

     bool scrollTo(const QPoint &newPosition)
     {
         const QPoint delta = newPosition - lastPos;
         updateSpeed(newPosition);
         return scrollWidget(delta.x(), delta.y());
     }
 };

 class FlickCharmPrivate
 {
 public:
     QHash<QWidget*, FlickData*> flickData;
     QBasicTimer ticker;
     QTime timeCounter;
     void startTicker(QObject *object)
     {
         if (!ticker.isActive())
             ticker.start(15, object);
         timeCounter.start();
     }
 };

 FlickCharm::FlickCharm(QObject *parent): QObject(parent)
 {
     d = new FlickCharmPrivate;
 }

 FlickCharm::~FlickCharm()
 {
     delete d;
 }

 void FlickCharm::activateOn(QWidget *widget)
 {
     QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
     if (scrollArea) {
         scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

         QWidget *viewport = scrollArea->viewport();

         viewport->installEventFilter(this);
         scrollArea->installEventFilter(this);

         d->flickData.remove(viewport);
         d->flickData[viewport] = new FlickData;
         d->flickData[viewport]->widget = widget;
         d->flickData[viewport]->state = FlickData::Steady;

         return;
     }

     QWebView *webView = qobject_cast<QWebView*>(widget);
     if (webView) {
         QWebFrame *frame = webView->page()->mainFrame();
         frame->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
         frame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);

         webView->installEventFilter(this);

         d->flickData.remove(webView);
         d->flickData[webView] = new FlickData;
         d->flickData[webView]->widget = webView;
         d->flickData[webView]->state = FlickData::Steady;

         return;
     }

     qWarning() << "FlickCharm only works on QAbstractScrollArea (and derived classes)";
     qWarning() << "or QWebView (and derived classes)";
 }

 void FlickCharm::deactivateFrom(QWidget *widget)
 {
     QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
     if (scrollArea) {
         QWidget *viewport = scrollArea->viewport();

         viewport->removeEventFilter(this);
         scrollArea->removeEventFilter(this);

         delete d->flickData[viewport];
         d->flickData.remove(viewport);

         return;
     }

     QWebView *webView = qobject_cast<QWebView*>(widget);
     if (webView) {
         webView->removeEventFilter(this);

         delete d->flickData[webView];
         d->flickData.remove(webView);

         return;
     }
 }

 static QPoint deaccelerate(const QPoint &speed, const int deltatime)
 {
     const int deltaSpeed = deltatime;

     int x = speed.x();
     int y = speed.y();
     x = (x == 0) ? x : (x > 0) ? qMax(0, x - deltaSpeed) : qMin(0, x + deltaSpeed);
     y = (y == 0) ? y : (y > 0) ? qMax(0, y - deltaSpeed) : qMin(0, y + deltaSpeed);
     return QPoint(x, y);
 }

 bool FlickCharm::eventFilter(QObject *object, QEvent *event)
 {
     if (!object->isWidgetType())
         return false;

     const QEvent::Type type = event->type();

     switch (type) {
     case QEvent::MouseButtonPress:
     case QEvent::MouseMove:
     case QEvent::MouseButtonRelease:
         break;
     case QEvent::MouseButtonDblClick: // skip double click
         return true;
     default:
         return false;
     }

     QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
     if (type == QEvent::MouseMove && mouseEvent->buttons() != Qt::LeftButton)
         return false;

     if (mouseEvent->modifiers() != Qt::NoModifier)
         return false;

     QWidget *viewport = qobject_cast<QWidget*>(object);
     FlickData *data = d->flickData.value(viewport);
     if (!viewport || !data || data->ignored.removeAll(event))
         return false;

     const QPoint mousePos = mouseEvent->pos();
     bool consumed = false;
     switch (data->state) {

     case FlickData::Steady:
         if (type == QEvent::MouseButtonPress) {
             consumed = true;
             data->pressPos = mousePos;
         } else if (type == QEvent::MouseButtonRelease) {
             consumed = true;
             QMouseEvent *event1 = new QMouseEvent(QEvent::MouseButtonPress,
                                                   data->pressPos, Qt::LeftButton,
                                                   Qt::LeftButton, Qt::NoModifier);
             QMouseEvent *event2 = new QMouseEvent(QEvent::MouseButtonRelease,
                                                   data->pressPos, Qt::LeftButton,
                                                   Qt::LeftButton, Qt::NoModifier);

             data->ignored << event1;
             data->ignored << event2;
             QApplication::postEvent(object, event1);
             QApplication::postEvent(object, event2);
         } else if (type == QEvent::MouseMove) {
             consumed = true;
             data->scrollTo(mousePos);

             const QPoint delta = mousePos - data->pressPos;
             if (delta.x() > fingerAccuracyThreshold || delta.y() > fingerAccuracyThreshold)
                 data->state = FlickData::ManualScroll;
         }
         break;

     case FlickData::ManualScroll:
         if (type == QEvent::MouseMove) {
             consumed = true;
             data->scrollTo(mousePos);
         } else if (type == QEvent::MouseButtonRelease) {
             consumed = true;
             data->state = FlickData::AutoScroll;
             data->lastPosValid = false;
             d->startTicker(this);
         }
         break;

     case FlickData::AutoScroll:
         if (type == QEvent::MouseButtonPress) {
             consumed = true;
             data->state = FlickData::AutoScrollAcceleration;
             data->waitingAcceleration = true;
             data->accelerationTimer.start();
             data->updateSpeed(mousePos);
             data->pressPos = mousePos;
         } else if (type == QEvent::MouseButtonRelease) {
             consumed = true;
             data->state = FlickData::Steady;
             data->resetSpeed();
         }
         break;

     case FlickData::AutoScrollAcceleration:
         if (type == QEvent::MouseMove) {
             consumed = true;
             data->updateSpeed(mousePos);
             data->accelerationTimer.start();
             if (data->speed.isNull())
                 data->state = FlickData::ManualScroll;
         } else if (type == QEvent::MouseButtonRelease) {
             consumed = true;
             data->state = FlickData::AutoScroll;
             data->waitingAcceleration = false;
             data->lastPosValid = false;
         }
         break;
     default:
         break;
     }
     data->lastPos = mousePos;
     return true;
 }

 void FlickCharm::timerEvent(QTimerEvent *event)
 {
     int count = 0;
     QHashIterator<QWidget*, FlickData*> item(d->flickData);
     while (item.hasNext()) {
         item.next();
         FlickData *data = item.value();
         if (data->state == FlickData::AutoScrollAcceleration
             && data->waitingAcceleration
             && data->accelerationTimer.elapsed() > 40) {
             data->state = FlickData::ManualScroll;
             data->resetSpeed();
         }
         if (data->state == FlickData::AutoScroll || data->state == FlickData::AutoScrollAcceleration) {
             const int timeElapsed = d->timeCounter.elapsed();
             const QPoint delta = (data->speed) * timeElapsed / 1000;
             bool hasScrolled = data->scrollWidget(delta.x(), delta.y());

             if (data->speed.isNull() || !hasScrolled)
                 data->state = FlickData::Steady;
             else
                 count++;
             data->speed = deaccelerate(data->speed, timeElapsed);
         }
     }

     if (!count)
         d->ticker.stop();
     else
         d->timeCounter.start();

     QObject::timerEvent(event);
 }