src/geonamessearch.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2009, Hein Ragas
   5  * Copyright (C) 2013, Rob Norris <rw_norris@hotmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  */
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <glib.h>
  29 #include <glib/gstdio.h>
  30 #include <glib/gprintf.h>
  31 #include <glib/gi18n.h>
  32
  33 #include "viking.h"
  34 #include "geonamessearch.h"
  35
  36 /* Compatibility */
  37 #if ! GLIB_CHECK_VERSION(2,22,0)
  38 #define g_mapped_file_unref g_mapped_file_free
  39 #endif
  40
  41 // TODO - offer configuration of this value somewhere
  42 //  ATM decided it's not essential enough to warrant putting in the preferences
  43 #define GEONAMES_MAX_ENTRIES 20
  44
  45 #define GEONAMES_WIKIPEDIA_URL_FMT "http://api.geonames.org/wikipediaBoundingBoxJSON?formatted=true&north=%s&south=%s&east=%s&west=%s&lang=%s&maxRows=%d&username="VIK_CONFIG_GEONAMES_USERNAME
  46
  47 #define GEONAMES_FEATURE_PATTERN "\"feature\": \""
  48 #define GEONAMES_LONGITUDE_PATTERN "\"lng\": "
  49 #define GEONAMES_NAME_PATTERN "\"name\": \""
  50 #define GEONAMES_LATITUDE_PATTERN "\"lat\": "
  51 #define GEONAMES_ELEVATION_PATTERN "\"elevation\": "
  52 #define GEONAMES_TITLE_PATTERN "\"title\": \""
  53 #define GEONAMES_WIKIPEDIAURL_PATTERN "\"wikipediaUrl\": \""
  54 #define GEONAMES_THUMBNAILIMG_PATTERN "\"thumbnailImg\": \""
  55 #define GEONAMES_SEARCH_NOT_FOUND "not understand the location"
  56
  57 /* found_geoname: Type to contain data returned from GeoNames.org */
  58
  59 typedef struct {
  60   gchar *name;
  61   gchar *feature;
  62   struct LatLon ll;
  63   gdouble elevation;
  64   gchar *cmt;
  65   gchar *desc;
  66 } found_geoname;
  67
  68 static found_geoname *new_found_geoname()
  69 {
  70   found_geoname *ret;
  71
  72   ret = (found_geoname *)g_malloc(sizeof(found_geoname));
  73   ret->name = NULL;
  74   ret->feature = NULL;
  75   ret->cmt = NULL;
  76   ret->desc = NULL;
  77   ret->ll.lat = 0.0;
  78   ret->ll.lon = 0.0;
  79   ret->elevation = VIK_DEFAULT_ALTITUDE;
  80   return ret;
  81 }
  82
  83 static found_geoname *copy_found_geoname(found_geoname *src)
  84 {
  85   found_geoname *dest = new_found_geoname();
  86   dest->name = g_strdup(src->name);
  87   dest->feature = g_strdup(src->feature);
  88   dest->ll.lat = src->ll.lat;
  89   dest->ll.lon = src->ll.lon;
  90   dest->elevation = src->elevation;
  91   dest->cmt = g_strdup(src->cmt);
  92   dest->desc = g_strdup(src->desc);
  93   return(dest);
  94 }
  95
  96 static void free_list_geonames(found_geoname *geoname, gpointer userdata)
  97 {
  98   g_free(geoname->name);
  99   g_free(geoname->feature);
 100   g_free(geoname->cmt);
 101   g_free(geoname->desc);
 102 }
 103
 104 static void free_geoname_list(GList *found_places)
 105 {
 106   g_list_foreach(found_places, (GFunc)free_list_geonames, NULL);
 107   g_list_free(found_places);
 108 }
 109
 110 static void none_found(VikWindow *vw)
 111 {
 112   GtkWidget *dialog = NULL;
 113
 114   dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL );
 115   gtk_window_set_title(GTK_WINDOW(dialog), _("Search"));
 116
 117   GtkWidget *search_label = gtk_label_new(_("No entries found!"));
 118   gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), search_label, FALSE, FALSE, 5 );
 119   gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
 120   gtk_widget_show_all(dialog);
 121
 122   gtk_dialog_run ( GTK_DIALOG(dialog) );
 123   gtk_widget_destroy(dialog);
 124 }
 125
 126 static GList *a_select_geoname_from_list(GtkWindow *parent, GList *geonames, gboolean multiple_selection_allowed, const gchar *title, const gchar *msg)
 127 {
 128   GtkTreeIter iter;
 129   GtkCellRenderer *renderer;
 130   GtkWidget *view;
 131   found_geoname *geoname;
 132   gchar *latlon_string;
 133   int column_runner;
 134
 135   GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
 136                                                   parent,
 137                                                   GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 138                                                   GTK_STOCK_CANCEL,
 139                                                   GTK_RESPONSE_REJECT,
 140                                                   GTK_STOCK_OK,
 141                                                   GTK_RESPONSE_ACCEPT,
 142                                                   NULL);
 143   /* When something is selected then OK */
 144   gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
 145   GtkWidget *response_w = NULL;
 146 #if GTK_CHECK_VERSION (2, 20, 0)
 147   /* Default to not apply - as initially nothing is selected! */
 148   response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
 149 #endif
 150   GtkWidget *label = gtk_label_new ( msg );
 151   GtkTreeStore *store = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 152
 153   GList *geoname_runner = geonames;
 154   while (geoname_runner)
 155   {
 156     geoname = (found_geoname *)geoname_runner->data;
 157     latlon_string = g_strdup_printf("(%f,%f)", geoname->ll.lat, geoname->ll.lon);
 158     gtk_tree_store_append(store, &iter, NULL);
 159     gtk_tree_store_set(store, &iter, 0, geoname->name, 1, geoname->feature, 2, latlon_string, -1);
 160     geoname_runner = g_list_next(geoname_runner);
 161     g_free(latlon_string);
 162   }
 163
 164   view = gtk_tree_view_new();
 165   renderer = gtk_cell_renderer_text_new();
 166   column_runner = 0;
 167   GtkTreeViewColumn *column;
 168   // NB could allow columns to be shifted around by doing this after each new
 169   // gtk_tree_view_column_set_reorderable ( column, TRUE );
 170   // However I don't think is that useful, so I haven't put it in
 171   column = gtk_tree_view_column_new_with_attributes( _("Name"), renderer, "text", column_runner, NULL);
 172   gtk_tree_view_column_set_sort_column_id (column, column_runner);
 173   gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
 174
 175   column_runner++;
 176   column = gtk_tree_view_column_new_with_attributes( _("Feature"), renderer, "text", column_runner, NULL);
 177   gtk_tree_view_column_set_sort_column_id (column, column_runner);
 178   gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
 179
 180   column_runner++;
 181   column = gtk_tree_view_column_new_with_attributes( _("Lat/Lon"), renderer, "text", column_runner, NULL);
 182   gtk_tree_view_column_set_sort_column_id (column, column_runner);
 183   gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
 184
 185   gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
 186   gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
 187       multiple_selection_allowed ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_BROWSE );
 188   g_object_unref(store);
 189
 190   GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
 191   gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
 192   gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
 193
 194   gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), label, FALSE, FALSE, 0);
 195   gtk_box_pack_start (GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), scrolledwindow, TRUE, TRUE, 0);
 196
 197   // Ensure a reasonable number of items are shown, but let the width be automatically sized
 198   gtk_widget_set_size_request ( dialog, -1, 400) ;
 199   gtk_widget_show_all ( dialog );
 200
 201   if ( response_w )
 202     gtk_widget_grab_focus ( response_w );
 203
 204   while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT )
 205   {
 206     GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 207     GList *selected_geonames = NULL;
 208
 209     // Possibily not the fastest method but we don't have thousands of entries to process...
 210     if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter) ) {
 211       do {
 212         if ( gtk_tree_selection_iter_is_selected ( selection, &iter ) ) {
 213           // For every selected item,
 214           // compare the name from the displayed view to every geoname entry to find the geoname this selection represents
 215           gchar* name;
 216           gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &name, -1 );
 217           // I believe the name of these items to be always unique
 218           geoname_runner = geonames;
 219           while ( geoname_runner ) {
 220             if ( !strcmp ( ((found_geoname*)geoname_runner->data)->name, name ) ) {
 221               found_geoname *copied = copy_found_geoname(geoname_runner->data);
 222               selected_geonames = g_list_prepend(selected_geonames, copied);
 223               break;
 224             }
 225             geoname_runner = g_list_next(geoname_runner);
 226           }
 227           g_free ( name );
 228         }
 229       }
 230       while ( gtk_tree_model_iter_next ( GTK_TREE_MODEL(store), &iter ) );
 231     }
 232
 233     if (selected_geonames)
 234     {
 235       gtk_widget_destroy ( dialog );
 236       return selected_geonames;
 237     }
 238     a_dialog_error_msg(parent, _("Nothing was selected"));
 239   }
 240   gtk_widget_destroy ( dialog );
 241   return NULL;
 242 }
 243
 244 static GList *get_entries_from_file(gchar *file_name)
 245 {
 246   gchar *text, *pat;
 247   GMappedFile *mf;
 248   gsize len;
 249   gboolean more = TRUE;
 250   gchar lat_buf[32], lon_buf[32], elev_buf[32];
 251   gchar *s;
 252   gint fragment_len;
 253   GList *found_places = NULL;
 254   found_geoname *geoname = NULL;
 255   gchar **found_entries;
 256   gchar *entry;
 257   int entry_runner;
 258   gchar *wikipedia_url = NULL;
 259   gchar *thumbnail_url = NULL;
 260
 261   lat_buf[0] = lon_buf[0] = elev_buf[0] = '\0';
 262
 263   if ((mf = g_mapped_file_new(file_name, FALSE, NULL)) == NULL) {
 264     g_critical(_("couldn't map temp file"));
 265     return NULL;
 266   }
 267   len = g_mapped_file_get_length(mf);
 268   text = g_mapped_file_get_contents(mf);
 269
 270   if (g_strstr_len(text, len, GEONAMES_SEARCH_NOT_FOUND) != NULL) {
 271     more = FALSE;
 272   }
 273   found_entries = g_strsplit(text, "},", 0);
 274   entry_runner = 0;
 275   entry = found_entries[entry_runner];
 276   while (entry)
 277   {
 278     more = TRUE;
 279     geoname = new_found_geoname();
 280     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_FEATURE_PATTERN))) {
 281       pat += strlen(GEONAMES_FEATURE_PATTERN);
 282       fragment_len = 0;
 283       s = pat;
 284       while (*pat != '"') {
 285         fragment_len++;
 286         pat++;
 287       }
 288       geoname->feature = g_strndup(s, fragment_len);
 289     }
 290     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_LONGITUDE_PATTERN)) == NULL) {
 291       more = FALSE;
 292     }
 293     else {
 294       pat += strlen(GEONAMES_LONGITUDE_PATTERN);
 295       s = lon_buf;
 296       if (*pat == '-')
 297         *s++ = *pat++;
 298       while ((s < (lon_buf + sizeof(lon_buf))) && (pat < (text + len)) &&
 299               (g_ascii_isdigit(*pat) || (*pat == '.')))
 300         *s++ = *pat++;
 301       *s = '\0';
 302       if ((pat >= (text + len)) || (lon_buf[0] == '\0')) {
 303         more = FALSE;
 304       }
 305       geoname->ll.lon = g_ascii_strtod(lon_buf, NULL);
 306     }
 307     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_ELEVATION_PATTERN))) {
 308       pat += strlen(GEONAMES_ELEVATION_PATTERN);
 309       s = elev_buf;
 310       if (*pat == '-')
 311         *s++ = *pat++;
 312       while ((s < (elev_buf + sizeof(elev_buf))) && (pat < (text + len)) &&
 313               (g_ascii_isdigit(*pat) || (*pat == '.')))
 314         *s++ = *pat++;
 315       *s = '\0';
 316       geoname->elevation = g_ascii_strtod(elev_buf, NULL);
 317     }
 318     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_NAME_PATTERN))) {
 319       pat += strlen(GEONAMES_NAME_PATTERN);
 320       fragment_len = 0;
 321       s = pat;
 322       while (*pat != '"') {
 323         fragment_len++;
 324         pat++;
 325       }
 326       geoname -> name = g_strndup(s, fragment_len);
 327     }
 328     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_TITLE_PATTERN))) {
 329       pat += strlen(GEONAMES_TITLE_PATTERN);
 330       fragment_len = 0;
 331       s = pat;
 332       while (*pat != '"') {
 333         fragment_len++;
 334         pat++;
 335       }
 336       geoname -> name = g_strndup(s, fragment_len);
 337     }
 338     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_WIKIPEDIAURL_PATTERN))) {
 339       pat += strlen(GEONAMES_WIKIPEDIAURL_PATTERN);
 340       fragment_len = 0;
 341       s = pat;
 342       while (*pat != '"') {
 343         fragment_len++;
 344         pat++;
 345       }
 346       wikipedia_url = g_strndup(s, fragment_len);
 347     }
 348     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_THUMBNAILIMG_PATTERN))) {
 349       pat += strlen(GEONAMES_THUMBNAILIMG_PATTERN);
 350       fragment_len = 0;
 351       s = pat;
 352       while (*pat != '"') {
 353         fragment_len++;
 354         pat++;
 355       }
 356       thumbnail_url = g_strndup(s, fragment_len);
 357     }
 358     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_LATITUDE_PATTERN)) == NULL) {
 359       more = FALSE;
 360     }
 361     else {
 362       pat += strlen(GEONAMES_LATITUDE_PATTERN);
 363       s = lat_buf;
 364       if (*pat == '-')
 365         *s++ = *pat++;
 366       while ((s < (lat_buf + sizeof(lat_buf))) && (pat < (text + len)) &&
 367               (g_ascii_isdigit(*pat) || (*pat == '.')))
 368         *s++ = *pat++;
 369       *s = '\0';
 370       if ((pat >= (text + len)) || (lat_buf[0] == '\0')) {
 371         more = FALSE;
 372       }
 373       geoname->ll.lat = g_ascii_strtod(lat_buf, NULL);
 374     }
 375     if (!more) {
 376       if (geoname) {
 377         g_free(geoname);
 378       }
 379     }
 380     else {
 381       if (wikipedia_url) {
 382         // Really we should support the GPX URL tag and then put that in there...
 383         geoname->cmt = g_strdup_printf("http://%s", wikipedia_url);
 384         if (thumbnail_url) {
 385           geoname -> desc = g_strdup_printf("<a href=\"http://%s\" target=\"_blank\"><img src=\"%s\" border=\"0\"/></a>", wikipedia_url, thumbnail_url);
 386         }
 387         else {
 388           geoname -> desc = g_strdup_printf("<a href=\"http://%s\" target=\"_blank\">%s</a>", wikipedia_url, geoname->name);
 389         }
 390       }
 391       if (wikipedia_url) {
 392         g_free(wikipedia_url);
 393         wikipedia_url = NULL;
 394       }
 395       if (thumbnail_url) {
 396         g_free(thumbnail_url);
 397         thumbnail_url = NULL;
 398       }
 399       found_places = g_list_prepend(found_places, geoname);
 400     }
 401     entry_runner++;
 402     entry = found_entries[entry_runner];
 403   }
 404   g_strfreev(found_entries);
 405   found_places = g_list_reverse(found_places);
 406   g_mapped_file_unref(mf);
 407   return(found_places);
 408 }
 409
 410 void a_geonames_wikipedia_box ( VikWindow *vw, VikTrwLayer *vtl, struct LatLon maxmin[2] )
 411 {
 412   gchar *uri;
 413   gchar *tmpname;
 414   GList *wiki_places;
 415   GList *selected;
 416   GList *wp_runner;
 417   VikWaypoint *wiki_wp;
 418   found_geoname *wiki_geoname;
 419
 420   /**
 421    * See http://www.geonames.org/export/wikipedia-webservice.html#wikipediaBoundingBox
 422    */
 423   // Wikipedia articles supported languages are de,en,es,fr,it,nl,pl,pt,ru,zh (default = en)
 424   gboolean got_language = FALSE;
 425   const gchar *language = g_getenv("LANGUAGE");
 426   gchar lang[3] = "en";
 427   if (strlen(language) > 1) {
 428     got_language = TRUE;
 429   } else {
 430     language = g_getenv("LANG");
 431     if (strlen(language) > 1)
 432       got_language = TRUE;
 433   }
 434   if ( got_language ) {
 435     lang[0] = language[0];
 436     lang[1] = language[1];
 437   }
 438
 439   /* encode doubles in a C locale */
 440   gchar *north = a_coords_dtostr(maxmin[0].lat);
 441   gchar *south = a_coords_dtostr(maxmin[1].lat);
 442   gchar *east = a_coords_dtostr(maxmin[0].lon);
 443   gchar *west = a_coords_dtostr(maxmin[1].lon);
 444   uri = g_strdup_printf ( GEONAMES_WIKIPEDIA_URL_FMT, north, south, east, west, lang, GEONAMES_MAX_ENTRIES );
 445   g_free(north); north = NULL;
 446   g_free(south); south = NULL;
 447   g_free(east);  east = NULL;
 448   g_free(west);  west = NULL;
 449   tmpname = a_download_uri_to_tmp_file ( uri, NULL );
 450   if (!tmpname) {
 451     none_found(vw);
 452     return;
 453   }
 454   wiki_places = get_entries_from_file(tmpname);
 455   if (g_list_length(wiki_places) == 0) {
 456     none_found(vw);
 457     goto done;
 458   }
 459   selected = a_select_geoname_from_list(VIK_GTK_WINDOW_FROM_WIDGET(vw), wiki_places, TRUE, _("Select articles"), _("Select the articles you want to add."));
 460   wp_runner = selected;
 461   while (wp_runner) {
 462     wiki_geoname = (found_geoname *)wp_runner->data;
 463     wiki_wp = vik_waypoint_new();
 464     wiki_wp->visible = TRUE;
 465     vik_coord_load_from_latlon(&(wiki_wp->coord), vik_trw_layer_get_coord_mode ( vtl ), &(wiki_geoname->ll));
 466     wiki_wp->altitude = wiki_geoname->elevation;
 467     vik_waypoint_set_comment(wiki_wp, wiki_geoname->cmt);
 468     vik_waypoint_set_description(wiki_wp, wiki_geoname->desc);
 469     // Use the featue type to generate a suitable waypoint icon
 470     //  http://www.geonames.org/wikipedia/wikipedia_features.html
 471     // Only a few values supported as only a few symbols make sense
 472     // The feature name may not be translated
 473     // Double check the english and the translated
 474     if ( wiki_geoname->feature ) {
 475       if ( !strcmp (wiki_geoname->feature, "city") || !strcmp (wiki_geoname->feature, _("city")))
 476         vik_waypoint_set_symbol(wiki_wp, "city (medium)");
 477       if ( !strcmp (wiki_geoname->feature, "edu") || !strcmp (wiki_geoname->feature, _("edu")))
 478         vik_waypoint_set_symbol(wiki_wp, "school");
 479       if ( !strcmp (wiki_geoname->feature, "airport") || !strcmp (wiki_geoname->feature, _("airport")))
 480         vik_waypoint_set_symbol(wiki_wp, "airport");
 481       if ( !strcmp (wiki_geoname->feature, "mountain") || !strcmp (wiki_geoname->feature, _("mountain")))
 482         vik_waypoint_set_symbol(wiki_wp, "summit");
 483       if ( !strcmp (wiki_geoname->feature, "forest") || !strcmp (wiki_geoname->feature, _("forest")))
 484         vik_waypoint_set_symbol(wiki_wp, "forest");
 485       if ( !strcmp (wiki_geoname->feature, "church") || !strcmp (wiki_geoname->feature, _("church")))
 486         vik_waypoint_set_symbol(wiki_wp, "church");
 487     }
 488     vik_trw_layer_filein_add_waypoint ( vtl, wiki_geoname->name, wiki_wp );
 489     wp_runner = g_list_next(wp_runner);
 490   }
 491   free_geoname_list(wiki_places);
 492   free_geoname_list(selected);
 493   g_free(uri);
 494 done:
 495   (void)util_remove(tmpname);
 496   g_free(tmpname);
 497 }