QScroller merge, part 1

This merge consists of the actual kinetic scroller implementation, its
autotests plus a few examples.  QAbstractScrollArea and QAbstractItemView
have been extended to support the new scroll events.

The complete history is in
http://scm.dev.nokia.troll.no/projects/qt/repos/rgriebls-qt-flickgesture/logs/4.7-flickgesture

(part 2 is the QML Flickable replacement / part 3 is QWebView support)

Task-number: QTBUG-9054
Reviewed-by: Ralf Engels

3 files changed, 293 insertions, 0 deletions

diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index 5633cb8..422aeeb 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -4568,4 +4568,223 @@ const QGestureEventPrivate *QGestureEvent::d_func() const
 
 #endif // QT_NO_GESTURES
 
+/*!
+    \class QScrollPrepareEvent
+    \since 4.8
+    \ingroup events
+
+    \brief The QScrollPrepareEvent class is send in preparation of a scrolling.
+
+    The scroll prepare event is send before scrolling (usually by QScroller) is started.
+    The object receiving this event should set viewportSize, maxContentPos and contentPos.
+    It also should accept this event to indicate that scrolling should be started.
+
+    It is not guaranteed that a QScrollEvent will be send after an acceepted
+    QScrollPrepareEvent, e.g. in a case where the maximum content position is (0,0).
+
+    \sa QScrollEvent, QScroller
+*/
+
+/*!
+    Creates new QScrollPrepareEvent
+    The \a startPos is the position of a touch or mouse event that started the scrolling.
+*/
+QScrollPrepareEvent::QScrollPrepareEvent(const QPointF &startPos)
+    : QEvent(QEvent::ScrollPrepare)
+{
+    d = reinterpret_cast<QEventPrivate *>(new QScrollPrepareEventPrivate());
+    d_func()->startPos = startPos;
+}
+
+/*!
+    Destroys QScrollEvent.
+*/
+QScrollPrepareEvent::~QScrollPrepareEvent()
+{
+    delete reinterpret_cast<QScrollPrepareEventPrivate *>(d);
+}
+
+/*!
+    Returns the position of the touch or mouse event that started the scrolling.
+*/
+QPointF QScrollPrepareEvent::startPos() const
+{
+    return d_func()->startPos;
+}
+
+/*!
+    Returns size of the area that is to be scrolled as set by setViewportSize
+
+    \sa setViewportSize()
+*/
+QSizeF QScrollPrepareEvent::viewportSize() const
+{
+    return d_func()->viewportSize;
+}
+
+/*!
+    Returns the range of coordinates for the content as set by setContentPosRange().
+*/
+QRectF QScrollPrepareEvent::contentPosRange() const
+{
+    return d_func()->contentPosRange;
+}
+
+/*!
+    Returns the current position of the content as set by setContentPos.
+*/
+QPointF QScrollPrepareEvent::contentPos() const
+{
+    return d_func()->contentPos;
+}
+
+
+/*!
+    Sets the size of the area that is to be scrolled to \a size.
+
+    \sa viewportSize()
+*/
+void QScrollPrepareEvent::setViewportSize(const QSizeF &size)
+{
+    d_func()->viewportSize = size;
+}
+
+/*!
+    Sets the range of content coordinates to \a rect.
+
+    \sa contentPosRange()
+*/
+void QScrollPrepareEvent::setContentPosRange(const QRectF &rect)
+{
+    d_func()->contentPosRange = rect;
+}
+
+/*!
+    Sets the current content position to \a pos.
+
+    \sa contentPos()
+*/
+void QScrollPrepareEvent::setContentPos(const QPointF &pos)
+{
+    d_func()->contentPos = pos;
+}
+
+
+/*!
+    \internal
+*/
+QScrollPrepareEventPrivate *QScrollPrepareEvent::d_func()
+{
+    return reinterpret_cast<QScrollPrepareEventPrivate *>(d);
+}
+
+/*!
+    \internal
+*/
+const QScrollPrepareEventPrivate *QScrollPrepareEvent::d_func() const
+{
+    return reinterpret_cast<const QScrollPrepareEventPrivate *>(d);
+}
+
+/*!
+    \class QScrollEvent
+    \since 4.8
+    \ingroup events
+
+    \brief The QScrollEvent class is send when scrolling.
+
+    The scroll event is send to indicate that the receiver should be scrolled.
+    Usually the receiver should be something visual like QWidget or QGraphicsObject.
+
+    Some care should be taken that no conflicting QScrollEvents are sent from two
+    sources. Using QScroller::scrollTo is save however.
+
+    \sa QScrollPrepareEvent, QScroller
+*/
+
+/*!
+    \enum QScrollEvent::ScrollState
+
+    This enum describes the states a scroll event can have.
+
+    \value ScrollStarted Set for the first scroll event of a scroll activity.
+
+    \value ScrollUpdated Set for all but the first and the last scroll event of a scroll activity.
+
+    \value ScrollFinished Set for the last scroll event of a scroll activity.
+
+    \sa QScrollEvent::scrollState()
+*/
+
+/*!
+    Creates a new QScrollEvent
+    \a contentPos is the new content position, \a overshootDistance is the
+    new overshoot distance while \a scrollState indicates if this scroll
+    event is the first one, the last one or some event in between.
+*/
+QScrollEvent::QScrollEvent(const QPointF &contentPos, const QPointF &overshootDistance, ScrollState scrollState)
+    : QEvent(QEvent::Scroll)
+{
+    d = reinterpret_cast<QEventPrivate *>(new QScrollEventPrivate());
+    d_func()->contentPos = contentPos;
+    d_func()->overshoot= overshootDistance;
+    d_func()->state = scrollState;
+}
+
+/*!
+    Destroys QScrollEvent.
+*/
+QScrollEvent::~QScrollEvent()
+{
+    delete reinterpret_cast<QScrollEventPrivate *>(d);
+}
+
+/*!
+    Returns the new scroll position.
+*/
+QPointF QScrollEvent::contentPos() const
+{
+    return d_func()->contentPos;
+}
+
+/*!
+    Returns the new overshoot distance.
+    See QScroller for an explanation of the term overshoot.
+
+    \sa QScroller
+*/
+QPointF QScrollEvent::overshootDistance() const
+{
+    return d_func()->overshoot;
+}
+
+/*!
+    Returns the current scroll state as a combination of ScrollStateFlag values.
+    ScrollStarted (or ScrollFinished) will be set, if this scroll event is the first (or last) event in a scrolling activity.
+    Please note that both values can be set at the same time, if the activity consists of a single QScrollEvent.
+    All other scroll events in between will have their state set to ScrollUpdated.
+
+    A widget could for example revert selections when scrolling is started and stopped.
+*/
+QScrollEvent::ScrollState QScrollEvent::scrollState() const
+{
+    return d_func()->state;
+}
+
+/*!
+    \internal
+*/
+QScrollEventPrivate *QScrollEvent::d_func()
+{
+    return reinterpret_cast<QScrollEventPrivate *>(d);
+}
+
+/*!
+    \internal
+*/
+const QScrollEventPrivate *QScrollEvent::d_func() const
+{
+    return reinterpret_cast<const QScrollEventPrivate *>(d);
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index 9c70c02..6c0076d 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -880,6 +880,52 @@ private:
 };
 #endif // QT_NO_GESTURES
 
+class QScrollPrepareEventPrivate;
+class Q_GUI_EXPORT QScrollPrepareEvent : public QEvent
+{
+public:
+    QScrollPrepareEvent(const QPointF &startPos);
+    ~QScrollPrepareEvent();
+
+    QPointF startPos() const;
+
+    QSizeF viewportSize() const;
+    QRectF contentPosRange() const;
+    QPointF contentPos() const;
+
+    void setViewportSize(const QSizeF &size);
+    void setContentPosRange(const QRectF &rect);
+    void setContentPos(const QPointF &pos);
+
+private:
+    QScrollPrepareEventPrivate *d_func();
+    const QScrollPrepareEventPrivate *d_func() const;
+};
+
+
+class QScrollEventPrivate;
+class Q_GUI_EXPORT QScrollEvent : public QEvent
+{
+public:
+    enum ScrollState
+    {
+        ScrollStarted,
+        ScrollUpdated,
+        ScrollFinished
+    };
+
+    QScrollEvent(const QPointF &contentPos, const QPointF &overshoot, ScrollState scrollState);
+    ~QScrollEvent();
+
+    QPointF contentPos() const;
+    QPointF overshootDistance() const;
+    ScrollState scrollState() const;
+
+private:
+    QScrollEventPrivate *d_func();
+    const QScrollEventPrivate *d_func() const;
+};
+
 QT_END_NAMESPACE
 
 QT_END_HEADER
diff --git a/src/gui/kernel/qevent_p.h b/src/gui/kernel/qevent_p.h
index e323aa9..02f41e7 100644
--- a/src/gui/kernel/qevent_p.h
+++ b/src/gui/kernel/qevent_p.h
@@ -178,6 +178,34 @@ public:
     QUrl url;
 };
 
+
+class QScrollPrepareEventPrivate
+{
+public:
+    inline QScrollPrepareEventPrivate()
+        : target(0)
+    {
+    }
+
+    QObject* target;
+    QPointF startPos;
+    QSizeF viewportSize;
+    QRectF contentPosRange;
+    QPointF contentPos;
+};
+
+class QScrollEventPrivate
+{
+public:
+    inline QScrollEventPrivate()
+    {
+    }
+
+    QPointF contentPos;
+    QPointF overshoot;
+    QScrollEvent::ScrollState state;
+};
+
 QT_END_NAMESPACE
 
 #endif // QEVENT_P_H