InputHandler.h

Go to the documentation of this file.

#ifndef OSMSCOUT_CLIENT_QT_INPUTHANDLER_H
#define OSMSCOUT_CLIENT_QT_INPUTHANDLER_H
 
/*
 OSMScout - a Qt backend for libosmscout and libosmscout-map
 Copyright (C) 2016  Lukas Karas
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 */
 
#include <QObject>
#include <QVector2D>
#include <QTouchEvent>
#include <QTimer>
#include <QElapsedTimer>
#include <QQueue>
 
#include <osmscout/util/Bearing.h>
#include <osmscout/util/GeoBox.h>
#include <osmscout/util/Magnification.h>
 
#include <osmscoutclientqt/ClientQtImportExport.h>
#include <osmscoutclientqt/VehiclePosition.h>
 
namespace osmscout {

class OSMSCOUT_CLIENT_QT_API TapRecognizer : public QObject{
  Q_OBJECT
 
private:
  enum TapRecState{
    INACTIVE = 0,
    PRESSED = 1, // timer started with hold interval, if expired - long-tap is emitted
    RELEASED = 2, // timer started with tap interval, if expired - tap is emitted
    PRESSED2 = 3, // timer started with hold interval, if expired - tap-long-tap
  };
 
  int startFingerId;
  int startX;
  int startY;
 
  QTimer timer;
  TapRecState state;
  int holdIntervalMs;
  int hold2IntervalMs;
  int tapIntervalMs;
  int moveTolerance;
 
private slots:
  void onTimeout();
 
public:
  TapRecognizer():
          state(INACTIVE),
          holdIntervalMs(1000),
          hold2IntervalMs(500),
          tapIntervalMs(200),
          moveTolerance(15)
  {
    timer.setSingleShot(true);
    connect(&timer, &QTimer::timeout, this, &TapRecognizer::onTimeout);
  }
 
  ~TapRecognizer() override = default;
 
  void touch(const QTouchEvent &event);
 
  void setPhysicalDpi(double physicalDpi)
  {
    moveTolerance = physicalDpi / 10.0; // ~ 2.5 mm
  }
 
signals:
  void tap(const QPoint p);
  void doubleTap(const QPoint p);
  void longTap(const QPoint p);
  void tapLongTap(const QPoint p);
  void tapAndDrag(const QPoint p);
};

struct AccumulatorEvent
{
  QPointF pos;
  QElapsedTimer timer;
};

class MoveAccumulator : public QObject{
  Q_OBJECT
 
private:
  int memory; // ms
  QQueue<AccumulatorEvent> events;
  double factor;
  double vectorLengthTreshold;
 
public:

  MoveAccumulator(int memory = 100, double factor = 4, double vectorLengthTreshold = 5):
    memory(memory), factor(factor), vectorLengthTreshold(vectorLengthTreshold)
  {
  }
  ~MoveAccumulator() override = default;
 
  MoveAccumulator& operator+=(const QPointF p);
  QVector2D collect();
};

class OSMSCOUT_CLIENT_QT_API MapView: public QObject
{
  Q_OBJECT
 
  Q_PROPERTY(double   lat       READ GetLat       CONSTANT)
  Q_PROPERTY(double   lon       READ GetLon       CONSTANT)
  Q_PROPERTY(double   angle     READ GetAngle     CONSTANT)
  Q_PROPERTY(double   mag       READ GetMag       CONSTANT)
  Q_PROPERTY(uint32_t magLevel  READ GetMagLevel  CONSTANT)
  Q_PROPERTY(double   mapDpi    READ GetMapDpi    CONSTANT)
 
public:
  explicit inline MapView(QObject *parent=nullptr): QObject(parent) {}
 
  MapView(QObject* parent,
          const osmscout::GeoCoord& center,
          const Bearing& angle,
          const osmscout::Magnification& magnification,
          double mapDpi)
    :
    QObject(parent),
    center(center),
    angle(angle),
    magnification(magnification),
    mapDpi(mapDpi)
  {}
 
  MapView(const osmscout::GeoCoord& center,
          const Bearing& angle,
          const osmscout::Magnification& magnification,
          double mapDpi)
    :
    center(center),
    angle(angle),
    magnification(magnification),
    mapDpi(mapDpi)
  {}

  MapView(const MapView& mv)
    :
    QObject(),
    center(mv.center),
    angle(mv.angle),
    magnification(mv.magnification),
    mapDpi(mv.mapDpi)
  {}
 
  ~MapView() override = default;
 
  double GetLat() const{ return center.GetLat(); }
  double GetLon() const{ return center.GetLon(); }
  double GetAngle() const{ return angle.AsRadians(); }
  double GetMag() const{ return magnification.GetMagnification(); }
  double GetMagLevel() const{ return magnification.GetLevel(); }
  double GetMapDpi() const{ return mapDpi; }
 
  bool IsValid() const{ return mapDpi > 0; }
 
  MapView& operator=(const MapView &mv)
  {
    center = mv.center;
    angle = mv.angle;
    magnification = mv.magnification;
    mapDpi = mv.mapDpi;
 
    return *this;
  }
 
  osmscout::GeoCoord           center;
  Bearing                      angle; // canvas clockwise
  osmscout::Magnification      magnification;
  double                       mapDpi{0};
};
 
inline bool operator==(const MapView& a, const MapView& b)
{
  return a.center == b.center && a.angle == b.angle && a.magnification == b.magnification && a.mapDpi == b.mapDpi;
}
inline bool operator!=(const MapView& a, const MapView& b)
{
  return ! (a == b);
}

class OSMSCOUT_CLIENT_QT_API InputHandler : public QObject{
    Q_OBJECT
public:
    explicit InputHandler(const MapView &view);
    ~InputHandler() override = default;
 
    virtual void painted();
    virtual bool animationInProgress();
 
    virtual bool showCoordinates(const osmscout::GeoCoord &coord, const osmscout::Magnification &magnification, const osmscout::Bearing &bearing);
    virtual bool zoom(double zoomFactor, const QPoint &widgetPosition, const QRect &widgetDimension);
    virtual bool move(const QVector2D &vector); // move vector in pixels
    virtual bool rotateTo(double angle);
    virtual bool rotateBy(double angleChange);
    virtual bool touch(const QTouchEvent &event);
    virtual bool currentPosition(bool locationValid, osmscout::GeoCoord currentPosition);
    virtual bool vehiclePosition(const VehiclePosition &vehiclePosition, bool autoRotateMap);
    virtual bool isLockedToPosition();
    virtual bool isFollowVehicle();
    virtual bool focusOutEvent(QFocusEvent *event);
    virtual void widgetResized(const QSizeF &widgetSize);
 
signals:
    void viewChanged(const MapView &view);
 
protected:
    MapView view;
};

class OSMSCOUT_CLIENT_QT_API MoveHandler : public InputHandler {
    Q_OBJECT
 
private:
    QElapsedTimer animationStart;
    QTimer timer;
    MapView startMapView;
    QVector2D _move;
    osmscout::Magnification targetMagnification;
    double targetAngle;
    int animationDuration;
 
    const int MOVE_ANIMATION_DURATION = 1000; // ms
    const int ZOOM_ANIMATION_DURATION = 500; // ms
    const int ROTATE_ANIMATION_DURATION = 1000; //ms
    const int ANIMATION_TICK = 16;
 
private slots:
    void onTimeout();
 
public:
    explicit MoveHandler(const MapView &view);
    ~MoveHandler() override = default;
 
    bool animationInProgress() override;

    bool moveNow(const QVector2D &vector); // move vector in pixels, without animation
 
    bool zoom(double zoomFactor, const QPoint &widgetPosition, const QRect &widgetDimension) override;
    bool move(const QVector2D &vector) override; // move vector in pixels
    bool rotateTo(double angle) override;
    bool rotateBy(double angleChange) override;
    bool touch(const QTouchEvent &event) override;
};

class OSMSCOUT_CLIENT_QT_API ZoomGestureHandler : public InputHandler
{
  Q_OBJECT
private:
  Magnification startMag;
  QPoint gestureStart;
  double zoomDistance;
 
public:
  ZoomGestureHandler(const MapView &view, const QPoint &p, double zoomDistance);
  ~ZoomGestureHandler() override = default;
 
  bool touch(const QTouchEvent &event) override;
};

class OSMSCOUT_CLIENT_QT_API JumpHandler : public InputHandler {
    Q_OBJECT
 
private:
    QElapsedTimer animationStart;
    QTimer timer;
    MapView startMapView;
    MapView targetMapView;
    double angleDiff; // radians
 
    double moveAnimationDuration;
    double zoomAnimationDuration;
 
    static constexpr int ANIMATION_DURATION = 1000; // ms
    static constexpr int ANIMATION_TICK = 16; // ms
 
private slots:
    void onTimeout();
 
public:
    explicit JumpHandler(const MapView &view,
                         double moveAnimationDuration = (double)ANIMATION_DURATION,
                         double zoomAnimationDuration = (double)ANIMATION_DURATION);
 
    ~JumpHandler() override = default;
 
    bool animationInProgress() override;
    bool showCoordinates(const osmscout::GeoCoord &coord, const osmscout::Magnification &magnification, const osmscout::Bearing &bearing) override;
};

class OSMSCOUT_CLIENT_QT_API DragHandler : public MoveHandler {
    Q_OBJECT
public:
    explicit DragHandler(const MapView &view);
    ~DragHandler() override = default;
 
    bool animationInProgress() override;
 
    bool zoom(double zoomFactor, const QPoint &widgetPosition, const QRect &widgetDimension) override;
    bool move(const QVector2D &vector) override; // move vector in pixels
    bool rotateBy(double angleChange) override;
 
    bool touch(const QTouchEvent &event) override;
 
private:
    bool moving;
    MapView startView;
    int fingerId;
    int startX;
    int startY;
    bool ended;
    MoveAccumulator moveAccumulator;
};

class OSMSCOUT_CLIENT_QT_API MultitouchHandler : public MoveHandler {
    Q_OBJECT
public:
    explicit MultitouchHandler(const MapView &view);
    ~MultitouchHandler() override = default;
 
    bool animationInProgress() override;
 
    bool zoom(double zoomFactor, const QPoint &widgetPosition, const QRect &widgetDimension) override;
    bool move(const QVector2D &vector) override; // move vector in pixels
    bool rotateBy(double angleChange) override;
 
    bool touch(const QTouchEvent &event) override;
 
private:
    bool moving;
    MapView startView;
    bool initialized;
    bool ended;
    MoveAccumulator moveAccumulator;
 
    // we take only first two touch points into account
    QTouchEvent::TouchPoint startPointA;
    QTouchEvent::TouchPoint startPointB;
};

class OSMSCOUT_CLIENT_QT_API LockHandler : public JumpHandler {
    Q_OBJECT
public:
    LockHandler(const MapView &view, const QSizeF &widgetSize):
      JumpHandler(view), window(widgetSize)
    {};
 
    ~LockHandler() override = default;
 
    bool currentPosition(bool locationValid, osmscout::GeoCoord currentPosition) override;
    bool showCoordinates(const osmscout::GeoCoord &coord, const osmscout::Magnification &magnification, const osmscout::Bearing &bearing) override;
    bool isLockedToPosition() override;
    bool focusOutEvent(QFocusEvent *event) override;
    void widgetResized(const QSizeF &widgetSize) override;
private:
    QSizeF window;
};

class OSMSCOUT_CLIENT_QT_API VehicleFollowHandler : public JumpHandler {
Q_OBJECT
public:
  VehicleFollowHandler(const MapView &view, const QSizeF &widgetSize);
  ~VehicleFollowHandler() override = default;
 
  bool vehiclePosition(const VehiclePosition &vehiclePosition, bool autoRotateMap) override;
  bool isLockedToPosition() override;
  bool isFollowVehicle() override;
  void widgetResized(const QSizeF &widgetSize) override;
 
private:
  QSizeF window;
};
 
}
 
Q_DECLARE_METATYPE(osmscout::AccumulatorEvent)
Q_DECLARE_METATYPE(osmscout::MapView)
 
#endif /* OSMSCOUT_CLIENT_QT_INPUTHANDLER_H */