Fixed map jumping when starting a drag

[situare] / src / map / mapview.cpp

diff --git a/src/map/mapview.cpp b/src/map/mapview.cpp
index 6b38ff4..8cdcf29 100644 (file)
--- a/src/map/mapview.cpp
+++ b/src/map/mapview.cpp
@@ -24,7 +24,9 @@
 
 #include <QDebug>
 #include <QMouseEvent>
+#include <QParallelAnimationGroup>
 
+#include "coordinates/scenecoordinate.h"
 #include "mapcommon.h"
 #include "mapscroller.h"
 
@@ -35,11 +37,16 @@ const qreal MS_PER_S = 1000;
 // const values for tuning the kinetic scroll effect
 const int KINETIC_MIN_DRAG_LENGTH_VIEW_PIXELS = 30;
 const int KINETIC_MAX_TIME_FROM_LAST_MOUSE_EVENT_MS = 100;
+const qreal KINETIC_MAX_VIEW_DISTANCE_FACTOR = 0.8;
 const int KINETIC_SCROLL_TIME_MS = 750;
 const qreal KINETIC_SPEED_TO_DISTANCE_FACTOR = 0.15 * sqrt(KINETIC_SCROLL_TIME_MS / MS_PER_S);
 
+const qreal ZOOM_TIME_MS = 350; ///< Length of the zoom effect (ms)
+
 MapView::MapView(QWidget *parent)
-    : QGraphicsView(parent)
+    : QGraphicsView(parent),
+      m_doubleTapZoomRunning(false),
+      m_panelIsOpen(false)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
@@ -49,24 +56,92 @@ MapView::MapView(QWidget *parent)
     m_zoomAnimation = new QPropertyAnimation(this, "viewScale", this);
     connect(m_zoomAnimation, SIGNAL(finished()),
         this, SIGNAL(viewZoomFinished()));
-
     setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing);
 
     m_scroller = &MapScroller::getInstance();
+
+    m_scrollAndZoomAnimation = new QParallelAnimationGroup();
+    m_scrollAndZoomAnimation->addAnimation(m_scroller);
+    m_scrollAndZoomAnimation->addAnimation(m_zoomAnimation);
+    connect(m_scrollAndZoomAnimation, SIGNAL(finished()),
+            this, SLOT(doubleTapZoomFinished()));
+}
+
+void MapView::centerToSceneCoordinates(const SceneCoordinate &coordinate, bool isUserDragAction)
+{
+    qDebug() << __PRETTY_FUNCTION__ << "coordinate" << coordinate;
+
+    QPointF target = coordinate.toPointF();
+
+    if (!isUserDragAction) {
+        target += m_centerHorizontalShift;
+    }
+
+    centerOn(target);
+}
+
+void MapView::disableCenterShift()
+{
+    qWarning() << __PRETTY_FUNCTION__;
+
+    m_panelIsOpen = false;
+    updateCenterShift();
+
+    ///< @todo Update center position
 }
 
-void MapView::centerToSceneCoordinates(QPoint sceneCoordinate)
+void MapView::doubleTapZoomFinished()
 {
-    qDebug() << __PRETTY_FUNCTION__ << "sceneCoordinate" << sceneCoordinate;
+    qDebug() << __PRETTY_FUNCTION__;
+
+    m_doubleTapZoomRunning = false;
+    emit zoomIn();
+}
+
+void MapView::enableCenterShift()
+{
+    qWarning() << __PRETTY_FUNCTION__;
+
+    m_panelIsOpen = true;
+    updateCenterShift();
 
-    centerOn(sceneCoordinate);
+    ///< @todo Update center position
+}
+
+void MapView::mouseDoubleClickEvent(QMouseEvent *event)
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    if (m_zoomLevel + 1 <= OSM_MAX_ZOOM_LEVEL) {
+        QPoint pressPosition = mapToScene(event->pos()).toPoint();
+        QPoint viewCenterPosition = mapToScene(width() / 2 - 1, height() / 2 - 1).toPoint();
+        QPoint zoomPosition = viewCenterPosition - ((viewCenterPosition - pressPosition) / 2);
+
+        m_scrollAndZoomAnimation->stop();
+        m_doubleTapZoomRunning = true;
+
+        m_scroller->setEasingCurve(QEasingCurve::Linear);
+        m_scroller->setDuration(ZOOM_TIME_MS);
+        m_scroller->setStartValue(SceneCoordinate(m_scenePosition.x(), m_scenePosition.y()));
+        m_scroller->setEndValue(SceneCoordinate(zoomPosition.x(), zoomPosition.y()));
+
+        m_zoomAnimation->setEasingCurve(QEasingCurve::InQuad);
+        m_zoomAnimation->setDuration(ZOOM_TIME_MS);
+        m_zoomAnimation->setStartValue(viewScale());
+        m_zoomAnimation->setEndValue(pow(2, m_zoomLevel+1 - OSM_MAX_ZOOM_LEVEL));
+
+        m_scrollAndZoomAnimation->start();
+    }
 }
 
 void MapView::mouseMoveEvent(QMouseEvent *event)
 {
-    m_scenePosition += m_mouseLastScenePosition - mapToScene(event->pos()).toPoint();
+    qDebug() << __PRETTY_FUNCTION__;
+
+    if (m_doubleTapZoomRunning)
+        return;
 
-    qDebug() << __PRETTY_FUNCTION__ << "m_scenePosition:" << m_scenePosition;
+    m_scenePosition += m_mouseLastScenePosition - mapToScene(event->pos()).toPoint();
 
     if (m_index >= VALUES)
         m_index = 0;
@@ -76,7 +151,7 @@ void MapView::mouseMoveEvent(QMouseEvent *event)
     m_time.start();
     m_index++;
 
-    emit viewScrolled(m_scenePosition);
+    emit viewScrolled(SceneCoordinate(m_scenePosition.x(), m_scenePosition.y()), true);
 
     m_mouseLastScenePosition = mapToScene(event->pos()).toPoint();
     m_mouseLastViewPosition = event->pos();
@@ -86,6 +161,9 @@ void MapView::mousePressEvent(QMouseEvent *event)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
+    if (m_doubleTapZoomRunning)
+        return;
+
     m_time.start();
 
     m_scroller->stop();
@@ -107,6 +185,9 @@ void MapView::mouseReleaseEvent(QMouseEvent *event)
 {
     qDebug() << __PRETTY_FUNCTION__;
 
+    if (m_doubleTapZoomRunning)
+        return;
+
     int elapsed = m_time.elapsed();
 
     QGraphicsView::mouseReleaseEvent(event);
@@ -126,13 +207,21 @@ void MapView::mouseReleaseEvent(QMouseEvent *event)
 
         if (dragLength >= KINETIC_MIN_DRAG_LENGTH_VIEW_PIXELS) {
             dragViewSpeed /= values;
-            QPointF effectViewDistance= dragViewSpeed * KINETIC_SPEED_TO_DISTANCE_FACTOR;
+            QPointF effectViewDistance = dragViewSpeed * KINETIC_SPEED_TO_DISTANCE_FACTOR;
+
+            // limit the scroll distance in screen pixels
+            qreal biggerDistance = qMax(abs(effectViewDistance.x()), abs(effectViewDistance.y()));
+            if (biggerDistance > m_kineticMaxViewDistance)
+                effectViewDistance /= biggerDistance / m_kineticMaxViewDistance;
+
             QPointF effectSceneDistance = effectViewDistance
-                                          * (1 << (MAX_MAP_ZOOM_LEVEL - m_zoomLevel));
+                                          * (1 << (OSM_MAX_ZOOM_LEVEL - m_zoomLevel));
 
+            m_scroller->setEasingCurve(QEasingCurve::OutCirc);
             m_scroller->setDuration(KINETIC_SCROLL_TIME_MS);
-            m_scroller->setStartValue(m_scenePosition);
-            m_scroller->setEndValue(m_scenePosition + effectSceneDistance.toPoint());
+            m_scroller->setStartValue(SceneCoordinate(m_scenePosition.x(), m_scenePosition.y()));
+            QPointF endValue = QPointF(m_scenePosition) + effectSceneDistance;
+            m_scroller->setEndValue(SceneCoordinate(endValue.x(), endValue.y()));
             m_scroller->start();
         }
     }
@@ -142,7 +231,11 @@ void MapView::resizeEvent(QResizeEvent *event)
 {
     qDebug() << __PRETTY_FUNCTION__ << "Resize:" << event->size();
 
+    m_kineticMaxViewDistance = qMax(width(), height()) * KINETIC_MAX_VIEW_DISTANCE_FACTOR;
+
     emit viewResized(event->size());
+
+    updateCenterShift();
 }
 
 void MapView::setViewScale(qreal viewScale)
@@ -162,12 +255,27 @@ void MapView::setZoomLevel(int zoomLevel)
 
     if (m_zoomAnimation) {
         m_zoomAnimation->stop();
-        m_zoomAnimation->setDuration(ZOOM_TIME);
+        m_zoomAnimation->setEasingCurve(QEasingCurve::InQuad);
+        m_zoomAnimation->setDuration(ZOOM_TIME_MS);
         m_zoomAnimation->setStartValue(viewScale());
-        m_zoomAnimation->setEndValue(pow(2, zoomLevel - MAX_MAP_ZOOM_LEVEL));
+        m_zoomAnimation->setEndValue(pow(2, zoomLevel - OSM_MAX_ZOOM_LEVEL));
 
         m_zoomAnimation->start();
     }
+
+    updateCenterShift();
+}
+
+void MapView::updateCenterShift()
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    int shift = 0;
+
+    if (m_panelIsOpen)
+        shift = 200;
+
+    m_centerHorizontalShift = QPointF(shift * (1 << (OSM_MAX_ZOOM_LEVEL - m_zoomLevel)), 0);
 }
 
 qreal MapView::viewScale()
@@ -176,3 +284,11 @@ qreal MapView::viewScale()
 
     return transform().m11();
 }
+
+MapView::~MapView()
+{
+    qDebug() << __PRETTY_FUNCTION__;
+
+    m_scrollAndZoomAnimation->removeAnimation(m_scroller);
+    delete m_scrollAndZoomAnimation;
+}