Remove uses of deprecated MapPinchArea and MapFlickable.

These elements/properties are deprecated use the MapGestureArea and
gesture properties instead.

Change-Id: I755e69f6394dda7a92c33aa1fe37efcfd84aa9ff
Reviewed-by: Ian Chen <ian.1.chen@nokia.com>

1 files changed, 203 insertions, 215 deletions

diff --git a/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml b/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml
index 692525e0..08907047 100644
--- a/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml
+++ b/tests/auto/declarative_ui/tst_map_pinch_and_flick.qml
@@ -61,53 +61,56 @@ Item {
         x:0; y:0
         property variant lastPinchEvent: null
         property bool rejectPinch: false
-        pinch.onPinchStarted: {map.lastPinchEvent = pinch; if (rejectPinch) pinch.accepted = false;
+        gesture.onPinchStarted: {
+            map.lastPinchEvent = pinch;
+            if (rejectPinch)
+                pinch.accepted = false;
             //console.log('Pinch got started, point1: ' + pinch.point1 + ' point2: ' + pinch.point2 + ' angle: ' + pinch.angle)
         }
-        pinch.onPinchUpdated: {map.lastPinchEvent = pinch
+        gesture.onPinchUpdated: {
+            map.lastPinchEvent = pinch;
             //console.log('Pinch got updated, point1: ' + pinch.point1 + ' point2: ' + pinch.point2 + ' angle: ' + pinch.angle)
         }
-        pinch.onPinchFinished: {map.lastPinchEvent = pinch}
+        gesture.onPinchFinished: {
+            map.lastPinchEvent = pinch;
+        }
         property real flickStartedLatitude
         property real flickStartedLongitude
         property bool disableFlickOnStarted: false
         property bool disableFlickOnMovementStarted: false
-        flick.onMovementStarted: {
+        gesture.onPanStarted: {
             if (disableFlickOnMovementStarted)
-                map.flick.enabled = false
+                map.gesture.panEnabled = false
         }
-        flick.onFlickStarted: {
+        gesture.onFlickStarted: {
             flickStartedLatitude = map.center.latitude
             flickStartedLatitude = map.center.longitude
-            if (disableFlickOnStarted) {
-                map.flick.enabled = false
-            }
+            if (disableFlickOnStarted)
+                map.gesture.panEnabled = false
         }
     }
     SignalSpy {id: centerSpy; target: map; signalName: 'centerChanged'}
     SignalSpy {id: coordinate2LatitudeSpy; target: coordinate2; signalName: 'latitudeChanged'}
     SignalSpy {id: coordinate2LongitudeSpy; target: coordinate2; signalName: 'longitudeChanged'}
     SignalSpy {id: coordinate2AltitudeSpy; target: coordinate2; signalName: 'altitudeChanged'}
-    SignalSpy {id: pinchStartedSpy; target: map.pinch; signalName: 'pinchStarted'}
-    SignalSpy {id: pinchUpdatedSpy; target: map.pinch; signalName: 'pinchUpdated'}
-    SignalSpy {id: pinchFinishedSpy; target: map.pinch; signalName: 'pinchFinished'}
-    SignalSpy {id: pinchMaximumZoomLevelChangeSpy; target: map.pinch; signalName: 'maximumZoomLevelChangeChanged'}
-    //SignalSpy {id: pinchMinimumZoomLevelSpy; target: map.pinch; signalName: 'minimumZoomLevelChanged'}
-    //SignalSpy {id: pinchMaximumZoomLevelSpy; target: map.pinch; signalName: 'maximumZoomLevelChanged'}
-    //SignalSpy {id: pinchMinimumRotationSpy; target: map.pinch; signalName: 'minimumRotationChanged'}
-    //SignalSpy {id: pinchMaximumRotationSpy; target: map.pinch; signalName: 'maximumRotationChanged'}
-    SignalSpy {id: pinchRotationFactorSpy; target: map.pinch; signalName: 'rotationFactorChanged'}
-    SignalSpy {id: pinchEnabledSpy; target: map.pinch; signalName: 'enabledChanged'}
-    SignalSpy {id: pinchActiveSpy; target: map.pinch; signalName: 'activeChanged'}
-    SignalSpy {id: pinchActiveGesturesSpy; target: map.pinch; signalName: 'activeGesturesChanged'}
+    SignalSpy {id: pinchStartedSpy; target: map.gesture; signalName: 'pinchStarted'}
+    SignalSpy {id: pinchUpdatedSpy; target: map.gesture; signalName: 'pinchUpdated'}
+    SignalSpy {id: pinchFinishedSpy; target: map.gesture; signalName: 'pinchFinished'}
+    SignalSpy {id: pinchMaximumZoomLevelChangeSpy; target: map.gesture; signalName: 'maximumZoomLevelChangeChanged'}
+    //SignalSpy {id: pinchMinimumZoomLevelSpy; target: map.gesture; signalName: 'minimumZoomLevelChanged'}
+    //SignalSpy {id: pinchMaximumZoomLevelSpy; target: map.gesture; signalName: 'maximumZoomLevelChanged'}
+    //SignalSpy {id: pinchMinimumRotationSpy; target: map.gesture; signalName: 'minimumRotationChanged'}
+    //SignalSpy {id: pinchMaximumRotationSpy; target: map.gesture; signalName: 'maximumRotationChanged'}
+    SignalSpy {id: pinchRotationFactorSpy; target: map.gesture; signalName: 'rotationFactorChanged'}
+    SignalSpy {id: gestureEnabledSpy; target: map.gesture; signalName: 'enabledChanged'}
+    SignalSpy {id: pinchActiveSpy; target: map.gesture; signalName: 'pinchActiveChanged'}
+    SignalSpy {id: pinchActiveGesturesSpy; target: map.gesture; signalName: 'activeGesturesChanged'}
     SignalSpy {id: mapZoomLevelSpy; target: map; signalName: 'zoomLevelChanged'}
     SignalSpy {id: mapBearingSpy; target: map; signalName: 'bearingChanged'}
-    SignalSpy {id: flickEnabledSpy; target: map.flick; signalName: 'enabledChanged'}
-    SignalSpy {id: flickDecelerationSpy; target: map.flick; signalName: 'decelerationChanged'}
-    SignalSpy {id: flickMovementStartedSpy; target: map.flick; signalName: 'movementStarted'}
-    SignalSpy {id: flickMovementEndedSpy; target: map.flick; signalName: 'movementEnded'}
-    SignalSpy {id: flickStartedSpy; target: map.flick; signalName: 'flickStarted'}
-    SignalSpy {id: flickEndedSpy; target: map.flick; signalName: 'flickEnded'}
+    SignalSpy {id: flickDecelerationSpy; target: map.gesture; signalName: 'flickDecelerationChanged'}
+    SignalSpy {id: movementStoppedSpy; target: map.gesture; signalName: 'movementStopped'}
+    SignalSpy {id: flickStartedSpy; target: map.gesture; signalName: 'flickStarted'}
+    SignalSpy {id: flickFinishedSpy; target: map.gesture; signalName: 'flickFinished'}
 
     // From QtLocation.test plugin
     PinchGenerator {
@@ -135,188 +138,176 @@ Item {
             //pinchMinimumRotationSpy.clear()
             //pinchMaximumRotationSpy.clear()
             pinchRotationFactorSpy.clear()
-            pinchEnabledSpy.clear()
+            gestureEnabledSpy.clear()
             pinchActiveSpy.clear()
             pinchActiveGesturesSpy.clear()
             mapZoomLevelSpy.clear()
             mapBearingSpy.clear()
-            flickEnabledSpy.clear()
             flickDecelerationSpy.clear()
-            flickMovementStartedSpy.clear()
-            flickMovementEndedSpy.clear()
+            movementStoppedSpy.clear()
             flickStartedSpy.clear()
-            flickEndedSpy.clear()
+            flickFinishedSpy.clear()
         }
 
         function test_a_basic_properties() { // a to excecute first
             clear_data()
 
-            // pinch
-            compare(map.pinch.enabled, true)
-            map.pinch.enabled = false
-            compare(pinchEnabledSpy.count, 1)
-            compare(map.pinch.enabled, false)
-            map.pinch.enabled = false
-            compare(pinchEnabledSpy.count, 1)
-            compare(map.pinch.enabled, false)
-            map.pinch.enabled = true
-            compare(pinchEnabledSpy.count, 2)
-            compare(map.pinch.enabled, true)
-
-            compare(map.pinch.active, false)
-
-            verify(map.pinch.activeGestures & MapPinchArea.ZoomGesture)
-            verify(!(map.pinch.activeGestures & MapPinchArea.RotationGesture))
-            verify(!(map.pinch.activeGestures & MapPinchArea.TiltGesture))
-            map.pinch.activeGestures = MapPinchArea.NoGesture
-            compare(map.pinch.activeGestures, MapPinchArea.NoGesture)
+            compare(map.gesture.enabled, true)
+            map.gesture.enabled = false
+            compare(gestureEnabledSpy.count, 1)
+            compare(map.gesture.enabled, false)
+            map.gesture.enabled = false
+            compare(gestureEnabledSpy.count, 1)
+            compare(map.gesture.enabled, false)
+            map.gesture.enabled = true
+            compare(gestureEnabledSpy.count, 2)
+            compare(map.gesture.enabled, true)
+
+            compare(map.gesture.isPinchActive, false)
+
+            verify(map.gesture.activeGestures & MapGestureArea.ZoomGesture)
+            verify(!(map.gesture.activeGestures & MapGestureArea.RotationGesture))
+            verify(!(map.gesture.activeGestures & MapGestureArea.TiltGesture))
+            map.gesture.activeGestures = MapGestureArea.NoGesture
+            compare(map.gesture.activeGestures, MapGestureArea.NoGesture)
             compare(pinchActiveGesturesSpy.count, 1)
-            map.pinch.activeGestures = MapPinchArea.NoGesture
-            compare(map.pinch.activeGestures, MapPinchArea.NoGesture)
+            map.gesture.activeGestures = MapGestureArea.NoGesture
+            compare(map.gesture.activeGestures, MapGestureArea.NoGesture)
             compare(pinchActiveGesturesSpy.count, 1)
-            map.pinch.activeGestures = MapPinchArea.ZoomGesture | MapPinchArea.RotationGesture
-            compare(map.pinch.activeGestures, MapPinchArea.ZoomGesture | MapPinchArea.RotationGesture)
+            map.gesture.activeGestures = MapGestureArea.ZoomGesture | MapGestureArea.RotationGesture
+            compare(map.gesture.activeGestures, MapGestureArea.ZoomGesture | MapGestureArea.RotationGesture)
             compare(pinchActiveGesturesSpy.count, 2)
-            map.pinch.activeGestures = MapPinchArea.RotationGesture
-            compare(map.pinch.activeGestures, MapPinchArea.RotationGesture)
+            map.gesture.activeGestures = MapGestureArea.RotationGesture
+            compare(map.gesture.activeGestures, MapGestureArea.RotationGesture)
             compare(pinchActiveGesturesSpy.count, 3)
-            map.pinch.activeGestures = MapPinchArea.ZoomGesture
-            compare(map.pinch.activeGestures, MapPinchArea.ZoomGesture)
+            map.gesture.activeGestures = MapGestureArea.ZoomGesture
+            compare(map.gesture.activeGestures, MapGestureArea.ZoomGesture)
             compare(pinchActiveGesturesSpy.count, 4)
 
             /*
-            compare(map.pinch.minimumZoomLevel, map.minimumZoomLevel)
-            map.pinch.minimumZoomLevel = 5
+            compare(map.gesture.minimumZoomLevel, map.minimumZoomLevel)
+            map.gesture.minimumZoomLevel = 5
             compare(pinchMinimumZoomLevelSpy.count, 1)
-            compare(map.pinch.minimumZoomLevel, 5)
-            map.pinch.minimumZoomLevel = -1 // too small
-            map.pinch.minimumZoomLevel = 492 // too big
+            compare(map.gesture.minimumZoomLevel, 5)
+            map.gesture.minimumZoomLevel = -1 // too small
+            map.gesture.minimumZoomLevel = 492 // too big
             compare(pinchMinimumZoomLevelSpy.count, 1)
-            compare(map.pinch.minimumZoomLevel, 5)
-            map.pinch.minimumZoomLevel = map.minimumZoomLevel
+            compare(map.gesture.minimumZoomLevel, 5)
+            map.gesture.minimumZoomLevel = map.minimumZoomLevel
             compare(pinchMinimumZoomLevelSpy.count, 2)
-            compare(map.pinch.minimumZoomLevel, map.minimumZoomLevel)
+            compare(map.gesture.minimumZoomLevel, map.minimumZoomLevel)
 
-            compare(map.pinch.maximumZoomLevel, map.maximumZoomLevel)
-            map.pinch.maximumZoomLevel = 9
+            compare(map.gesture.maximumZoomLevel, map.maximumZoomLevel)
+            map.gesture.maximumZoomLevel = 9
             compare (pinchMaximumZoomLevelSpy.count, 1)
-            compare(map.pinch.maximumZoomLevel, 9)
-            map.pinch.maximumZoomLevel = -1 // too small
-            map.pinch.maximumZoomLevel = 3234 // too big
+            compare(map.gesture.maximumZoomLevel, 9)
+            map.gesture.maximumZoomLevel = -1 // too small
+            map.gesture.maximumZoomLevel = 3234 // too big
             compare(pinchMaximumZoomLevelSpy.count, 1)
-            compare(map.pinch.maximumZoomLevel, 9)
-            map.pinch.maximumZoomLevel = map.maximumZoomLevel
+            compare(map.gesture.maximumZoomLevel, 9)
+            map.gesture.maximumZoomLevel = map.maximumZoomLevel
             compare(pinchMaximumZoomLevelSpy.count, 2)
-            compare(map.pinch.maximumZoomLevel, map.maximumZoomLevel)
+            compare(map.gesture.maximumZoomLevel, map.maximumZoomLevel)
 
             clear_data()
-            map.pinch.minimumZoomLevel = 5  // ok
-            map.pinch.maximumZoomLevel = 9  // ok
-            map.pinch.minimumZoomLevel = 10 // bigger than max
-            map.pinch.maximumZoomLevel = 4  // smaller than min
+            map.gesture.minimumZoomLevel = 5  // ok
+            map.gesture.maximumZoomLevel = 9  // ok
+            map.gesture.minimumZoomLevel = 10 // bigger than max
+            map.gesture.maximumZoomLevel = 4  // smaller than min
             compare (pinchMaximumZoomLevelSpy.count, 1)
             compare (pinchMinimumZoomLevelSpy.count, 1)
-            compare(map.pinch.maximumZoomLevel, 9)
-            compare(map.pinch.minimumZoomLevel, 5)
-            map.pinch.minimumZoomLevel = map.minimumZoomLevel
-            map.pinch.maximumZoomLevel = map.maximumZoomLevel
+            compare(map.gesture.maximumZoomLevel, 9)
+            compare(map.gesture.minimumZoomLevel, 5)
+            map.gesture.minimumZoomLevel = map.minimumZoomLevel
+            map.gesture.maximumZoomLevel = map.maximumZoomLevel
             */
 
-            compare(map.pinch.maximumZoomLevelChange, 2)
-            map.pinch.maximumZoomLevelChange = 4
+            compare(map.gesture.maximumZoomLevelChange, 2)
+            map.gesture.maximumZoomLevelChange = 4
             compare(pinchMaximumZoomLevelChangeSpy.count, 1)
-            compare (map.pinch.maximumZoomLevelChange, 4)
-            map.pinch.maximumZoomLevelChange = 4
+            compare (map.gesture.maximumZoomLevelChange, 4)
+            map.gesture.maximumZoomLevelChange = 4
             compare(pinchMaximumZoomLevelChangeSpy.count, 1)
-            compare (map.pinch.maximumZoomLevelChange, 4)
-            map.pinch.maximumZoomLevelChange = 11   // too big
-            map.pinch.maximumZoomLevelChange = 0.01 // too small
-            map.pinch.maximumZoomLevelChange = -1   // too small
+            compare (map.gesture.maximumZoomLevelChange, 4)
+            map.gesture.maximumZoomLevelChange = 11   // too big
+            map.gesture.maximumZoomLevelChange = 0.01 // too small
+            map.gesture.maximumZoomLevelChange = -1   // too small
             compare(pinchMaximumZoomLevelChangeSpy.count, 1)
-            compare (map.pinch.maximumZoomLevelChange, 4)
-            map.pinch.maximumZoomLevelChange = 2
+            compare (map.gesture.maximumZoomLevelChange, 4)
+            map.gesture.maximumZoomLevelChange = 2
             compare(pinchMaximumZoomLevelChangeSpy.count, 2)
-            compare (map.pinch.maximumZoomLevelChange, 2)
+            compare (map.gesture.maximumZoomLevelChange, 2)
 
             /*
-            compare(map.pinch.minimumRotation, 0)
-            map.pinch.minimumRotation = 10
+            compare(map.gesture.minimumRotation, 0)
+            map.gesture.minimumRotation = 10
             compare(pinchMinimumRotationSpy.count, 1)
-            compare(map.pinch.minimumRotation, 10)
-            map.pinch.minimumRotation = 10
+            compare(map.gesture.minimumRotation, 10)
+            map.gesture.minimumRotation = 10
             compare(pinchMinimumRotationSpy.count, 1)
-            compare(map.pinch.minimumRotation, 10)
-            map.pinch.minimumRotation = -1  // too small
-            map.pinch.minimumRotation = 361 // too big
+            compare(map.gesture.minimumRotation, 10)
+            map.gesture.minimumRotation = -1  // too small
+            map.gesture.minimumRotation = 361 // too big
             compare(pinchMinimumRotationSpy.count, 1)
-            compare(map.pinch.minimumRotation, 10)
-            map.pinch.minimumRotation = 0
+            compare(map.gesture.minimumRotation, 10)
+            map.gesture.minimumRotation = 0
             compare(pinchMinimumRotationSpy.count, 2)
-            compare(map.pinch.minimumRotation, 0)
+            compare(map.gesture.minimumRotation, 0)
 
-            compare(map.pinch.maximumRotation, 45)
-            map.pinch.maximumRotation = 55
+            compare(map.gesture.maximumRotation, 45)
+            map.gesture.maximumRotation = 55
             compare(pinchMaximumRotationSpy.count,1)
-            compare(map.pinch.maximumRotation, 55)
-            map.pinch.maximumRotation = 55
+            compare(map.gesture.maximumRotation, 55)
+            map.gesture.maximumRotation = 55
             compare(pinchMaximumRotationSpy.count,1)
-            compare(map.pinch.maximumRotation, 55)
-            map.pinch.maximumRotation = -1  // too small
-            map.pinch.maximumRotation = 362 // too big
+            compare(map.gesture.maximumRotation, 55)
+            map.gesture.maximumRotation = -1  // too small
+            map.gesture.maximumRotation = 362 // too big
             compare(pinchMaximumRotationSpy.count,1)
-            compare(map.pinch.maximumRotation, 55)
-            map.pinch.maximumRotation = 45
+            compare(map.gesture.maximumRotation, 55)
+            map.gesture.maximumRotation = 45
             compare(pinchMaximumRotationSpy.count,2)
-            compare(map.pinch.maximumRotation, 45)
+            compare(map.gesture.maximumRotation, 45)
             */
 
-            compare(map.pinch.rotationFactor, 1)
-            map.pinch.rotationFactor = 2
+            compare(map.gesture.rotationFactor, 1)
+            map.gesture.rotationFactor = 2
             compare(pinchRotationFactorSpy.count, 1)
-            compare(map.pinch.rotationFactor, 2)
-            map.pinch.rotationFactor = 2
+            compare(map.gesture.rotationFactor, 2)
+            map.gesture.rotationFactor = 2
             compare(pinchRotationFactorSpy.count, 1)
-            compare(map.pinch.rotationFactor, 2)
-            map.pinch.rotationFactor = -1 // too small
-            map.pinch.rotationFactor = 6  // too big
+            compare(map.gesture.rotationFactor, 2)
+            map.gesture.rotationFactor = -1 // too small
+            map.gesture.rotationFactor = 6  // too big
             compare(pinchRotationFactorSpy.count, 1)
-            compare(map.pinch.rotationFactor, 2)
-            map.pinch.rotationFactor = 1
+            compare(map.gesture.rotationFactor, 2)
+            map.gesture.rotationFactor = 1
             compare(pinchRotationFactorSpy.count, 2)
-            compare(map.pinch.rotationFactor, 1)
+            compare(map.gesture.rotationFactor, 1)
             /*
-            compare(map.pinch.maximumTilt, 90)
-            compare(map.pinch.minimumTilt, 0)
-            compare(map.pinch.maximumTiltChange, 20)
+            compare(map.gesture.maximumTilt, 90)
+            compare(map.gesture.minimumTilt, 0)
+            compare(map.gesture.maximumTiltChange, 20)
             */
 
-            // flick
-            compare(map.flick.enabled, true)
-            map.flick.enabled = false
-            compare(flickEnabledSpy.count, 1)
-            compare(map.flick.enabled, false)
-            map.flick.enabled = false
-            compare(flickEnabledSpy.count, 1)
-            map.flick.enabled = true
-
-            compare(map.flick.deceleration, 2500)
-            map.flick.deceleration = 2600
+            compare(map.gesture.flickDeceleration, 2500)
+            map.gesture.flickDeceleration = 2600
             compare(flickDecelerationSpy.count, 1)
-            compare(map.flick.deceleration, 2600)
-            map.flick.deceleration = 2600
+            compare(map.gesture.flickDeceleration, 2600)
+            map.gesture.flickDeceleration = 2600
             compare(flickDecelerationSpy.count, 1)
-            compare(map.flick.deceleration, 2600)
-            map.flick.deceleration = 400 // too small
+            compare(map.gesture.flickDeceleration, 2600)
+            map.gesture.flickDeceleration = 400 // too small
             compare(flickDecelerationSpy.count, 2)
-            compare(map.flick.deceleration, 500) // clipped to min
-            map.flick.deceleration = 11000 // too big
+            compare(map.gesture.flickDeceleration, 500) // clipped to min
+            map.gesture.flickDeceleration = 11000 // too big
             compare(flickDecelerationSpy.count, 3)
-            compare(map.flick.deceleration, 10000) // clipped to max
+            compare(map.gesture.flickDeceleration, 10000) // clipped to max
         }
 
         function test_b_pinch_rotation() {
-            map.pinch.activeGestures = MapPinchArea.RotationGesture
-            map.pinch.rotationFactor = 1.0
+            map.gesture.activeGestures = MapGestureArea.RotationGesture
+            map.gesture.rotationFactor = 1.0
             map.zoomLevel = 8
             compare(map.zoomLevel, 8)
             map.center.latitude = 10
@@ -332,12 +323,12 @@ Item {
             tryCompare(pinchStartedSpy, "count", 1);
             wait(50);
             compare(pinchActiveSpy.count,1) // check that pinch is active
-            compare(map.pinch.active, true)
+            compare(map.gesture.isPinchActive, true)
             wait(200);
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(pinchActiveSpy.count,2)
-            compare(map.pinch.active, false)
+            compare(map.gesture.isPinchActive, false)
             compare(map.zoomLevel, 8) // mustn't change
             compare(mapBearingSpy.count, pinchUpdatedSpy.count)
             verify(map.bearing > 20 && map.bearing < 30) // roughly right
@@ -354,7 +345,7 @@ Item {
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(pinchActiveSpy.count,2)
-            compare(map.pinch.active, false)
+            compare(map.gesture.isPinchActive, false)
             compare(map.zoomLevel, 8) // mustn't change
             compare(mapBearingSpy.count, pinchUpdatedSpy.count)
             verify(map.bearing < 2 || map.bearing > 358) // roughly right
@@ -380,16 +371,16 @@ Item {
             compare(map.bearing, 16.5)
             map.bearing = 0
             // 5. rotation factor effects, repeat the basic ccw rotation
-            map.pinch.rotationFactor = 2
+            map.gesture.rotationFactor = 2
             pinchGenerator.pinch(Qt.point(100, 0),Qt.point(50, 0),Qt.point(0, 100),Qt.point(50, 100));
             tryCompare(pinchFinishedSpy, "count", 1);
             verify (map.bearing >  (ccw_basic * 2 - 5)) // roughly right, hence the '5'
             map.bearing = 0
-            map.pinch.rotationFactor = 0.5
+            map.gesture.rotationFactor = 0.5
             pinchGenerator.pinch(Qt.point(100, 0),Qt.point(50, 0),Qt.point(0, 100),Qt.point(50, 100));
             tryCompare(pinchFinishedSpy, "count", 2);
             verify (map.bearing > (ccw_basic / 2 - 1) && map.bearing < (ccw_basic / 2 + 1)) // roughly right, hence the '1'
-            map.pinch.rotationFactor = 1.0
+            map.gesture.rotationFactor = 1.0
             map.bearing = 0
             // 6. manually changing the bearing during pinch rotation
             clear_data()
@@ -397,7 +388,7 @@ Item {
             tryCompare(pinchStartedSpy, "count", 1);
 
             tryCompare(pinchActiveSpy, "count",1) // check that pinch is active
-            compare(map.pinch.active, true)
+            compare(map.gesture.isPinchActive, true)
             map.bearing += 100 // this will get overwritten
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(map.bearing, ccw_basic)
@@ -409,8 +400,8 @@ Item {
             compare(map.bearing, ccw_basic - 10)
             // 8. sanity check the biggest rotation factor
             clear_data()
-            map.pinch.rotationFactor = 5
-            compare(map.pinch.rotationFactor, 5)
+            map.gesture.rotationFactor = 5
+            compare(map.gesture.rotationFactor, 5)
             map.bearing = 0
             pinchGenerator.pinch(Qt.point(100, 0),Qt.point(50, 0),Qt.point(0, 100),Qt.point(50, 100)); //ccw
             tryCompare(pinchFinishedSpy, "count", 1);
@@ -422,9 +413,11 @@ Item {
             var i=0
             //var moveLatitude=0
             // few sanity checks
-            map.flick.enabled = true
+            map.gesture.activeGestures = MapGestureArea.PanGesture | MapGestureArea.FlickGesture;
+            map.gesture.enabled = true
+            map.gesture.panEnabled = true
             // to get maximum changes (robust autotest)
-            map.flick.deceleration = 500
+            map.gesture.flickDeceleration = 500
             map.zoomLevel = 0
             compare(map.center.latitude, coordinate1.latitude)
             compare(map.center.longitude, coordinate1.longitude)
@@ -439,14 +432,13 @@ Item {
             }
             mouseRelease(map, 0, (50 + i))
 
-            // order of signals is: movementStarted, flickStarted, either order: (flickEnded, movementEnded)
-            tryCompare(flickMovementStartedSpy, "count", 1)
+            // order of signals is: flickStarted, either order: (flickEnded, movementEnded)
             verify(map.center.latitude > 10) // latitude increases we are going 'up/north' (moving mouse down)
             var moveLatitude = map.center.latitude // store lat and check that flick continues
             tryCompare(flickStartedSpy, "count", 1)
 
-            tryCompare(flickMovementEndedSpy, "count", 1)
-            tryCompare(flickEndedSpy, "count", 1)
+            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(flickFinishedSpy, "count", 1)
             verify(map.center.latitude > moveLatitude)
             compare(map.center.longitude, 11) // should remain the same
 
@@ -460,12 +452,11 @@ Item {
                 mouseMove(map, 10, (50 + i), 0, Qt.LeftButton);
             }
             mouseRelease(map, 10, (50 + i))
-            tryCompare(flickMovementStartedSpy, "count", 1)
             verify(map.center.latitude < 70)
             moveLatitude = map.center.latitude // store lat and check that flick continues
             tryCompare(flickStartedSpy, "count", 1)
-            tryCompare(flickMovementEndedSpy, "count", 1)
-            tryCompare(flickEndedSpy, "count", 1)
+            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(flickFinishedSpy, "count", 1)
             verify(map.center.latitude < moveLatitude)
             compare(map.center.longitude, 11) // should remain the same
 
@@ -479,21 +470,20 @@ Item {
                 mouseMove(map, i, i, 0, Qt.LeftButton);
             }
             mouseRelease(map, i, i)
-            tryCompare(flickMovementStartedSpy, "count", 1)
             verify(map.center.latitude > 50)
             verify(map.center.longitude < 50)
             moveLatitude = map.center.latitude
             var moveLongitude = map.center.longitude
             tryCompare(flickStartedSpy, "count", 1)
-            tryCompare(flickMovementEndedSpy, "count", 1)
-            tryCompare(flickEndedSpy, "count", 1)
+            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(flickFinishedSpy, "count", 1)
             verify(map.center.latitude > moveLatitude)
             verify(map.center.longitude < moveLongitude)
             var diagonalFlickResultLatitude = map.center.latitude
             var diagonalFlickResultLongitude = map.center.longitude
             // 4. test flicking while disabled
             clear_data()
-            map.flick.enabled = false
+            map.gesture.panEnabled = false
             map.center.latitude = 50
             map.center.longitude = 50
             for (i=0; i < 50; i += 5) {
@@ -502,10 +492,9 @@ Item {
             }
             mouseRelease(map, i, i)
             compare(flickStartedSpy.count, 0)
-            compare(flickEndedSpy.count, 0)
-            compare(flickMovementStartedSpy.count, 0)
-            compare(flickMovementEndedSpy.count, 0)
-            map.flick.enabled = true
+            compare(flickFinishedSpy.count, 0)
+            compare(movementStoppedSpy.count, 0)
+            map.gesture.panEnabled = true
 
             // 5. disable during flick: onFlickStarted
             clear_data()
@@ -521,13 +510,13 @@ Item {
             tryCompare(flickStartedSpy, "count", 1)
             verify(map.center.latitude > 50)
             tryCompare(flickStartedSpy, "count", 1)
-            tryCompare(flickMovementEndedSpy, "count", 1)
-            tryCompare(flickEndedSpy, "count", 1)
+            tryCompare(movementStoppedSpy, "count", 1)
+            tryCompare(flickFinishedSpy, "count", 1)
             // compare that flick was interrupted (less movement than without interrupting)
             verify(diagonalFlickResultLatitude > map.center.latitude)
             verify(diagonalFlickResultLongitude < map.center.longitude)
             map.disableFlickOnStarted = false
-            map.flick.enabled = true
+            map.gesture.panEnabled = true
 
             // 6. disable during flick: onMovementStarted
             clear_data()
@@ -540,9 +529,8 @@ Item {
                 mouseMove(map, i, i, 0, Qt.LeftButton);
             }
             mouseRelease(map, i, i)
-            tryCompare(flickMovementStartedSpy, "count", 1)
             verify(map.center.latitude > 50)
-            tryCompare(flickMovementEndedSpy, "count", 1)
+            tryCompare(movementStoppedSpy, "count", 1)
             // compare that flick was interrupted (less movement than without interrupting)
             verify(diagonalFlickResultLatitude > map.center.latitude)
             verify(diagonalFlickResultLongitude < map.center.longitude)
@@ -550,12 +538,12 @@ Item {
         }
 
         function test_pinch_zoom() {
-            map.pinch.activeGestures = MapPinchArea.ZoomGesture
+            map.gesture.activeGestures = MapGestureArea.ZoomGesture
             map.zoomLevel = 9
             clear_data()
             // 1. typical zoom in
-            map.pinch.maximumZoomLevelChange = 2
-            compare(map.pinch.active, false)
+            map.gesture.maximumZoomLevelChange = 2
+            compare(map.gesture.isPinchActive, false)
             pinchGenerator.pinch(
                         Qt.point(0,50),   // point1From
                         Qt.point(50,50),  // point1To
@@ -577,7 +565,7 @@ Item {
             compare(map.lastPinchEvent.accepted, true)
             compare(map.lastPinchEvent.pointCount, 2)
             tryCompare(pinchActiveSpy, "count", 1) // check that pinch is active
-            compare(map.pinch.active, true)
+            compare(map.gesture.isPinchActive, true)
             wait(200)
             // check the pinch event data for pinchUpdated
             compare(map.lastPinchEvent.center.x, 50)
@@ -603,12 +591,12 @@ Item {
 
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
             compare(pinchActiveSpy.count,2)
-            compare(map.pinch.active, false)
+            compare(map.gesture.isPinchActive, false)
             compare(mapZoomLevelSpy.count, pinchUpdatedSpy.count)
             compare(map.zoomLevel, 8)
             // 2. typical zoom out
             clear_data();
-            map.pinch.maximumZoomLevelChange = 2
+            map.gesture.maximumZoomLevelChange = 2
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
@@ -627,8 +615,8 @@ Item {
             compare(map.zoomLevel, 9) // should remain the same
             // 4. typical zoom in with different change level
             clear_data();
-            map.pinch.maximumZoomLevelChange = 4
-            compare (map.pinch.maximumZoomLevelChange, 4)
+            map.gesture.maximumZoomLevelChange = 4
+            compare (map.gesture.maximumZoomLevelChange, 4)
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),
                                  Qt.point(100,50),Qt.point(50,50),
                                  40, 40, 10, 10);
@@ -636,8 +624,8 @@ Item {
             compare(map.zoomLevel, 7)
             // 5. typical zoom out with different change level
             clear_data();
-            map.pinch.maximumZoomLevelChange = 1
-            compare (map.pinch.maximumZoomLevelChange, 1)
+            map.gesture.maximumZoomLevelChange = 1
+            compare (map.gesture.maximumZoomLevelChange, 1)
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
@@ -647,8 +635,8 @@ Item {
             // 6. try to zoom in below minimum zoom level
             /*
             clear_data()
-            map.pinch.maximumZoomLevelChange = 4
-            map.pinch.minimumZoomLevel = 7
+            map.gesture.maximumZoomLevelChange = 4
+            map.gesture.minimumZoomLevel = 7
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50));
             wait(250);
             tryCompare(pinchFinishedSpy, "count", 1);
@@ -656,27 +644,27 @@ Item {
 
             // 7. try to zoom out above maximum zoom level
             clear_data()
-            map.pinch.maximumZoomLevelChange = 4
-            map.pinch.maximumZoomLevel = 8
+            map.gesture.maximumZoomLevelChange = 4
+            map.gesture.maximumZoomLevel = 8
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50));
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(map.zoomLevel, 8) // would go to 9
 
             // 8. pinch when max and min are same
             clear_data()
-            map.pinch.maximumZoomLevel = 8
-            map.pinch.minimumZoomLevel = 8
-            compare(map.pinch.maximumZoomLevel, 8)
-            compare(map.pinch.minimumZoomLevel, 8)
+            map.gesture.maximumZoomLevel = 8
+            map.gesture.minimumZoomLevel = 8
+            compare(map.gesture.maximumZoomLevel, 8)
+            compare(map.gesture.minimumZoomLevel, 8)
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),Qt.point(100,50),Qt.point(50,50));
             tryCompare(pinchFinishedSpy, "count", 1);
             compare(map.zoomLevel, 8)
 
             // 9. pinch when max..min is not where map zoomLevel currently is
             clear_data()
-            map.pinch.maximumZoomLevelChange = 4
-            map.pinch.minimumZoomLevel = 4
-            map.pinch.maximumZoomLevel = 6
+            map.gesture.maximumZoomLevelChange = 4
+            map.gesture.minimumZoomLevel = 4
+            map.gesture.maximumZoomLevel = 6
             // first when above the zoom range
             map.zoomLevel = 10
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50)); // zoom out
@@ -701,26 +689,26 @@ Item {
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),Qt.point(50,50), Qt.point(100,50)); // zoom out
             tryCompare(pinchFinishedSpy, "count", 6);
             compare(map.zoomLevel, 6)
-            map.pinch.minimumZoomLevel = map.minimumZoomLevel
-            map.pinch.maximumZoomLevel = map.maximumZoomLevel
+            map.gesture.minimumZoomLevel = map.minimumZoomLevel
+            map.gesture.maximumZoomLevel = map.maximumZoomLevel
             */
 
             // 10. pinch while pinch area is disabled
             clear_data()
-            map.pinch.enabled = false
-            map.pinch.maximumZoomLevelChange = 2
+            map.gesture.enabled = false
+            map.gesture.maximumZoomLevelChange = 2
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
             wait(200);
             compare(pinchActiveSpy.count, 0)
-            compare(map.pinch.active, false)
+            compare(map.gesture.isPinchActive, false)
             compare(pinchStartedSpy.count, 0)
             compare(pinchUpdatedSpy.count, 0);
             compare(pinchFinishedSpy.count, 0);
             compare(map.zoomLevel, 7.5)
             pinchGenerator.stop()
-            map.pinch.enabled = true
+            map.gesture.enabled = true
 
             // 11. pinch disabling during pinching
             clear_data()
@@ -728,22 +716,22 @@ Item {
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
             wait(300)
-            map.pinch.enabled = false
+            map.gesture.enabled = false
             // check that pinch is active. then disable the pinch. pinch area should still process
             // as long as it is active
             compare(pinchActiveSpy.count,1)
-            compare(map.pinch.active, true)
+            compare(map.gesture.isPinchActive, true)
             compare(pinchStartedSpy.count, 1)
             compare(pinchFinishedSpy.count, 0)
             var pinchupdates = pinchUpdatedSpy.count
             verify(pinchupdates > 0)
             tryCompare(pinchFinishedSpy, "count", 1)
             compare(pinchActiveSpy.count,2)
-            compare(map.pinch.active, false)
-            map.pinch.enabled = true
+            compare(map.gesture.isPinchActive, false)
+            map.gesture.enabled = true
             // 12. check nuthin happens if no active gestures
             clear_data()
-            map.pinch.activeGestures = MapPinchArea.NoGesture
+            map.gesture.activeGestures = MapGestureArea.NoGesture
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
@@ -753,23 +741,23 @@ Item {
             compare(pinchStartedSpy.count, 0);
             compare(map.zoomLevel, 8.5)
             pinchGenerator.stop()
-            map.pinch.activeGestures = MapPinchArea.ZoomGesture
+            map.gesture.activeGestures = MapGestureArea.ZoomGesture
             // 13. manually changing zoom level during active pinch zoom
             clear_data();
-            map.pinch.maximumZoomLevelChange = 2
+            map.gesture.maximumZoomLevelChange = 2
             pinchGenerator.pinch(Qt.point(50,50), Qt.point(0,50),
                                  Qt.point(50,50), Qt.point(100,50),
                                  40, 40, 10, 10);
             tryCompare(pinchStartedSpy, "count", 1);
             tryCompare(pinchActiveSpy, "count", 1)
-            compare(map.pinch.active, true)
+            compare(map.gesture.isPinchActive, true)
             map.zoomLevel = 3 // will get overridden by pinch
             tryCompare(pinchFinishedSpy, "count", 1);
             verify(pinchUpdatedSpy.count >= 5); // verify 'sane' number of updates received
             compare(map.zoomLevel, 9.5)
             // 14. try to zoom below and above plugin's support
             clear_data()
-            map.pinch.maximumZoomLevelChange = 4
+            map.gesture.maximumZoomLevelChange = 4
             map.zoomLevel = map.minimumZoomLevel + 0.5
             pinchGenerator.pinch(Qt.point(0,50),Qt.point(50,50),
                                  Qt.point(100,50),Qt.point(50,50),
@@ -790,7 +778,7 @@ Item {
             wait(300)
             compare(pinchUpdatedSpy.count, 0)
             compare(pinchFinishedSpy.count, 0)
-            compare(map.pinch.active, false)
+            compare(map.gesture.isPinchActive, false)
             compare(map.zoomLevel, 10)
             map.rejectPinch = false
             pinchGenerator.stop()