[drape] simple navigator

drape_frontend/drape_engine.cpp

@@ -6,33 +6,76 @@
 namespace df
 {
   DrapeEngine::DrapeEngine(RefPointer<OGLContextFactory> contextfactory, double vs, Viewport const & viewport)
+    : m_viewport(viewport)
+    , m_navigator(m_scales)
   {
     GLFunctions::Init();
     VizualizationParams::SetVisualScale(vs);
+    m_scales.SetParams(vs, ScalesProcessor::CalculateTileSize(m_viewport.GetWidth(), m_viewport.GetHeight()));
+    //m_modelView.Load();
+    m_navigator.LoadState();
 
     m_threadCommutator = MasterPointer<ThreadsCommutator>(new ThreadsCommutator());
     RefPointer<ThreadsCommutator> commutatorRef = m_threadCommutator.GetRefPointer();
 
-    m_frontend = MasterPointer<FrontendRenderer>(new FrontendRenderer(commutatorRef, contextfactory, viewport));
-    m_backend =  MasterPointer<BackendRenderer>(new BackendRenderer(commutatorRef, contextfactory, viewport));
+    m_frontend = MasterPointer<FrontendRenderer>(new FrontendRenderer(commutatorRef, contextfactory, m_viewport));
+    m_backend =  MasterPointer<BackendRenderer>(new BackendRenderer(commutatorRef, contextfactory, m_viewport));
+
+    UpdateCoverage();
   }
 
   DrapeEngine::~DrapeEngine()
   {
+    //m_modelView.Save();
+    m_navigator.SaveState();
     m_backend.Destroy();
     m_frontend.Destroy();
     m_threadCommutator.Destroy();
   }
 
-  void DrapeEngine::OnSizeChanged(int x0, int y0, int w, int h)
+  void DrapeEngine::Resize(int w, int h)
   {
+    if (m_viewport.GetWidth() == w && m_viewport.GetHeight() == h)
+      return;
+
+    //m_modelView.Resize(w, h);
+    m_viewport.SetViewport(0, 0, w, h);
+    m_navigator.OnSize(0, 0, w, h);
     m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
-                                    MovePointer<Message>(new ResizeMessage(x0, y0, w, h)));
+                                    MovePointer<Message>(new ResizeMessage(m_viewport)));
+    UpdateCoverage();
   }
 
-  void DrapeEngine::SetAngle(float radians)
+  void DrapeEngine::DragStarted(const m2::PointF & p)
+  {
+    //m_modelView.DrawStarted(p);
+    m_navigator.StartDrag(p, 0.0);
+    UpdateCoverage();
+  }
+
+  void DrapeEngine::Drag(m2::PointF const & p)
+  {
+    //m_modelView.Drag(p);
+    m_navigator.DoDrag(p, 0.0);
+    UpdateCoverage();
+  }
+
+  void DrapeEngine::DragEnded(m2::PointF const & p)
+  {
+    //m_modelView.DragEnded(p);
+    m_navigator.StopDrag(p, 0.0, false);
+    UpdateCoverage();
+  }
+
+  void DrapeEngine::Scale(const m2::PointF & p, double factor)
+  {
+    m_navigator.ScaleToPoint(p, factor, 0.0);
+    UpdateCoverage();
+  }
+
+  void DrapeEngine::UpdateCoverage()
   {
     m_threadCommutator->PostMessage(ThreadsCommutator::RenderThread,
-                                    MovePointer<Message>(new RotateMessage(radians)));
+                                    MovePointer<Message>(new UpdateCoverageMessage(m_navigator.Screen())));
   }
 }

drape_frontend/drape_engine.hpp

@@ -7,6 +7,8 @@
 #include "../drape/pointers.hpp"
 #include "../drape/oglcontextfactory.hpp"
 
+#include "../map/navigator.hpp"
+
 namespace df
 {
   class Viewport;
@@ -16,13 +18,23 @@ namespace df
     DrapeEngine(RefPointer<OGLContextFactory> oglcontextfactory, double vs, Viewport const & viewport);
     ~DrapeEngine();
 
-    void OnSizeChanged(int x0, int y0, int w, int h);
-    void SetAngle(float radians);
+    void Resize(int w, int h);
+    void DragStarted(m2::PointF const & p);
+    void Drag(m2::PointF const & p);
+    void DragEnded(m2::PointF const & p);
+    void Scale(m2::PointF const & p, double factor);
+
+  private:
+    void UpdateCoverage();
 
   private:
     MasterPointer<FrontendRenderer> m_frontend;
     MasterPointer<BackendRenderer>  m_backend;
 
     MasterPointer<ThreadsCommutator> m_threadCommutator;
+
+    ScalesProcessor m_scales;
+    Viewport m_viewport;
+    Navigator m_navigator;
   };
 }

drape_head/drape_surface.cpp

@@ -11,9 +11,12 @@
 #include "../std/bind.hpp"
 #include "../std/cmath.hpp"
 
+#include <QtGui/QMouseEvent>
+
 
 DrapeSurface::DrapeSurface()
-  : m_contextFactory(NULL)
+  : m_dragState(false)
+  , m_contextFactory(NULL)
 {
   setSurfaceType(QSurface::OpenGLSurface);
 
@@ -38,23 +41,56 @@ void DrapeSurface::exposeEvent(QExposeEvent *e)
       ThreadSafeFactory * factory = new ThreadSafeFactory(new QtOGLContextFactory(this));
       m_contextFactory = MasterPointer<OGLContextFactory>(factory);
       CreateEngine();
-      m_drapeEngine->SetAngle(0.0);
     }
   }
 }
 
-void DrapeSurface::timerEvent(QTimerEvent * e)
+void DrapeSurface::mousePressEvent(QMouseEvent * e)
 {
-  if (e->timerId() == m_timerID)
-  {
-    static const float _2pi = 2 * math::pi;
-    static float angle = 0.0;
-    angle += 0.0035;
-    if (angle > _2pi)
-      angle -= _2pi;
+  QWindow::mousePressEvent(e);
+  if (!isExposed())
+    return;
 
-    // TODO this is test
-    m_drapeEngine->SetAngle(angle);
+  if (e->button() == Qt::LeftButton)
+  {
+    m2::PointF p = GetDevicePosition(e->pos());
+    m_drapeEngine->DragStarted(p);
+    m_dragState = true;
+  }
+}
+
+void DrapeSurface::mouseMoveEvent(QMouseEvent * e)
+{
+  QWindow::mouseMoveEvent(e);
+  if (!isExposed())
+    return;
+
+  if (m_dragState)
+  {
+    m2::PointF p = GetDevicePosition(e->pos());
+    m_drapeEngine->Drag(p);
+  }
+}
+
+void DrapeSurface::mouseReleaseEvent(QMouseEvent * e)
+{
+  QWindow::mouseReleaseEvent(e);
+  if (!isExposed())
+    return;
+
+  if (m_dragState)
+  {
+    m2::PointF p = GetDevicePosition(e->pos());
+    m_drapeEngine->DragEnded(p);
+    m_dragState = false;
+  }
+}
+
+void DrapeSurface::wheelEvent(QWheelEvent * e)
+{
+  if (!m_dragState)
+  {
+    m_drapeEngine->Scale(GetDevicePosition(e->pos()), exp(e->delta() / 360.0));
   }
 }
 
@@ -68,12 +104,16 @@ void DrapeSurface::CreateEngine()
                     new df::DrapeEngine(f , pixelRatio, df::Viewport(pixelRatio, 0, 0, width(), height())));
 
   sizeChanged(0);
-
-  //m_timerID = startTimer(1000 / 30);
 }
 
 void DrapeSurface::sizeChanged(int)
 {
   if (!m_drapeEngine.IsNull())
-    m_drapeEngine->OnSizeChanged(0, 0, width(), height());
+    m_drapeEngine->Resize(width(), height());
+}
+
+m2::PointF DrapeSurface::GetDevicePosition(const QPoint & p)
+{
+  qreal ratio = devicePixelRatio();
+  return m2::PointF(p.x() /* ratio*/, p.y() /* ratio*/);
 }

drape_head/drape_surface.hpp

@@ -26,7 +26,10 @@ public:
 
 protected:
   void exposeEvent(QExposeEvent * e);
-  void timerEvent(QTimerEvent * e);
+  void mousePressEvent(QMouseEvent * e);
+  void mouseMoveEvent(QMouseEvent * e);
+  void mouseReleaseEvent(QMouseEvent * e);
+  void wheelEvent(QWheelEvent * e);
 
 private:
   void CreateEngine();
@@ -34,8 +37,9 @@ private:
   Q_SLOT void sizeChanged(int);
 
 private:
+  m2::PointF GetDevicePosition(const QPoint & p);
 
-  int m_timerID;
+  bool m_dragState;
 
 private:
   MasterPointer<OGLContextFactory> m_contextFactory;

drape_head/mainwindow.cpp

@@ -15,6 +15,7 @@ MainWindow::MainWindow(QWidget *parent)
   format.setDepthBufferSize(16);
   surface->setFormat(format);
   m_surface = QWidget::createWindowContainer(surface, this);
+  m_surface->setMouseTracking(true);
   setCentralWidget(m_surface);
 }