Simplify the QtKienticListController API by removing the need to specify the orientation.

3 files changed, 94 insertions, 170 deletions

diff --git a/src/experimental/qkineticlistcontroller.cpp b/src/experimental/qkineticlistcontroller.cpp
index 6443cd2..1de1e40 100644
--- a/src/experimental/qkineticlistcontroller.cpp
+++ b/src/experimental/qkineticlistcontroller.cpp
@@ -31,11 +31,10 @@ QT_BEGIN_NAMESPACE
 
 QtKineticListControllerPrivate::QtKineticListControllerPrivate()
     : timerId(0), timerInterval(50), timestamp(0),
-      horizontalVelocity(0), verticalVelocity(0),
-      maximumScrollVelocity(50), frictionFactor(0.85),
-      velocityThreshold(0.05), movementThreshold(5),
-      horizontalOvershoot(false), verticalOvershoot(false),
-      centerOnItem(false)
+      scrollVelocity(0), maximumScrollVelocity(50),
+      frictionFactor(0.85), velocityThreshold(0.05),
+      movementThreshold(5),
+      overshoot(false), centerOnItem(false)
 {
 }
 
@@ -43,43 +42,22 @@ QtKineticListControllerPrivate::~QtKineticListControllerPrivate()
 {
 }
 
-void QtKineticListControllerPrivate::setHorizontalOffset(qreal offset, qreal max)
+bool QtKineticListControllerPrivate::updateOffset()
 {
     if (!view)
-        return;
-    if (horizontalOvershoot) {
-        view->setHorizontalOffset(offset);
-    } else {
-        view->setHorizontalOffset(qBound<qreal>(0, offset, max));
-    }
-}
-
-void QtKineticListControllerPrivate::setVerticalOffset(qreal offset, qreal max)
-{
-    if (!view)
-        return;
-    if (verticalOvershoot) {
-        view->setVerticalOffset(offset);
+        return false;
+    bool cont = false;
+    if (view->orientation() == Qt::Horizontal) {
+        qreal offset = view->horizontalOffset();
+        qreal max = view->maximumHorizontalOffset();
+        cont = kineticUpdateOffset(&offset, max);
+        view->setHorizontalOffset(overshoot ? offset : qBound<qreal>(0, offset, max));
     } else {
-        view->setVerticalOffset(qBound<qreal>(0, offset, max));
+        qreal offset = view->verticalOffset();
+        qreal max = view->maximumVerticalOffset();
+        cont = kineticUpdateOffset(&offset, max);
+        view->setVerticalOffset(overshoot ? offset : qBound<qreal>(0, offset, max));
     }
-}
-
-bool QtKineticListControllerPrivate::updateHorizontalOffset()
-{
-    qreal offset = horizontalOffset();
-    qreal max = maximumHorizontalOffset();
-    bool cont = kineticUpdateOffset(&offset, &horizontalVelocity, max, horizontalOvershoot);
-    setHorizontalOffset(offset, max);
-    return cont;
-}
-
-bool QtKineticListControllerPrivate::updateVerticalOffset()
-{
-    qreal offset = verticalOffset();
-    qreal max = maximumVerticalOffset();
-    bool cont = kineticUpdateOffset(&offset, &verticalVelocity, max, verticalOvershoot);
-    setVerticalOffset(offset, max);
     return cont;
 }
 
@@ -90,20 +68,20 @@ bool QtKineticListControllerPrivate::updateVerticalOffset()
   return true if the timer should be continued
  */
 
-bool QtKineticListControllerPrivate::kineticUpdateOffset(qreal *offset, qreal *velocity, qreal max, bool overshoot)
+bool QtKineticListControllerPrivate::kineticUpdateOffset(qreal *offset, qreal max)
 {
     static const qreal k = -0.5; // overshoot spring constant
     static const qreal l = -0.02; // center spring constant
 
-    *offset += *velocity;
+    *offset += scrollVelocity;
     
     // check for overshoot at the top
     if (*offset <= 0) {
         if (overshoot) {
-            *velocity = qMin(k * *offset, *velocity + k * *offset);
+            scrollVelocity = qMin(k * *offset, scrollVelocity + k * *offset);
         } else {
             *offset = 0;
-            *velocity = 0;
+            scrollVelocity = 0;
             return false;
         }
     }
@@ -111,9 +89,9 @@ bool QtKineticListControllerPrivate::kineticUpdateOffset(qreal *offset, qreal *v
     // check for overshoot at the bottom
     if (*offset >= max) {
         if (overshoot) {
-            *velocity = qMax(k * (*offset - max), *velocity + k * (*offset - max));
+            scrollVelocity = qMax(k * (*offset - max), scrollVelocity + k * (*offset - max));
         } else {
-            *velocity = 0;
+            scrollVelocity = 0;
             *offset = max;
             return false;
         }
@@ -123,7 +101,7 @@ bool QtKineticListControllerPrivate::kineticUpdateOffset(qreal *offset, qreal *v
     // make sure that an item is at the center when we stop
     if (centerOnItem) {
         const QSizeF viewSize = view->size();
-        const QPointF viewCenter(viewSize.width()/2, viewSize.height()/2);
+        const QPointF viewCenter(viewSize.width() / 2, viewSize.height() / 2);
         const int centerIndex = view->itemAt(viewCenter);
         const QList<QtGraphicsListViewItem*> items = view->visibleItems();
         // ### this should be done in the view - get item geometry
@@ -138,18 +116,18 @@ bool QtKineticListControllerPrivate::kineticUpdateOffset(qreal *offset, qreal *v
             const QPointF itemCenter = centerItem->geometry().center();
             const QPointF delta = viewCenter - itemCenter;
             if (view->orientation() == Qt::Horizontal)
-                *velocity += l * delta.x();
+                scrollVelocity += l * delta.x();
             else
-                *velocity += l * delta.y();
+                scrollVelocity += l * delta.y();
         }
-        *velocity *= frictionFactor;
+        scrollVelocity *= frictionFactor;
         return true;
     }
 
     // apply friction
-    *velocity *= frictionFactor;
-    if (qAbs<qreal>(*velocity) < velocityThreshold) {
-        *velocity = 0;
+    scrollVelocity *= frictionFactor;
+    if (qAbs<qreal>(scrollVelocity) < velocityThreshold) {
+        scrollVelocity = 0;
         return false;
     }
     return true;
@@ -188,43 +166,23 @@ QtKineticListController::~QtKineticListController()
 }
 
 /*!
-  Sets the horizontal scroll velocity to the given \a velocity.
-  Note that setting this value wil also start the scrolling animation.
- */
-void QtKineticListController::setHorizontalScrollVelocity(qreal velocity)
-{
-    Q_D(QtKineticListController);
-    d->horizontalVelocity = qMin(velocity, d->maximumScrollVelocity);
-    d->startTimer();
-}
-
-/*!
-  Returns the horizontal scroll velocity.
- */
-qreal QtKineticListController::horizontalScrollVelocity() const
-{
-    Q_D(const QtKineticListController);
-    return d->horizontalVelocity;
-}
-
-/*!
-  Sets the vertical scroll velocity to the given \a velocity.
+  Sets the scroll velocity to the given \a velocity.
   Note that setting this value wil also start the scrolling animation.
  */
-void QtKineticListController::setVerticalScrollVelocity(qreal velocity)
+void QtKineticListController::setScrollVelocity(qreal velocity)
 {
     Q_D(QtKineticListController);
-    d->verticalVelocity = qMin(velocity, d->maximumScrollVelocity);
+    d->scrollVelocity = qMin(velocity, d->maximumScrollVelocity);
     d->startTimer();
 }
 
 /*!
-  Returns the vertical scroll velocity.
+  Returns the scroll velocity.
  */
-qreal QtKineticListController::verticalScrollVelocity() const
+qreal QtKineticListController::scrollVelocity() const
 {
     Q_D(const QtKineticListController);
-    return d->verticalVelocity;
+    return d->scrollVelocity;
 }
 
 /*!
@@ -248,42 +206,22 @@ qreal QtKineticListController::maximumScrollVelocity() const
 
 /*!
   Depending on the given \a enabled value, the controller will scroll past
-  the first and last item horizontally.
+  the first and last item.
  */
-void QtKineticListController::setHorizontalOvershootEnabled(bool enabled)
+void QtKineticListController::setOvershootEnabled(bool enabled)
 {
     Q_D(QtKineticListController);
-    d->horizontalOvershoot = enabled;
+    d->overshoot = enabled;
 }
 
 /*!
   Returns true if the controller is allowed to scroll past
-  the first and last item horizontally, otherwise returns false.
+  the first and last item, otherwise returns false.
  */
-bool QtKineticListController::isHorizontalOvershootEnabled() const
+bool QtKineticListController::isOvershootEnabled() const
 {
     Q_D(const QtKineticListController);
-    return d->horizontalOvershoot;
-}
-
-/*!
-  Depending on the given \a enabled value, the controller will scroll past
-  the first and last item vertically.
- */
-void QtKineticListController::setVerticalOvershootEnabled(bool enabled)
-{
-    Q_D(QtKineticListController);
-    d->verticalOvershoot = enabled;
-}
-
-/*!
-  Returns true if the controller is allowed to scroll past
-  the first and last item vertically, otherwise returns false.
- */
-bool QtKineticListController::isVerticalOvershootEnabled() const
-{
-    Q_D(const QtKineticListController);
-    return d->verticalOvershoot;
+    return d->overshoot;
 }
 
 /*!
@@ -324,16 +262,27 @@ bool QtKineticListController::hideEvent(QHideEvent *event)
 bool QtKineticListController::mouseMoveEvent(QGraphicsSceneMouseEvent *event, const QTransform &transform)
 {
     Q_UNUSED(event);
-    Q_UNUSED(transform); // ###
+    Q_UNUSED(transform);
     Q_D(QtKineticListController);
+    if (!d->view)
+        return false;
+
     int oldTimestamp = d->timestamp;
     d->timestamp = d->currentTime();
     d->timeDelta = d->timestamp - oldTimestamp;
-    d->movement = event->lastPos() - event->pos();
-    if (d->view) {
-        d->setVerticalOffset(d->view->verticalOffset() + d->movement.y(), d->view->maximumVerticalOffset());
-        d->setHorizontalOffset(d->view->horizontalOffset() + d->movement.x(), d->view->maximumHorizontalOffset());
+
+    if (d->view->orientation() == Qt::Horizontal) {
+        d->movement = event->lastPos().x() - event->pos().x();
+        qreal offset = d->view->horizontalOffset() + d->movement;
+        qreal max = d->view->maximumHorizontalOffset();
+        d->view->setHorizontalOffset(d->overshoot ? offset : qBound<qreal>(0, offset, max));
+    } else {
+        d->movement = event->lastPos().y() - event->pos().y();
+        qreal offset = d->view->verticalOffset() + d->movement;
+        qreal max = d->view->maximumVerticalOffset();
+        d->view->setVerticalOffset(d->overshoot ? offset : qBound<qreal>(0, offset, max));
     }
+
     return true;
 }
 
@@ -346,17 +295,15 @@ bool QtKineticListController::mousePressEvent(QGraphicsSceneMouseEvent *event, c
     Q_UNUSED(transform);
     Q_D(QtKineticListController);
 
-    if (!d->centerOnItem) {
-        setHorizontalScrollVelocity(0);
-        setVerticalScrollVelocity(0);
-    }
+    if (!d->centerOnItem)
+        setScrollVelocity(0);
 
     killTimer(d->timerId);
     d->timerId = 0;
 
     d->timestamp = d->currentTime();
     d->timeDelta = 0;
-    d->movement = QPointF();
+    d->movement = 0.;
 
     return true;
 }
@@ -367,24 +314,25 @@ bool QtKineticListController::mousePressEvent(QGraphicsSceneMouseEvent *event, c
 bool QtKineticListController::mouseReleaseEvent(QGraphicsSceneMouseEvent *event, const QTransform &transform)
 {
     Q_D(QtKineticListController);
+    if (!d->view)
+        return false;
+
     qreal dt = qreal(d->timeDelta) / qreal(d->timerInterval);
-    QPointF totalMovement = event->pos() - event->buttonDownPos(event->button());
-
-    if (qAbs<qreal>(totalMovement.x()) > d->movementThreshold)
-        setHorizontalScrollVelocity(d->movement.x() / dt);
-    else if (d->horizontalOffset() < 0 || d->horizontalOffset() > d->maximumHorizontalOffset())
-        d->startTimer(); // start bounce-back
-    else if (d->centerOnItem && qAbs(d->horizontalVelocity) > d->velocityThreshold)
-        d->startTimer(); // continue scrolling
-
-    if (qAbs<qreal>(totalMovement.y()) > d->movementThreshold)
-        setVerticalScrollVelocity(d->movement.y() / dt);
-    else if (d->verticalOffset() < 0 || d->verticalOffset() > d->maximumVerticalOffset())
-        d->startTimer(); // start bounce-back
-    else if (d->centerOnItem && qAbs(d->verticalVelocity) > d->velocityThreshold)
-        d->startTimer(); // continue scrolling
-
-    if (qAbs<qreal>(totalMovement.x()) < d->movementThreshold && qAbs<qreal>(totalMovement.y()) < d->movementThreshold)
+    QPointF dp = event->pos() - event->buttonDownPos(event->button());
+    qreal totalMovement = (d->view->orientation() == Qt::Horizontal ? dp.x() : dp.y());
+
+    if (qAbs<qreal>(totalMovement) > d->movementThreshold) {
+        setScrollVelocity(d->movement / dt); // start kinetic scrolling
+    } else {
+        qreal offset = (d->view->orientation() == Qt::Horizontal ? d->view->horizontalOffset() : d->view->verticalOffset());
+        qreal maximumOffset = (d->view->orientation() == Qt::Horizontal ? d->view->maximumHorizontalOffset() : d->view->maximumVerticalOffset());
+        if (offset < 0 || offset > maximumOffset)
+            d->startTimer(); // start bounce-back
+        else if (d->centerOnItem && qAbs(d->scrollVelocity) > d->velocityThreshold)
+            d->startTimer(); // continue scrolling
+    }
+
+    if (qAbs<qreal>(totalMovement) < d->movementThreshold)
         return QtListController::mouseReleaseEvent(event, transform);
 
     return true;
@@ -395,12 +343,11 @@ bool QtKineticListController::mouseReleaseEvent(QGraphicsSceneMouseEvent *event,
  */
 bool QtKineticListController::wheelEvent(QGraphicsSceneWheelEvent *event, const QTransform &transform)
 {
-    Q_UNUSED(transform); // ###
+    Q_ASSERT(event);
+    Q_UNUSED(transform);
     Q_D(QtKineticListController);
-    if (event->orientation() == Qt::Horizontal)
-        setHorizontalScrollVelocity(d->horizontalVelocity - event->delta()/8.);
-    if (event->orientation() == Qt::Vertical)
-        setVerticalScrollVelocity(d->verticalVelocity - event->delta()/8.);
+    if (d->view && d->view->orientation() == event->orientation())
+        setScrollVelocity(d->scrollVelocity - event->delta() / 8.);
     return true;
 }
 
@@ -411,9 +358,7 @@ void QtKineticListController::timerEvent(QTimerEvent *event)
 {
     Q_D(QtKineticListController);
     if (event->timerId() == d->timerId) {
-        bool h = d->updateHorizontalOffset();
-        bool v = d->updateVerticalOffset();
-        if (!h && !v) {
+        if (!d->updateOffset()) {
             killTimer(d->timerId);
             d->timerId = 0;
         }
diff --git a/src/experimental/qkineticlistcontroller.h b/src/experimental/qkineticlistcontroller.h
index 34bdec4..f892d61 100644
--- a/src/experimental/qkineticlistcontroller.h
+++ b/src/experimental/qkineticlistcontroller.h
@@ -36,31 +36,23 @@ class QtKineticListControllerPrivate;
 class Q_ITEMVIEWSNG_EXPORT QtKineticListController : public QtListController
 {
     Q_OBJECT
-    Q_PROPERTY(qreal horizontalScrollVelocity READ horizontalScrollVelocity WRITE setHorizontalScrollVelocity)
-    Q_PROPERTY(qreal verticalScrollVelocity READ verticalScrollVelocity WRITE setVerticalScrollVelocity)
+    Q_PROPERTY(qreal scrollVelocity READ scrollVelocity WRITE setScrollVelocity)
     Q_PROPERTY(qreal maximumScrollVelocity READ maximumScrollVelocity WRITE setMaximumScrollVelocity)
-    Q_PROPERTY(bool horizontalOvershootEnabled READ isHorizontalOvershootEnabled WRITE setHorizontalOvershootEnabled)
-    Q_PROPERTY(bool verticalOvershootEnabled READ isVerticalOvershootEnabled WRITE setVerticalOvershootEnabled)
+    Q_PROPERTY(bool overshootEnabled READ isOvershootEnabled WRITE setOvershootEnabled)
     Q_PROPERTY(bool centerOnItemEnabled READ isCenterOnItemEnabled WRITE setCenterOnItemEnabled)
 
 public:
     QtKineticListController(QObject *parent = 0);
     virtual ~QtKineticListController();
 
-    void setHorizontalScrollVelocity(qreal velocity);
-    qreal horizontalScrollVelocity() const;
-
-    void setVerticalScrollVelocity(qreal velocity);
-    qreal verticalScrollVelocity() const;
+    void setScrollVelocity(qreal velocity);
+    qreal scrollVelocity() const;
 
     void setMaximumScrollVelocity(qreal velocity);
     qreal maximumScrollVelocity() const;
 
-    void setHorizontalOvershootEnabled(bool enable);
-    bool isHorizontalOvershootEnabled() const;
-
-    void setVerticalOvershootEnabled(bool enable);
-    bool isVerticalOvershootEnabled() const;
+    void setOvershootEnabled(bool enable);
+    bool isOvershootEnabled() const;
 
     void setCenterOnItemEnabled(bool enable);
     bool isCenterOnItemEnabled() const;
diff --git a/src/experimental/qkineticlistcontroller_p.h b/src/experimental/qkineticlistcontroller_p.h
index 53e9dff..296ca15 100644
--- a/src/experimental/qkineticlistcontroller_p.h
+++ b/src/experimental/qkineticlistcontroller_p.h
@@ -49,19 +49,8 @@ public:
     QtKineticListControllerPrivate();
     ~QtKineticListControllerPrivate();
 
-    inline qreal horizontalOffset() const { return view ? view->horizontalOffset() : 0.; }
-    inline qreal verticalOffset() const { return view ? view->verticalOffset() : 0.; }
-
-    inline qreal maximumHorizontalOffset() const { return view ? view->maximumHorizontalOffset() : 0.; }
-    inline qreal maximumVerticalOffset() const { return view ? view->maximumVerticalOffset() : 0.; }
-
-    void setHorizontalOffset(qreal offset, qreal max);
-    void setVerticalOffset(qreal offset, qreal max);
-
-    bool updateHorizontalOffset();
-    bool updateVerticalOffset();
-
-    bool kineticUpdateOffset(qreal *offset, qreal *velocity, qreal max, bool overshoot);
+    bool updateOffset();
+    bool kineticUpdateOffset(qreal *offset, qreal max);
     
     void startTimer();
     int currentTime() const;
@@ -70,20 +59,18 @@ public:
     int timerId;
     int timerInterval;
     int timestamp;
-    qreal horizontalVelocity;
-    qreal verticalVelocity;
+    qreal scrollVelocity;
     qreal maximumScrollVelocity;
     qreal frictionFactor;
     qreal velocityThreshold;
 
     // user movement
     int timeDelta;
-    QPointF movement;
+    qreal movement;
     qreal movementThreshold;
 
     // bounceback
-    bool horizontalOvershoot;
-    bool verticalOvershoot;
+    bool overshoot;
     bool centerOnItem;
 };