src/geonamessearch.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2003-2005, Evan Battaglia <gtoevan@gmx.net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * Created by Quy Tonthat <qtonthat@gmail.com>
  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 "util.h"
  35 #include "curl_download.h"
  36
  37 #define GEONAMES_WIKIPEDIA_URL_FMT "http://ws.geonames.org/wikipediaBoundingBoxJSON?formatted=true&north=%f&south=%f&east=%f&west=%f"
  38 #define GEONAMES_SEARCH_URL_FMT "http://ws.geonames.org/searchJSON?formatted=true&style=medium&maxRows=10&lang=en&q=%s"
  39 #define GEONAMES_COUNTRY_PATTERN "\"countryName\": \""
  40 #define GEONAMES_LONGITUDE_PATTERN "\"lng\": "
  41 #define GEONAMES_NAME_PATTERN "\"name\": \""
  42 #define GEONAMES_LATITUDE_PATTERN "\"lat\": "
  43 #define GEONAMES_TITLE_PATTERN "\"title\": \""
  44 #define GEONAMES_WIKIPEDIAURL_PATTERN "\"wikipediaUrl\": \""
  45 #define GEONAMES_THUMBNAILIMG_PATTERN "\"thumbnailImg\": \""
  46 #define GEONAMES_SEARCH_NOT_FOUND "not understand the location"
  47
  48 static gchar *last_search_str = NULL;
  49 static VikCoord *last_coord = NULL;
  50 static gchar *last_successful_search_str = NULL;
  51
  52 /* found_geoname: Type to contain data returned from GeoNames.org */
  53
  54 typedef struct {
  55   gchar *name;
  56   gchar *country;
  57   struct LatLon ll;
  58   gchar *desc;
  59 } found_geoname;
  60
  61 found_geoname *new_found_geoname()
  62 {
  63   found_geoname *ret;
  64
  65   ret = (found_geoname *)g_malloc(sizeof(found_geoname));
  66   ret->name = NULL;
  67   ret->country = NULL;
  68   ret->desc = NULL;
  69   ret->ll.lat = 0.0;
  70   ret->ll.lon = 0.0;
  71   return(ret);
  72 }
  73
  74 found_geoname *copy_found_geoname(found_geoname *src)
  75 {
  76   found_geoname *dest = new_found_geoname();
  77   dest->name = g_strdup(src->name);
  78   dest->country = g_strdup(src->country);
  79   dest->ll.lat = src->ll.lat;
  80   dest->ll.lon = src->ll.lon;
  81   dest->desc = g_strdup(src->desc);
  82   return(dest);
  83 }
  84
  85 static void free_list_geonames(found_geoname *geoname, gpointer userdata)
  86 {
  87   g_free(geoname->name);
  88   g_free(geoname->country);
  89   g_free(geoname->desc);
  90 }
  91
  92 void free_geoname_list(GList *found_places)
  93 {
  94   g_list_foreach(found_places, (GFunc)free_list_geonames, NULL);
  95   g_list_free(found_places);
  96 }
  97
  98 gchar * a_geonamessearch_get_search_string_for_this_place(VikWindow *vw)
  99 {
 100   if (!last_coord)
 101     return NULL;
 102
 103   VikViewport *vvp = vik_window_viewport(vw);
 104   const VikCoord *cur_center = vik_viewport_get_center(vvp);
 105   if (vik_coord_equals(cur_center, last_coord)) {
 106     return(last_successful_search_str);
 107   }
 108   else
 109     return NULL;
 110 }
 111
 112 static void none_found(VikWindow *vw)
 113 {
 114   GtkWidget *dialog = NULL;
 115
 116   dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL );
 117   gtk_window_set_title(GTK_WINDOW(dialog), _("Search"));
 118
 119   GtkWidget *search_label = gtk_label_new(_("No entries found!"));
 120   gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), search_label, FALSE, FALSE, 5 );
 121   gtk_widget_show_all(dialog);
 122
 123   gtk_dialog_run ( GTK_DIALOG(dialog) );
 124   gtk_widget_destroy(dialog);
 125 }
 126
 127 static gboolean prompt_try_again(VikWindow *vw)
 128 {
 129   GtkWidget *dialog = NULL;
 130   gboolean ret = TRUE;
 131
 132   dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
 133   gtk_window_set_title(GTK_WINDOW(dialog), _("Search"));
 134
 135   GtkWidget *search_label = gtk_label_new(_("I don't know that place. Do you want another search?"));
 136   gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), search_label, FALSE, FALSE, 5 );
 137   gtk_widget_show_all(dialog);
 138
 139   if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT )
 140     ret = FALSE;
 141
 142   gtk_widget_destroy(dialog);
 143   return ret;
 144 }
 145
 146 static gchar *  a_prompt_for_search_string(VikWindow *vw)
 147 {
 148   GtkWidget *dialog = NULL;
 149
 150   dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
 151   gtk_window_set_title(GTK_WINDOW(dialog), _("Search"));
 152
 153   GtkWidget *search_label = gtk_label_new(_("Enter address or place name:"));
 154   GtkWidget *search_entry = gtk_entry_new();
 155   if (last_search_str)
 156     gtk_entry_set_text(GTK_ENTRY(search_entry), last_search_str);
 157
 158   gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), search_label, FALSE, FALSE, 5 );
 159   gtk_box_pack_start ( GTK_BOX(GTK_DIALOG(dialog)->vbox), search_entry, FALSE, FALSE, 5 );
 160   gtk_widget_show_all(dialog);
 161
 162   if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
 163     gtk_widget_destroy(dialog);
 164     return NULL;
 165   }
 166
 167   gchar *search_str = g_strdup ( gtk_entry_get_text ( GTK_ENTRY(search_entry) ) );
 168
 169   gtk_widget_destroy(dialog);
 170
 171   if (search_str[0] != '\0') {
 172     if (last_search_str)
 173       g_free(last_search_str);
 174     last_search_str = g_strdup(search_str);
 175   }
 176
 177   return(search_str);   /* search_str needs to be freed by caller */
 178 }
 179
 180
 181 void buttonToggled(GtkCellRendererToggle* renderer, gchar* pathStr, gpointer data)
 182 {
 183    GtkTreeIter iter;
 184    gboolean enabled;
 185    GtkTreePath* path = gtk_tree_path_new_from_string(pathStr);
 186    gtk_tree_model_get_iter(GTK_TREE_MODEL (data), &iter, path);
 187    gtk_tree_model_get(GTK_TREE_MODEL (data), &iter, 0, &enabled, -1);
 188    enabled = !enabled;
 189    gtk_tree_store_set(GTK_TREE_STORE (data), &iter, 0, enabled, -1);
 190 }
 191
 192 GList *a_select_geoname_from_list(GtkWindow *parent, GList *geonames, gboolean multiple_selection_allowed, const gchar *title, const gchar *msg)
 193 {
 194   GtkTreeIter iter;
 195   GtkCellRenderer *renderer;
 196   GtkCellRenderer *toggle_render;
 197   GtkWidget *view;
 198   found_geoname *geoname;
 199   gchar *latlon_string;
 200   int column_runner;
 201   gboolean checked;
 202   gboolean to_copy;
 203
 204   GtkWidget *dialog = gtk_dialog_new_with_buttons (title,
 205                                                   parent,
 206                                                   GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 207                                                   GTK_STOCK_CANCEL,
 208                                                   GTK_RESPONSE_REJECT,
 209                                                   GTK_STOCK_OK,
 210                                                   GTK_RESPONSE_ACCEPT,
 211                                                   NULL);
 212   GtkWidget *label = gtk_label_new ( msg );
 213   GtkTreeStore *store;
 214   if (multiple_selection_allowed)
 215   {
 216     store = gtk_tree_store_new(4, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 217   }
 218   else
 219   {
 220     store = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 221   }
 222   GList *geoname_runner = geonames;
 223   while (geoname_runner)
 224   {
 225     geoname = (found_geoname *)geoname_runner->data;
 226     latlon_string = g_strdup_printf("(%f,%f)", geoname->ll.lat, geoname->ll.lon);
 227     gtk_tree_store_append(store, &iter, NULL);
 228     if (multiple_selection_allowed)
 229     {
 230       gtk_tree_store_set(store, &iter, 0, FALSE, 1, geoname->name, 2, geoname->country, 3, latlon_string, -1);
 231     }
 232     else
 233     {
 234       gtk_tree_store_set(store, &iter, 0, geoname->name, 1, geoname->country, 2, latlon_string, -1);
 235     }
 236     geoname_runner = g_list_next(geoname_runner);
 237     g_free(latlon_string);
 238   }
 239   view = gtk_tree_view_new();
 240   renderer = gtk_cell_renderer_text_new();
 241   column_runner = 0;
 242   if (multiple_selection_allowed)
 243   {
 244     toggle_render = gtk_cell_renderer_toggle_new();
 245     g_object_set(toggle_render, "activatable", TRUE, NULL);
 246     g_signal_connect(toggle_render, "toggled", (GCallback) buttonToggled, GTK_TREE_MODEL(store));
 247     gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Select", toggle_render, "active", column_runner, NULL);
 248     column_runner++;
 249   }
 250   gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Name", renderer, "text", column_runner, NULL);
 251   column_runner++;
 252   gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Country", renderer, "text", column_runner, NULL);
 253   column_runner++;
 254   gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(view), -1, "Lat/Lon", renderer, "text", column_runner, NULL);
 255   gtk_tree_view_set_headers_visible( GTK_TREE_VIEW(view), TRUE);
 256   gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
 257   gtk_tree_selection_set_mode( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
 258       multiple_selection_allowed ? GTK_SELECTION_MULTIPLE : GTK_SELECTION_BROWSE );
 259   g_object_unref(store);
 260
 261   gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), label, FALSE, FALSE, 0);
 262   gtk_widget_show ( label );
 263   gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), view, FALSE, FALSE, 0);
 264   gtk_widget_show ( view );
 265   while ( gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT )
 266   {
 267     GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 268     GList *selected_geonames = NULL;
 269
 270     gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store), &iter);
 271     geoname_runner = geonames;
 272     while (geoname_runner)
 273     {
 274       to_copy = FALSE;
 275       if (multiple_selection_allowed)
 276       {
 277         gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &checked, -1);
 278         if (checked) {
 279           to_copy = TRUE;
 280         }
 281       }
 282       else
 283       {
 284         if (gtk_tree_selection_iter_is_selected(selection, &iter))
 285         {
 286           to_copy = TRUE;
 287         }
 288       }
 289       if (to_copy) {
 290         found_geoname *copied = copy_found_geoname(geoname_runner->data);
 291         selected_geonames = g_list_prepend(selected_geonames, copied);
 292       }
 293       geoname_runner = g_list_next(geoname_runner);
 294       gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
 295     }
 296     if (selected_geonames)
 297     {
 298       gtk_widget_destroy ( dialog );
 299       return (selected_geonames);
 300     }
 301     a_dialog_error_msg(parent, _("Nothing was selected"));
 302   }
 303   gtk_widget_destroy ( dialog );
 304   return NULL;
 305 }
 306
 307 GList *get_entries_from_file(gchar *file_name)
 308 {
 309   gchar *text, *pat;
 310   GMappedFile *mf;
 311   gsize len;
 312   gboolean more = TRUE;
 313   gchar lat_buf[32], lon_buf[32];
 314   gchar *s;
 315   gint fragment_len;
 316   GList *found_places = NULL;
 317   found_geoname *geoname = NULL;
 318   gchar **found_entries;
 319   gchar *entry;
 320   int entry_runner;
 321   gchar *wikipedia_url = NULL;
 322   gchar *thumbnail_url = NULL;
 323
 324   lat_buf[0] = lon_buf[0] = '\0';
 325
 326   if ((mf = g_mapped_file_new(file_name, FALSE, NULL)) == NULL) {
 327     g_critical(_("couldn't map temp file"));
 328     exit(1);
 329   }
 330   len = g_mapped_file_get_length(mf);
 331   text = g_mapped_file_get_contents(mf);
 332
 333   if (g_strstr_len(text, len, GEONAMES_SEARCH_NOT_FOUND) != NULL) {
 334     more = FALSE;
 335   }
 336   found_entries = g_strsplit(text, "},", 0);
 337   entry_runner = 0;
 338   entry = found_entries[entry_runner];
 339   while (entry)
 340   {
 341     more = TRUE;
 342     geoname = new_found_geoname();
 343     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_COUNTRY_PATTERN))) {
 344       pat += strlen(GEONAMES_COUNTRY_PATTERN);
 345       fragment_len = 0;
 346       s = pat;
 347       while (*pat != '"') {
 348         fragment_len++;
 349         pat++;
 350       }
 351       geoname -> country = g_strndup(s, fragment_len);
 352     }
 353     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_LONGITUDE_PATTERN)) == NULL) {
 354       more = FALSE;
 355     }
 356     else {
 357       pat += strlen(GEONAMES_LONGITUDE_PATTERN);
 358       s = lon_buf;
 359       if (*pat == '-')
 360         *s++ = *pat++;
 361       while ((s < (lon_buf + sizeof(lon_buf))) && (pat < (text + len)) &&
 362               (g_ascii_isdigit(*pat) || (*pat == '.')))
 363         *s++ = *pat++;
 364       *s = '\0';
 365       if ((pat >= (text + len)) || (lon_buf[0] == '\0')) {
 366         more = FALSE;
 367       }
 368       geoname->ll.lon = g_ascii_strtod(lon_buf, NULL);
 369     }
 370     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_NAME_PATTERN))) {
 371       pat += strlen(GEONAMES_NAME_PATTERN);
 372       fragment_len = 0;
 373       s = pat;
 374       while (*pat != '"') {
 375         fragment_len++;
 376         pat++;
 377       }
 378       geoname -> name = g_strndup(s, fragment_len);
 379     }
 380     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_TITLE_PATTERN))) {
 381       pat += strlen(GEONAMES_TITLE_PATTERN);
 382       fragment_len = 0;
 383       s = pat;
 384       while (*pat != '"') {
 385         fragment_len++;
 386         pat++;
 387       }
 388       geoname -> name = g_strndup(s, fragment_len);
 389     }
 390     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_WIKIPEDIAURL_PATTERN))) {
 391       pat += strlen(GEONAMES_WIKIPEDIAURL_PATTERN);
 392       fragment_len = 0;
 393       s = pat;
 394       while (*pat != '"') {
 395         fragment_len++;
 396         pat++;
 397       }
 398       wikipedia_url = g_strndup(s, fragment_len);
 399     }
 400     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_THUMBNAILIMG_PATTERN))) {
 401       pat += strlen(GEONAMES_THUMBNAILIMG_PATTERN);
 402       fragment_len = 0;
 403       s = pat;
 404       while (*pat != '"') {
 405         fragment_len++;
 406         pat++;
 407       }
 408       thumbnail_url = g_strndup(s, fragment_len);
 409     }
 410     if ((pat = g_strstr_len(entry, strlen(entry), GEONAMES_LATITUDE_PATTERN)) == NULL) {
 411       more = FALSE;
 412     }
 413     else {
 414       pat += strlen(GEONAMES_LATITUDE_PATTERN);
 415       s = lat_buf;
 416       if (*pat == '-')
 417         *s++ = *pat++;
 418       while ((s < (lat_buf + sizeof(lat_buf))) && (pat < (text + len)) &&
 419               (g_ascii_isdigit(*pat) || (*pat == '.')))
 420         *s++ = *pat++;
 421       *s = '\0';
 422       if ((pat >= (text + len)) || (lat_buf[0] == '\0')) {
 423         more = FALSE;
 424       }
 425       geoname->ll.lat = g_ascii_strtod(lat_buf, NULL);
 426     }
 427     if (!more) {
 428       if (geoname) {
 429         g_free(geoname);
 430       }
 431     }
 432     else {
 433       if (wikipedia_url) {
 434         if (thumbnail_url) {
 435           geoname -> desc = g_strdup_printf("<a href=\"http://%s\" target=\"_blank\"><img src=\"%s\" border=\"0\"/></a>", wikipedia_url, thumbnail_url);
 436         }
 437         else {
 438           geoname -> desc = g_strdup_printf("<a href=\"http://%s\" target=\"_blank\">%s</a>", wikipedia_url, geoname->name);
 439         }
 440       }
 441       if (wikipedia_url) {
 442         g_free(wikipedia_url);
 443         wikipedia_url = NULL;
 444       }
 445       if (thumbnail_url) {
 446         g_free(thumbnail_url);
 447         thumbnail_url = NULL;
 448       }
 449       found_places = g_list_prepend(found_places, geoname);
 450     }
 451     entry_runner++;
 452     entry = found_entries[entry_runner];
 453   }
 454   g_strfreev(found_entries);
 455   found_places = g_list_reverse(found_places);
 456   g_mapped_file_free(mf);
 457   return(found_places);
 458 }
 459
 460
 461 static int parse_file_for_latlon(VikWindow *vw, gchar *file_name, struct LatLon *ll)
 462 {
 463   /* return codes:
 464     1 : All OK, position selected;
 465     2 : No position selected;
 466     3 : No places found. */
 467   int found = 1;
 468   found_geoname *geoname;
 469   GList *found_places = get_entries_from_file(file_name);
 470   int num_found_places;
 471
 472   num_found_places = g_list_length(found_places);
 473   if (num_found_places == 0) {
 474     found = 3;
 475   }
 476   else {
 477     if (num_found_places == 1) {
 478       geoname = (found_geoname *)found_places->data;
 479       ll->lat = geoname->ll.lat;
 480       ll->lon = geoname->ll.lon;
 481     }
 482     else
 483     {
 484       GList *selected = a_select_geoname_from_list(VIK_GTK_WINDOW_FROM_WIDGET(vw), found_places, FALSE, "Select place", "Select the place to go to");
 485       if (selected)
 486       {
 487         geoname = (found_geoname *)selected->data;
 488         ll->lat = geoname->ll.lat;
 489         ll->lon = geoname->ll.lon;
 490         g_list_foreach(selected, (GFunc)free_list_geonames, NULL);
 491       }
 492       else
 493       {
 494         found = 2;
 495       }
 496     }
 497   }
 498   free_geoname_list(found_places);
 499   return (found);
 500 }
 501
 502 gchar *download_url(gchar *uri)
 503 {
 504   FILE *tmp_file;
 505   int tmp_fd;
 506   gchar *tmpname;
 507
 508   if ((tmp_fd = g_file_open_tmp ("vikgsearch.XXXXXX", &tmpname, NULL)) == -1) {
 509     g_critical(_("couldn't open temp file"));
 510     exit(1);
 511   }
 512   tmp_file = fdopen(tmp_fd, "r+");
 513
 514   // TODO: curl may not be available
 515   if (curl_download_uri(uri, tmp_file, NULL)) {  // error
 516     fclose(tmp_file);
 517     tmp_file = NULL;
 518     g_remove(tmpname);
 519     g_free(tmpname);
 520     return(NULL);
 521   }
 522   fclose(tmp_file);
 523   tmp_file = NULL;
 524   return(tmpname);
 525 }
 526
 527 static int geonames_search_get_coord(VikWindow *vw, VikViewport *vvp, gchar *srch_str, VikCoord *coord)
 528 {
 529   gchar *uri;
 530   gchar *escaped_srch_str;
 531   int ret = 1;  /* OK */
 532   struct LatLon ll;
 533   gchar *tmpname;
 534
 535   g_debug("%s: raw search: %s", __FUNCTION__, srch_str);
 536   escaped_srch_str = uri_escape(srch_str);
 537   g_debug("%s: escaped search: %s", __FUNCTION__, escaped_srch_str);
 538
 539   //uri = g_strdup_printf(GEONAMES_SEARCH_URL_FMT, srch_str);
 540   uri = g_strdup_printf(GEONAMES_SEARCH_URL_FMT, escaped_srch_str);
 541
 542   tmpname = download_url(uri);
 543   if (!tmpname) {
 544     ret = -1;
 545     goto done;
 546   }
 547   ret = parse_file_for_latlon(vw, tmpname, &ll);
 548   if (ret == 3) {
 549     goto done;
 550   }
 551
 552   vik_coord_load_from_latlon ( coord, vik_viewport_get_coord_mode(vvp), &ll );
 553
 554   if (last_coord)
 555     g_free(last_coord);
 556   last_coord = g_malloc(sizeof(VikCoord));
 557   *last_coord = *coord;
 558   if (last_successful_search_str)
 559     g_free(last_successful_search_str);
 560   last_successful_search_str = g_strdup(last_search_str);
 561
 562 done:
 563   g_free(escaped_srch_str);
 564   g_free(uri);
 565   if (tmpname) {
 566     g_remove(tmpname);
 567     g_free(tmpname);
 568   }
 569   return ret;
 570 }
 571
 572 void a_geonames_search(VikWindow *vw, VikLayersPanel *vlp, VikViewport *vvp)
 573 {
 574   VikCoord new_center;
 575   gchar *s_str;
 576   gboolean more = TRUE;
 577   int ret;
 578
 579   do {
 580     s_str = a_prompt_for_search_string(vw);
 581     if ((!s_str) || (s_str[0] == 0)) {
 582       more = FALSE;
 583     }
 584     else {
 585       ret = geonames_search_get_coord(vw, vvp, s_str, &new_center);
 586       if (ret == 1) {
 587         vik_viewport_set_center_coord(vvp, &new_center);
 588         vik_layers_panel_emit_update(vlp);
 589         more = FALSE;
 590       }
 591       else {
 592         if (ret == 3) {
 593           if (!prompt_try_again(vw)) {
 594             more = FALSE;
 595           }
 596         }
 597       }
 598     }
 599     if (s_str) {
 600       g_free(s_str);
 601     }
 602   } while (more);
 603 }
 604
 605 void a_geonames_wikipedia_box(VikWindow *vw, VikTrwLayer *vtl, VikLayersPanel *vlp, struct LatLon maxmin[2])
 606 {
 607   gchar *uri;
 608   gchar *tmpname;
 609   GList *wiki_places;
 610   GList *selected;
 611   GList *wp_runner;
 612   VikWaypoint *wiki_wp;
 613   found_geoname *wiki_geoname;
 614
 615   uri = g_strdup_printf(GEONAMES_WIKIPEDIA_URL_FMT, maxmin[0].lat, maxmin[1].lat, maxmin[0].lon, maxmin[1].lon);
 616   tmpname = download_url(uri);
 617   if (!tmpname) {
 618     none_found(vw);
 619     return;
 620   }
 621   wiki_places = get_entries_from_file(tmpname);
 622   if (g_list_length(wiki_places) == 0) {
 623     none_found(vw);
 624     return;
 625   }
 626   selected = a_select_geoname_from_list(VIK_GTK_WINDOW_FROM_WIDGET(vw), wiki_places, TRUE, "Select articles", "Select the articles you want to add.");
 627   wp_runner = selected;
 628   while (wp_runner) {
 629     wiki_geoname = (found_geoname *)wp_runner->data;
 630     wiki_wp = vik_waypoint_new();
 631     wiki_wp->altitude = VIK_DEFAULT_ALTITUDE;
 632     wiki_wp->visible = TRUE;
 633     vik_coord_load_from_latlon(&(wiki_wp->coord), vik_trw_layer_get_coord_mode ( vtl ), &(wiki_geoname->ll));
 634     vik_waypoint_set_comment(wiki_wp, wiki_geoname->desc);
 635     vik_trw_layer_filein_add_waypoint ( vtl, wiki_geoname->name, wiki_wp );
 636     wp_runner = g_list_next(wp_runner);
 637   }
 638   free_geoname_list(wiki_places);
 639   free_geoname_list(selected);
 640   g_free(uri);
 641   if (tmpname) {
 642     g_free(tmpname);
 643   }
 644   vik_layers_panel_emit_update(vlp);
 645 }