flickcharm.cpp Example File
demos/embedded/anomaly/src/flickcharm.cpp
 #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, 
         ManualScroll, 
         AutoScroll, 
         AutoScrollAcceleration 
     } 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);
                 
                 
                 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; 
                     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; 
                     
                     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;
     }
     
     
     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: 
         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);
 }
| Copyright © 2010 Nokia Corporation and/or its subsidiary(-ies) | Trademarks | Qt 4.6.3 |