FCL/sf/mw/qt: comparison demos/embedded/anomaly/src/flickcharm.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:2f34d5167611
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the demos of the Qt Toolkit.
 **
 #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, Pressed, ManualScroll, AutoScroll, Stop } State;
+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 offset;
+QPoint lastPos;
-QPoint dragPos;
 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;
 return;
 }
 }
-static QPoint scrollOffset(QWidget *widget)
+static QPoint deaccelerate(const QPoint &speed, const int deltatime)
 {
-int x = 0, y = 0;
+const int deltaSpeed = deltatime;
-QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
+int x = speed.x();
-if (scrollArea) {
+int y = speed.y();
-x = scrollArea->horizontalScrollBar()->value();
+x = (x == 0) ? x : (x > 0) ? qMax(0, x - deltaSpeed) : qMin(0, x + deltaSpeed);
-y = scrollArea->verticalScrollBar()->value();
+y = (y == 0) ? y : (y > 0) ? qMax(0, y - deltaSpeed) : qMin(0, y + deltaSpeed);
-}
-QWebView *webView = qobject_cast<QWebView*>(widget);
-if (webView) {
-QWebFrame *frame = webView->page()->mainFrame();
-x = frame->evaluateJavaScript("window.scrollX").toInt();
-y = frame->evaluateJavaScript("window.scrollY").toInt();
-}
 return QPoint(x, y);
 }
-static void setScrollOffset(QWidget *widget, const QPoint &p)
-{
-QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
-if (scrollArea) {
-scrollArea->horizontalScrollBar()->setValue(p.x());
-scrollArea->verticalScrollBar()->setValue(p.y());
-}
-QWebView *webView = qobject_cast<QWebView*>(widget);
-QWebFrame *frame = webView ? webView->page()->mainFrame() : 0;
-if (frame)
-frame->evaluateJavaScript(QString("window.scrollTo(%1,%2);").arg(p.x()).arg(p.y()));
-}
-static QPoint deaccelerate(const QPoint &speed, int a = 1, int max = 64)
-{
-int x = qBound(-max, speed.x(), max);
-int y = qBound(-max, speed.y(), max);
-x = (x == 0) ? x : (x > 0) ? qMax(0, x - a) : qMin(0, x + a);
-y = (y == 0) ? y : (y > 0) ? qMax(0, y - a) : qMin(0, y + a);
-return QPoint(x, y);
-}
 bool FlickCharm::eventFilter(QObject *object, QEvent *event)
 {
 if (!object->isWidgetType())
 return false;
-QEvent::Type type = event->type();
+const QEvent::Type type = event->type();
-if (type != QEvent::MouseButtonPress &&
-type != QEvent::MouseButtonRelease &&
+switch (type) {
-type != QEvent::MouseMove)
+case QEvent::MouseButtonPress:
-return false;
+case QEvent::MouseMove:
+case QEvent::MouseButtonRelease:
-QMouseEvent *mouseEvent = 0;
+break;
-switch (event->type()) {
+case QEvent::MouseButtonDblClick: // skip double click
-case QEvent::MouseButtonPress:
+return true;
-case QEvent::MouseButtonRelease:
+default:
-case QEvent::MouseMove:
+return false;
-mouseEvent = static_cast<QMouseEvent*>(event);
+}
-break;
-}
+QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
+if (type == QEvent::MouseMove && mouseEvent->buttons() != Qt::LeftButton)
-if (!mouseEvent || mouseEvent->modifiers() != Qt::NoModifier)
+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 (mouseEvent->type() == QEvent::MouseButtonPress)
+if (type == QEvent::MouseButtonPress) {
-if (mouseEvent->buttons() == Qt::LeftButton) {
+consumed = true;
-consumed = true;
+data->pressPos = mousePos;
-data->state = FlickData::Pressed;
+} else if (type == QEvent::MouseButtonRelease) {
-data->pressPos = mouseEvent->pos();
+consumed = true;
-data->offset = scrollOffset(data->widget);
-}
-break;
-case FlickData::Pressed:
-if (mouseEvent->type() == QEvent::MouseButtonRelease) {
-consumed = true;
-data->state = FlickData::Steady;
 QMouseEvent *event1 = new QMouseEvent(QEvent::MouseButtonPress,
 data->pressPos, Qt::LeftButton,
 Qt::LeftButton, Qt::NoModifier);
-QMouseEvent *event2 = new QMouseEvent(*mouseEvent);
+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) {
-if (mouseEvent->type() == QEvent::MouseMove) {
+consumed = true;
-consumed = true;
+data->scrollTo(mousePos);
-data->state = FlickData::ManualScroll;
-data->dragPos = QCursor::pos();
+const QPoint delta = mousePos - data->pressPos;
-if (!d->ticker.isActive())
+if (delta.x() > fingerAccuracyThreshold || delta.y() > fingerAccuracyThreshold)
-d->ticker.start(20, this);
+data->state = FlickData::ManualScroll;
 }
 break;
 case FlickData::ManualScroll:
-if (mouseEvent->type() == QEvent::MouseMove) {
+if (type == QEvent::MouseMove) {
 consumed = true;
-QPoint delta = mouseEvent->pos() - data->pressPos;
+data->scrollTo(mousePos);
-setScrollOffset(data->widget, data->offset - delta);
+} else if (type == QEvent::MouseButtonRelease) {
-}
-if (mouseEvent->type() == QEvent::MouseButtonRelease) {
 consumed = true;
 data->state = FlickData::AutoScroll;
+data->lastPosValid = false;
+d->startTicker(this);
 }
 break;
 case FlickData::AutoScroll:
-if (mouseEvent->type() == QEvent::MouseButtonPress) {
+if (type == QEvent::MouseButtonPress) {
 consumed = true;
-data->state = FlickData::Stop;
+data->state = FlickData::AutoScrollAcceleration;
-data->speed = QPoint(0, 0);
+data->waitingAcceleration = true;
-data->pressPos = mouseEvent->pos();
+data->accelerationTimer.start();
-data->offset = scrollOffset(data->widget);
+data->updateSpeed(mousePos);
-}
+data->pressPos = mousePos;
-if (mouseEvent->type() == QEvent::MouseButtonRelease) {
+} else if (type == QEvent::MouseButtonRelease) {
 consumed = true;
 data->state = FlickData::Steady;
-data->speed = QPoint(0, 0);
+data->resetSpeed();
 }
 break;
-case FlickData::Stop:
+case FlickData::AutoScrollAcceleration:
-if (mouseEvent->type() == QEvent::MouseButtonRelease) {
+if (type == QEvent::MouseMove) {
 consumed = true;
-data->state = FlickData::Steady;
+data->updateSpeed(mousePos);
-}
+data->accelerationTimer.start();
-if (mouseEvent->type() == QEvent::MouseMove) {
+if (data->speed.isNull())
-consumed = true;
+data->state = FlickData::ManualScroll;
-data->state = FlickData::ManualScroll;
+} else if (type == QEvent::MouseButtonRelease) {
-data->dragPos = QCursor::pos();
+consumed = true;
-if (!d->ticker.isActive())
+data->state = FlickData::AutoScroll;
-d->ticker.start(20, this);
+data->waitingAcceleration = false;
-}
+data->lastPosValid = false;
-break;
+}
+break;
 default:
 break;
 }
+data->lastPos = mousePos;
-return consumed;
+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
-if (data->state == FlickData::ManualScroll) {
+&& data->waitingAcceleration
-count++;
+&& data->accelerationTimer.elapsed() > 40) {
-data->speed = QCursor::pos() - data->dragPos;
+data->state = FlickData::ManualScroll;
-data->dragPos = QCursor::pos();
+data->resetSpeed();
 }
+if (data->state == FlickData::AutoScroll || data->state == FlickData::AutoScrollAcceleration) {
-if (data->state == FlickData::AutoScroll) {
+const int timeElapsed = d->timeCounter.elapsed();
-count++;
+const QPoint delta = (data->speed) * timeElapsed / 1000;
-data->speed = deaccelerate(data->speed);
+bool hasScrolled = data->scrollWidget(delta.x(), delta.y());
-QPoint p = scrollOffset(data->widget);
-setScrollOffset(data->widget, p - data->speed);
+if (data->speed.isNull() || !hasScrolled)
-if (data->speed == QPoint(0, 0))
 data->state = FlickData::Steady;
+else
+count++;
+data->speed = deaccelerate(data->speed, timeElapsed);
 }
 }
 if (!count)
 d->ticker.stop();
+else
+d->timeCounter.start();
 QObject::timerEvent(event);
 }

changeset 18	2f34d5167611
parent 0	1918ee327afb