Add separate event thread

11 files changed, 398 insertions, 218 deletions

diff --git a/navit/graphics/qt5/CMakeLists.txt b/navit/graphics/qt5/CMakeLists.txt
index 9ecd7171e..8aa76934d 100644
--- a/navit/graphics/qt5/CMakeLists.txt
+++ b/navit/graphics/qt5/CMakeLists.txt
@@ -31,6 +31,6 @@ if(USE_QWIDGET)
 	set(GRAPHICS_QT5_ADDITIONAL ${GRAPHICS_QT5_ADDITIONAL} "QNavitWidget.cpp")
 endif ()
 
-module_add_library(graphics_qt5 graphics_qt5.cpp event_qt5.cpp navitinstance.h ${GRAPHICS_QT5_ADDITIONAL})
+module_add_library(graphics_qt5 graphics_qt5.cpp event_qt5.cpp qt5graphicsworker.cpp navitinstance.h ${GRAPHICS_QT5_ADDITIONAL})
 # pass QML and QWIDGET preference to source
 target_compile_definitions(graphics_qt5 PRIVATE USE_QML=${QML} USE_QWIDGET=${QWIDGET} HAVE_FREETYPE=${HAVE_FREETYPE})
diff --git a/navit/graphics/qt5/QNavitQuick_2.cpp b/navit/graphics/qt5/QNavitQuick_2.cpp
index ecceb9ebf..53b237bdf 100644
--- a/navit/graphics/qt5/QNavitQuick_2.cpp
+++ b/navit/graphics/qt5/QNavitQuick_2.cpp
@@ -56,6 +56,14 @@ QNavitQuick_2::QNavitQuick_2(QQuickItem* parent)
       m_moveX(0),
       m_moveY(0) {
     setAcceptedMouseButtons(Qt::AllButtons);
+
+    connect(this, &QNavitQuick_2::onResizeEvent, qt5_timer, &Qt5GraphicsWorker::resizeEvent);
+    connect(this, &QNavitQuick_2::onMapMove, qt5_timer, &Qt5GraphicsWorker::mapMove);
+    connect(this, &QNavitQuick_2::onZoomIn, qt5_timer, &Qt5GraphicsWorker::zoomIn);
+    connect(this, &QNavitQuick_2::onZoomOut, qt5_timer, &Qt5GraphicsWorker::zoomOut);
+    connect(this, &QNavitQuick_2::onZoomToRoute, qt5_timer, &Qt5GraphicsWorker::zoomToRoute);
+    connect(this, &QNavitQuick_2::onSetNumAttr, qt5_timer, &Qt5GraphicsWorker::setNumAttr);
+    connect(this, &QNavitQuick_2::onCenterOnPosition, qt5_timer, &Qt5GraphicsWorker::centerOnPosition);
 }
 
 void QNavitQuick_2::paintOverlays(QPainter* painter, struct graphics_priv* gp, QPaintEvent* event) {
@@ -98,6 +106,7 @@ void QNavitQuick_2::paint(QPainter* painter) {
     if(!(graphics_priv->disable)) {
         paintOverlays(painter, graphics_priv, &event);
     }
+    qDebug() << "Painting thread : " << QThread::currentThread();
     updateZoomLevel();
 }
 
@@ -128,8 +137,9 @@ void QNavitQuick_2::geometryChanged(const QRectF& newGeometry, const QRectF& old
     dbg(lvl_debug, "pixmap %p %dx%d", graphics_priv->pixmap, graphics_priv->pixmap->width(),
         graphics_priv->pixmap->height())
     /* if the root window got resized, tell navit about it */
-    if (graphics_priv->root)
-        resize_callback(graphics_priv, width(), height());
+    if (graphics_priv->root){
+        emit onResizeEvent(m_navitInstance, width(), height());
+    }
 }
 
 void QNavitQuick_2::mousePressEvent(QMouseEvent* event) {
@@ -147,16 +157,7 @@ void QNavitQuick_2::mousePressEvent(QMouseEvent* event) {
 
 void QNavitQuick_2::mouseReleaseEvent(QMouseEvent* event) {
     if(event->button() == Qt::LeftButton){
-        if(m_navitInstance){
-            struct point origin;
-            origin.x = m_originX;
-            origin.y = m_originY;
-            struct point destination;
-            destination.x = event->x();
-            destination.y = event->y();
-
-            navit_drag_map(m_navitInstance->getNavit(), &origin, &destination);
-        }
+        mapMove(m_originX, m_originY, event->x(), event->y());
         m_moveX = 0;
         m_moveY = 0;
     }
@@ -189,59 +190,50 @@ void QNavitQuick_2::mouseMoveEvent(QMouseEvent* event) {
 }
 
 void QNavitQuick_2::wheelEvent(QWheelEvent* event) {
-    if (event->delta() > 0){
-        zoomInToPoint(2, event->x(), event->y());
+    if (event->angleDelta().y() > 0){
+        zoomInToPoint(2, event->position().x(), event->position().y());
     } else {
-        zoomOutFromPoint(2, event->x(), event->y());
+        zoomOutFromPoint(2, event->position().x(), event->position().y());
     }
 }
 
 void QNavitQuick_2::mapMove(int originX, int originY, int destinationX, int destinationY) {
-    if(m_navitInstance){
-        struct point origin;
-        origin.x = originX;
-        origin.y = originY;
-        struct point destination;
-        destination.x = destinationX;
-        destination.y = destinationY;
-
-        navit_drag_map(m_navitInstance->getNavit(), &origin, &destination);
-    }
+    struct point *origin = new struct point;
+    origin->x = originX;
+    origin->y = originY;
+    struct point *destination = new struct point;
+    destination->x = destinationX;
+    destination->y = destinationY;
+
+    emit onMapMove(m_navitInstance, origin, destination);
 }
 
-void QNavitQuick_2::zoomIn(int zoomLevel){
-    if(m_navitInstance){
-        navit_zoom_in(m_navitInstance->getNavit(), zoomLevel, nullptr);
-    }
+void QNavitQuick_2::zoomIn(int zoomLevel, point *p){
+    emit onZoomIn(m_navitInstance, zoomLevel, p);
 }
-void QNavitQuick_2::zoomOut(int zoomLevel){    
-    if(m_navitInstance){
-        navit_zoom_out(m_navitInstance->getNavit(), zoomLevel, nullptr);
-    }
+void QNavitQuick_2::zoomOut(int zoomLevel, point *p){
+    emit onZoomOut(m_navitInstance, zoomLevel, p);
 }
 
 void QNavitQuick_2::zoomInToPoint(int zoomLevel, int x, int y){
     if(m_navitInstance){
-        struct point p;
-        p.x = x;
-        p.y = y;
-        navit_zoom_in(m_navitInstance->getNavit(), zoomLevel, &p);
+        struct point *p = new struct point;
+        p->x = x;
+        p->y = y;
+        zoomIn(zoomLevel, p);
     }
 }
 
 void QNavitQuick_2::zoomOutFromPoint(int zoomLevel, int x, int y){
     if(m_navitInstance){
-        struct point p;
-        p.x = x;
-        p.y = y;
-        navit_zoom_out(m_navitInstance->getNavit(), zoomLevel, &p);
+        struct point *p = new struct point;
+        p->x = x;
+        p->y = y;
+        zoomOut(zoomLevel, p);
     }
 }
-
 void QNavitQuick_2::zoomToRoute(){
-    if(m_navitInstance){
-        navit_zoom_to_route(m_navitInstance->getNavit(), 1);
-    }
+    emit onZoomToRoute(m_navitInstance);
 }
 
 void QNavitQuick_2::setNavitNumProperty(enum attr_type type, int value){
@@ -250,7 +242,8 @@ void QNavitQuick_2::setNavitNumProperty(enum attr_type type, int value){
 
         attr.type = type;
         attr.u.num = value;
-        navit_set_attr(m_navitInstance->getNavit(), &attr);
+
+        emit onSetNumAttr(m_navitInstance, &attr);
     }
 }
 
@@ -263,45 +256,30 @@ int QNavitQuick_2::getNavitNumProperty(enum attr_type type){
 }
 
 void QNavitQuick_2::setPitch(int pitch){
-    if(pitch != m_pitch){
-        setNavitNumProperty(attr_pitch, pitch);
-    }
+    setNavitNumProperty(attr_pitch, pitch);
 }
 
-void QNavitQuick_2::setFollowVehicle(bool followVehicle, int followTime){
-    if(followVehicle != m_followVehicle){
-        setNavitNumProperty(attr_follow, followTime);
-        setNavitNumProperty(attr_follow_cursor, followVehicle);
-    }
+void QNavitQuick_2::setFollowVehicle(bool followVehicle){
+    qDebug() << "setFollowVehicle " << followVehicle;
+    setNavitNumProperty(attr_follow, 0);
+    setNavitNumProperty(attr_follow_cursor, followVehicle);
 }
 
 void QNavitQuick_2::setTracking(bool tracking) {
-    if(tracking != m_tracking){
-        setNavitNumProperty(attr_tracking, tracking);
-    }
+    setNavitNumProperty(attr_tracking, tracking);
 }
 
 void QNavitQuick_2::setAutozoom(bool autoZoom){
-    if(autoZoom != m_autoZoom){
-        setNavitNumProperty(attr_autozoom, (int)autoZoom);
-        setNavitNumProperty(attr_autozoom_active, (int)autoZoom);
-    }
+    setNavitNumProperty(attr_autozoom, (int)autoZoom);
+    setNavitNumProperty(attr_autozoom_active, (int)autoZoom);
 }
 
 void QNavitQuick_2::setOrientation(int orientation){
-    if(orientation != m_orientation){
-        setNavitNumProperty(attr_orientation, orientation);
-    }
+    setNavitNumProperty(attr_orientation, orientation);
 }
 
 void QNavitQuick_2::addBookmark(QString label, int x, int y){
-    if(m_navitInstance){
-        struct attr attr;
-        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance, x ,y);
-        navit_get_attr(m_navitInstance->getNavit(), attr_bookmarks, &attr, nullptr);
-
-        bookmarks_add_bookmark(attr.u.bookmarks, &c, label.toUtf8().data());
-    }
+    NavitHelper::addBookmark(m_navitInstance, label, x, y);
 }
 NavitInstance* QNavitQuick_2::navitInstance(){
     return m_navitInstance;
@@ -335,26 +313,14 @@ void QNavitQuick_2::setNavitInstance(NavitInstance *navit){
 
 QString QNavitQuick_2::getAddress(int x, int y){
     if(m_navitInstance){
-        coord c = NavitHelper::positionToCoord(m_navitInstance, x, y);
+        coord c = NavitHelper::positionToCoord(m_navitInstance->getNavit(), x, y);
         return NavitHelper::getAddress(m_navitInstance, c);
     }
     return "";
 }
 
-QVariantMap QNavitQuick_2::positionToCoordinates(int x, int y){
-    QVariantMap ret;
-    if(m_navitInstance){
-        struct coord c = NavitHelper::positionToCoord(m_navitInstance, x ,y);
-        ret.insert("x", c.x);
-        ret.insert("y", c.y);
-    }
-    return ret;
-}
-
 void QNavitQuick_2::centerOnPosition(){
-    if(m_navitInstance){
-        navit_set_center_cursor_draw(m_navitInstance->getNavit());
-    }
+    emit onCenterOnPosition(m_navitInstance);
 }
 
 void QNavitQuick_2::updateZoomLevel(){
diff --git a/navit/graphics/qt5/QNavitQuick_2.h b/navit/graphics/qt5/QNavitQuick_2.h
index 968f6cb17..e24c5cdb5 100644
--- a/navit/graphics/qt5/QNavitQuick_2.h
+++ b/navit/graphics/qt5/QNavitQuick_2.h
@@ -27,6 +27,8 @@
 #include <QVariantMap>
 #include <QtMath>
 
+#include <QThread>
+
 extern "C" {
 #include "config.h"
 #include "item.h" /* needs to be first, as attr.h depends on it */
@@ -36,6 +38,7 @@ extern "C" {
 #include "graphics_qt5.h"
 #include "navitinstance.h"
 #include "navithelper.h"
+#include "qt5graphicsworker.h"
 
 class QNavitQuick_2 : public QQuickPaintedItem {
     Q_OBJECT
@@ -51,20 +54,19 @@ public:
     void paint(QPainter* painter);
     QNavitQuick_2(QQuickItem* parent = 0);
 
-    Q_INVOKABLE void zoomIn(int zoomLevel);
-    Q_INVOKABLE void zoomOut(int zoomLevel);
+    Q_INVOKABLE void zoomIn(int zoomLevel, point *p = nullptr);
+    Q_INVOKABLE void zoomOut(int zoomLevel, point *p = nullptr);
     Q_INVOKABLE void zoomInToPoint(int zoomLevel, int x, int y);
     Q_INVOKABLE void zoomOutFromPoint(int zoomLevel, int x, int y);
     Q_INVOKABLE void zoomToRoute();
     Q_INVOKABLE void mapMove(int originX, int originY, int destinationX, int destinationY);
     Q_INVOKABLE void addBookmark(QString label, int x, int y);
-    Q_INVOKABLE QVariantMap positionToCoordinates(int x, int y);
     Q_INVOKABLE QString getAddress(int x, int y);
     Q_INVOKABLE void centerOnPosition();
 
     void setPitch(int pitch);
     void setAutozoom(bool autoZoom);
-    void setFollowVehicle(bool followVehicle, int followTime = 0);
+    void setFollowVehicle(bool followVehicle);
     void setTracking(bool tracking);
     void setOrientation(int orientation);
     NavitInstance *navitInstance();
@@ -107,6 +109,14 @@ signals:
     void pressAndHold(QMouseEvent* mouse);
     void propertiesChanged();
     void zoomLevelChanged();
+
+    void onResizeEvent(NavitInstance *navitInstance, int width, int height);
+    void onMapMove(struct NavitInstance *navitInstance, struct point *origin, struct point *destination);
+    void onZoomIn(struct NavitInstance *navitInstance, int zoomLevel, struct point *p);
+    void onZoomOut(struct NavitInstance *navitInstance, int zoomLevel, struct point *p);
+    void onZoomToRoute(struct NavitInstance* navitInstance);
+    void onSetNumAttr(struct NavitInstance *navitInstance, struct attr *attr);
+    void onCenterOnPosition(struct NavitInstance *navitInstance);
 };
 
 #endif
diff --git a/navit/graphics/qt5/event_qt5.cpp b/navit/graphics/qt5/event_qt5.cpp
index 1c6f0e685..5fe915cd5 100644
--- a/navit/graphics/qt5/event_qt5.cpp
+++ b/navit/graphics/qt5/event_qt5.cpp
@@ -47,108 +47,77 @@ extern "C" {
 //#include "event_qt5.moc"
 #include "graphics_qt5.h"
 #include <QSocketNotifier>
-
-struct event_watch {
-    QSocketNotifier* sn;
-    struct callback* cb;
-    int fd;
-};
+#include "qt5graphicsworker.h"
 
 static void event_qt5_remove_timeout(struct event_timeout* to);
 
-qt5_navit_timer::qt5_navit_timer(QObject* parent)
-    : QObject(parent) {
-    timer_type = g_hash_table_new(NULL, NULL);
-    timer_callback = g_hash_table_new(NULL, NULL);
-    watches = g_hash_table_new(NULL, NULL);
-    dbg(lvl_debug, "qt5_navit_timer object created");
-}
-
-void qt5_navit_timer::watchEvent(int id) {
-    struct event_watch* ret = g_new0(struct event_watch, 1);
-    ret = (struct event_watch*)g_hash_table_lookup(watches, (void*)(long)id);
-    if (ret) {
-        dbg(lvl_debug, "callback found, calling it");
-        callback_call_0(ret->cb);
-    }
-}
-
-void qt5_navit_timer::timerEvent(QTimerEvent* event) {
-    int id = event->timerId();
-    void* multi = NULL;
-    //        dbg(lvl_debug, "TimerEvent (%d)", id);
-    struct callback* cb = (struct callback*)g_hash_table_lookup(timer_callback, (void*)(long)id);
-    if (cb)
-        callback_call_0(cb);
-    /* remove timer if it was oneshot timer */
-    if (g_hash_table_lookup_extended(timer_type, (void*)(long)id, NULL, &multi)) {
-        /* it's still in the list */
-        if (((int)(long)multi) == 0)
-            event_qt5_remove_timeout((struct event_timeout*)(long)id);
-    }
-    //        dbg(lvl_debug, "TimerEvent (%d) leave", id);
-}
-
-qt5_navit_timer* qt5_timer = NULL;
+Qt5GraphicsWorker* qt5_timer = nullptr;
+QThread *qt5_event_thread = nullptr;
 
 static void event_qt5_main_loop_run(void) {
-    dbg(lvl_debug, "enter");
-    if (navit_app != NULL)
+    qDebug() << "Starting mainloop";
+    if (navit_app != nullptr)
         navit_app->exec();
 }
 
 static void event_qt5_main_loop_quit(void) {
-    dbg(lvl_debug, "enter");
+    qDebug() << "Quitting mainloop";
+
     exit(0);
 }
 
 static struct event_watch* event_qt5_add_watch(int fd, enum event_watch_cond cond, struct callback* cb) {
-    dbg(lvl_debug, "enter fd=%d", (int)(long)fd);
-    struct event_watch* ret = g_new0(struct event_watch, 1);
-    ret->fd = fd;
-    ret->cb = cb;
-    g_hash_table_insert(qt5_timer->watches, GINT_TO_POINTER(fd), ret);
-    ret->sn = new QSocketNotifier(fd, QSocketNotifier::Read, qt5_timer);
-    QObject::connect(ret->sn, SIGNAL(activated(int)), qt5_timer, SLOT(watchEvent(int)));
-    return ret;
+    qDebug() << "Adding watch : " << fd;
+    struct Qt5GraphicsWorker::eventWatch *ew = (Qt5GraphicsWorker::eventWatch*) malloc( sizeof(struct Qt5GraphicsWorker::eventWatch));
+    ew->fd = fd;
+    ew->cb = cb;
+
+    qt5_timer->m_watches.insert(fd, ew);
+    ew->sn = new QSocketNotifier(fd, QSocketNotifier::Read, qt5_timer);
+    QObject::connect(ew->sn, SIGNAL(activated(int)), qt5_timer, SLOT(watchEvent(int)));
+    return (event_watch*) ew;
 }
 
-static void event_qt5_remove_watch(struct event_watch* ev) {
-    dbg(lvl_debug, "enter");
-    g_hash_table_remove(qt5_timer->watches, GINT_TO_POINTER(ev->fd));
-    delete (ev->sn);
-    g_free(ev);
+static void event_qt5_remove_watch(struct event_watch* ew) {
+    Qt5GraphicsWorker::eventWatch *watch = (Qt5GraphicsWorker::eventWatch*)ew;
+    qDebug() << "Removing watch : " << watch->fd;
+    qt5_timer->m_watches.remove(watch->fd);
+    delete (watch->sn);
+    g_free(watch);
 }
 
 static struct event_timeout* event_qt5_add_timeout(int timeout, int multi, struct callback* cb) {
-    int id;
-    dbg(lvl_debug, "add timeout %d, mul %d, %p ==", timeout, multi, cb);
-    id = qt5_timer->startTimer(timeout);
-    dbg(lvl_debug, "%d", id);
-    g_hash_table_insert(qt5_timer->timer_callback, (void*)(long)id, cb);
-    g_hash_table_insert(qt5_timer->timer_type, (void*)(long)id, (void*)(long)!!multi);
-    return (struct event_timeout*)(long)id;
+    struct Qt5GraphicsWorker::eventTimeout *et = (Qt5GraphicsWorker::eventTimeout*) malloc( sizeof(struct Qt5GraphicsWorker::eventTimeout));
+    et->type = !!multi;
+    et->cb = cb;
+
+    emit qt5_timer->addTimeout(et, timeout);
+    return (event_timeout*) et;
 }
 
-static void event_qt5_remove_timeout(struct event_timeout* to) {
-    dbg(lvl_debug, "remove timeout (%d)", (int)(long)to);
-    qt5_timer->killTimer((int)(long)to);
-    g_hash_table_remove(qt5_timer->timer_callback, to);
-    g_hash_table_remove(qt5_timer->timer_type, to);
+static void event_qt5_remove_timeout(struct event_timeout* et) {
+    Qt5GraphicsWorker::eventTimeout *timeout = (Qt5GraphicsWorker::eventTimeout*)et;
+    qDebug() << "Removing timeout : " << timeout->id;
+    emit qt5_timer->removeTimeout(timeout);
+
 }
 
 static struct event_idle* event_qt5_add_idle(int priority, struct callback* cb) {
-    dbg(lvl_debug, "add idle event");
-    return (struct event_idle*)event_qt5_add_timeout(0, 1, cb);
+    struct Qt5GraphicsWorker::eventIdle *et = (Qt5GraphicsWorker::eventIdle*) malloc( sizeof(struct Qt5GraphicsWorker::eventIdle));
+    et->cb = cb;
+
+    emit qt5_timer->addIdle(et);
+    return (struct event_idle*) et;
 }
 
 static void event_qt5_remove_idle(struct event_idle* ev) {
-    dbg(lvl_debug, "Remove idle timeout");
-    event_qt5_remove_timeout((struct event_timeout*)ev);
+    Qt5GraphicsWorker::eventIdle *idle = (Qt5GraphicsWorker::eventIdle*)ev;
+    qDebug() << "Removing idle : " << idle->id;
+    emit qt5_timer->removeIdle(idle);
 }
 
 static void event_qt5_call_callback(struct callback_list* cb) {
-    dbg(lvl_debug, "enter");
+    qDebug() << "event_qt5_call_callback";
 }
 
 static struct event_methods event_qt5_methods = {
@@ -162,11 +131,24 @@ static struct event_methods event_qt5_methods = {
     event_qt5_remove_idle,
     event_qt5_call_callback,
 };
-
 static struct event_priv* event_qt5_new(struct event_methods* meth) {
+    QThread::currentThread()->setObjectName("main");
     *meth = event_qt5_methods;
-    qt5_timer = new qt5_navit_timer(NULL);
-    return NULL;
+
+    qDebug() << "Starting event thread : " << QThread::currentThread();
+
+    if(!qt5_timer){
+        qt5_timer = new Qt5GraphicsWorker();
+    }
+
+    if(!qt5_event_thread){
+        qt5_event_thread = new QThread;
+        qt5_event_thread->setObjectName("event thread");
+        qt5_event_thread->start();
+    }
+    qt5_timer->moveToThread(qt5_event_thread);
+
+    return nullptr;
 }
 
 void qt5_event_init(void) {
diff --git a/navit/graphics/qt5/event_qt5.h b/navit/graphics/qt5/event_qt5.h
index 7fe184cd1..e76f8a16c 100644
--- a/navit/graphics/qt5/event_qt5.h
+++ b/navit/graphics/qt5/event_qt5.h
@@ -18,20 +18,9 @@
  */
 
 #include <QObject>
+#include <QThread>
 #include <glib.h>
-
-class qt5_navit_timer : public QObject {
-    Q_OBJECT
-public: qt5_navit_timer(QObject* parent = 0);
-    GHashTable* timer_type;
-    GHashTable* timer_callback;
-    GHashTable* watches;
-
-public slots:
-    void watchEvent(int id);
-
-protected:
-    void timerEvent(QTimerEvent* event);
-};
+#include <QMutex>
+#include <QHash>
 
 void qt5_event_init(void);
diff --git a/navit/graphics/qt5/qt5graphicsworker.cpp b/navit/graphics/qt5/qt5graphicsworker.cpp
new file mode 100644
index 000000000..516d6fe86
--- /dev/null
+++ b/navit/graphics/qt5/qt5graphicsworker.cpp
@@ -0,0 +1,103 @@
+#include "qt5graphicsworker.h"
+
+Qt5GraphicsWorker::Qt5GraphicsWorker(QObject *parent) : QObject(parent) {
+    dbg(lvl_debug, "qt5_navit_timer object created")
+
+    connect(this, &Qt5GraphicsWorker::addIdle, this, &Qt5GraphicsWorker::addIdleHandler);
+    connect(this, &Qt5GraphicsWorker::addTimeout, this, &Qt5GraphicsWorker::addTimeoutHandler);
+    connect(this, &Qt5GraphicsWorker::removeIdle, this, &Qt5GraphicsWorker::removeIdleHandler);
+    connect(this, &Qt5GraphicsWorker::removeTimeout, this, &Qt5GraphicsWorker::removeTimeoutHandler);
+}
+
+void Qt5GraphicsWorker::watchEvent(int id) {
+    struct eventWatch* ret = m_watches[id];
+    if (ret) {
+        qDebug() << "Watch event : " << id;
+        callback_call_0(ret->cb);
+    }
+}
+
+void Qt5GraphicsWorker::addIdleHandler(struct eventIdle* ei){
+    ei->id = startTimer(0);
+    m_idles.insert(ei->id, ei);
+    qDebug() << "Added idle : " << ei->id << " thread : " << QThread::currentThread();
+}
+void Qt5GraphicsWorker::addTimeoutHandler(struct eventTimeout* et, int timeout){
+    et->id = startTimer(timeout);
+    m_timeouts.insert(et->id, et);
+    qDebug() << "Added timeout : " << et->id << " thread : " << QThread::currentThread();
+}
+void Qt5GraphicsWorker::removeIdleHandler(struct eventIdle* ei){
+    killTimer(ei->id);
+    m_idles.remove(ei->id);
+    free(ei);
+}
+void Qt5GraphicsWorker::removeTimeoutHandler(struct eventTimeout* et){
+    killTimer(et->id);
+    m_timeouts.remove(et->id);
+    free(et);
+}
+
+void Qt5GraphicsWorker::timerEvent(QTimerEvent* event) {
+    int id = event->timerId();
+
+    struct callback* cb = nullptr;
+    struct eventTimeout* et = nullptr;
+
+    if(m_idles.contains(id)){
+        cb = m_idles[id]->cb;
+//        qDebug() << "Idle event : " << id << " thread : " << QThread::currentThread();
+    } else if(m_timeouts.contains(id)) {
+        et = m_timeouts[id];
+//        qDebug() << "Timeout event : " << id << " thread : " << QThread::currentThread();
+        cb = et->cb;
+    }
+
+    if (cb)
+        callback_call_0(cb);
+
+    if(et && et->type == 0){
+        removeTimeoutHandler(et);
+//        qDebug() << "Oneshot timeout removed : " << id;
+    }
+}
+
+
+void Qt5GraphicsWorker::resizeEvent(NavitInstance *navitInstance, int width, int height) {
+    if(navitInstance){
+        resize_callback(navitInstance->m_graphics_priv, width, height);
+    }
+}
+void Qt5GraphicsWorker::mapMove(NavitInstance *navitInstance, struct point *origin, struct point *destination){
+    if(navitInstance){
+        qDebug() << "Map move thread : " << QThread::currentThread();
+        navit_drag_map(navitInstance->getNavit(), origin, destination);
+    }
+}
+void Qt5GraphicsWorker::zoomIn(NavitInstance *navitInstance, int zoomLevel, struct point *p){
+    if(navitInstance){
+        navit_zoom_in(navitInstance->getNavit(), zoomLevel, p);
+    }
+}
+void Qt5GraphicsWorker::zoomOut(NavitInstance *navitInstance, int zoomLevel, struct point *p){
+    if(navitInstance){
+        navit_zoom_out(navitInstance->getNavit(), zoomLevel, p);
+    }
+}
+void Qt5GraphicsWorker::zoomToRoute(NavitInstance *navitInstance) {
+    if(navitInstance){
+        navit_zoom_to_route(navitInstance->getNavit(), 1);
+    }
+
+}
+void Qt5GraphicsWorker::setNumAttr(NavitInstance *navitInstance, struct attr *attr) {
+    if(navitInstance && attr){
+        navit_set_attr(navitInstance->getNavit(), attr);
+    }
+}
+
+void Qt5GraphicsWorker::centerOnPosition(NavitInstance *navitInstance) {
+    if(navitInstance){
+        navit_set_center_cursor_draw(navitInstance->getNavit());
+    }
+}
diff --git a/navit/graphics/qt5/qt5graphicsworker.h b/navit/graphics/qt5/qt5graphicsworker.h
new file mode 100644
index 000000000..76e4e68a9
--- /dev/null
+++ b/navit/graphics/qt5/qt5graphicsworker.h
@@ -0,0 +1,91 @@
+#ifndef QT5GRAPHICSWORKER_H
+#define QT5GRAPHICSWORKER_H
+
+#include <QObject>
+#include <QThread>
+#include <glib.h>
+#include <QMutex>
+#include <QHash>
+
+extern "C" {
+#include "config.h"
+
+#include "callback.h"
+#include "color.h"
+#include "debug.h"
+#include "event.h"
+
+#include "point.h" /* needs to be before graphics.h */
+
+#include "graphics.h"
+#include "item.h"
+#include "keys.h"
+#include "navit.h"
+
+#include "event.h"
+}
+
+#if defined(WINDOWS) || defined(WIN32) || defined(HAVE_API_WIN32_CE)
+#include <windows.h>
+#endif
+
+#include "graphics_qt5.h"
+#include <QSocketNotifier>
+
+class Qt5GraphicsWorker : public QObject {
+    Q_OBJECT
+public:
+    Qt5GraphicsWorker(QObject *parent = nullptr);
+    struct eventWatch {
+        QSocketNotifier* sn;
+        struct callback* cb;
+        int fd;
+    };
+
+    struct eventTimeout {
+        int id;
+        struct callback *cb;
+        int type;
+    };
+
+    struct eventIdle {
+        int id;
+        struct callback *cb;
+    };
+
+    QHash<int, int> m_timer_type;
+    QHash<int, struct callback *> m_timer_callback;
+    QHash<int, struct eventWatch*> m_watches;
+    QHash<int, struct eventTimeout*> m_timeouts;
+    QHash<int, struct eventIdle*> m_idles;
+
+    void resizeEvent(NavitInstance *navitInstance, int width, int height);
+    void mapMove(NavitInstance *navitInstance, struct point *origin, struct point *destination);
+    void zoomIn(NavitInstance *navitInstance, int zoomLevel, struct point *p);
+    void zoomOut(NavitInstance *navitInstance, int zoomLevel, struct point *p);
+    void zoomToRoute(NavitInstance *navitInstance);
+    void setNumAttr(NavitInstance *navitInstance, struct attr *attr);
+    void centerOnPosition(NavitInstance *navitInstance);
+
+signals:
+    void addIdle(struct eventIdle* ei);
+    void addTimeout(struct eventTimeout* et, int timeout);
+    void removeIdle(struct eventIdle* ei);
+    void removeTimeout(struct eventTimeout* et);
+
+public slots:
+    void watchEvent(int id);
+
+    void addIdleHandler(struct eventIdle* ei);
+    void addTimeoutHandler(struct eventTimeout* et, int timeout);
+    void removeIdleHandler(struct eventIdle* ei);
+    void removeTimeoutHandler(struct eventTimeout* et);
+
+protected:
+    void timerEvent(QTimerEvent* event);
+private:
+};
+
+extern Qt5GraphicsWorker* qt5_timer;
+
+#endif // QT5GRAPHICSWORKER_H
diff --git a/navit/gui/qt5_qml/navithelper.cpp b/navit/gui/qt5_qml/navithelper.cpp
index 16b4a185e..210f30634 100644
--- a/navit/gui/qt5_qml/navithelper.cpp
+++ b/navit/gui/qt5_qml/navithelper.cpp
@@ -215,31 +215,31 @@ QString NavitHelper::getAddress(NavitInstance *navitInstance, struct coord cente
         if(!town.isEmpty())
             address.append(town);
 
-        return address.join(", ");;
+        return address.join(", ");
     }
     return QString();
 }
 
 
-coord NavitHelper::positionToCoord (NavitInstance *navitInstance, int x, int y){
+coord NavitHelper::positionToCoord (struct navit *navit, int x, int y){
     struct coord co;
-    if(navitInstance){
+    if(navit){
         struct point p;
         p.x = x;
         p.y = y;
 
 
-        struct transformation * trans = navit_get_trans(navitInstance->getNavit());
+        struct transformation * trans = navit_get_trans(navit);
         transform_reverse(trans, &p, &co);
 
     }
     return co;
 }
-pcoord NavitHelper::positionToPcoord (NavitInstance *navitInstance, int x, int y){
+pcoord NavitHelper::positionToPcoord (struct navit *navit, int x, int y){
     struct pcoord c;
-    if(navitInstance){
-        struct coord co = positionToCoord(navitInstance, x, y);
-        struct transformation * trans = navit_get_trans(navitInstance->getNavit());
+    if(navit){
+        struct coord co = positionToCoord(navit, x, y);
+        struct transformation * trans = navit_get_trans(navit);
 
         c.pro = transform_get_projection(trans);
         c.x = co.x;
@@ -248,10 +248,10 @@ pcoord NavitHelper::positionToPcoord (NavitInstance *navitInstance, int x, int y
     }
     return c;
 }
-pcoord NavitHelper::coordToPcoord (NavitInstance *navitInstance, int x, int y){
+pcoord NavitHelper::coordToPcoord (struct navit *navit, int x, int y){
     struct pcoord c;
-    if(navitInstance){
-        struct transformation * trans = navit_get_trans(navitInstance->getNavit());
+    if(navit){
+        struct transformation * trans = navit_get_trans(navit);
 
         c.pro = transform_get_projection(trans);
         c.x = x;
@@ -260,29 +260,38 @@ pcoord NavitHelper::coordToPcoord (NavitInstance *navitInstance, int x, int y){
     return c;
 }
 
+static void setDestinationStatic(struct navit *navit, char * label, int x, int y) {
+    if(navit){
+        navit_set_destination(navit, nullptr, nullptr, 0);
+        struct pcoord c = NavitHelper::coordToPcoord(navit, x, y);
+        navit_set_destination(navit, &c, label, 1);
+    }
+}
 void NavitHelper::setDestination(NavitInstance *navitInstance, QString label, int x, int y){
     if(navitInstance){
-        navit_set_destination(navitInstance->getNavit(), nullptr, nullptr, 0);
-        struct pcoord c = coordToPcoord(navitInstance, x, y);
-        navit_set_destination(navitInstance->getNavit(), &c, label.toUtf8().data(), 1);
+        event_add_timeout(0, 0, callback_new_4(callback_cast(setDestinationStatic), navitInstance->getNavit(), label.toUtf8().data(), x ,y));
+    }
+}
+
+static void setPositionStatic(struct navit *navit, int x, int y) {
+    if(navit){
+        struct pcoord c = NavitHelper::coordToPcoord(navit, x, y);
+        navit_set_position(navit, &c);
     }
 }
 
 void NavitHelper::setPosition(NavitInstance *navitInstance, int x, int y){
     if(navitInstance){
-        struct pcoord c = NavitHelper::coordToPcoord(navitInstance, x, y);
-
-        navit_set_position(navitInstance->getNavit(), &c);
+        event_add_timeout(0, 0, callback_new_3(callback_cast(setPositionStatic), navitInstance->getNavit(), x ,y));
     }
 }
 
-void NavitHelper::addStop(NavitInstance *navitInstance, int position, QString label, int x, int y) {
-        struct pcoord c = coordToPcoord(navitInstance, x, y);
-
-        int dstcount=navit_get_destination_count(navitInstance->getNavit())+1;
+static void addStopStatic(struct navit *navit, int position, char *label, pcoord *c) {
+    if(navit){
+        int dstcount=navit_get_destination_count(navit)+1;
         int pos,i;
         struct pcoord *dst=(pcoord *)g_alloca(dstcount*sizeof(struct pcoord));
-        dstcount=navit_get_destinations(navitInstance->getNavit(),dst,dstcount);
+        dstcount=navit_get_destinations(navit,dst,dstcount);
 
         pos=position;
         if(pos<0)
@@ -291,18 +300,30 @@ void NavitHelper::addStop(NavitInstance *navitInstance, int position, QString la
         for(i=dstcount; i>pos; i--)
             dst[i]=dst[i-1];
 
-        dst[pos]=c;
+        dst[pos]=*c;
 
-        navit_add_destination_description(navitInstance->getNavit(),&c,label.toUtf8().data());
-        navit_set_destinations(navitInstance->getNavit(),dst,dstcount+1,label.toUtf8().data(),1);
+        navit_add_destination_description(navit,c,label);
+        navit_set_destinations(navit,dst,dstcount+1,label,1);
+    }
 }
-void NavitHelper::addBookmark(NavitInstance *navitInstance, QString label, int x, int y){
-    if(navitInstance){
 
+void NavitHelper::addStop(NavitInstance *navitInstance, int position, QString label, int x, int y) {
+    if(navitInstance){
+        struct pcoord c = NavitHelper::coordToPcoord(navitInstance->getNavit(), x, y);
+        event_add_timeout(0, 0, callback_new_4(callback_cast(addStopStatic), navitInstance->getNavit(), position, label.toUtf8().data(), &c));
+    }
+}
+void addBookmarkStatic(struct navit *navit, QString label, int x, int y){
+    if(navit){
         struct attr attr;
-        struct pcoord c = NavitHelper::positionToPcoord(navitInstance, x ,y);
-        navit_get_attr(navitInstance->getNavit(), attr_bookmarks, &attr, nullptr);
+        struct pcoord c = NavitHelper::positionToPcoord(navit, x ,y);
+        navit_get_attr(navit, attr_bookmarks, &attr, nullptr);
 
         bookmarks_add_bookmark(attr.u.bookmarks, &c, label.toUtf8().data());
     }
 }
+void NavitHelper::addBookmark(NavitInstance *navitInstance, QString label, int x, int y){
+    if(navitInstance){
+        event_add_timeout(0, 0, callback_new_4(callback_cast(addBookmarkStatic), navitInstance->getNavit(), label.toUtf8().data(), x, y));
+    }
+}
diff --git a/navit/gui/qt5_qml/navithelper.h b/navit/gui/qt5_qml/navithelper.h
index 6c0513089..f362e9490 100644
--- a/navit/gui/qt5_qml/navithelper.h
+++ b/navit/gui/qt5_qml/navithelper.h
@@ -24,6 +24,9 @@ extern "C" {
 #include "bookmarks.h"
 
 #include "proxy.h"
+
+#include "event.h"
+#include "callback.h"
 }
 
 class NavitHelper
@@ -35,9 +38,9 @@ public:
     static QVariantMap getPOI(NavitInstance *navitInstance, struct coord center, int distance = 2);
     static QString getClosest(QList<QVariantMap> items, int maxDistance = -1);
     static QString formatDist(int dist);
-    static pcoord positionToPcoord (NavitInstance *navitInstance, int x, int y);
-    static coord positionToCoord (NavitInstance *navitInstance, int x, int y);
-    static pcoord coordToPcoord(NavitInstance *navitInstance, int x, int y);
+    static pcoord positionToPcoord (navit *navit, int x, int y);
+    static coord positionToCoord (navit *navit, int x, int y);
+    static pcoord coordToPcoord(navit *navit, int x, int y);
     static void setDestination(NavitInstance *navitInstance, QString label, int x, int y);
     static void setPosition(NavitInstance *navitInstance, int x, int y);
     static void addBookmark(NavitInstance *navitInstance, QString label, int x, int y);
diff --git a/navit/gui/qt5_qml/navitpoimodel.h b/navit/gui/qt5_qml/navitpoimodel.h
index c50a002ca..635c7c34f 100644
--- a/navit/gui/qt5_qml/navitpoimodel.h
+++ b/navit/gui/qt5_qml/navitpoimodel.h
@@ -35,13 +35,18 @@ extern "C" {
 }
 
 
-class POISearchWorker : public QThread
+class POISearchWorker : public QObject
 {
     Q_OBJECT
 public:
     POISearchWorker (NavitInstance * navit, QString filter, int screenX, int screenY, int distance);
     ~POISearchWorker ();
-    void run() override;
+    void start();
+    void proccess();
+    void proccessMapset();
+    void proccessMapsetItem();
+    void finish();
+    static void callbackHandler(POISearchWorker this_);
 signals:
     void gotSearchResult(QVariantMap poi);
 private:
@@ -50,6 +55,15 @@ private:
     int m_screenX;
     int m_screenY;
     int m_distance;
+    enum projection m_pro;
+    struct mapset_handle * m_h = nullptr;
+    struct map_selection * m_sel = nullptr;
+    struct coord m_center;
+
+    struct map *m_m = nullptr;
+
+    struct callback * m_idleCallback = nullptr;
+    struct event_idle * m_idle = nullptr;
 };
 
 class NavitPOIModel : public QAbstractItemModel
@@ -96,6 +110,7 @@ private:
     void stopWorker(bool clearModel = false);
     POISearchWorker *m_poiWorker = nullptr;
     QMutex modelMutex;
+
 };
 
 #endif // NAVITPOIMODEL_H
diff --git a/navit/gui/qt5_qml/navitroute.cpp b/navit/gui/qt5_qml/navitroute.cpp
index d1d025355..034f82aad 100644
--- a/navit/gui/qt5_qml/navitroute.cpp
+++ b/navit/gui/qt5_qml/navitroute.cpp
@@ -317,22 +317,22 @@ void NavitRoute::cancelNavigation(){
 void NavitRoute::setDestination(QString label, int x, int y){
     if(m_navitInstance){
         cancelNavigation();
-        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance, x, y);
+        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance->getNavit(), x, y);
         NavitHelper::setDestination(m_navitInstance, label, c.x, c.y);
     }
 }
 
 void NavitRoute::setPosition(int x, int y){
     if(m_navitInstance){
-        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance, x, y);
-        navit_set_position(m_navitInstance->getNavit(), &c);
+        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance->getNavit(), x, y);
+//        navit_set_position(m_navitInstance->getNavit(), &c);
         NavitHelper::setPosition(m_navitInstance, c.x, c.y);
     }
 }
 
 void NavitRoute::addStop(QString label, int x, int y,  int position){
     if(m_navitInstance){
-        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance, x, y);
+        struct pcoord c = NavitHelper::positionToPcoord(m_navitInstance->getNavit(), x, y);
         NavitHelper::addStop(m_navitInstance, position, label, c.x, c.y);
     }
 }