fix:qt5_gui move NavitHelper to gt5_graphics and link qt5_graphicsqml-gui-wip

5 files changed, 427 insertions, 3 deletions

diff --git a/navit/graphics/qt5/CMakeLists.txt b/navit/graphics/qt5/CMakeLists.txt
index 9ecd7171e..d162f29a0 100644
--- a/navit/graphics/qt5/CMakeLists.txt
+++ b/navit/graphics/qt5/CMakeLists.txt
@@ -13,6 +13,8 @@ set(QML 0)
 set(QWIDGET 0)
 set(HAVE_FREETYPE 0)
 
+set(MODULE_BUILD_TYPE SHARED)
+
 # check if we have FREETYPE
 if(font/freetype)
 	set(HAVE_FREETYPE 1)
@@ -31,6 +33,9 @@ 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 navithelper.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/navithelper.cpp b/navit/graphics/qt5/navithelper.cpp
new file mode 100644
index 000000000..11923b382
--- /dev/null
+++ b/navit/graphics/qt5/navithelper.cpp
@@ -0,0 +1,362 @@
+#include "navithelper.h"
+
+char * get_icon(struct navit *nav, struct item *item) {
+
+  struct attr layout;
+  struct attr icon_src;
+  GList *layer;
+  navit_get_attr(nav, attr_layout, &layout, NULL);
+  layer=layout.u.layout->layers;
+
+  while(layer) {
+    GList *itemgra=((struct layer *)layer->data)->itemgras;
+    while(itemgra) {
+      GList *types=((struct itemgra *)itemgra->data)->type;
+      while(types) {
+        if((long)types->data==item->type) {
+          GList *element=((struct itemgra *)itemgra->data)->elements;
+          while(element) {
+            struct element * el= (struct element *)element->data;
+            if(el->type==element::element_icon) {
+              char *src;
+              char *icon;
+              struct graphics_image *img;
+              if(item_is_custom_poi(*item)) {
+                struct map_rect *mr=map_rect_new(item->map, NULL);
+                item=map_rect_get_item_byid(mr, item->id_hi, item->id_lo);
+                if(item_attr_get(item, attr_icon_src, &icon_src)) {
+                  src=el->u.icon.src;
+                  if(!src || !src[0])
+                    src="%s";
+                  icon=g_strdup_printf(src,map_convert_string_tmp(item->map,icon_src.u.str));
+                } else {
+                  icon=g_strdup(el->u.icon.src);
+                }
+              } else {
+                icon=g_strdup(el->u.icon.src);
+              }
+              icon[strlen(icon)-3]='s';
+              icon[strlen(icon)-2]='v';
+              icon[strlen(icon)-1]='g';
+              return icon;
+              // FIXME
+              g_free(icon);
+            }
+            element=g_list_next(element);
+          }
+        }
+        types=g_list_next(types);
+      }
+      itemgra=g_list_next(itemgra);
+    }
+    layer=g_list_next(layer);
+  }
+  return "unknown.svg";
+}
+
+NavitHelper::NavitHelper()
+{
+
+}
+
+QString NavitHelper::formatDist(int dist) {
+  double distance = dist/1000;
+  if (dist > 10000)
+    return QString::number(distance, 'f', 0);
+  else if (dist>0)
+    return QString("%1.%2").arg(distance).arg((dist%1000)/100);
+  return QString();
+}
+
+
+QString NavitHelper::getClosest(QList<QVariantMap> items, int maxDistance) {
+  QString ret;
+  int retDistance = 1000000;
+  for(QVariantMap item : items){
+    if(item.value("distance") < retDistance){
+      ret = item.value("label").toString();
+      retDistance = item.value("distance").toInt();
+    }
+  }
+  if(maxDistance > 0 && retDistance > maxDistance){
+    return QString();
+  }
+
+  return ret;
+}
+
+QVariantMap NavitHelper::getPOI(NavitInstance *navitInstance, struct coord center, int distance){
+  if(navitInstance){
+    struct transformation * trans;
+
+    struct map_selection * sel, * selm;
+    struct coord c;
+    struct pcoord pcenter;
+    struct mapset_handle * h;
+    struct map * m;
+    struct map_rect * mr;
+    struct item * item;
+
+    enum projection pro;
+    int idist = 0;
+
+    trans = navit_get_trans(navitInstance->getNavit());
+    pro = transform_get_projection(trans);
+
+    pcenter.x = center.x;
+    pcenter.y = center.y;
+    pcenter.pro = pro;
+
+    int distanceSel =  distance * transform_scale(abs(center.y) + distance * 1.5);
+    sel = map_selection_rect_new(&(pcenter), distanceSel, 18);
+
+    dbg(lvl_debug, "center is at %x, %x", center.x, center.y);
+
+    h = mapset_open(navit_get_mapset(navitInstance->getNavit()));
+    QList<QVariantMap> pois;
+    while ((m = mapset_next(h, 1))) {
+      selm = map_selection_dup_pro(sel, pro, map_projection(m));
+      mr = map_rect_new(m, selm);
+      dbg(lvl_debug, "mr=%p", mr);
+      if (mr) {
+        while ((item = map_rect_get_item(mr))) {
+          if ( item_is_poi(*item) &&
+              item_coord_get_pro(item, &c, 1, pro) &&
+              coord_rect_contains(&sel->u.c_rect, &c) &&
+              (idist = transform_distance(pro, &center, &c)) < distance) {
+            item_attr_rewind(item);
+            struct attr attr;
+            char * label;
+            char * icon = get_icon(navitInstance->getNavit(), item);
+
+            if (item_attr_get(item, attr_label, &attr)) {
+              label = map_convert_string(item->map, attr.u.str);
+
+              QVariantMap poi;
+              poi.insert("label", label);
+              poi.insert("distance", idist);
+              pois << poi;
+            }
+          }
+        }
+        map_rect_destroy(mr);
+      }
+      map_selection_destroy(selm);
+    }
+    map_selection_destroy(sel);
+    mapset_close(h);
+
+    QVariantMap ret;
+    int retDistance = 1000000;
+    for(QVariantMap poi : pois){
+      if(poi.value("distance") < retDistance){
+        ret = poi;
+        retDistance = poi.value("distance").toInt();
+      }
+    }
+
+    return ret;
+  }
+  return QVariantMap();
+}
+
+QString NavitHelper::getAddress(NavitInstance *navitInstance, struct coord center, QString filter){
+  if(navitInstance){
+    struct transformation * trans;
+
+    struct map_selection * sel, * selm;
+    struct coord c;
+    struct pcoord pcenter;
+    struct mapset_handle * h;
+    struct map * m;
+    struct map_rect * mr;
+    struct item * item;
+
+    enum projection pro;
+    int idist = 0;
+    int distance = 1000;
+
+    trans = navit_get_trans(navitInstance->getNavit());
+    pro = transform_get_projection(trans);
+
+    pcenter.x = center.x;
+    pcenter.y = center.y;
+    pcenter.pro = pro;
+
+    int distanceSel =  distance * transform_scale(abs(center.y) + distance * 1.5);
+    sel = map_selection_rect_new(&(pcenter), distanceSel, 18);
+
+    dbg(lvl_debug, "center is at %x, %x", center.x, center.y);
+
+    h = mapset_open(navit_get_mapset(navitInstance->getNavit()));
+    QList<QVariantMap> housenumbers;
+    QList<QVariantMap> streets;
+    QList<QVariantMap> districts;
+    QList<QVariantMap> towns;
+    while ((m = mapset_next(h, 1))) {
+      selm = map_selection_dup_pro(sel, pro, map_projection(m));
+      mr = map_rect_new(m, selm);
+      dbg(lvl_debug, "mr=%p", mr);
+      if (mr) {
+        while ((item = map_rect_get_item(mr))) {
+          if(!filter.isEmpty() && filter != item_to_name(item->type)){
+            continue;
+          }
+
+          if ( (item_is_house_number(*item) || item_is_street(*item) || item_is_district(*item) || item_is_town(*item)) &&
+              item_coord_get_pro(item, &c, 1, pro) &&
+              coord_rect_contains(&sel->u.c_rect, &c) &&
+              (idist = transform_distance(pro, &center, &c)) < distance) {
+            item_attr_rewind(item);
+            struct attr attr;
+            char * label;
+            char * icon = get_icon(navitInstance->getNavit(), item);
+
+            if (item_attr_get(item, attr_label, &attr)) {
+              label = map_convert_string(item->map, attr.u.str);
+              //TODO: District city and country search doesn't always work
+              if(item_is_house_number(*item)){
+                QVariantMap street;
+                street.insert("label", label);
+                street.insert("distance", idist);
+                streets << street;
+              } else if(item_is_street(*item)){
+                QVariantMap street;
+                street.insert("label", label);
+                street.insert("distance", idist);
+                streets << street;
+              } else if (item_is_town(*item)) {
+                QVariantMap town;
+                town.insert("label", label);
+                town.insert("distance", idist);
+                towns << town;
+              } else if (item_is_district(*item)) {
+                QVariantMap district;
+                district.insert("label", label);
+                district.insert("distance",  idist);
+                districts << district;
+              }
+            }
+          }
+        }
+        map_rect_destroy(mr);
+      }
+      map_selection_destroy(selm);
+    }
+    map_selection_destroy(sel);
+    mapset_close(h);
+
+    QStringList address;
+    QString housenumber = getClosest(housenumbers, 15);
+    QString street = getClosest(streets, 100);
+    QString district = getClosest(districts);
+    QString town = getClosest(towns);
+
+    if(!housenumber.isEmpty()){
+      address.append(housenumber);
+    } else if(!street.isEmpty()) {
+      address.append(street);
+    }
+
+    if(street.isEmpty()){
+      QString streetFar = getClosest(streets, 500);
+      address.append(QString("%1 %2").arg("Near").arg(streetFar));
+    }
+
+    if(!district.isEmpty())
+      address.append(district);
+
+    if(!town.isEmpty())
+      address.append(town);
+
+    return address.join(", ");;
+  }
+  return QString();
+}
+
+
+coord NavitHelper::positionToCoord (NavitInstance *navitInstance, int x, int y){
+  struct coord co;
+  if(navitInstance){
+    struct point p;
+    p.x = x;
+    p.y = y;
+
+
+    struct transformation * trans = navit_get_trans(navitInstance->getNavit());
+    transform_reverse(trans, &p, &co);
+
+  }
+  return co;
+}
+pcoord NavitHelper::positionToPcoord (NavitInstance *navitInstance, int x, int y){
+  struct pcoord c;
+  if(navitInstance){
+    struct coord co = positionToCoord(navitInstance, x, y);
+    struct transformation * trans = navit_get_trans(navitInstance->getNavit());
+
+    c.pro = transform_get_projection(trans);
+    c.x = co.x;
+    c.y = co.y;
+
+  }
+  return c;
+}
+pcoord NavitHelper::coordToPcoord (NavitInstance *navitInstance, int x, int y){
+  struct pcoord c;
+  if(navitInstance){
+    struct transformation * trans = navit_get_trans(navitInstance->getNavit());
+
+    c.pro = transform_get_projection(trans);
+    c.x = x;
+    c.y = y;
+  }
+  return c;
+}
+
+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);
+  }
+}
+
+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);
+  }
+}
+
+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;
+  int pos,i;
+  struct pcoord *dst=(pcoord *)g_alloca(dstcount*sizeof(struct pcoord));
+  dstcount=navit_get_destinations(navitInstance->getNavit(),dst,dstcount);
+
+  pos=position;
+  if(pos<0)
+    pos=0;
+
+  for(i=dstcount; i>pos; i--)
+    dst[i]=dst[i-1];
+
+  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);
+}
+void NavitHelper::addBookmark(NavitInstance *navitInstance, QString label, int x, int y){
+  if(navitInstance){
+
+    struct attr attr;
+    struct pcoord c = NavitHelper::positionToPcoord(navitInstance, x ,y);
+    navit_get_attr(navitInstance->getNavit(), attr_bookmarks, &attr, nullptr);
+
+    bookmarks_add_bookmark(attr.u.bookmarks, &c, label.toUtf8().data());
+  }
+}
diff --git a/navit/graphics/qt5/navithelper.h b/navit/graphics/qt5/navithelper.h
new file mode 100644
index 000000000..07716d1b5
--- /dev/null
+++ b/navit/graphics/qt5/navithelper.h
@@ -0,0 +1,53 @@
+#ifndef NAVITHELPER_H
+#define NAVITHELPER_H
+
+#include <QString>
+#include <QDebug>
+
+#include "navitinstance.h"
+
+#include <glib.h>
+extern "C" {
+#include "config.h"
+#include "item.h" /* needs to be first, as attr.h depends on it */
+#include "navit.h"
+
+#include "coord.h"
+#include "attr.h"
+#include "xmlconfig.h" // for NAVIT_OBJECT
+#include "layout.h"
+#include "map.h"
+#include "transform.h"
+
+#include "mapset.h"
+#include "search.h"
+#include "bookmarks.h"
+
+#include "proxy.h"
+
+#include "layout.h"
+
+#include "debug.h"
+
+#include "search.h"
+}
+
+class NavitHelper
+{
+ public:
+  NavitHelper();
+
+  static QString getAddress(NavitInstance * navitInstance, struct coord center, QString filter = "");
+  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 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);
+  static void addStop(NavitInstance *navitInstance, int position, QString label, int x, int y);
+};
+
+#endif // NAVITHELPER_H
diff --git a/navit/gui/qt5_qml/CMakeLists.txt b/navit/gui/qt5_qml/CMakeLists.txt
index bb5fbb9bc..6fc807bcc 100644
--- a/navit/gui/qt5_qml/CMakeLists.txt
+++ b/navit/gui/qt5_qml/CMakeLists.txt
@@ -5,8 +5,12 @@ set(CMAKE_AUTOMOC ON)
 
 qt5_add_resources(GUI_QT5_QML_QRC "gui_qt5_qml.qrc")
 
+set(gui_qt5_qml_LIBS graphics_qt5)
+
 module_add_library(gui_qt5_qml gui_qt5_qml.cpp ${GUI_QT5_QML_QRC}
         navitpoimodel.cpp navitrecentsmodel.cpp navitfavouritesmodel.cpp navitsearchmodel.cpp
-        navithelper.cpp navitroute.cpp navitlayoutsmodel.cpp navitlayersmodel.cpp
+        navitroute.cpp navitlayoutsmodel.cpp navitlayersmodel.cpp
         navitvehiclesmodel.cpp navitmapsmodel.cpp proxy.c)
 
+
+#target_link_libraries(gui_qt5_qml graphics_qt5)
diff --git a/navit/gui/qt5_qml/navitsearchmodel.h b/navit/gui/qt5_qml/navitsearchmodel.h
index bc925576e..2c6ab823c 100644
--- a/navit/gui/qt5_qml/navitsearchmodel.h
+++ b/navit/gui/qt5_qml/navitsearchmodel.h
@@ -140,7 +140,7 @@ private:
 
     struct search_list *m_searchResultList;
 
-    char *m_country_iso2;
+    char *m_country_iso2 = nullptr;
 
     enum SearchType m_search_type;