A new implementation of the Gesture API.

Implemented gestures using gesture events and separate
QGesture/QGestureRecognizer classes.

Reviewed-by: trustme

23 files changed, 1740 insertions, 1217 deletions

diff --git a/src/gui/kernel/kernel.pri b/src/gui/kernel/kernel.pri
index 760d73c..88c1f73 100644
--- a/src/gui/kernel/kernel.pri
+++ b/src/gui/kernel/kernel.pri
@@ -45,10 +45,11 @@ HEADERS += \
 	kernel/qkeymapper_p.h \
 	kernel/qgesture.h \
 	kernel/qgesture_p.h \
-	kernel/qstandardgestures.h \
-        kernel/qstandardgestures_p.h \
-        kernel/qsoftkeymanager_p.h \
-        kernel/qguiplatformplugin_p.h
+	kernel/qstandardgestures_p.h \
+	kernel/qgesturerecognizer.h \
+	kernel/qgesturemanager_p.h \
+	kernel/qsoftkeymanager_p.h \
+	kernel/qguiplatformplugin_p.h
 
 SOURCES += \
 	kernel/qaction.cpp \
@@ -79,13 +80,18 @@ SOURCES += \
 	kernel/qwidgetaction.cpp \
 	kernel/qkeymapper.cpp \
 	kernel/qgesture.cpp \
-        kernel/qstandardgestures.cpp \
-        kernel/qsoftkeymanager.cpp \
-        kernel/qguiplatformplugin.cpp
+	kernel/qstandardgestures.cpp \
+	kernel/qgesturerecognizer.cpp \
+	kernel/qgesturemanager.cpp \
+	kernel/qsoftkeymanager.cpp \
+	kernel/qguiplatformplugin.cpp
 
 win32 {
 	DEFINES += QT_NO_DIRECTDRAW
 
+        HEADERS += \
+                kernel/qwinnativepangesturerecognizer_win_p.h
+
 	SOURCES += \
 		kernel/qapplication_win.cpp \
 		kernel/qclipboard_win.cpp \
@@ -96,7 +102,8 @@ win32 {
 		kernel/qsound_win.cpp \
 		kernel/qwidget_win.cpp \
 		kernel/qole_win.cpp \
-		kernel/qkeymapper_win.cpp
+                kernel/qkeymapper_win.cpp \
+                kernel/qwinnativepangesturerecognizer_win.cpp
 
         !contains(DEFINES, QT_NO_DIRECTDRAW):LIBS += ddraw.lib
 }
diff --git a/src/gui/kernel/qapplication.cpp b/src/gui/kernel/qapplication.cpp
index 43addb6..afc6f63 100644
--- a/src/gui/kernel/qapplication.cpp
+++ b/src/gui/kernel/qapplication.cpp
@@ -99,6 +99,9 @@
 
 #include "qapplication.h"
 
+#include "qgesture.h"
+#include "private/qgesturemanager_p.h"
+
 #ifndef QT_NO_LIBRARY
 #include "qlibrary.h"
 #endif
@@ -154,6 +157,14 @@ bool QApplicationPrivate::autoSipEnabled = false;
 bool QApplicationPrivate::autoSipEnabled = true;
 #endif
 
+QGestureManager* QGestureManager::instance()
+{
+    QApplicationPrivate *d = qApp->d_func();
+    if (!d->gestureManager)
+        d->gestureManager = new QGestureManager(qApp);
+    return d->gestureManager;
+}
+
 QApplicationPrivate::QApplicationPrivate(int &argc, char **argv, QApplication::Type type)
     : QCoreApplicationPrivate(argc, argv)
 {
@@ -177,6 +188,8 @@ QApplicationPrivate::QApplicationPrivate(int &argc, char **argv, QApplication::T
     directPainters = 0;
 #endif
 
+    gestureManager = 0;
+
     if (!self)
         self = this;
 }
@@ -3632,6 +3645,13 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
 #endif // !QT_NO_WHEELEVENT || !QT_NO_TABLETEVENT
     }
 
+    // walk through parents and check for gestures
+    if (d->gestureManager) {
+        if (d->gestureManager->filterEvent(receiver, e))
+            return true;
+    }
+
+
     // User input and window activation makes tooltips sleep
     switch (e->type()) {
     case QEvent::Wheel:
@@ -4133,6 +4153,65 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
         }
         break;
     }
+    case QEvent::Gesture:
+    case QEvent::GestureOverride:
+    {
+        if (receiver->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(receiver);
+            QGestureEvent *gestureEvent = static_cast<QGestureEvent *>(e);
+            QList<QGesture *> allGestures = gestureEvent->allGestures();
+
+            bool eventAccepted = gestureEvent->isAccepted();
+            bool wasAccepted = eventAccepted;
+            while (w) {
+                // send only gestures the widget expects
+                QList<QGesture *> gestures;
+                QWidgetPrivate *wd = w->d_func();
+                for (int i = 0; i < allGestures.size();) {
+                    QGesture *g = allGestures.at(i);
+                    Qt::GestureType type = g->gestureType();
+                    if (wd->gestureContext.contains(type)) {
+                        allGestures.removeAt(i);
+                        gestures.append(g);
+                        gestureEvent->setAccepted(g, false);
+                    } else {
+                        ++i;
+                    }
+                }
+                if (!gestures.isEmpty()) {
+                    QGestureEvent ge(gestures);
+                    ge.t = gestureEvent->t;
+                    ge.spont = gestureEvent->spont;
+                    ge.m_accept = wasAccepted;
+                    res = d->notify_helper(w, &ge);
+                    gestureEvent->spont = false;
+                    eventAccepted = ge.isAccepted();
+                    if (res && eventAccepted)
+                        break;
+                    if (!eventAccepted) {
+                        // ### two ways to ignore the event/gesture
+
+                        // if the whole event wasn't accepted, put back those
+                        // gestures that were not accepted.
+                        for (int i = 0; i < gestures.size(); ++i) {
+                            QGesture *g = gestures.at(i);
+                            if (!ge.isAccepted(g))
+                                allGestures.append(g);
+                        }
+                    }
+                }
+                if (allGestures.isEmpty())
+                    break;
+                if (w->isWindow())
+                    break;
+                w = w->parentWidget();
+            }
+            gestureEvent->m_accept = eventAccepted;
+        } else {
+            res = d->notify_helper(receiver, e);
+        }
+        break;
+    }
     default:
         res = d->notify_helper(receiver, e);
         break;
@@ -5540,6 +5619,16 @@ Q_GUI_EXPORT void qt_translateRawTouchEvent(QWidget *window,
     QApplicationPrivate::translateRawTouchEvent(window, deviceType, touchPoints);
 }
 
+Qt::GestureType QApplication::registerGestureRecognizer(QGestureRecognizer *recognizer)
+{
+    return QGestureManager::instance()->registerGestureRecognizer(recognizer);
+}
+
+void QApplication::unregisterGestureRecognizer(Qt::GestureType type)
+{
+    QGestureManager::instance()->unregisterGestureRecognizer(type);
+}
+
 QT_END_NAMESPACE
 
 #include "moc_qapplication.cpp"
diff --git a/src/gui/kernel/qapplication.h b/src/gui/kernel/qapplication.h
index 5f21a56..12b398d 100644
--- a/src/gui/kernel/qapplication.h
+++ b/src/gui/kernel/qapplication.h
@@ -86,6 +86,7 @@ class QDecoration;
 
 class QApplication;
 class QApplicationPrivate;
+class QGestureRecognizer;
 #if defined(qApp)
 #undef qApp
 #endif
@@ -289,6 +290,9 @@ public:
     static Qt::NavigationMode navigationMode();
 #endif
 
+    Qt::GestureType registerGestureRecognizer(QGestureRecognizer *recognizer);
+    void unregisterGestureRecognizer(Qt::GestureType type);
+
 Q_SIGNALS:
     void lastWindowClosed();
     void focusChanged(QWidget *old, QWidget *now);
@@ -400,6 +404,7 @@ private:
     friend class QDirectPainter;
     friend class QDirectPainterPrivate;
 #endif
+    friend class QGestureManager;
 
 #if defined(Q_WS_MAC) || defined(Q_WS_X11)
     Q_PRIVATE_SLOT(d_func(), void _q_alertTimeOut())
diff --git a/src/gui/kernel/qapplication_p.h b/src/gui/kernel/qapplication_p.h
index 95b6d28..2d3d18c 100644
--- a/src/gui/kernel/qapplication_p.h
+++ b/src/gui/kernel/qapplication_p.h
@@ -83,8 +83,8 @@ class QGraphicsSystem;
 class QInputContext;
 class QObject;
 class QWidget;
-class QGestureManager;
 class QSocketNotifier;
+class QGestureManager;
 
 extern bool qt_is_gui_used;
 #ifndef QT_NO_CLIPBOARD
@@ -265,20 +265,6 @@ typedef struct tagGESTURECONFIG
 
 #endif // Q_WS_WIN
 
-class QPanGesture;
-class QPinchGesture;
-class QSwipeGesture;
-
-struct QStandardGestures
-{
-    QPanGesture *pan;
-    QPinchGesture *pinch;
-    QSwipeGesture *swipe;
-
-    QStandardGestures() : pan(0), pinch(0), swipe(0) { }
-};
-
-
 class QScopedLoopLevelCounter
 {
     QThreadData *threadData;
@@ -522,6 +508,8 @@ public:
     void sendSyntheticEnterLeave(QWidget *widget);
 #endif
 
+    QGestureManager *gestureManager;
+
     QMap<int, QWidget *> widgetForTouchPointId;
     QMap<int, QTouchEvent::TouchPoint> appCurrentTouchPoints;
     static void updateTouchPointsForWidget(QWidget *widget, QTouchEvent *touchEvent);
@@ -536,9 +524,6 @@ public:
                                        QTouchEvent::DeviceType deviceType,
                                        const QList<QTouchEvent::TouchPoint> &touchPoints);
 
-    typedef QMap<QWidget*, QStandardGestures> WidgetStandardGesturesMap;
-    WidgetStandardGesturesMap widgetGestures;
-
 #if defined(Q_WS_WIN)
     static PtrRegisterTouchWindow RegisterTouchWindow;
     static PtrGetTouchInputInfo GetTouchInputInfo;
@@ -555,7 +540,6 @@ public:
     PtrBeginPanningFeedback BeginPanningFeedback;
     PtrUpdatePanningFeedback UpdatePanningFeedback;
     PtrEndPanningFeedback EndPanningFeedback;
-    QWidget *gestureWidget;
 #endif
 
 #ifdef QT_RX71_MULTITOUCH
diff --git a/src/gui/kernel/qapplication_win.cpp b/src/gui/kernel/qapplication_win.cpp
index 270562f..540f0a2 100644
--- a/src/gui/kernel/qapplication_win.cpp
+++ b/src/gui/kernel/qapplication_win.cpp
@@ -92,8 +92,6 @@ extern void qt_wince_hide_taskbar(HWND hwnd); //defined in qguifunctions_wince.c
 #include <private/qkeymapper_p.h>
 #include <private/qlocale_p.h>
 #include "qevent_p.h"
-#include "qstandardgestures.h"
-#include "qstandardgestures_p.h"
 
 //#define ALIEN_DEBUG
 
@@ -854,7 +852,6 @@ void qt_init(QApplicationPrivate *priv, int)
         (PtrEndPanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
                                                    "EndPanningFeedback");
 #endif
-    priv->gestureWidget = 0;
 }
 
 /*****************************************************************************
@@ -2499,24 +2496,24 @@ LRESULT CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam
             if (qAppPriv->GetGestureInfo)
                 bResult = qAppPriv->GetGestureInfo((HANDLE)msg.lParam, &gi);
             if (bResult) {
-                if (gi.dwID == GID_BEGIN) {
-                    // find the alien widget for the gesture position.
-                    // This might not be accurate as the position is the center
-                    // point of two fingers for multi-finger gestures.
-                    QPoint pt(gi.ptsLocation.x, gi.ptsLocation.y);
-                    QWidget *w = widget->childAt(widget->mapFromGlobal(pt));
-                    qAppPriv->gestureWidget = w ? w : widget;
-                }
-                if (qAppPriv->gestureWidget)
-                    static_cast<QETWidget*>(qAppPriv->gestureWidget)->translateGestureEvent(msg, gi);
-                if (qAppPriv->CloseGestureInfoHandle)
-                    qAppPriv->CloseGestureInfoHandle((HANDLE)msg.lParam);
-                if (gi.dwID == GID_END)
-                    qAppPriv->gestureWidget = 0;
-            } else {
-                DWORD dwErr = GetLastError();
-                if (dwErr > 0)
-                    qWarning() << "translateGestureEvent: error = " << dwErr;
+//                if (gi.dwID == GID_BEGIN) {
+//                    // find the alien widget for the gesture position.
+//                    // This might not be accurate as the position is the center
+//                    // point of two fingers for multi-finger gestures.
+//                    QPoint pt(gi.ptsLocation.x, gi.ptsLocation.y);
+//                    QWidget *w = widget->childAt(widget->mapFromGlobal(pt));
+//                    qAppPriv->gestureWidget = w ? w : widget;
+//                }
+//                if (qAppPriv->gestureWidget)
+//                    static_cast<QETWidget*>(qAppPriv->gestureWidget)->translateGestureEvent(msg, gi);
+//                if (qAppPriv->CloseGestureInfoHandle)
+//                    qAppPriv->CloseGestureInfoHandle((HANDLE)msg.lParam);
+//                if (gi.dwID == GID_END)
+//                    qAppPriv->gestureWidget = 0;
+//            } else {
+//                DWORD dwErr = GetLastError();
+//                if (dwErr > 0)
+//                    qWarning() << "translateGestureEvent: error = " << dwErr;
             }
             result = true;
             break;
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index 7b9cc9a..4316714 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -49,6 +49,8 @@
 #include "qmime.h"
 #include "qdnd_p.h"
 #include "qevent_p.h"
+#include "qgesture.h"
+#include "qgesture_p.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -3357,6 +3359,9 @@ QDebug operator<<(QDebug dbg, const QEvent *e) {
     case QEvent::ChildRemoved: n = n ? n : "ChildRemoved";
         dbg.nospace() << "QChildEvent(" << n << ", " << (static_cast<const QChildEvent*>(e))->child();
         return dbg.space();
+    case QEvent::Gesture:
+        n = "Gesture";
+        break;
     default:
         dbg.nospace() << "QEvent(" << (const void *)e << ", type = " << e->type() << ')';
         return dbg.space();
@@ -4186,4 +4191,73 @@ QTouchEvent::TouchPoint &QTouchEvent::TouchPoint::operator=(const QTouchEvent::T
     return *this;
 }
 
+/*!
+    \class QGestureEvent
+    \since 4.6
+    \ingroup events
+
+    \brief The QGestureEvent class provides the description of triggered
+    gestures.
+
+    The QGestureEvent class contains a list of gestures that are being executed
+    right now (\l{QGestureEvent::}{activeGestures()}) and a list of gestures
+    that are \l{QGestureEvent::canceledGestures}{cancelled} (a gesture might be
+    cancelled because the window lost focus, or because of timeout, etc).
+
+    \sa QGesture
+*/
+
+/*!
+    Creates new QGestureEvent containing a list of \a gestures.
+*/
+QGestureEvent::QGestureEvent(const QList<QGesture*> &gestures)
+    : QEvent(QEvent::Gesture), gestures_(gestures)
+{
+}
+
+QList<QGesture*> QGestureEvent::allGestures() const
+{
+    return gestures_;
+}
+
+QGesture* QGestureEvent::gesture(Qt::GestureType type)
+{
+    for(int i = 0; i < gestures_.size(); ++i)
+        if (gestures_.at(i)->gestureType() == type)
+            return gestures_.at(i);
+    return 0;
+}
+
+QList<QGesture*> QGestureEvent::activeGestures() const
+{
+    return gestures_;
+}
+
+QList<QGesture*> QGestureEvent::canceledGestures() const
+{
+    return gestures_;
+}
+
+void QGestureEvent::setAccepted(QGesture *gesture, bool value)
+{
+    setAccepted(false);
+    if (gesture)
+        gesture->d_func()->accept = value;
+}
+
+void QGestureEvent::accept(QGesture *gesture)
+{
+    setAccepted(gesture, true);
+}
+
+void QGestureEvent::ignore(QGesture *gesture)
+{
+    setAccepted(gesture, false);
+}
+
+bool QGestureEvent::isAccepted(QGesture *gesture) const
+{
+    return gesture ? gesture->d_func()->accept : false;
+}
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index 4396766..224b479 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -819,6 +819,40 @@ protected:
     friend class QApplicationPrivate;
 };
 
+class QGesture;
+class Q_GUI_EXPORT QGestureEvent : public QEvent
+{
+public:
+    QGestureEvent(const QList<QGesture *> &gestures);
+
+    QList<QGesture *> allGestures() const;
+    QGesture *gesture(Qt::GestureType type);
+
+    QList<QGesture *> activeGestures() const;
+    QList<QGesture *> canceledGestures() const;
+
+#ifdef Q_NO_USING_KEYWORD
+    inline void setAccepted(bool accepted) { QEvent::setAccepted(accepted); }
+    inline bool isAccepted() const { return QEvent::isAccepted(); }
+
+    inline void accept() { QEvent::accept(); }
+    inline void ignore() { QEvent::ignore(); }
+#else
+    using QEvent::setAccepted;
+    using QEvent::isAccepted;
+    using QEvent::accept;
+    using QEvent::ignore;
+#endif
+
+    void setAccepted(QGesture *, bool);
+    void accept(QGesture *);
+    void ignore(QGesture *);
+    bool isAccepted(QGesture *) const;
+
+private:
+    QList<QGesture *> gestures_;
+};
+
 QT_END_NAMESPACE
 
 QT_END_HEADER
diff --git a/src/gui/kernel/qgesture.cpp b/src/gui/kernel/qgesture.cpp
index 237ce46..bb74aec 100644
--- a/src/gui/kernel/qgesture.cpp
+++ b/src/gui/kernel/qgesture.cpp
@@ -40,274 +40,290 @@
 ****************************************************************************/
 
 #include "qgesture.h"
-#include <private/qgesture_p.h>
-#include "qgraphicsitem.h"
+#include "private/qgesture_p.h"
 
 QT_BEGIN_NAMESPACE
 
+ /*!
+    \class QGesture
+    \since 4.6
 
-class QEventFilterProxyGraphicsItem : public QGraphicsItem
-{
-public:
-    QEventFilterProxyGraphicsItem(QGesture *g)
-            : gesture(g)
-    {
-    }
-    bool sceneEventFilter(QGraphicsItem *, QEvent *event)
-    {
-        return gesture ? gesture->filterEvent(event) : false;
-    }
-    QRectF boundingRect() const { return QRectF(); }
-    void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*) { }
+    \brief The QGesture class represents a gesture, containing all
+    properties that describe a gesture.
 
-private:
-    QGesture *gesture;
-};
+    The widget receives a QGestureEvent with a list of QGesture
+    objects that represent gestures that are occuring on it. The class
+    has a list of properties that can be queried by the user to get
+    some gesture-specific arguments (i.e. position of the tap in the
+    DoubleTap gesture).
 
-/*!
-    \class QGesture
-    \since 4.6
-    \preliminary
-
-    \brief The QGesture class is the base class for implementing custom
-    gestures.
-
-    This class represents both an object that recognizes a gesture out of a set
-    of input events (a gesture recognizer), and a gesture object itself that
-    can be used to get extended information about the triggered gesture.
-
-    The class has a list of properties that can be queried by the user to get
-    some gesture-specific parameters (for example, an offset of a Pan gesture).
-
-    Usually gesture recognizer implements a state machine, storing its state
-    internally in the recognizer object. The recognizer receives input events
-    through the \l{QGesture::}{filterEvent()} virtual function and decides
-    whether the event should change the state of the recognizer by emitting an
-    appropriate signal.
-
-    Input events should be either fed to the recognizer one by one with a
-    filterEvent() function, or the gesture recognizer should be attached to an
-    object it filters events for by specifying it as a parent object. The
-    QGesture object installs itself as an event filter to the parent object
-    automatically, the unsetObject() function should be used to remove an event
-    filter from the parent object. To make a
-    gesture that operates on a QGraphicsItem, both the appropriate QGraphicsView
-    should be passed as a parent object and setGraphicsItem() functions should
-    be used to attach a gesture to a graphics item.
-
-    This is a base class, to create a custom gesture type, you should subclass
-    it and implement its pure virtual functions.
-
-    \sa QPanGesture
+    When creating custom gesture recognizers, they might add new
+    properties to the gesture object, or custom gesture developers
+    might subclass the QGesture objects to provide some extended
+    information.
+
+    \sa QGestureEvent, QGestureRecognizer
 */
 
-/*! \fn bool QGesture::filterEvent(QEvent *event)
+QGesture::QGesture(Qt::GestureType type, QObject *parent)
+    : QObject(*new QGesturePrivate, parent)
+{
+    d_func()->gestureType = type;
+}
 
-    Parses input \a event and emits a signal when detects a gesture.
+QGesture::QGesture(QObject *parent)
+    : QObject(*new QGesturePrivate, parent)
+{
+    d_func()->gestureType = Qt::CustomGesture;
+}
 
-    In your reimplementation of this function, if you want to filter the \a
-    event out, i.e. stop it being handled further, return true; otherwise
-    return false;
+QGesture::QGesture(QGesturePrivate &dd, Qt::GestureType type, QObject *parent)
+    : QObject(dd, parent)
+{
+    d_func()->gestureType = type;
+}
 
-    This is a pure virtual function that needs to be implemented in subclasses.
-*/
+QGesture::~QGesture()
+{
+}
 
-/*! \fn void QGesture::started()
+Qt::GestureType QGesture::gestureType() const
+{
+    return d_func()->gestureType;
+}
 
-    The signal is emitted when the gesture is started. Extended information
-    about the gesture is contained in the signal sender object.
+Qt::GestureState QGesture::state() const
+{
+    return d_func()->state;
+}
 
-    In addition to started(), a triggered() signal should also be emitted.
-*/
+QObject* QGesture::targetObject() const
+{
+    return d_func()->targetObject;
+}
 
-/*! \fn void QGesture::triggered()
+void QGesture::setTargetObject(QObject *value)
+{
+    d_func()->targetObject = value;
+}
 
-    The signal is emitted when the gesture is detected. Extended information
-    about the gesture is contained in the signal sender object.
-*/
+QPointF QGesture::hotSpot() const
+{
+    return d_func()->hotSpot;
+}
 
-/*! \fn void QGesture::finished()
+void QGesture::setHotSpot(const QPointF &value)
+{
+    Q_D(QGesture);
+    d->hotSpot = value;
+    d->isHotSpotSet = true;
+}
 
-    The signal is emitted when the gesture is finished. Extended information
-    about the gesture is contained in the signal sender object.
-*/
+bool QGesture::hasHotSpot() const
+{
+    return d_func()->isHotSpotSet;
+}
 
-/*! \fn void QGesture::canceled()
+void QGesture::unsetHotSpot()
+{
+    d_func()->isHotSpotSet = false;
+}
 
-  The signal is emitted when the gesture is canceled, for example the
-  reset() function is called while the gesture was in the process of
-  emitting a triggered() signal.  Extended information about the
-  gesture is contained in the sender object.
-*/
+// QPanGesture
 
-/*!
-  Creates a new gesture handler object and marks it as a child of \a
-  parent.  \a gestureTarget is the object that the gesture will watch
-  for events.
+QPanGesture::QPanGesture(QObject *parent)
+    : QGesture(*new QPanGesturePrivate, Qt::PanGesture, parent)
+{
 
-  The \a parent object is also the default event source for the
-  gesture, meaning that the gesture installs itself as an event filter
-  for the \a parent.
+}
 
-  \sa setGraphicsItem()
-*/
-QGesture::QGesture(QObject *gestureTarget, QObject *parent)
-    : QObject(*new QGesturePrivate, parent)
+QSizeF QPanGesture::totalOffset() const
 {
-    setGestureTarget(gestureTarget);
+    return d_func()->totalOffset;
 }
 
-/*! \internal
- */
-QGesture::QGesture(QGesturePrivate &dd, QObject *gestureTarget, QObject *parent)
-    : QObject(dd, parent)
+QSizeF QPanGesture::lastOffset() const
 {
-    setGestureTarget(gestureTarget);
+    return d_func()->lastOffset;
 }
 
-/*!
-    Destroys the gesture object.
-*/
-QGesture::~QGesture()
+QSizeF QPanGesture::offset() const
 {
+    return d_func()->offset;
 }
 
-/*!
-    \property QGesture::gestureTarget
+qreal QPanGesture::acceleration() const
+{
+    return d_func()->acceleration;
+}
 
-    Gesture target is the object that the gesture will watch for events.
-    Typically this means that the gesture installs an event filter on the
-    target object.
-*/
-void QGesture::setGestureTarget(QObject *object)
+
+void QPanGesture::setTotalOffset(const QSizeF &value)
 {
-    d_func()->setupGestureTarget(object);
+    d_func()->totalOffset = value;
 }
 
-QObject* QGesture::gestureTarget() const
+void QPanGesture::setLastOffset(const QSizeF &value)
 {
-    return d_func()->gestureTarget;
+    d_func()->lastOffset = value;
 }
 
-void QGesturePrivate::setupGestureTarget(QObject *object)
+void QPanGesture::setOffset(const QSizeF &value)
 {
-    Q_Q(QGesture);
-    if (gestureTarget)
-        gestureTarget->removeEventFilter(q);
-    if (object)
-        object->installEventFilter(q);
-    gestureTarget = object;
+    d_func()->offset = value;
 }
 
-/*! \internal
- */
-bool QGesture::eventFilter(QObject *receiver, QEvent *event)
+void QPanGesture::setAcceleration(qreal value)
 {
-    Q_D(QGesture);
-    if (d->graphicsItem && receiver == parent())
-        return false;
-    return filterEvent(event);
+    d_func()->acceleration = value;
 }
 
-/*!
-    \property QGesture::state
+// QPinchGesture
 
-    \brief The current state of the gesture.
-*/
+QPinchGesture::QPinchGesture(QObject *parent)
+    : QGesture(*new QPinchGesturePrivate, Qt::PinchGesture, parent)
+{
 
-/*!
-  Returns the gesture recognition state.
- */
-Qt::GestureState QGesture::state() const
+}
+
+QPinchGesture::WhatChanged QPinchGesture::whatChanged() const
 {
-    return d_func()->state;
+    return d_func()->whatChanged;
 }
 
-/*!
-  Sets this gesture's recognition state to \a state and emits appropriate
-  signals.
+void QPinchGesture::setWhatChanged(QPinchGesture::WhatChanged value)
+{
+    d_func()->whatChanged = value;
+}
 
-  This functions emits the signals according to the old state and the new
-  \a state, and it should be called after all the internal properties have been
-  initialized.
 
-  \sa started(), triggered(), finished(), canceled()
- */
-void QGesture::updateState(Qt::GestureState state)
+QPointF QPinchGesture::startCenterPoint() const
 {
-    Q_D(QGesture);
-    if (d->state == state) {
-        if (state == Qt::GestureUpdated)
-            emit triggered();
-        return;
-    }
-    const Qt::GestureState oldState = d->state;
-    if (state != Qt::NoGesture && oldState > state) {
-        // comparing the state as ints: state should only be changed from
-        // started to (optionally) updated and to finished.
-        d->state = state;
-        qWarning("QGesture::updateState: incorrect new state");
-        return;
-    }
-    if (oldState == Qt::NoGesture) {
-        d->state = Qt::GestureStarted;
-        emit started();
-    }
-    d->state = state;
-    if (state == Qt::GestureUpdated)
-        emit triggered();
-    else if (state == Qt::GestureFinished)
-        emit finished();
-    else if (state == Qt::NoGesture)
-        emit canceled();
-
-    if (state == Qt::GestureFinished) {
-        // gesture is finished, so we reset the internal state.
-        d->state = Qt::NoGesture;
-    }
-}
-
-/*!
-    Sets the \a graphicsItem the gesture is filtering events for.
-
-    The gesture will install an event filter to the \a graphicsItem and
-    redirect them to the filterEvent() function.
-
-    \sa graphicsItem()
-*/
-void QGesture::setGraphicsItem(QGraphicsItem *graphicsItem)
+    return d_func()->startCenterPoint;
+}
+
+QPointF QPinchGesture::lastCenterPoint() const
 {
-    Q_D(QGesture);
-    if (d->graphicsItem && d->eventFilterProxyGraphicsItem)
-        d->graphicsItem->removeSceneEventFilter(d->eventFilterProxyGraphicsItem);
-    d->graphicsItem = graphicsItem;
-    if (!d->eventFilterProxyGraphicsItem)
-        d->eventFilterProxyGraphicsItem = new QEventFilterProxyGraphicsItem(this);
-    if (graphicsItem)
-        graphicsItem->installSceneEventFilter(d->eventFilterProxyGraphicsItem);
+    return d_func()->lastCenterPoint;
 }
 
-/*!
-    Returns the graphics item the gesture is filtering events for.
+QPointF QPinchGesture::centerPoint() const
+{
+    return d_func()->centerPoint;
+}
 
-    \sa setGraphicsItem()
-*/
-QGraphicsItem* QGesture::graphicsItem() const
+void QPinchGesture::setStartCenterPoint(const QPointF &value)
 {
-    return d_func()->graphicsItem;
+    d_func()->startCenterPoint = value;
 }
 
-/*! \fn void QGesture::reset()
+void QPinchGesture::setLastCenterPoint(const QPointF &value)
+{
+    d_func()->lastCenterPoint = value;
+}
 
-    Resets the internal state of the gesture. This function might be called by
-    the filterEvent() implementation in a derived class, or by the user to
-    cancel a gesture.  The base class implementation calls
-    updateState(Qt::NoGesture) which emits the canceled()
-    signal if the state() of the gesture indicated it was active.
-*/
-void QGesture::reset()
+void QPinchGesture::setCenterPoint(const QPointF &value)
+{
+    d_func()->centerPoint = value;
+}
+
+
+qreal QPinchGesture::totalScaleFactor() const
+{
+    return d_func()->totalScaleFactor;
+}
+
+qreal QPinchGesture::lastScaleFactor() const
+{
+    return d_func()->lastScaleFactor;
+}
+
+qreal QPinchGesture::scaleFactor() const
+{
+    return d_func()->scaleFactor;
+}
+
+void QPinchGesture::setTotalScaleFactor(qreal value)
+{
+    d_func()->totalScaleFactor = value;
+}
+
+void QPinchGesture::setLastScaleFactor(qreal value)
+{
+    d_func()->lastScaleFactor = value;
+}
+
+void QPinchGesture::setScaleFactor(qreal value)
+{
+    d_func()->scaleFactor = value;
+}
+
+
+qreal QPinchGesture::totalRotationAngle() const
+{
+    return d_func()->totalRotationAngle;
+}
+
+qreal QPinchGesture::lastRotationAngle() const
+{
+    return d_func()->lastRotationAngle;
+}
+
+qreal QPinchGesture::rotationAngle() const
+{
+    return d_func()->rotationAngle;
+}
+
+void QPinchGesture::setTotalRotationAngle(qreal value)
+{
+    d_func()->totalRotationAngle = value;
+}
+
+void QPinchGesture::setLastRotationAngle(qreal value)
+{
+    d_func()->lastRotationAngle = value;
+}
+
+void QPinchGesture::setRotationAngle(qreal value)
+{
+    d_func()->rotationAngle = value;
+}
+
+// QSwipeGesture
+
+QSwipeGesture::QSwipeGesture(QObject *parent)
+    : QGesture(*new QSwipeGesturePrivate, Qt::SwipeGesture, parent)
+{
+}
+
+QSwipeGesture::SwipeDirection QSwipeGesture::horizontalDirection() const
+{
+    return d_func()->horizontalDirection;
+}
+
+QSwipeGesture::SwipeDirection QSwipeGesture::verticalDirection() const
+{
+    return d_func()->verticalDirection;
+}
+
+void QSwipeGesture::setHorizontalDirection(QSwipeGesture::SwipeDirection value)
+{
+    d_func()->horizontalDirection = value;
+}
+
+void QSwipeGesture::setVerticalDirection(QSwipeGesture::SwipeDirection value)
+{
+    d_func()->verticalDirection = value;
+}
+
+qreal QSwipeGesture::swipeAngle() const
+{
+    return d_func()->swipeAngle;
+}
+
+void QSwipeGesture::setSwipeAngle(qreal value)
 {
-    updateState(Qt::NoGesture);
+    d_func()->swipeAngle = value;
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qgesture.h b/src/gui/kernel/qgesture.h
index 440565e..b37120f 100644
--- a/src/gui/kernel/qgesture.h
+++ b/src/gui/kernel/qgesture.h
@@ -55,7 +55,8 @@ QT_BEGIN_NAMESPACE
 
 QT_MODULE(Gui)
 
-class QGraphicsItem;
+Q_DECLARE_METATYPE(Qt::GestureState)
+
 class QGesturePrivate;
 class Q_GUI_EXPORT QGesture : public QObject
 {
@@ -63,37 +64,149 @@ class Q_GUI_EXPORT QGesture : public QObject
     Q_DECLARE_PRIVATE(QGesture)
 
     Q_PROPERTY(Qt::GestureState state READ state)
-    Q_PROPERTY(QObject* gestureTarget READ gestureTarget WRITE setGestureTarget)
+    Q_PROPERTY(Qt::GestureType gestureType READ gestureType)
+    Q_PROPERTY(QPointF hotSpot READ hotSpot WRITE setHotSpot RESET unsetHotSpot)
+    Q_PROPERTY(bool hasHotSpot READ hasHotSpot)
+    Q_PROPERTY(QObject* targetObject READ targetObject WRITE setTargetObject)
 
 public:
-    explicit QGesture(QObject *gestureTarget = 0, QObject *parent = 0);
+    explicit QGesture(Qt::GestureType type = Qt::CustomGesture, QObject *parent = 0);
+    explicit QGesture(QObject *parent);
     ~QGesture();
 
-    virtual bool filterEvent(QEvent *event) = 0;
+    Qt::GestureType gestureType() const;
 
-    void setGestureTarget(QObject *object);
-    QObject* gestureTarget() const;
+    Qt::GestureState state() const;
 
-    void setGraphicsItem(QGraphicsItem *);
-    QGraphicsItem *graphicsItem() const;
+    QObject *targetObject() const;
+    void setTargetObject(QObject *value);
 
-    Qt::GestureState state() const;
+    QPointF hotSpot() const;
+    void setHotSpot(const QPointF &value);
+    bool hasHotSpot() const;
+    void unsetHotSpot();
 
 protected:
-    QGesture(QGesturePrivate &dd, QObject *gestureTarget, QObject *parent);
-    bool eventFilter(QObject*, QEvent*);
+    QGesture(QGesturePrivate &dd, Qt::GestureType type, QObject *parent);
 
-    virtual void reset();
-    void updateState(Qt::GestureState state);
+private:
+    friend class QGestureEvent;
+    friend class QGestureRecognizer;
+    friend class QGestureManager;
+};
 
-Q_SIGNALS:
-    void started();
-    void triggered();
-    void finished();
-    void canceled();
+class QPanGesturePrivate;
+class Q_GUI_EXPORT QPanGesture : public QGesture
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPanGesture)
 
-private:
-    friend class QWidget;
+    Q_PROPERTY(QSizeF totalOffset READ totalOffset WRITE setTotalOffset)
+    Q_PROPERTY(QSizeF lastOffset READ lastOffset WRITE setLastOffset)
+    Q_PROPERTY(QSizeF offset READ offset WRITE setOffset)
+    Q_PROPERTY(qreal acceleration READ acceleration WRITE setAcceleration)
+
+public:
+    QPanGesture(QObject *parent = 0);
+
+    QSizeF totalOffset() const;
+    QSizeF lastOffset() const;
+    QSizeF offset() const;
+    qreal acceleration() const;
+
+    void setTotalOffset(const QSizeF &value);
+    void setLastOffset(const QSizeF &value);
+    void setOffset(const QSizeF &value);
+    void setAcceleration(qreal value);
+
+    friend class QPanGestureRecognizer;
+    friend class QWinNativePanGestureRecognizer;
+};
+
+class QPinchGesturePrivate;
+class Q_GUI_EXPORT QPinchGesture : public QGesture
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QPinchGesture)
+
+public:
+    enum WhatChange {
+        ScaleFactorChanged = 0x1,
+        RotationAngleChanged = 0x2,
+        CenterPointChanged = 0x4
+    };
+    Q_DECLARE_FLAGS(WhatChanged, WhatChange)
+
+    Q_PROPERTY(WhatChanged whatChanged READ whatChanged WRITE setWhatChanged)
+
+    Q_PROPERTY(qreal totalScaleFactor READ totalScaleFactor WRITE setTotalScaleFactor)
+    Q_PROPERTY(qreal lastScaleFactor READ lastScaleFactor WRITE setLastScaleFactor)
+    Q_PROPERTY(qreal scaleFactor READ scaleFactor WRITE setScaleFactor)
+
+    Q_PROPERTY(qreal totalRotationAngle READ totalRotationAngle WRITE setTotalRotationAngle)
+    Q_PROPERTY(qreal lastRotationAngle READ lastRotationAngle WRITE setLastRotationAngle)
+    Q_PROPERTY(qreal rotationAngle READ rotationAngle WRITE setRotationAngle)
+
+    Q_PROPERTY(QPointF startCenterPoint READ startCenterPoint WRITE setStartCenterPoint)
+    Q_PROPERTY(QPointF lastCenterPoint READ lastCenterPoint WRITE setLastCenterPoint)
+    Q_PROPERTY(QPointF centerPoint READ centerPoint WRITE setCenterPoint)
+
+public:
+    QPinchGesture(QObject *parent = 0);
+
+    WhatChanged whatChanged() const;
+    void setWhatChanged(WhatChanged value);
+
+    QPointF startCenterPoint() const;
+    QPointF lastCenterPoint() const;
+    QPointF centerPoint() const;
+    void setStartCenterPoint(const QPointF &value);
+    void setLastCenterPoint(const QPointF &value);
+    void setCenterPoint(const QPointF &value);
+
+    qreal totalScaleFactor() const;
+    qreal lastScaleFactor() const;
+    qreal scaleFactor() const;
+    void setTotalScaleFactor(qreal value);
+    void setLastScaleFactor(qreal value);
+    void setScaleFactor(qreal value);
+
+    qreal totalRotationAngle() const;
+    qreal lastRotationAngle() const;
+    qreal rotationAngle() const;
+    void setTotalRotationAngle(qreal value);
+    void setLastRotationAngle(qreal value);
+    void setRotationAngle(qreal value);
+
+    friend class QPinchGestureRecognizer;
+};
+
+Q_DECLARE_METATYPE(QPinchGesture::WhatChanged)
+
+class QSwipeGesturePrivate;
+class Q_GUI_EXPORT QSwipeGesture : public QGesture
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QSwipeGesture)
+    Q_ENUMS(SwipeDirection)
+
+    Q_PROPERTY(SwipeDirection horizontalDirection READ horizontalDirection WRITE setHorizontalDirection)
+    Q_PROPERTY(SwipeDirection verticalDirection READ verticalDirection WRITE setVerticalDirection)
+    Q_PROPERTY(qreal swipeAngle READ swipeAngle WRITE setSwipeAngle)
+
+public:
+    enum SwipeDirection { NoDirection, Left, Right, Up, Down };
+    QSwipeGesture(QObject *parent = 0);
+
+    SwipeDirection horizontalDirection() const;
+    SwipeDirection verticalDirection() const;
+    void setHorizontalDirection(SwipeDirection value);
+    void setVerticalDirection(SwipeDirection value);
+
+    qreal swipeAngle() const;
+    void setSwipeAngle(qreal value);
+
+    friend class QSwipeGestureRecognizer;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qgesture_p.h b/src/gui/kernel/qgesture_p.h
index 52e399f..7f69a4e 100644
--- a/src/gui/kernel/qgesture_p.h
+++ b/src/gui/kernel/qgesture_p.h
@@ -61,29 +61,83 @@
 
 QT_BEGIN_NAMESPACE
 
-class QObject;
-class QGraphicsItem;
 class QGesturePrivate : public QObjectPrivate
 {
     Q_DECLARE_PUBLIC(QGesture)
 
 public:
     QGesturePrivate()
-        : gestureTarget(0), graphicsItem(0), eventFilterProxyGraphicsItem(0),
-          state(Qt::NoGesture), implicitGesture(false)
+        : gestureType(Qt::CustomGesture), state(Qt::NoGesture), isHotSpotSet(false),
+          targetObject(0), accept(true)
     {
     }
 
-    virtual void setupGestureTarget(QObject *o);
+    Qt::GestureType gestureType;
+    Qt::GestureState state;
+    QPointF hotSpot;
+    bool isHotSpotSet;
+    QObject *targetObject;
+    bool accept;
+};
 
-    QPointer<QObject> gestureTarget;
-    QGraphicsItem *graphicsItem;
-    QGraphicsItem *eventFilterProxyGraphicsItem;
+class QPanGesturePrivate : public QGesturePrivate
+{
+    Q_DECLARE_PUBLIC(QPanGesture)
 
-    Qt::GestureState state;
+public:
+    QPanGesturePrivate()
+        : acceleration(0)
+    {
+    }
+
+    QSizeF totalOffset;
+    QSizeF lastOffset;
+    QSizeF offset;
+    QPoint lastPosition;
+    qreal acceleration;
+};
+
+class QPinchGesturePrivate : public QGesturePrivate
+{
+    Q_DECLARE_PUBLIC(QPinchGesture)
+
+public:
+    QPinchGesturePrivate()
+        : whatChanged(0), totalScaleFactor(0), lastScaleFactor(0), scaleFactor(0),
+          totalRotationAngle(0), lastRotationAngle(0), rotationAngle(0)
+    {
+    }
+
+    QPinchGesture::WhatChanged whatChanged;
+
+    QPointF startCenterPoint;
+    QPointF lastCenterPoint;
+    QPointF centerPoint;
+
+    qreal totalScaleFactor;
+    qreal lastScaleFactor;
+    qreal scaleFactor;
+
+    qreal totalRotationAngle;
+    qreal lastRotationAngle;
+    qreal rotationAngle;
+};
+
+class QSwipeGesturePrivate : public QGesturePrivate
+{
+    Q_DECLARE_PUBLIC(QSwipeGesture)
+
+public:
+    QSwipeGesturePrivate()
+        : horizontalDirection(QSwipeGesture::NoDirection),
+          verticalDirection(QSwipeGesture::NoDirection),
+          swipeAngle(0)
+    {
+    }
 
-    // the flag specifies if the gesture was created implicitely by Qt.
-    bool implicitGesture;
+    QSwipeGesture::SwipeDirection horizontalDirection;
+    QSwipeGesture::SwipeDirection verticalDirection;
+    qreal swipeAngle;
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qgesturemanager.cpp b/src/gui/kernel/qgesturemanager.cpp
new file mode 100644
index 0000000..000f44f
--- /dev/null
+++ b/src/gui/kernel/qgesturemanager.cpp
@@ -0,0 +1,453 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qgesturemanager_p.h"
+#include "private/qstandardgestures_p.h"
+#include "private/qwidget_p.h"
+#include "private/qgesture_p.h"
+#include "private/qgraphicsitem_p.h"
+#include "qgesture.h"
+#include "qevent.h"
+#include "qgraphicsitem.h"
+
+#include "qdebug.h"
+
+// #define GESTURE_DEBUG
+#ifndef GESTURE_DEBUG
+# define DEBUG if (0) qDebug
+#else
+# define DEBUG qDebug
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QGestureManager::QGestureManager(QObject *parent)
+    : QObject(parent), state(NotGesture), lastCustomGestureId(0)
+{
+    qRegisterMetaType<Qt::GestureState>();
+
+    registerGestureRecognizer(new QPanGestureRecognizer);
+}
+
+QGestureManager::~QGestureManager()
+{
+
+}
+
+Qt::GestureType QGestureManager::registerGestureRecognizer(QGestureRecognizer *recognizer)
+{
+    QGesture *dummy = recognizer->createGesture(0);
+    if (!dummy) {
+        qWarning("QGestureManager::registerGestureRecognizer: the recognizer doesn't provide gesture object");
+        return Qt::GestureType(0);
+    }
+    Qt::GestureType type = dummy->gestureType();
+    if (type == Qt::CustomGesture) {
+        // generate a new custom gesture id
+        ++lastCustomGestureId;
+        type = Qt::GestureType(Qt::CustomGesture + lastCustomGestureId);
+    }
+    recognizers.insertMulti(type, recognizer);
+    delete dummy;
+    return type;
+}
+
+void QGestureManager::unregisterGestureRecognizer(Qt::GestureType)
+{
+
+}
+
+QGesture* QGestureManager::getState(QObject *object, Qt::GestureType type)
+{
+    // if the widget is being deleted we should be carefull and not to
+    // create a new state, as it will create QWeakPointer which doesnt work
+    // from the destructor.
+    if (object->isWidgetType()) {
+        if (static_cast<QWidget *>(object)->d_func()->data.in_destructor)
+            return 0;
+    }
+
+    QWeakPointer<QGesture> state = objectGestures.value(QGestureManager::ObjectGesture(object, type));
+    if (!state) {
+        QGestureRecognizer *recognizer = recognizers.value(type);
+        if (recognizer) {
+            state = recognizer->createGesture(object);
+            if (!state)
+                return 0;
+            if (state.data()->gestureType() == Qt::CustomGesture) {
+                // if the recognizer didn't fill in the gesture type, then this
+                // is a custom gesture with autogenerated it and we fill it.
+                state.data()->d_func()->gestureType = type;
+            }
+            objectGestures.insert(QGestureManager::ObjectGesture(object, type), state);
+            gestureToRecognizer[state.data()] = recognizer;
+        }
+    }
+    return state.data();
+}
+
+bool QGestureManager::filterEvent(QObject *receiver, QEvent *event)
+{
+    QSet<QGesture *> triggeredGestures;
+    QSet<QGesture *> finishedGestures;
+    QSet<QGesture *> newMaybeGestures;
+    QSet<QGesture *> canceledGestures;
+    QSet<QGesture *> notGestures;
+
+    QGraphicsObject *graphicsObject = qobject_cast<QGraphicsObject *>(receiver);
+    if (receiver->isWidgetType() || graphicsObject) {
+        QMap<QObject *, Qt::GestureType> contexts;
+        if (receiver->isWidgetType()) {
+            QWidget *w = static_cast<QWidget *>(receiver);
+            if (!w->d_func()->gestureContext.isEmpty()) {
+                typedef QMap<Qt::GestureType, Qt::GestureContext>::const_iterator ContextIterator;
+                for(ContextIterator it = w->d_func()->gestureContext.begin(),
+                    e = w->d_func()->gestureContext.end(); it != e; ++it) {
+                    contexts.insertMulti(w, it.key());
+                }
+            }
+            // find all gesture contexts for the widget tree
+            w = w->parentWidget();
+            while (w)
+            {
+                typedef QMap<Qt::GestureType, Qt::GestureContext>::const_iterator ContextIterator;
+                for (ContextIterator it = w->d_func()->gestureContext.begin(),
+                     e = w->d_func()->gestureContext.end(); it != e; ++it) {
+                    if (it.value() == Qt::WidgetWithChildrenGesture)
+                        contexts.insertMulti(w, it.key());
+                }
+                w = w->parentWidget();
+            }
+        } else {
+            QGraphicsObject *item = graphicsObject;
+            if (!item->QGraphicsItem::d_func()->gestureContext.isEmpty()) {
+                typedef QMap<Qt::GestureType, Qt::GestureContext>::const_iterator ContextIterator;
+                for(ContextIterator it = item->QGraphicsItem::d_func()->gestureContext.begin(),
+                    e = item->QGraphicsItem::d_func()->gestureContext.end(); it != e; ++it) {
+                    contexts.insertMulti(item, it.key());
+                }
+            }
+            // find all gesture contexts for the widget tree
+            item = item->parentObject();
+            while (item)
+            {
+                typedef QMap<Qt::GestureType, Qt::GestureContext>::const_iterator ContextIterator;
+                for (ContextIterator it = item->QGraphicsItem::d_func()->gestureContext.begin(),
+                     e = item->QGraphicsItem::d_func()->gestureContext.end(); it != e; ++it) {
+                    if (it.value() == Qt::WidgetWithChildrenGesture)
+                        contexts.insertMulti(item, it.key());
+                }
+                item = item->parentObject();
+            }
+        }
+        // filter the event through recognizers
+        typedef QMap<QObject *, Qt::GestureType>::const_iterator ContextIterator;
+        for (ContextIterator cit = contexts.begin(), ce = contexts.end(); cit != ce; ++cit) {
+            Qt::GestureType gestureType = cit.value();
+            QMap<Qt::GestureType, QGestureRecognizer *>::const_iterator
+                    rit = recognizers.lowerBound(gestureType),
+                    re = recognizers.upperBound(gestureType);
+            for (; rit != re; ++rit) {
+                QGestureRecognizer *recognizer = rit.value();
+                QObject *target = cit.key();
+                QGesture *state = getState(target, gestureType);
+                if (!state)
+                    continue;
+                QGestureRecognizer::Result result = recognizer->filterEvent(state, target, event);
+                QGestureRecognizer::Result type = result & QGestureRecognizer::ResultState_Mask;
+                if (type == QGestureRecognizer::GestureTriggered) {
+                    DEBUG() << "QGestureManager: gesture triggered: " << state;
+                    triggeredGestures << state;
+                } else if (type == QGestureRecognizer::GestureFinished) {
+                    DEBUG() << "QGestureManager: gesture finished: " << state;
+                    finishedGestures << state;
+                } else if (type == QGestureRecognizer::MaybeGesture) {
+                    DEBUG() << "QGestureManager: maybe gesture: " << state;
+                    newMaybeGestures << state;
+                } else if (type == QGestureRecognizer::NotGesture) {
+                    DEBUG() << "QGestureManager: not gesture: " << state;
+                    notGestures << state;
+                } else if (type == QGestureRecognizer::Ignore) {
+                    DEBUG() << "QGestureManager: gesture ignored the event: " << state;
+                } else {
+                    DEBUG() << "QGestureManager: hm, lets assume the recognizer ignored the event: " << state;
+                }
+                if (result & QGestureRecognizer::ConsumeEventHint) {
+                    DEBUG() << "QGestureManager: we were asked to consume the event: " << state;
+                    //TODO: consume events if asked
+                }
+            }
+        }
+    } else if (QGesture *state = qobject_cast<QGesture*>(receiver)) {
+        if (QGestureRecognizer *recognizer = gestureToRecognizer.value(state)) {
+            QGestureRecognizer::Result result = recognizer->filterEvent(state, state, event);
+            QGestureRecognizer::Result type = result & QGestureRecognizer::ResultState_Mask;
+            if (type == QGestureRecognizer::GestureTriggered) {
+                DEBUG() << "QGestureManager: gesture triggered: " << state;
+                triggeredGestures << state;
+            } else if (type == QGestureRecognizer::GestureFinished) {
+                DEBUG() << "QGestureManager: gesture finished: " << state;
+                finishedGestures << state;
+            } else if (type == QGestureRecognizer::MaybeGesture) {
+                DEBUG() << "QGestureManager: maybe gesture: " << state;
+                newMaybeGestures << state;
+            } else if (type == QGestureRecognizer::NotGesture) {
+                DEBUG() << "QGestureManager: not gesture: " << state;
+                notGestures << state;
+            } else if (type == QGestureRecognizer::Ignore) {
+                DEBUG() << "QGestureManager: gesture ignored the event: " << state;
+            } else {
+                DEBUG() << "QGestureManager: hm, lets assume the recognizer ignored the event: " << state;
+            }
+        }
+    } else {
+        return false;
+    }
+
+    QSet<QGesture *> startedGestures = triggeredGestures - activeGestures;
+    triggeredGestures &= activeGestures;
+
+    // check if a running gesture switched back to maybe state
+    QSet<QGesture *> activeToMaybeGestures = activeGestures & newMaybeGestures;
+
+    // check if a running gesture switched back to not gesture state, i.e. were canceled
+    QSet<QGesture *> activeToCancelGestures = activeGestures & notGestures;
+    canceledGestures += activeToCancelGestures;
+
+    // start timers for new gestures in maybe state
+    foreach (QGesture *state, newMaybeGestures) {
+        QBasicTimer &timer = maybeGestures[state];
+        if (!timer.isActive())
+            timer.start(3000, this);
+    }
+    // kill timers for gestures that were in maybe state
+    QSet<QGesture *> notMaybeGestures = (startedGestures | triggeredGestures | finishedGestures | canceledGestures | notGestures);
+    foreach(QGesture *gesture, notMaybeGestures) {
+        QMap<QGesture *, QBasicTimer>::iterator it =
+                maybeGestures.find(gesture);
+        if (it != maybeGestures.end()) {
+            it.value().stop();
+            maybeGestures.erase(it);
+        }
+    }
+
+    Q_ASSERT((startedGestures & finishedGestures).isEmpty());
+    Q_ASSERT((startedGestures & newMaybeGestures).isEmpty());
+    Q_ASSERT((startedGestures & canceledGestures).isEmpty());
+    Q_ASSERT((finishedGestures & newMaybeGestures).isEmpty());
+    Q_ASSERT((finishedGestures & canceledGestures).isEmpty());
+    Q_ASSERT((canceledGestures & newMaybeGestures).isEmpty());
+
+    QSet<QGesture *> notStarted = finishedGestures - activeGestures;
+    if (!notStarted.isEmpty()) {
+        // there are some gestures that claim to be finished, but never started.
+        qWarning("QGestureManager::filterEvent: some gestures were finished even though they've never started");
+        finishedGestures -= notStarted;
+    }
+
+    activeGestures += startedGestures;
+    // sanity check: all triggered gestures should already be in active gestures list
+    Q_ASSERT((activeGestures & triggeredGestures).size() == triggeredGestures.size());
+    activeGestures -= finishedGestures;
+    activeGestures -= activeToMaybeGestures;
+    activeGestures -= canceledGestures;
+
+    // set the proper gesture state on each gesture
+    foreach (QGesture *gesture, startedGestures)
+        gesture->d_func()->state = Qt::GestureStarted;
+    foreach (QGesture *gesture, triggeredGestures)
+        gesture->d_func()->state = Qt::GestureUpdated;
+    foreach (QGesture *gesture, finishedGestures)
+        gesture->d_func()->state = Qt::GestureFinished;
+    foreach (QGesture *gesture, canceledGestures)
+        gesture->d_func()->state = Qt::GestureCanceled;
+    foreach (QGesture *gesture, activeToMaybeGestures)
+        gesture->d_func()->state = Qt::GestureFinished;
+
+    if (!activeGestures.isEmpty() || !maybeGestures.isEmpty() ||
+        !startedGestures.isEmpty() || !triggeredGestures.isEmpty() ||
+        !finishedGestures.isEmpty() || !canceledGestures.isEmpty()) {
+        DEBUG() << "QGestureManager::filterEvent:"
+                << "\n\tactiveGestures:" << activeGestures
+                << "\n\tmaybeGestures:" << maybeGestures.keys()
+                << "\n\tstarted:" << startedGestures
+                << "\n\ttriggered:" << triggeredGestures
+                << "\n\tfinished:" << finishedGestures
+                << "\n\tcanceled:" << canceledGestures;
+    }
+
+    deliverEvents(startedGestures+triggeredGestures+finishedGestures+canceledGestures, receiver);
+
+    // reset gestures that ended
+    QSet<QGesture *> endedGestures = finishedGestures + canceledGestures;
+    foreach (QGesture *gesture, endedGestures) {
+        if (QGestureRecognizer *recognizer = gestureToRecognizer.value(gesture, 0)) {
+            recognizer->reset(gesture);
+        }
+        gestureTargets.remove(gesture);
+    }
+    return false;
+}
+
+void QGestureManager::deliverEvents(const QSet<QGesture*> &gestures, QObject *lastReceiver)
+{
+    if (gestures.isEmpty())
+        return;
+
+    // group gestures by widgets
+    typedef QMap<QObject *, QList<QGesture *> > GesturesPerReceiver;
+    GesturesPerReceiver groupedGestures;
+    // for conflicted gestures the key is always the innermost widget (i.e. the child)
+    GesturesPerReceiver conflictedGestures;
+    QMultiHash<QObject *, QGesture *> objectGestures;
+
+    foreach (QGesture *gesture, gestures) {
+        QObject *target = gestureTargets.value(gesture, 0);
+        if (!target) {
+            Q_ASSERT(gesture->state() == Qt::GestureStarted);
+            if (gesture->hasHotSpot()) {
+                // guess the target using the hotspot of the gesture
+                QPoint pt = gesture->hotSpot().toPoint();
+                if (!pt.isNull()) {
+                    if (QWidget *w = qApp->topLevelAt(pt))
+                        target = w->childAt(w->mapFromGlobal(pt));
+                }
+            }
+            if (!target) {
+                target = gesture->targetObject();
+                if (!target)
+                    target = lastReceiver;
+            }
+        }
+        if (target) {
+            gestureTargets.insert(gesture, target);
+            if (target->isWidgetType())
+                objectGestures.insert(target, gesture);
+            groupedGestures[target].append(gesture);
+        } else {
+            qWarning() << "QGestureManager::deliverEvent: could not find the target for gesture"
+                    << gesture->gestureType();
+        }
+    }
+
+    typedef QMultiHash<QObject *, QGesture *>::const_iterator ObjectGesturesIterator;
+    for (ObjectGesturesIterator it = objectGestures.begin(), e = objectGestures.end(); it != e; ++it) {
+        QObject *object1 = it.key();
+        QWidget *widget1 = qobject_cast<QWidget *>(object1);
+        QGraphicsObject *item1 = qobject_cast<QGraphicsObject *>(object1);
+        QGesture *gesture1 = it.value();
+        ObjectGesturesIterator cit = it;
+        for (++cit; cit != e; ++cit) {
+            QObject *object2 = cit.key();
+            QWidget *widget2 = qobject_cast<QWidget *>(object2);
+            QGraphicsObject *item2 = qobject_cast<QGraphicsObject *>(object2);
+            QGesture *gesture2 = cit.value();
+            // TODO: ugly, rewrite this.
+            if ((widget1 && widget2 && widget2->isAncestorOf(widget1)) ||
+                (item1 && item2 && item2->isAncestorOf(item1))) {
+                groupedGestures[object2].removeOne(gesture2);
+                groupedGestures[object1].removeOne(gesture1);
+                conflictedGestures[object1].append(gesture1);
+            } else if ((widget1 && widget2 && widget1->isAncestorOf(widget2)) ||
+                       (item1 && item2 && item1->isAncestorOf(item2))) {
+                groupedGestures[object2].removeOne(gesture2);
+                groupedGestures[object1].removeOne(gesture1);
+                conflictedGestures[object2].append(gesture2);
+            }
+        }
+    }
+
+    DEBUG() << "deliverEvents: conflicted =" << conflictedGestures.values()
+            << " grouped =" << groupedGestures.values();
+
+    // if there are conflicting gestures, send the GestureOverride event
+    for (GesturesPerReceiver::const_iterator it = conflictedGestures.begin(),
+        e = conflictedGestures.end(); it != e; ++it) {
+        DEBUG() << "QGestureManager::deliverEvents: sending GestureOverride to"
+                << it.key()
+                << " gestures:" << it.value();
+        QGestureEvent event(it.value());
+        event.t = QEvent::GestureOverride;
+        event.ignore();
+        QApplication::sendEvent(it.key(), &event);
+        if (!event.isAccepted()) {
+            // nobody accepted the GestureOverride, put it back to deliver to
+            // the closest context (i.e. to the inner-most widget).
+            DEBUG() <<" override was not accepted";
+            groupedGestures[it.key()].append(it.value());
+        }
+    }
+
+    for (GesturesPerReceiver::const_iterator it = groupedGestures.begin(),
+        e = groupedGestures.end(); it != e; ++it) {
+        if (!it.value().isEmpty()) {
+            DEBUG() << "QGestureManager::deliverEvents: sending to" << it.key()
+                    << " gestures:" << it.value();
+            QGestureEvent event(it.value());
+            QApplication::sendEvent(it.key(), &event);
+        }
+    }
+}
+
+void QGestureManager::timerEvent(QTimerEvent *event)
+{
+    QMap<QGesture*, QBasicTimer>::iterator it = maybeGestures.begin(),
+                                            e = maybeGestures.end();
+    for (; it != e; ) {
+        QBasicTimer &timer = it.value();
+        Q_ASSERT(timer.isActive());
+        if (timer.timerId() == event->timerId()) {
+            timer.stop();
+            QGesture *gesture = it.key();
+            it = maybeGestures.erase(it);
+            DEBUG() << "QGestureManager::timerEvent: gesture stopped due to timeout:" << gesture;
+            QGestureRecognizer *recognizer = gestureToRecognizer.value(gesture, 0);
+            if (recognizer)
+                recognizer->reset(gesture);
+        } else {
+            ++it;
+        }
+    }
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qgesturemanager_p.cpp"
diff --git a/src/gui/kernel/qgesturemanager_p.h b/src/gui/kernel/qgesturemanager_p.h
new file mode 100644
index 0000000..c61819f
--- /dev/null
+++ b/src/gui/kernel/qgesturemanager_p.h
@@ -0,0 +1,125 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGESTUREMANAGER_P_H
+#define QGESTUREMANAGER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qobject.h"
+#include "qbasictimer.h"
+#include "private/qwidget_p.h"
+#include "qgesturerecognizer.h"
+
+QT_BEGIN_NAMESPACE
+
+class QBasicTimer;
+class QGestureManager : public QObject
+{
+    Q_OBJECT
+public:
+    QGestureManager(QObject *parent);
+    ~QGestureManager();
+
+    Qt::GestureType registerGestureRecognizer(QGestureRecognizer *recognizer);
+    void unregisterGestureRecognizer(Qt::GestureType type);
+
+    bool filterEvent(QObject *receiver, QEvent *event);
+
+    // declared in qapplication.cpp
+    static QGestureManager* instance();
+
+protected:
+    void timerEvent(QTimerEvent *event);
+
+private:
+    QMultiMap<Qt::GestureType, QGestureRecognizer *> recognizers;
+
+    QSet<QGesture *> activeGestures;
+    QMap<QGesture *, QBasicTimer> maybeGestures;
+
+    enum State {
+        Gesture,
+        NotGesture,
+        MaybeGesture // this means timers are up and waiting for some
+                     // more events, and input events are handled by
+                     // gesture recognizer explicitely
+    } state;
+
+    struct ObjectGesture
+    {
+        QWeakPointer<QObject> object;
+        Qt::GestureType gesture;
+
+        ObjectGesture(QObject *o, const Qt::GestureType &g) : object(o), gesture(g) { }
+        inline bool operator<(const ObjectGesture& rhs) const
+        {
+            if (object.data() < rhs.object.data())
+                return true;
+            if (object == rhs.object)
+                return gesture < rhs.gesture;
+            return false;
+        }
+    };
+
+    QMap<ObjectGesture, QWeakPointer<QGesture> > objectGestures;
+    QMap<QGesture *, QGestureRecognizer *> gestureToRecognizer;
+
+    QHash<QGesture *, QObject *> gestureTargets;
+
+    int lastCustomGestureId;
+
+    QGesture *getState(QObject *widget, Qt::GestureType gesture);
+    void deliverEvents(const QSet<QGesture *> &gestures, QObject *lastReceiver);
+};
+
+QT_END_NAMESPACE
+
+#endif // QGESTUREMANAGER_P_H
diff --git a/src/gui/kernel/qgesturerecognizer.cpp b/src/gui/kernel/qgesturerecognizer.cpp
new file mode 100644
index 0000000..590f09e
--- /dev/null
+++ b/src/gui/kernel/qgesturerecognizer.cpp
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgesturerecognizer.h"
+
+#include "private/qgesture_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QGestureRecognizer::QGestureRecognizer()
+{
+}
+
+QGestureRecognizer::~QGestureRecognizer()
+{
+}
+
+QGesture *QGestureRecognizer::createGesture(QObject *)
+{
+    return new QGesture;
+}
+
+void QGestureRecognizer::reset(QGesture *state)
+{
+    if (state) {
+        QGesturePrivate *d = state->d_func();
+        d->state = Qt::NoGesture;
+        d->hotSpot = QPointF();
+        d->targetObject = 0;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/kernel/qgesturerecognizer.h b/src/gui/kernel/qgesturerecognizer.h
new file mode 100644
index 0000000..c85afd2
--- /dev/null
+++ b/src/gui/kernel/qgesturerecognizer.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGESTURERECOGNIZER_H
+#define QGESTURERECOGNIZER_H
+
+#include "qglobal.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Gui)
+
+class QObject;
+class QEvent;
+class QGesture;
+class Q_GUI_EXPORT QGestureRecognizer
+{
+public:
+    enum ResultFlags
+    {
+        Ignore            = 0x0001,
+        NotGesture        = 0x0002,
+        MaybeGesture      = 0x0004,
+        GestureTriggered  = 0x0008, // Gesture started or updated
+        GestureFinished   = 0x0010,
+
+        ResultState_Mask  = 0x00ff,
+
+        ConsumeEventHint        = 0x0100,
+        // StoreEventHint          = 0x0200,
+        // ReplayStoredEventsHint  = 0x0400,
+        // DiscardStoredEventsHint = 0x0800,
+
+        ResultHint_Mask   = 0xff00
+    };
+    Q_DECLARE_FLAGS(Result, ResultFlags)
+
+    QGestureRecognizer();
+    virtual ~QGestureRecognizer();
+
+    virtual QGesture *createGesture(QObject *target);
+    virtual QGestureRecognizer::Result filterEvent(QGesture *state, QObject *watched, QEvent *event) = 0;
+
+    virtual void reset(QGesture *state);
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QGestureRecognizer::Result)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGESTURERECOGNIZER_H
diff --git a/src/gui/kernel/qstandardgestures.cpp b/src/gui/kernel/qstandardgestures.cpp
index 3cfb987..dfc3499 100644
--- a/src/gui/kernel/qstandardgestures.cpp
+++ b/src/gui/kernel/qstandardgestures.cpp
@@ -39,174 +39,45 @@
 **
 ****************************************************************************/
 
-#include "qstandardgestures.h"
 #include "qstandardgestures_p.h"
-
-#include <qabstractscrollarea.h>
-#include <qscrollbar.h>
-#include <private/qapplication_p.h>
-#include <private/qevent_p.h>
-#include <private/qwidget_p.h>
-#include <qmath.h>
+#include "qgesture.h"
+#include "qgesture_p.h"
+#include "qevent.h"
+#include "qwidget.h"
 
 QT_BEGIN_NAMESPACE
 
-#ifdef Q_WS_WIN
-QWidgetPrivate *qt_widget_private(QWidget *widget);
-#endif
-
-/*!
-    \class QPanGesture
-    \preliminary
-    \since 4.6
-
-    \brief The QPanGesture class represents a Pan gesture,
-    providing additional information related to panning.
-*/
-
-/*!
-    \enum QSwipeGesture::SwipeDirection
-    \brief This enum specifies the direction of the swipe gesture.
-
-    \value NoDirection
-    \value Left
-    \value Right
-    \value Up
-    \value Down
-*/
-
-/*!
-  Creates a new pan gesture handler object and marks it as a child of
-  \a parent. The pan gesture handler watches \a gestureTarget for its
-  events.
-
-  On some platform like Windows it's necessary to provide a non-null
-  widget as \a parent to get native gesture support.
-*/
-QPanGesture::QPanGesture(QWidget *gestureTarget, QObject *parent)
-    : QGesture(*new QPanGesturePrivate, gestureTarget, parent)
+QPanGestureRecognizer::QPanGestureRecognizer()
 {
-    setObjectName(QLatin1String("QPanGesture"));
-}
-
-void QPanGesturePrivate::setupGestureTarget(QObject *newGestureTarget)
-{
-    Q_Q(QPanGesture);
-    QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
-
-    if (gestureTarget && gestureTarget->isWidgetType()) {
-        QWidget *w = static_cast<QWidget*>(gestureTarget.data());
-        if (qAppPriv->widgetGestures[w].pan == q)
-            qAppPriv->widgetGestures[w].pan = 0;
-#if defined(Q_WS_WIN)
-        qt_widget_private(w)->winSetupGestures();
-#elif defined(Q_WS_MAC)
-        w->setAttribute(Qt::WA_AcceptTouchEvents, false);
-        w->setAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents, false);
-#endif
-    }
-
-    if (newGestureTarget && newGestureTarget->isWidgetType()) {
-        QWidget *w = static_cast<QWidget*>(newGestureTarget);
-        qAppPriv->widgetGestures[w].pan = q;
-#if defined(Q_WS_WIN)
-        qt_widget_private(w)->winSetupGestures();
-#elif defined(Q_WS_MAC)
-        w->setAttribute(Qt::WA_AcceptTouchEvents);
-        w->setAttribute(Qt::WA_TouchPadAcceptSingleTouchEvents);
-#endif
-    }
-    QGesturePrivate::setupGestureTarget(newGestureTarget);
-}
-
-/*! \internal */
-bool QPanGesture::event(QEvent *event)
-{
-#if defined(QT_MAC_USE_COCOA)
-    Q_D(QPanGesture);
-    if (event->type() == QEvent::Timer) {
-        const QTimerEvent *te = static_cast<QTimerEvent *>(event);
-        if (te->timerId() == d->singleTouchPanTimer.timerId()) {
-            d->singleTouchPanTimer.stop();
-            updateState(Qt::GestureStarted);
-        }
-    }
-#endif
-
-    return QObject::event(event);
 }
 
-bool QPanGesture::eventFilter(QObject *receiver, QEvent *event)
+QGesture *QPanGestureRecognizer::createGesture(QObject *target)
 {
-    Q_D(QPanGesture);
-
-    if (d->implicitGesture && d->gestureTarget && d->gestureTarget->isWidgetType() &&
-        static_cast<QWidget*>(d->gestureTarget.data())->testAttribute(Qt::WA_DontUseStandardGestures))
-        return false;
-
-#ifdef Q_WS_WIN
-    if (receiver->isWidgetType() && event->type() == QEvent::NativeGesture) {
-        QNativeGestureEvent *ev = static_cast<QNativeGestureEvent*>(event);
-        QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
-        QApplicationPrivate::WidgetStandardGesturesMap::iterator it;
-        it = qAppPriv->widgetGestures.find(static_cast<QWidget*>(receiver));
-        if (it == qAppPriv->widgetGestures.end())
-            return false;
-        if (this != it.value().pan)
-            return false;
-        Qt::GestureState nextState = Qt::NoGesture;
-        switch(ev->gestureType) {
-        case QNativeGestureEvent::GestureBegin:
-            // next we might receive the first gesture update event, so we
-            // prepare for it.
-            d->state = Qt::NoGesture;
-            return false;
-        case QNativeGestureEvent::Pan:
-            nextState = Qt::GestureUpdated;
-            event->accept();
-            break;
-        case QNativeGestureEvent::GestureEnd:
-            if (state() == Qt::NoGesture)
-                return false; // some other gesture has ended
-            nextState = Qt::GestureFinished;
-            break;
-        default:
-            return false;
-        }
-        if (state() == Qt::NoGesture) {
-            d->lastOffset = d->totalOffset = d->offset = QSize();
-        } else {
-            d->lastOffset = d->offset;
-            d->offset = QSize(ev->position.x() - d->lastPosition.x(),
-                              ev->position.y() - d->lastPosition.y());
-            d->totalOffset += d->offset;
-        }
-        d->lastPosition = ev->position;
-        updateState(nextState);
-        return true;
+    if (target && target->isWidgetType()) {
+        static_cast<QWidget *>(target)->setAttribute(Qt::WA_AcceptTouchEvents);
     }
-#endif
-    return QGesture::eventFilter(receiver, event);
+    return new QPanGesture;
 }
 
-/*! \internal */
-bool QPanGesture::filterEvent(QEvent *event)
+QGestureRecognizer::Result QPanGestureRecognizer::filterEvent(QGesture *state, QObject *, QEvent *event)
 {
-    Q_D(QPanGesture);
+    QPanGesture *q = static_cast<QPanGesture*>(state);
+    QPanGesturePrivate *d = q->d_func();
 
-    if (d->implicitGesture && d->gestureTarget && d->gestureTarget->isWidgetType() &&
-        static_cast<QWidget*>(d->gestureTarget.data())->testAttribute(Qt::WA_DontUseStandardGestures))
-        return false;
-
-#if defined(Q_WS_WIN)
     const QTouchEvent *ev = static_cast<const QTouchEvent*>(event);
 
-    if (event->type() == QEvent::TouchBegin) {
+    QGestureRecognizer::Result result;
+
+    switch (event->type()) {
+    case QEvent::TouchBegin: {
+        result = QGestureRecognizer::MaybeGesture;
         QTouchEvent::TouchPoint p = ev->touchPoints().at(0);
         d->lastPosition = p.pos().toPoint();
         d->lastOffset = d->totalOffset = d->offset = QSize();
-    } else if (event->type() == QEvent::TouchEnd) {
-        if (state() != Qt::NoGesture) {
+        break;
+    }
+    case QEvent::TouchEnd: {
+        if (q->state() != Qt::NoGesture) {
             if (ev->touchPoints().size() == 2) {
                 QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
                 QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);
@@ -216,11 +87,14 @@ bool QPanGesture::filterEvent(QEvent *event)
                               p1.pos().y() - p1.lastPos().y() + p2.pos().y() - p2.lastPos().y()) / 2;
                 d->totalOffset += d->offset;
             }
-            updateState(Qt::GestureFinished);
+            result = QGestureRecognizer::GestureFinished;
+        } else {
+            result = QGestureRecognizer::NotGesture;
         }
-        reset();
-    } else if (event->type() == QEvent::TouchUpdate) {
-        if (ev->touchPoints().size() == 2) {
+        break;
+    }
+    case QEvent::TouchUpdate: {
+        if (ev->touchPoints().size() >= 2) {
             QTouchEvent::TouchPoint p1 = ev->touchPoints().at(0);
             QTouchEvent::TouchPoint p2 = ev->touchPoints().at(1);
             d->lastOffset = d->offset;
@@ -230,10 +104,60 @@ bool QPanGesture::filterEvent(QEvent *event)
             d->totalOffset += d->offset;
             if (d->totalOffset.width() > 10  || d->totalOffset.height() > 10 ||
                 d->totalOffset.width() < -10 || d->totalOffset.height() < -10) {
-                updateState(Qt::GestureUpdated);
+                result = QGestureRecognizer::GestureTriggered;
+            } else {
+                result = QGestureRecognizer::MaybeGesture;
             }
         }
+        break;
+    }
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        result = QGestureRecognizer::Ignore;
+        break;
+    default:
+        result = QGestureRecognizer::Ignore;
+        break;
+    }
+    return result;
+}
+
+void QPanGestureRecognizer::reset(QGesture *state)
+{
+    QPanGesture *pan = static_cast<QPanGesture*>(state);
+    QPanGesturePrivate *d = pan->d_func();
+
+    d->totalOffset = d->lastOffset = d->offset = QSizeF();
+    d->lastPosition = QPoint();
+    d->acceleration = 0;
+
+//#if defined(QT_MAC_USE_COCOA)
+//    d->singleTouchPanTimer.stop();
+//    d->prevMousePos = QPointF(0, 0);
+//#endif
+
+    QGestureRecognizer::reset(state);
+}
+
+/*! \internal */
+/*
+bool QPanGestureRecognizer::event(QEvent *event)
+{
+#if defined(QT_MAC_USE_COCOA)
+    Q_D(QPanGesture);
+    if (event->type() == QEvent::Timer) {
+        const QTimerEvent *te = static_cast<QTimerEvent *>(event);
+        if (te->timerId() == d->singleTouchPanTimer.timerId()) {
+            d->singleTouchPanTimer.stop();
+            updateState(Qt::GestureStarted);
+        }
     }
+#endif
+
+    bool consume = false;
+
+#if defined(Q_WS_WIN)
 #elif defined(QT_MAC_USE_COCOA)
     // The following implements single touch
     // panning on Mac:
@@ -244,16 +168,25 @@ bool QPanGesture::filterEvent(QEvent *event)
     switch (event->type()) {
     case QEvent::TouchBegin: {
         if (ev->touchPoints().size() == 1) {
+            d->delayManager->setEnabled(true);
+            consume = d->delayManager->append(d->gestureTarget, *event);
             d->lastPosition = QCursor::pos();
             d->singleTouchPanTimer.start(panBeginDelay, this);
         }
         break;}
     case QEvent::TouchEnd: {
-        if (state() != Qt::NoGesture)
+        d->delayManager->setEnabled(false);
+        if (state() != Qt::NoGesture) {
             updateState(Qt::GestureFinished);
+            consume = true;
+            d->delayManager->clear();
+        } else {
+            d->delayManager->replay();
+        }
         reset();
         break;}
     case QEvent::TouchUpdate: {
+        consume = d->delayManager->append(d->gestureTarget, *event);
         if (ev->touchPoints().size() == 1) {
             if (state() == Qt::NoGesture) {
                 // INVARIANT: The singleTouchTimer has still not fired.
@@ -261,11 +194,15 @@ bool QPanGesture::filterEvent(QEvent *event)
                 // the starting point that it makes sense to cancel:
                 const QPointF startPos = ev->touchPoints().at(0).startPos().toPoint();
                 const QPointF p = ev->touchPoints().at(0).pos().toPoint();
-                if ((startPos - p).manhattanLength() > panBeginRadius)
+                if ((startPos - p).manhattanLength() > panBeginRadius) {
+                    d->delayManager->replay();
+                    consume = false;
                     reset();
-                else
+                } else {
                     d->lastPosition = QCursor::pos();
+                }
             } else {
+                d->delayManager->clear();
                 QPointF mousePos = QCursor::pos();
                 QPointF dist = mousePos - d->lastPosition;
                 d->lastPosition = mousePos;
@@ -275,527 +212,25 @@ bool QPanGesture::filterEvent(QEvent *event)
                 updateState(Qt::GestureUpdated);
             }
         } else if (state() == Qt::NoGesture) {
+            d->delayManager->replay();
+            consume = false;
             reset();
         }
         break;}
+    case QEvent::MouseButtonPress:
+    case QEvent::MouseMove:
+    case QEvent::MouseButtonRelease:
+        if (d->delayManager->isEnabled())
+            consume = d->delayManager->append(d->gestureTarget, *event);
+        break;
     default:
         return false;
     }
 #else
     Q_UNUSED(event);
 #endif
-    return false;
-}
-
-/*! \internal */
-void QPanGesture::reset()
-{
-    Q_D(QPanGesture);
-    d->lastOffset = d->totalOffset = d->offset = QSize(0, 0);
-    d->lastPosition = QPoint(0, 0);
-
-#if defined(QT_MAC_USE_COCOA)
-    d->singleTouchPanTimer.stop();
-    d->prevMousePos = QPointF(0, 0);
-#endif
-
-    QGesture::reset();
-}
-
-/*!
-    \property QPanGesture::totalOffset
-
-    Specifies a total pan offset since the start of the gesture.
-*/
-QSizeF QPanGesture::totalOffset() const
-{
-    Q_D(const QPanGesture);
-    return d->totalOffset;
-}
-
-/*!
-    \property QPanGesture::lastOffset
-
-    Specifies a pan offset the last time the gesture was triggered.
-*/
-QSizeF QPanGesture::lastOffset() const
-{
-    Q_D(const QPanGesture);
-    return d->lastOffset;
-}
-
-/*!
-    \property QPanGesture::offset
-
-    Specifies the current pan offset since the last time the gesture was
-    triggered.
-*/
-QSizeF QPanGesture::offset() const
-{
-    Q_D(const QPanGesture);
-    return d->offset;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-/*!
-    \class QPinchGesture
-    \preliminary
-    \since 4.6
-
-    \brief The QPinchGesture class represents a Pinch gesture,
-    providing additional information related to zooming and/or rotation.
-*/
-
-/*!
-  Creates a new Pinch gesture handler object and marks it as a child
-  of \a parent. The pan gesture handler watches \a gestureTarget for its
-  events.
-
-  On some platform like Windows it's necessary to provide a non-null
-  widget as \a parent to get native gesture support.
-*/
-QPinchGesture::QPinchGesture(QWidget *gestureTarget, QObject *parent)
-    : QGesture(*new QPinchGesturePrivate, gestureTarget, parent)
-{
-    setObjectName(QLatin1String("QPinchGesture"));
-}
-
-void QPinchGesturePrivate::setupGestureTarget(QObject *newGestureTarget)
-{
-    Q_Q(QPinchGesture);
-    if (gestureTarget && gestureTarget->isWidgetType()) {
-        QWidget *w = static_cast<QWidget*>(gestureTarget.data());
-        QApplicationPrivate::instance()->widgetGestures[w].pinch = 0;
-#ifdef Q_WS_WIN
-        qt_widget_private(w)->winSetupGestures();
-#endif
-    }
-
-    if (newGestureTarget && newGestureTarget->isWidgetType()) {
-        QWidget *w = static_cast<QWidget*>(newGestureTarget);
-        QApplicationPrivate::instance()->widgetGestures[w].pinch = q;
-#ifdef Q_WS_WIN
-        qt_widget_private(w)->winSetupGestures();
-#endif
-    }
-    QGesturePrivate::setupGestureTarget(newGestureTarget);
-}
-
-/*! \internal */
-bool QPinchGesture::event(QEvent *event)
-{
-    return QObject::event(event);
-}
-
-bool QPinchGesture::eventFilter(QObject *receiver, QEvent *event)
-{
-    Q_D(QPinchGesture);
-
-    if (d->implicitGesture && d->gestureTarget && d->gestureTarget->isWidgetType() &&
-        static_cast<QWidget*>(d->gestureTarget.data())->testAttribute(Qt::WA_DontUseStandardGestures))
-        return false;
-
-#if defined(Q_WS_WIN) || defined(Q_WS_MAC)
-    if (receiver->isWidgetType() && event->type() == QEvent::NativeGesture) {
-        QNativeGestureEvent *ev = static_cast<QNativeGestureEvent*>(event);
-#if defined(Q_WS_WIN)
-        QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
-        QApplicationPrivate::WidgetStandardGesturesMap::iterator it;
-        it = qAppPriv->widgetGestures.find(static_cast<QWidget*>(receiver));
-        if (it == qAppPriv->widgetGestures.end())
-            return false;
-        if (this != it.value().pinch)
-            return false;
-#endif
-        Qt::GestureState nextState = Qt::NoGesture;
-
-        switch(ev->gestureType) {
-        case QNativeGestureEvent::GestureBegin:
-            // next we might receive the first gesture update event, so we
-            // prepare for it.
-            d->state = Qt::NoGesture;
-            d->changes = 0;
-            d->totalScaleFactor = d->scaleFactor = d->lastScaleFactor = 1.;
-            d->totalRotationAngle = d->rotationAngle = d->lastRotationAngle = 0.;
-            d->startCenterPoint = d->centerPoint = d->lastCenterPoint = QPointF();
-#if defined(Q_WS_WIN)
-            d->initialDistance = 0;
-            d->lastSequenceId = ev->sequenceId;
-#endif
-            return false;
-        case QNativeGestureEvent::Rotate: {
-            d->lastScaleFactor = d->scaleFactor;
-            d->lastRotationAngle = d->rotationAngle;
-#if defined(Q_WS_MAC)
-            d->rotationAngle += ev->percentage;
-            nextState = Qt::GestureUpdated;
-#elif defined(Q_WS_WIN)
-            // This is a workaround for an issue with the native rotation
-            // gesture on Windows 7. For some reason the rotation angle in the
-            // first WM_GESTURE message in a sequence contains value that is
-            // off a little bit and causes the rotating item to "jump", so
-            // we just ignore the first WM_GESTURE in every sequence.
-            bool windowsRotateWorkaround = false;
-            if (!d->lastSequenceId) {
-                windowsRotateWorkaround = true;
-                d->lastSequenceId = ev->sequenceId;
-            }
-            if (d->lastSequenceId > 0 && d->lastSequenceId != (ulong)-1 && ev->sequenceId != d->lastSequenceId) {
-                // this is the first WM_GESTURE message in a sequence.
-                d->totalRotationAngle += d->rotationAngle;
-                windowsRotateWorkaround = true;
-                // a magic value to mark that the next WM_GESTURE message is
-                // the second message in a sequence and we should clear the
-                // lastRotationAngle
-                d->lastSequenceId = (ulong)-1;
-            }
-            if (!windowsRotateWorkaround) {
-                d->rotationAngle = -1 * GID_ROTATE_ANGLE_FROM_ARGUMENT(ev->argument) * 180. / M_PI;
-                if (d->lastSequenceId == (ulong)-1) {
-                    // a special case since we need to set the lastRotationAngle to
-                    // rotationAngle when the first WM_GESTURE is received in each
-                    // sequence.
-                    d->lastRotationAngle = d->rotationAngle;
-                }
-                d->lastSequenceId = ev->sequenceId;
-            }
-            if (!windowsRotateWorkaround)
-                nextState = Qt::GestureUpdated;
-#endif
-            d->changes = QPinchGesture::RotationAngleChanged;
-            event->accept();
-            break;
-        }
-        case QNativeGestureEvent::Zoom:
-            d->lastRotationAngle = d->rotationAngle;
-            d->lastScaleFactor = d->scaleFactor;
-#if defined(Q_WS_WIN)
-            if (d->initialDistance != 0) {
-                int distance = int(qint64(ev->argument));
-                if (d->lastSequenceId && ev->sequenceId != d->lastSequenceId) {
-                    d->totalScaleFactor *= d->scaleFactor;
-                    d->initialDistance = int(qint64(ev->argument));
-                    d->lastScaleFactor = d->scaleFactor = (qreal) distance / d->initialDistance;
-                } else {
-                    d->scaleFactor = (qreal) distance / d->initialDistance;
-                }
-                d->lastSequenceId = ev->sequenceId;
-            } else {
-                d->initialDistance = int(qint64(ev->argument));
-            }
-#elif defined(Q_WS_MAC)
-            d->scaleFactor += ev->percentage;
-#endif
-            nextState = Qt::GestureUpdated;
-            d->changes = QPinchGesture::ScaleFactorChanged;
-            event->accept();
-            break;
-        case QNativeGestureEvent::GestureEnd:
-            if (state() == Qt::NoGesture)
-                return false; // some other gesture has ended
-            nextState = Qt::GestureFinished;
-            break;
-        default:
-            return false;
-        }
-        if (d->startCenterPoint.isNull())
-            d->startCenterPoint = d->centerPoint;
-        d->lastCenterPoint = d->centerPoint;
-        d->centerPoint = static_cast<QWidget*>(receiver)->mapFromGlobal(ev->position);
-        if (d->lastCenterPoint != d->centerPoint)
-            d->changes |= QPinchGesture::CenterPointChanged;
-        updateState(nextState);
-        return true;
-    }
-#endif
-    return QGesture::eventFilter(receiver, event);
-}
-
-
-/*! \internal */
-bool QPinchGesture::filterEvent(QEvent *event)
-{
-    Q_D(QPinchGesture);
-
-    if (d->implicitGesture && d->gestureTarget && d->gestureTarget->isWidgetType() &&
-        static_cast<QWidget*>(d->gestureTarget.data())->testAttribute(Qt::WA_DontUseStandardGestures))
-        return false;
-
-    Q_UNUSED(event);
-    return false;
-}
-
-/*! \internal */
-void QPinchGesture::reset()
-{
-    Q_D(QPinchGesture);
-    d->changes = 0;
-    d->totalScaleFactor = d->scaleFactor = d->lastScaleFactor = 1.;
-    d->totalRotationAngle = d->rotationAngle = d->lastRotationAngle = 0.;
-    d->startCenterPoint = d->centerPoint = d->lastCenterPoint = QPointF();
-    QGesture::reset();
-}
-
-/*! \enum QPinchGesture::WhatChange
-  \value ScaleFactorChanged
-  \value RotationAngleChanged
-  \value CenterPointChanged
-*/
-
-/*!
-    \property QPinchGesture::whatChanged
-
-    Specifies which values were changed in the gesture.
-*/
-QPinchGesture::WhatChanged QPinchGesture::whatChanged() const
-{
-    return d_func()->changes;
-}
-
-/*!
-    \property QPinchGesture::totalScaleFactor
-
-    Specifies a total scale factor of the pinch gesture since the gesture
-    started.
-*/
-qreal QPinchGesture::totalScaleFactor() const
-{
-    Q_D(const QPinchGesture);
-    return d->totalScaleFactor * d->scaleFactor;
-}
-
-/*!
-    \property QPinchGesture::scaleFactor
-
-    Specifies a scale factor of the pinch gesture.
-
-    If the gesture consists of several pinch sequences (i.e. zoom and rotate
-    sequences), then this property specifies the scale factor in the current
-    sequence. When pinching changes the rotation angle only, the value of this
-    property is 1.
-*/
-qreal QPinchGesture::scaleFactor() const
-{
-    return d_func()->scaleFactor;
-}
-
-/*!
-    \property QPinchGesture::lastScaleFactor
-
-    Specifies a previous scale factor of the pinch gesture.
-*/
-qreal QPinchGesture::lastScaleFactor() const
-{
-    return d_func()->lastScaleFactor;
-}
-
-/*!
-    \property QPinchGesture::totalRotationAngle
-
-    Specifies a total rotation angle of the gesture since the gesture started.
-
-    The angle is specified in degrees.
-*/
-qreal QPinchGesture::totalRotationAngle() const
-{
-    Q_D(const QPinchGesture);
-    return d->totalRotationAngle + d->rotationAngle;
-}
-
-/*!
-    \property QPinchGesture::rotationAngle
-
-    Specifies a rotation angle of the gesture.
-
-    If the gesture consists of several pinch sequences (i.e. zoom and rotate
-    sequences), then this property specifies the rotation angle in the current
-    sequence. When pinching changes the scale factor only, the value of this
-    property is 0.
-
-    The angle is specified in degrees.
-*/
-qreal QPinchGesture::rotationAngle() const
-{
-    return d_func()->rotationAngle;
-}
-
-/*!
-    \property QPinchGesture::lastRotationAngle
-
-    Specifies a previous rotation angle of the gesture.
-
-    The angle is specified in degrees.
-*/
-qreal QPinchGesture::lastRotationAngle() const
-{
-    return d_func()->lastRotationAngle;
-}
-
-/*!
-    \property QPinchGesture::centerPoint
-
-    Specifies a center point of the gesture. The point can be used as a center
-    point that the object is rotated around.
-*/
-QPointF QPinchGesture::centerPoint() const
-{
-    return d_func()->centerPoint;
-}
-
-/*!
-    \property QPinchGesture::lastCenterPoint
-
-    Specifies a previous center point of the gesture.
-*/
-QPointF QPinchGesture::lastCenterPoint() const
-{
-    return d_func()->lastCenterPoint;
-}
-
-/*!
-    \property QPinchGesture::startCenterPoint
-
-    Specifies an initial center point of the gesture. Difference between the
-    startCenterPoint and the centerPoint is the distance at which pinching
-    fingers has shifted.
-*/
-QPointF QPinchGesture::startCenterPoint() const
-{
-    return d_func()->startCenterPoint;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-/*!
-    \class QSwipeGesture
-    \preliminary
-    \since 4.6
-
-    \brief The QSwipeGesture class represents a swipe gesture,
-    providing additional information related to swiping.
-*/
-
-/*!
-  Creates a new Swipe gesture handler object and marks it as a
-  child of \a parent. The swipe gesture handler watches \a
-  gestureTarget for its events.
-
-  On some platform like Windows it's necessary to provide a non-null
-  widget as \a parent to get native gesture support.
-*/
-QSwipeGesture::QSwipeGesture(QWidget *gestureTarget, QObject *parent)
-    : QGesture(*new QSwipeGesturePrivate, gestureTarget, parent)
-{
-    setObjectName(QLatin1String("QSwipeGesture"));
-}
-
-void QSwipeGesturePrivate::setupGestureTarget(QObject *newGestureTarget)
-{
-    Q_Q(QSwipeGesture);
-    if (gestureTarget && gestureTarget->isWidgetType()) {
-        QWidget *w = static_cast<QWidget*>(gestureTarget.data());
-        QApplicationPrivate::instance()->widgetGestures[w].swipe = 0;
-#if defined(Q_WS_WIN)
-        qt_widget_private(w)->winSetupGestures();
-#endif
-    }
-
-    if (newGestureTarget && newGestureTarget->isWidgetType()) {
-        QWidget *w = static_cast<QWidget*>(newGestureTarget);
-        QApplicationPrivate::instance()->widgetGestures[w].swipe = q;
-#if defined(Q_WS_WIN)
-        qt_widget_private(w)->winSetupGestures();
-#endif
-    }
-    QGesturePrivate::setupGestureTarget(newGestureTarget);
-}
-
-/*!
-  \property QSwipeGesture::swipeAngle
-
-  Holds the angle of the swipe gesture, 0..360.
-*/
-qreal QSwipeGesture::swipeAngle() const
-{
-    Q_D(const QSwipeGesture);
-    return d->swipeAngle;
-}
-
-/*!
-  \property QSwipeGesture::horizontalDirection
-
-  Holds the direction for the horizontal component of the swipe
-  gesture, SwipeDirection::Left or SwipeDirection::Right.
-  SwipeDirection::NoDirection if there is no horizontal
-  component to the swipe gesture.
-*/
-QSwipeGesture::SwipeDirection QSwipeGesture::horizontalDirection() const
-{
-    Q_D(const QSwipeGesture);
-    if (d->swipeAngle < 0 || d->swipeAngle == 90 || d->swipeAngle == 270)
-        return QSwipeGesture::NoDirection;
-    else if (d->swipeAngle < 90 || d->swipeAngle > 270)
-        return QSwipeGesture::Right;
-    else
-        return QSwipeGesture::Left;
-}
-
-
-/*!
-  \property QSwipeGesture::verticalDirection
-
-  Holds the direction for the vertical component of the swipe
-  gesture, SwipeDirection::Down or SwipeDirection::Up.
-  SwipeDirection::NoDirection if there is no vertical
-  component to the swipe gesture.
-*/
-QSwipeGesture::SwipeDirection QSwipeGesture::verticalDirection() const
-{
-    Q_D(const QSwipeGesture);
-    if (d->swipeAngle <= 0 || d->swipeAngle == 180)
-        return QSwipeGesture::NoDirection;
-    else if (d->swipeAngle < 180)
-        return QSwipeGesture::Up;
-    else
-        return QSwipeGesture::Down;
-}
-
-bool QSwipeGesture::eventFilter(QObject *receiver, QEvent *event)
-{
-    Q_D(QSwipeGesture);
-    if (receiver->isWidgetType() && event->type() == QEvent::NativeGesture) {
-        QNativeGestureEvent *ev = static_cast<QNativeGestureEvent*>(event);
-        switch (ev->gestureType) {
-        case QNativeGestureEvent::Swipe:
-            d->swipeAngle = ev->angle;
-            updateState(Qt::GestureStarted);
-            updateState(Qt::GestureUpdated);
-            updateState(Qt::GestureFinished);
-            break;
-        default:
-            return false;
-        }
-        return true;
-    }
-    return QGesture::eventFilter(receiver, event);
-}
-
-/*! \internal */
-bool QSwipeGesture::filterEvent(QEvent *)
-{
-    return false;
-}
-
-/*! \internal */
-void QSwipeGesture::reset()
-{
-    Q_D(QSwipeGesture);
-    d->swipeAngle = -1;
-    QGesture::reset();
+    return QGestureRecognizer::Ignore;
 }
+    */
 
 QT_END_NAMESPACE
-
-#include "moc_qstandardgestures.cpp"
-
diff --git a/src/gui/kernel/qstandardgestures.h b/src/gui/kernel/qstandardgestures.h
deleted file mode 100644
index 9e8291b..0000000
--- a/src/gui/kernel/qstandardgestures.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
-**
-** This file is part of the QtGui module 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 qt-info@nokia.com.
-**
-**
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QSTANDARDGESTURES_H
-#define QSTANDARDGESTURES_H
-
-#include <QtGui/qevent.h>
-#include <QtCore/qbasictimer.h>
-
-#include <QtGui/qgesture.h>
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Gui)
-
-class QPanGesturePrivate;
-class Q_GUI_EXPORT QPanGesture : public QGesture
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE(QPanGesture)
-
-    Q_PROPERTY(QSizeF totalOffset READ totalOffset)
-    Q_PROPERTY(QSizeF lastOffset READ lastOffset)
-    Q_PROPERTY(QSizeF offset READ offset)
-
-public:
-    QPanGesture(QWidget *gestureTarget, QObject *parent = 0);
-
-    bool filterEvent(QEvent *event);
-
-    QSizeF totalOffset() const;
-    QSizeF lastOffset() const;
-    QSizeF offset() const;
-
-protected:
-    void reset();
-
-private:
-    bool event(QEvent *event);
-    bool eventFilter(QObject *receiver, QEvent *event);
-
-    friend class QWidget;
-    friend class QAbstractScrollAreaPrivate;
-};
-
-class QPinchGesturePrivate;
-class Q_GUI_EXPORT QPinchGesture : public QGesture
-{
-    Q_OBJECT
-    Q_DECLARE_PRIVATE(QPinchGesture)
-
-public:
-    enum WhatChange {
-        ScaleFactorChanged = 0x1,
-        RotationAngleChanged = 0x2,
-        CenterPointChanged = 0x4
-    };
-    Q_DECLARE_FLAGS(WhatChanged, WhatChange)
-
-    Q_PROPERTY(WhatChanged whatChanged READ whatChanged)
-
-    Q_PROPERTY(qreal totalScaleFactor READ totalScaleFactor)
-    Q_PROPERTY(qreal lastScaleFactor READ lastScaleFactor)
-    Q_PROPERTY(qreal scaleFactor READ scaleFactor)
-
-    Q_PROPERTY(qreal totalRotationAngle READ totalRotationAngle)
-    Q_PROPERTY(qreal lastRotationAngle READ lastRotationAngle)
-    Q_PROPERTY(qreal rotationAngle READ rotationAngle)
-
-    Q_PROPERTY(QPointF startCenterPoint READ startCenterPoint)
-    Q_PROPERTY(QPointF lastCenterPoint READ lastCenterPoint)
-    Q_PROPERTY(QPointF centerPoint READ centerPoint)
-
-public:
-
-    QPinchGesture(QWidget *gestureTarget, QObject *parent = 0);
-
-    bool filterEvent(QEvent *event);
-    void reset();
-
-    WhatChanged whatChanged() const;
-
-    QPointF startCenterPoint() const;
-    QPointF lastCenterPoint() const;
-    QPointF centerPoint() const;
-
-    qreal totalScaleFactor() const;
-    qreal lastScaleFactor() const;
-    qreal scaleFactor() const;
-
-    qreal totalRotationAngle() const;
-    qreal lastRotationAngle() const;
-    qreal rotationAngle() const;
-
-private:
-    bool event(QEvent *event);
-    bool eventFilter(QObject *receiver, QEvent *event);
-
-    friend class QWidget;
-};
-
-class QSwipeGesturePrivate;
-class Q_GUI_EXPORT QSwipeGesture : public QGesture
-{
-    Q_OBJECT
-    Q_ENUMS(SwipeDirection)
-
-    Q_PROPERTY(SwipeDirection horizontalDirection READ horizontalDirection)
-    Q_PROPERTY(SwipeDirection verticalDirection READ verticalDirection)
-    Q_PROPERTY(qreal swipeAngle READ swipeAngle)
-
-    Q_DECLARE_PRIVATE(QSwipeGesture)
-
-public:
-    enum SwipeDirection { NoDirection, Left, Right, Up, Down };
-    QSwipeGesture(QWidget *gestureTarget, QObject *parent = 0);
-
-    bool filterEvent(QEvent *event);
-    void reset();
-
-    SwipeDirection horizontalDirection() const;
-    SwipeDirection verticalDirection() const;
-    qreal swipeAngle() const;
-
-private:
-    bool eventFilter(QObject *receiver, QEvent *event);
-
-    friend class QWidget;
-};
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
-#endif // QSTANDARDGESTURES_H
diff --git a/src/gui/kernel/qstandardgestures_p.h b/src/gui/kernel/qstandardgestures_p.h
index 79aadfd..fec5c2f 100644
--- a/src/gui/kernel/qstandardgestures_p.h
+++ b/src/gui/kernel/qstandardgestures_p.h
@@ -53,83 +53,20 @@
 // We mean it.
 //
 
-#include "qevent.h"
-#include "qbasictimer.h"
-#include "qdebug.h"
-
-#include "qgesture.h"
-#include "qgesture_p.h"
-
-#include "qstandardgestures.h"
-#include "qbasictimer.h"
+#include "qgesturerecognizer.h"
+#include "private/qgesture_p.h"
 
 QT_BEGIN_NAMESPACE
 
-class QPanGesturePrivate : public QGesturePrivate
-{
-    Q_DECLARE_PUBLIC(QPanGesture)
-
-public:
-    void setupGestureTarget(QObject *o);
-
-    QSizeF totalOffset;
-    QSizeF lastOffset;
-    QSizeF offset;
-    QPointF lastPosition;
-
-#if defined(QT_MAC_USE_COCOA)
-    QBasicTimer singleTouchPanTimer;
-    QPointF prevMousePos;
-#endif
-};
-
-class QPinchGesturePrivate : public QGesturePrivate
+class QPanGestureRecognizer : public QGestureRecognizer
 {
-    Q_DECLARE_PUBLIC(QPinchGesture)
-
 public:
-    QPinchGesturePrivate()
-        : changes(0), totalScaleFactor(0.), lastScaleFactor(0.), scaleFactor(0.),
-          totalRotationAngle(0.), lastRotationAngle(0.), rotationAngle(0.)
-#ifdef Q_WS_WIN
-          ,initialDistance(0), lastSequenceId(0)
-#endif
-    {
-    }
+    QPanGestureRecognizer();
 
-    void setupGestureTarget(QObject *o);
-
-    QPinchGesture::WhatChanged changes;
-
-    qreal totalScaleFactor; // total scale factor, excluding the current sequence.
-    qreal lastScaleFactor;
-    qreal scaleFactor; // scale factor in the current sequence.
-
-    qreal totalRotationAngle; // total rotation angle, excluding the current sequence.
-    qreal lastRotationAngle;
-    qreal rotationAngle; // rotation angle in the current sequence.
-
-    QPointF startCenterPoint;
-    QPointF lastCenterPoint;
-    QPointF centerPoint;
-#ifdef Q_WS_WIN
-    int initialDistance;
-    ulong lastSequenceId;
-#endif
-};
-
-class QSwipeGesturePrivate : public QGesturePrivate
-{
-    Q_DECLARE_PUBLIC(QSwipeGesture)
-
-public:
-    QSwipeGesturePrivate()
-        : swipeAngle(-1)
-    {
-    }
+    QGesture *createGesture(QObject *target);
 
-    void setupGestureTarget(QObject *o);
-    qreal swipeAngle;
+    QGestureRecognizer::Result filterEvent(QGesture *state, QObject *watched, QEvent *event);
+    void reset(QGesture *state);
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index 56602f7..bce06e0 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -115,6 +115,7 @@
 #include "private/qevent_p.h"
 
 #include "private/qgraphicssystem_p.h"
+#include "private/qgesturemanager_p.h"
 
 // widget/widget data creation count
 //#define QWIDGET_EXTRA_DEBUG
@@ -8332,6 +8333,9 @@ bool QWidget::event(QEvent *event)
         (void) QApplication::sendEvent(this, &mouseEvent);
         break;
     }
+    case QEvent::Gesture:
+        event->ignore();
+        break;
 #ifndef QT_NO_PROPERTIES
     case QEvent::DynamicPropertyChange: {
         const QByteArray &propName = static_cast<QDynamicPropertyChangeEvent *>(event)->propertyName();
@@ -11668,6 +11672,13 @@ QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const
     Synonym for QList<QWidget *>.
 */
 
+void QWidget::grabGesture(Qt::GestureType type, Qt::GestureContext context)
+{
+    Q_D(QWidget);
+    d->gestureContext.insert(type, context);
+    (void)QGestureManager::instance(); // create a gesture manager
+}
+
 QT_END_NAMESPACE
 
 #include "moc_qwidget.cpp"
diff --git a/src/gui/kernel/qwidget.h b/src/gui/kernel/qwidget.h
index 76418af..3501c6e 100644
--- a/src/gui/kernel/qwidget.h
+++ b/src/gui/kernel/qwidget.h
@@ -96,7 +96,6 @@ class QIcon;
 class QWindowSurface;
 class QLocale;
 class QGraphicsProxyWidget;
-class QGestureManager;
 class QGraphicsEffect;
 #if defined(Q_WS_X11)
 class QX11Info;
@@ -355,6 +354,8 @@ public:
     QGraphicsEffect *graphicsEffect() const;
     void setGraphicsEffect(QGraphicsEffect *effect);
 
+    void grabGesture(Qt::GestureType type, Qt::GestureContext context = Qt::WidgetWithChildrenGesture);
+
 public Q_SLOTS:
     void setWindowTitle(const QString &);
 #ifndef QT_NO_STYLE_STYLESHEET
@@ -737,6 +738,8 @@ private:
     friend class QGraphicsProxyWidgetPrivate;
     friend class QStyleSheetStyle;
     friend struct QWidgetExceptionCleaner;
+    friend class QGestureManager;
+    friend class QWinNativePanGestureRecognizer;
 
 #ifdef Q_WS_MAC
     friend class QCoreGraphicsPaintEnginePrivate;
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index c06ef73..a549740 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -64,6 +64,8 @@
 #include "QtGui/qapplication.h"
 #include <private/qgraphicseffect_p.h>
 
+#include <private/qgesture_p.h>
+
 #ifdef Q_WS_WIN
 #include "QtCore/qt_windows.h"
 #include <private/qdnd_p.h>
@@ -578,6 +580,7 @@ public:
 #ifndef QT_NO_ACTION
     QList<QAction*> actions;
 #endif
+    QMap<Qt::GestureType, Qt::GestureContext> gestureContext;
 
     // Bit fields.
     uint high_attributes[3]; // the low ones are in QWidget::widget_attributes
@@ -604,6 +607,7 @@ public:
     bool isBackgroundInherited() const;
 #elif defined(Q_WS_WIN) // <--------------------------------------------------------- WIN
     uint noPaintOnScreen : 1; // see qwidget_win.cpp ::paintEngine()
+    uint nativeGesturePanEnabled : 1;
 
     bool shouldShowMaximizeButton();
     void winUpdateIsOpaque();
diff --git a/src/gui/kernel/qwidget_win.cpp b/src/gui/kernel/qwidget_win.cpp
index a0982f4..2b11bec 100644
--- a/src/gui/kernel/qwidget_win.cpp
+++ b/src/gui/kernel/qwidget_win.cpp
@@ -2029,11 +2029,6 @@ void QWidgetPrivate::winSetupGestures()
     if (!q || !q->isVisible())
         return;
     QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
-    QApplicationPrivate::WidgetStandardGesturesMap::const_iterator it =
-            qAppPriv->widgetGestures.find(q);
-    if (it == qAppPriv->widgetGestures.end())
-        return;
-    const QStandardGestures &gestures = it.value();
     WId winid = q->effectiveWinId();
 
     bool needh = false;
@@ -2052,10 +2047,10 @@ void QWidgetPrivate::winSetupGestures()
         singleFingerPanEnabled = asa->d_func()->singleFingerPanEnabled;
     }
     if (winid && qAppPriv->SetGestureConfig) {
-        GESTURECONFIG gc[3];
+        GESTURECONFIG gc[1];
         memset(gc, 0, sizeof(gc));
         gc[0].dwID = GID_PAN;
-        if (gestures.pan) {
+        if (nativeGesturePanEnabled) {
             gc[0].dwWant = GC_PAN;
             if (needv && singleFingerPanEnabled)
                 gc[0].dwWant |= GC_PAN_WITH_SINGLE_FINGER_VERTICALLY;
@@ -2069,16 +2064,16 @@ void QWidgetPrivate::winSetupGestures()
             gc[0].dwBlock = GC_PAN;
         }
 
-        gc[1].dwID = GID_ZOOM;
-        if (gestures.pinch)
-            gc[1].dwWant = GC_ZOOM;
-        else
-            gc[1].dwBlock = GC_ZOOM;
-        gc[2].dwID = GID_ROTATE;
-        if (gestures.pinch)
-            gc[2].dwWant = GC_ROTATE;
-        else
-            gc[2].dwBlock = GC_ROTATE;
+//        gc[1].dwID = GID_ZOOM;
+//        if (gestures.pinch)
+//            gc[1].dwWant = GC_ZOOM;
+//        else
+//            gc[1].dwBlock = GC_ZOOM;
+//        gc[2].dwID = GID_ROTATE;
+//        if (gestures.pinch)
+//            gc[2].dwWant = GC_ROTATE;
+//        else
+//            gc[2].dwBlock = GC_ROTATE;
 
         qAppPriv->SetGestureConfig(winid, 0, sizeof(gc)/sizeof(gc[0]), gc, sizeof(gc[0]));
     }
diff --git a/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp b/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp
new file mode 100644
index 0000000..4619594
--- /dev/null
+++ b/src/gui/kernel/qwinnativepangesturerecognizer_win.cpp
@@ -0,0 +1,124 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qwinnativepangesturerecognizer_win_p.h"
+
+#include "qevent.h"
+#include "qgraphicsitem.h"
+#include "qgesture.h"
+
+#include "private/qgesture_p.h"
+#include "private/qevent_p.h"
+#include "private/qapplication_p.h"
+#include "private/qwidget_p.h"
+
+QT_BEGIN_NAMESPACE
+
+QWinNativePanGestureRecognizer::QWinNativePanGestureRecognizer()
+{
+}
+
+QGesture* QWinNativePanGestureRecognizer::createGesture(QObject *target) const
+{
+    if (!target)
+        return new QPanGesture; // a special case
+    if (qobject_cast<QGraphicsObject*>(target))
+        return 0;
+    if (!target->isWidgetType())
+        return 0;
+
+    QWidget *q = static_cast<QWidget*>(target);
+    QWidgetPrivate *d = q->d_func();
+    d->nativeGesturePanEnabled = true;
+    d->winSetupGestures();
+
+    return new QPanGesture;
+}
+
+QGestureRecognizer::Result QWinNativePanGestureRecognizer::filterEvent(QGesture *state, QObject *, QEvent *event)
+{
+    QPanGesture *q = static_cast<QPanGesture*>(state);
+    QPanGesturePrivate *d = q->d_func();
+
+    QGestureRecognizer::Result result = QGestureRecognizer::Ignore;
+    if (event->type() == QEvent::NativeGesture) {
+        QNativeGestureEvent *ev = static_cast<QNativeGestureEvent*>(event);
+        switch(ev->gestureType) {
+        case QNativeGestureEvent::GestureBegin:
+            break;
+        case QNativeGestureEvent::Pan:
+            result = QGestureRecognizer::GestureTriggered;
+            event->accept();
+            break;
+        case QNativeGestureEvent::GestureEnd:
+            if (q->state() == Qt::NoGesture)
+                return QGestureRecognizer::Ignore; // some other gesture has ended
+            result = QGestureRecognizer::GestureFinished;
+            break;
+        default:
+            return QGestureRecognizer::Ignore;
+        }
+        if (q->state() == Qt::NoGesture) {
+            d->lastOffset = d->totalOffset = d->offset = QSize();
+        } else {
+            d->lastOffset = d->offset;
+            d->offset = QSize(ev->position.x() - d->lastPosition.x(),
+                              ev->position.y() - d->lastPosition.y());
+            d->totalOffset += d->offset;
+        }
+        d->lastPosition = ev->position;
+    }
+    return result;
+}
+
+void QWinNativePanGestureRecognizer::reset(QGesture *state)
+{
+    QPanGesture *pan = static_cast<QPanGesture*>(state);
+    QPanGesturePrivate *d = pan->d_func();
+
+    d->totalOffset = d->lastOffset = d->offset = QSizeF();
+    d->lastPosition = QPoint();
+    d->acceleration = 0;
+
+    QGestureRecognizer::reset(state);
+}
+
+QT_END_NAMESPACE
diff --git a/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h b/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h
new file mode 100644
index 0000000..a1e8511
--- /dev/null
+++ b/src/gui/kernel/qwinnativepangesturerecognizer_win_p.h
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QWINNATIVEPANGESTURERECOGNIZER_WIN_P_H
+#define QWINNATIVEPANGESTURERECOGNIZER_WIN_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QGestureRecognizer>
+
+QT_BEGIN_NAMESPACE
+
+class QWinNativePanGestureRecognizer : public QGestureRecognizer
+{
+public:
+    QWinNativePanGestureRecognizer();
+
+    QGesture* createGesture(QObject *target) const;
+
+    QGestureRecognizer::Result filterEvent(QGesture *state, QObject *watched, QEvent *event);
+    void reset(QGesture *state);
+};
+
+QT_END_NAMESPACE
+
+#endif // QWINNATIVEPANGESTURERECOGNIZER_WIN_P_H