git.maemo.org Git - belltower/blob - belltower.c

   1 /*
   2  * belltower
   3  * an app to find belltowers under Maemo 5
   4  *
   5  * Copyright (c) 2009 Thomas Thurman <tthurman@gnome.org>
   6  * Released under the GPL
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <glib.h>
  13 #include <hildon/hildon.h>
  14 #include <gtk/gtk.h>
  15 #include <location/location-gps-device.h>
  16 #include <location/location-distance-utils.h>
  17 #include <dbus/dbus-glib.h>
  18
  19 #define MAX_FIELDS 50
  20
  21 GtkWidget *window;
  22
  23 LocationGPSDevice *device;
  24
  25 typedef enum {
  26   /** stop scanning the database */
  27   FILTER_STOP,
  28   /** ignore this one */
  29   FILTER_IGNORE,
  30   /** add this one to the list */
  31   FILTER_ACCEPT
  32 } FilterResult;
  33
  34 /*
  35   FIXME:
  36   We should really do this by looking at the header row of the table.
  37   They might decide to put in new columns some day.
  38 */
  39 typedef enum {
  40   FieldPrimaryKey,
  41   FieldNationalGrid,
  42   FieldAccRef,
  43   FieldSNLat,
  44   FieldSNLong,
  45   FieldPostcode,
  46   FieldTowerBase,
  47   FieldCounty,
  48   FieldCountry,
  49   FieldDiocese,
  50   FieldPlace,
  51   FieldPlace2,
  52   FieldPlaceCL,
  53   FieldDedication,
  54   FieldBells,
  55   FieldWt,
  56   FieldApp,
  57   FieldNote,
  58   FieldHz,
  59   FieldDetails,
  60   FieldGF,
  61   FieldToilet,
  62   FieldUR,
  63   FieldPDNo,
  64   FieldPracticeNight,
  65   FieldPSt,
  66   FieldPrXF,
  67   FieldOvhaulYr,
  68   FieldContractor,
  69   FieldExtraInfo,
  70   FieldWebPage,
  71   FieldUpdated,
  72   FieldAffiliations,
  73   FieldAltName,
  74   FieldLat,
  75   FieldLong,
  76   FieldSimulator
  77 } field;
  78
  79 typedef struct {
  80   int serial;
  81
  82   /* the raw data */
  83
  84   char* fields[MAX_FIELDS];
  85   int n_fields;
  86 } tower;
  87
  88 gboolean gps_working = FALSE;
  89 double current_lat = 40.2452778;
  90 double current_long = -75.65;;
  91
  92 static void
  93 show_message (char *message)
  94 {
  95   HildonNote* note = HILDON_NOTE
  96     (hildon_note_new_information (GTK_WINDOW (window),
  97                                   message?message:
  98                                   "Some message was supposed to be here."));
  99   gtk_dialog_run (GTK_DIALOG (note));
 100   gtk_widget_destroy (GTK_WIDGET (note));
 101 }
 102
 103 static gint
 104 distance_to_tower (tower *details)
 105 {
 106   char *endptr;
 107   double tower_lat;
 108   double tower_long;
 109   double km_distance;
 110   const double km_to_miles = 1.609344;
 111
 112   tower_lat = strtod(details->fields[FieldLat], &endptr);
 113   if (*endptr) return -1;
 114   tower_long = strtod(details->fields[FieldLong], &endptr);
 115   if (*endptr) return -1;
 116
 117   km_distance = location_distance_between (current_lat,
 118                                            current_long,
 119                                            tower_lat,
 120                                            tower_long);
 121
 122   return (int) (km_distance / km_to_miles);
 123 }
 124
 125 static gchar*
 126 distance_to_tower_str (tower *details)
 127 {
 128   int miles = distance_to_tower (details);
 129
 130   if (miles==-1)
 131     {
 132       return g_strdup ("unknown");
 133     }
 134   else
 135     {
 136       return g_strdup_printf("%dmi", (int) miles);
 137     }
 138 }
 139
 140 static void
 141 call_dbus (DBusBusType type,
 142            char *name,
 143            char *path,
 144            char *interface,
 145            char *method,
 146            char *parameter)
 147 {
 148   DBusGConnection *connection;
 149   GError *error = NULL;
 150
 151   DBusGProxy *proxy;
 152
 153   connection = dbus_g_bus_get (type,
 154                                &error);
 155   if (connection == NULL)
 156     {
 157       show_message (error->message);
 158       g_error_free (error);
 159       return;
 160     }
 161
 162   proxy = dbus_g_proxy_new_for_name (connection, name, path, interface);
 163
 164   error = NULL;
 165   if (!dbus_g_proxy_call (proxy, method, &error,
 166                           G_TYPE_STRING, parameter,
 167                           G_TYPE_INVALID,
 168                           G_TYPE_INVALID))
 169     {
 170       show_message (error->message);
 171       g_error_free (error);
 172     }
 173 }
 174
 175 static void
 176 show_browser (gchar *url)
 177 {
 178   call_dbus (DBUS_BUS_SESSION,
 179              "com.nokia.osso_browser",
 180              "/com/nokia/osso_browser/request",
 181              "com.nokia.osso_browser",
 182              "load_url",
 183              url);
 184 }
 185
 186 typedef FilterResult (*ParseDoveCallback)(tower *details, gpointer data);
 187 typedef void (*ButtonCallback)(void);
 188
 189 GtkWidget *tower_window, *buttons, *tower_table;
 190 HildonAppMenu *menu;
 191
 192 static void
 193 add_table_field (char *name,
 194                  char *value)
 195 {
 196   int row;
 197   GtkLabel *label;
 198   gchar *str;
 199
 200   g_object_get(tower_table, "n-rows", &row);
 201
 202   row++;
 203
 204   gtk_table_resize (GTK_TABLE (tower_table), row, 2);
 205
 206   label = GTK_LABEL (gtk_label_new (NULL));
 207   str = g_strdup_printf("<b>%s</b>", name);
 208   gtk_label_set_markup (label, str);
 209   g_free (str);
 210   gtk_label_set_justify (label, GTK_JUSTIFY_RIGHT);
 211   gtk_table_attach_defaults (GTK_TABLE (tower_table),
 212                              GTK_WIDGET (label),
 213                              0, 1, row, row+1);
 214
 215   label = GTK_LABEL (gtk_label_new (value));
 216   gtk_label_set_justify (label, GTK_JUSTIFY_LEFT);
 217   gtk_table_attach_defaults (GTK_TABLE (tower_table),
 218                              GTK_WIDGET (label),
 219                              1, 2, row, row+1);
 220 }
 221
 222 static void
 223 add_button (char *label,
 224             ButtonCallback callback)
 225 {
 226   GtkWidget *button;
 227
 228   button = gtk_button_new_with_label (label);
 229   g_signal_connect (button, "clicked", G_CALLBACK (callback), NULL);
 230   hildon_app_menu_append (menu, GTK_BUTTON (button));
 231   button = hildon_button_new_with_text (HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT,
 232                                         HILDON_BUTTON_ARRANGEMENT_VERTICAL,
 233                                         label, NULL);
 234   g_signal_connect (button, "clicked", G_CALLBACK (callback), NULL);
 235   gtk_box_pack_end (GTK_BOX (buttons), button, FALSE, FALSE, 0);
 236 }
 237
 238
 239 static void
 240 bookmark_toggled (GtkButton *button,
 241                   gpointer dummy)
 242 {
 243   show_message ("Bookmarks are not yet implemented.");
 244 }
 245
 246 char *tower_website = NULL;
 247 char *tower_map = NULL;
 248 char *tower_directions = NULL;
 249 char *peals_list = NULL;
 250
 251 static void
 252 show_tower_website (void)
 253 {
 254   show_browser (tower_website);
 255 }
 256
 257 static void
 258 show_tower_map (void)
 259 {
 260   show_browser (tower_map);
 261 }
 262
 263 static void
 264 show_peals_list (void)
 265 {
 266   show_browser (peals_list);
 267 }
 268
 269 static FilterResult
 270 get_countries_cb (tower *details,
 271                   gpointer data)
 272 {
 273   GHashTable *hash = (GHashTable *)data;
 274
 275   if (details->serial==0)
 276     return TRUE; /* header row */
 277
 278   if (!g_hash_table_lookup_extended (hash,
 279                                     details->fields[FieldCountry],
 280                                      NULL, NULL))
 281     {
 282       g_hash_table_insert (hash,
 283                            g_strdup(details->fields[FieldCountry]),
 284                            g_strdup (details->fields[FieldCountry]));
 285     }
 286
 287   return FILTER_IGNORE;
 288 }
 289
 290 typedef struct {
 291   GHashTable *hash;
 292   gchar *country_name;
 293 } country_cb_data;
 294
 295 typedef struct {
 296   char *country;
 297   char *county;
 298 } country_and_county;
 299
 300 static FilterResult
 301 get_counties_cb (tower *details,
 302                  gpointer data)
 303 {
 304   country_cb_data *d = (country_cb_data *)data;
 305
 306   if (details->serial==0)
 307     return FILTER_IGNORE; /* header row */
 308
 309   if (strcmp(details->fields[FieldCountry], d->country_name)!=0)
 310     return FILTER_IGNORE; /* wrong country */
 311
 312   if (!g_hash_table_lookup_extended (d->hash,
 313                                     details->fields[FieldCounty],
 314                                      NULL, NULL))
 315     {
 316       g_hash_table_insert (d->hash,
 317                            g_strdup(details->fields[FieldCounty]),
 318                            g_strdup (details->fields[FieldCounty]));
 319     }
 320
 321   return FILTER_IGNORE;
 322 }
 323
 324 static FilterResult
 325 get_nearby_towers_cb (tower *details,
 326                       gpointer data)
 327 {
 328   if (details->serial==0)
 329     return FILTER_IGNORE; /* header row */
 330
 331   if (distance_to_tower (details) < 50)
 332     {
 333       return FILTER_ACCEPT;
 334     }
 335   else
 336     {
 337       return FILTER_IGNORE;
 338     }
 339 }
 340
 341 static FilterResult
 342 get_towers_by_county_cb (tower *details,
 343                          gpointer data)
 344 {
 345   country_and_county *cac = (country_and_county *) data;
 346
 347   if ((!cac->county || strcmp (cac->county, details->fields[FieldCounty])==0) &&
 348       (!cac->country || strcmp (cac->country, details->fields[FieldCountry])==0))
 349     {
 350       return FILTER_ACCEPT;
 351     }
 352   else
 353     {
 354       return FILTER_IGNORE;
 355     }
 356 }
 357
 358 static FilterResult
 359 get_towers_by_search_cb (tower *details,
 360                          gpointer data)
 361 {
 362   char *s = (char *) data;
 363
 364   if (strcasestr(details->fields[FieldCountry], s) ||
 365       strcasestr(details->fields[FieldCounty], s) ||
 366       strcasestr(details->fields[FieldDedication], s) ||
 367       strcasestr(details->fields[FieldPlace], s))
 368     {
 369       return FILTER_ACCEPT;
 370     }
 371   else
 372     {
 373       return FILTER_IGNORE;
 374     }
 375 }
 376
 377 static FilterResult
 378 single_tower_cb (tower *details,
 379                  gpointer data)
 380 {
 381
 382   GtkWidget *hbox, *button;
 383   gchar *str;
 384   gint tenor_weight;
 385   gchar *primary_key = (gchar*) data;
 386   gchar *miles;
 387
 388   if (strcmp(details->fields[FieldPrimaryKey], primary_key)!=0)
 389     {
 390       /* not this one; keep going */
 391       return FILTER_IGNORE;
 392     }
 393
 394   tower_window = hildon_stackable_window_new ();
 395
 396   if (g_str_has_prefix (details->fields[FieldDedication],
 397                         "S "))
 398     {
 399       /* FIXME: This needs to be cleverer, because we can have
 400        * e.g. "S Peter and S Paul".
 401        * May have to use regexps.
 402        * Reallocation in general even when unchanged is okay,
 403        * because it's the common case (most towers are S Something)
 404        */
 405
 406       /* FIXME: Since we're passing this in as markup,
 407        * we need to escape the strings.
 408        */
 409
 410       str = g_strdup_printf("S<sup>t</sup> %s, %s",
 411                               details->fields[FieldDedication]+2,
 412                               details->fields[FieldPlace]);
 413
 414     }
 415   else
 416     {
 417       str = g_strdup_printf("%s, %s",
 418                               details->fields[FieldDedication],
 419                               details->fields[FieldPlace]);
 420     }
 421
 422   hildon_window_set_markup (HILDON_WINDOW (tower_window),
 423                             str);
 424   g_free (str);
 425
 426   hbox = gtk_hbox_new (FALSE, 0);
 427   tower_table = gtk_table_new (0, 2, FALSE);
 428   buttons = gtk_vbox_new (TRUE, 0);
 429   menu = HILDON_APP_MENU (hildon_app_menu_new ());
 430
 431   miles = distance_to_tower_str(details);
 432
 433   add_table_field ("Distance", miles);
 434   add_table_field ("Postcode", details->fields[FieldPostcode]);
 435   add_table_field ("County", details->fields[FieldCounty]);
 436   add_table_field ("Country", details->fields[FieldCountry]);
 437   add_table_field ("Diocese", details->fields[FieldDiocese]);
 438   add_table_field ("Practice night", details->fields[FieldPracticeNight]);
 439   add_table_field ("Bells", details->fields[FieldBells]);
 440
 441   g_free (miles);
 442
 443   tenor_weight = atoi (details->fields[FieldWt]);
 444   str = g_strdup_printf("%dcwt %dqr %dlb in %s",
 445                         tenor_weight/112,
 446                         (tenor_weight % 112)/28,
 447                         tenor_weight % 28,
 448                         details->fields[FieldNote]
 449                         );
 450   add_table_field ("Tenor", str);
 451   g_free (str);
 452
 453   add_button ("Tower website", show_tower_website);
 454   add_button ("Peals", show_peals_list);
 455   add_button ("Map", show_tower_map);
 456   add_button ("Directions", NULL);
 457
 458   /* don't use a toggle button: it looks stupid */
 459   button = hildon_button_new_with_text (HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT,
 460                                         HILDON_BUTTON_ARRANGEMENT_VERTICAL,
 461                                         "Bookmark", NULL);
 462   g_signal_connect (button, "clicked", G_CALLBACK (bookmark_toggled), NULL);
 463   gtk_box_pack_start (GTK_BOX (buttons), button, FALSE, FALSE, 0);
 464
 465   gtk_widget_show_all (GTK_WIDGET (menu));
 466   hildon_window_set_app_menu (HILDON_WINDOW (tower_window), menu);
 467
 468   gtk_box_pack_end (GTK_BOX (hbox), buttons, TRUE, TRUE, 0);
 469   gtk_box_pack_end (GTK_BOX (hbox), tower_table, TRUE, TRUE, 0);
 470
 471   gtk_container_add (GTK_CONTAINER (tower_window), hbox);
 472
 473   g_free (tower_website);
 474   tower_website = g_strdup_printf ("http://%s", details->fields[FieldWebPage]);
 475   g_free (peals_list);
 476   peals_list = g_strdup_printf ("http://www.pealbase.ismysite.co.uk/felstead/tbid.php?tid=%s",
 477        details->fields[FieldTowerBase]);
 478   g_free (tower_map);
 479   tower_map = g_strdup_printf ("http://maps.google.com/maps?q=%s,%s",
 480         details->fields[FieldLat],
 481         details->fields[FieldLong]);
 482   gtk_widget_show_all (GTK_WIDGET (tower_window));
 483
 484   return FILTER_STOP;
 485 }
 486
 487 /**
 488  * A tower that was accepted by a filter.
 489  */
 490 typedef struct {
 491   char *sortkey;
 492   char *primarykey;
 493   char *displayname;
 494 } FoundTower;
 495
 496 static FoundTower *
 497 found_tower_new (tower *basis)
 498 {
 499   FoundTower* result = g_new (FoundTower, 1);
 500
 501   result->sortkey = g_strdup (basis->fields[FieldPrimaryKey]);
 502   result->primarykey = g_strdup (basis->fields[FieldPrimaryKey]);
 503
 504   if (gps_working)
 505     {
 506       gchar *distance = distance_to_tower_str (basis);
 507       result->displayname = g_strdup_printf ("%s, %s (%s, %s) (%s)",
 508                                              basis->fields[FieldDedication],
 509                                              basis->fields[FieldPlace],
 510                                              basis->fields[FieldBells],
 511                                              basis->fields[FieldPracticeNight],
 512                                              distance);
 513       g_free (distance);
 514     }
 515   else
 516     {
 517       result->displayname = g_strdup_printf ("%s, %s (%s, %s)",
 518                                              basis->fields[FieldDedication],
 519                                              basis->fields[FieldPlace],
 520                                              basis->fields[FieldBells],
 521                                              basis->fields[FieldPracticeNight]);
 522     }
 523
 524   return result;
 525 }
 526
 527 static void
 528 found_tower_free (FoundTower *tower)
 529 {
 530   g_free (tower->sortkey);
 531   g_free (tower->primarykey);
 532   g_free (tower->displayname);
 533   g_free (tower);
 534 }
 535
 536 static void
 537 parse_dove (ParseDoveCallback callback,
 538             GSList **filter_results,
 539             gpointer data)
 540 {
 541   FILE *dove = fopen("/usr/share/belltower/dove.txt", "r");
 542   char tower_rec[4096];
 543   tower result;
 544   char *i;
 545   gboolean seen_newline;
 546
 547   if (!dove)
 548     {
 549       show_message ("Cannot open Dove database!");
 550       exit (255);
 551     }
 552
 553   result.serial = 0;
 554
 555   while (fgets (tower_rec, sizeof (tower_rec), dove))
 556     {
 557       seen_newline = FALSE;
 558       result.fields[0] = tower_rec;
 559       result.n_fields = 0;
 560       for (i=tower_rec; *i; i++) {
 561         if (*i=='\n')
 562           {
 563             seen_newline = TRUE;
 564           }
 565         if (*i=='\\' || *i=='\n')
 566           {
 567             *i = 0;
 568             result.n_fields++;
 569             result.fields[result.n_fields] = i+1;
 570           }
 571       }
 572
 573       if (!seen_newline)
 574         {
 575           /* keep it simple, stupid */
 576           show_message ("Line too long, cannot continue.");
 577           exit (255);
 578         }
 579
 580       if (strcmp (result.fields[FieldCountry], "")==0)
 581         {
 582           result.fields[FieldCountry] = "England";
 583         }
 584
 585       switch (callback (&result, data))
 586         {
 587         case FILTER_IGNORE:
 588           /* nothing */
 589           break;
 590
 591         case FILTER_STOP:
 592           fclose (dove);
 593           return;
 594
 595         case FILTER_ACCEPT:
 596           if (filter_results)
 597             {
 598               *filter_results = g_slist_append (*filter_results,
 599                                                 found_tower_new (&result));
 600             }
 601         }
 602
 603       result.serial++;
 604     }
 605
 606   fclose (dove);
 607 }
 608
 609 static void
 610 show_tower (char *primary_key)
 611 {
 612   parse_dove (single_tower_cb, NULL, primary_key);
 613 }
 614
 615 static void
 616 show_towers_from_list (GSList *list)
 617 {
 618   GtkWidget *dialog;
 619   GtkWidget *selector;
 620   gint result = -1;
 621   GSList *cursor;
 622   gchar foo[2048];
 623
 624   if (!list)
 625     {
 626       hildon_banner_show_information(window,
 627                                      NULL,
 628                                      "No towers found.");
 629       return;
 630     }
 631
 632   if (!list->next)
 633     {
 634       /* only one; don't bother showing the list */
 635       FoundTower* found = (FoundTower*) list->data;
 636
 637       hildon_banner_show_information(window,
 638                                      NULL,
 639                                      "One tower found.");
 640       show_tower (found->primarykey);
 641
 642       /* FIXME: and free the list */
 643       return;
 644     }
 645
 646   dialog = hildon_picker_dialog_new (GTK_WINDOW (window));
 647   selector = hildon_touch_selector_new_text ();
 648
 649   for (cursor=list; cursor; cursor=cursor->next)
 650     {
 651       FoundTower* found = (FoundTower*) cursor->data;
 652       hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector),
 653                                          found->displayname);
 654     }
 655
 656   hildon_picker_dialog_set_selector (HILDON_PICKER_DIALOG (dialog),
 657                                      HILDON_TOUCH_SELECTOR (selector));
 658
 659   gtk_widget_show_all (GTK_WIDGET (dialog));
 660
 661   if (gtk_dialog_run (GTK_DIALOG (dialog))==GTK_RESPONSE_OK)
 662     {
 663       GList *rows = hildon_touch_selector_get_selected_rows (HILDON_TOUCH_SELECTOR (selector),
 664                                                              0);
 665       GtkTreePath *path = (GtkTreePath*) rows->data;
 666       gint *indices = gtk_tree_path_get_indices (path);
 667
 668       result = *indices;
 669     }
 670
 671   gtk_widget_destroy (GTK_WIDGET (dialog));
 672
 673   if (result!=-1)
 674     {
 675       FoundTower *found = (FoundTower *) g_slist_nth_data (list, result);
 676       show_tower (found->primarykey);
 677     }
 678
 679   /* FIXME: and free the list */
 680 }
 681
 682 static gint strcmp_f (gconstpointer a,
 683                       gconstpointer b)
 684 {
 685   return strcmp ((char*)a, (char*)b);
 686 }
 687
 688 static void
 689 put_areas_into_list (gpointer key,
 690                      gpointer value,
 691                      gpointer data)
 692 {
 693   GSList **list = (GSList **)data;
 694   *list = g_slist_insert_sorted (*list,
 695                                  value,
 696                                  strcmp_f);
 697 }
 698
 699 static void
 700 nearby_towers (void)
 701 {
 702   GSList *matches = NULL;
 703
 704   if (!gps_working)
 705     {
 706       show_message ("I don't know where you are!");
 707       return;
 708     }
 709
 710   parse_dove (get_nearby_towers_cb,
 711               &matches,
 712               NULL);
 713
 714   show_towers_from_list (matches);
 715 }
 716
 717 static void
 718 towers_by_subarea (gchar *area)
 719 {
 720   GtkWidget *dialog = hildon_picker_dialog_new (GTK_WINDOW (window));
 721   GtkWidget *selector = hildon_touch_selector_new_text ();
 722   GHashTable *hash = g_hash_table_new_full (g_str_hash,
 723                                             g_str_equal,
 724                                             g_free,
 725                                             g_free);
 726   GSList *list=NULL, *cursor;
 727   gchar *title = g_strdup_printf ("Areas of %s", area);
 728   country_cb_data d = { hash, area };
 729   country_and_county cac = { area, NULL };
 730
 731   gtk_window_set_title (GTK_WINDOW (dialog), title);
 732   g_free (title);
 733
 734   parse_dove (get_counties_cb, NULL, &d);
 735
 736   g_hash_table_foreach (hash,
 737                         put_areas_into_list,
 738                         &list);
 739
 740   for (cursor=list; cursor; cursor=cursor->next)
 741     {
 742       hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector),
 743                                          cursor->data);
 744     }
 745
 746   hildon_picker_dialog_set_selector (HILDON_PICKER_DIALOG (dialog),
 747                                      HILDON_TOUCH_SELECTOR (selector));
 748
 749   gtk_widget_show_all (GTK_WIDGET (dialog));
 750
 751   if (gtk_dialog_run (GTK_DIALOG (dialog))==GTK_RESPONSE_OK)
 752     {
 753       GSList *matches = NULL;
 754       cac.county = strdup (hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
 755
 756       parse_dove (get_towers_by_county_cb,
 757                   &matches,
 758                   &cac);
 759       g_free (cac.county);
 760
 761       show_towers_from_list (matches);
 762     }
 763   g_hash_table_unref (hash);
 764   gtk_widget_destroy (GTK_WIDGET (dialog));
 765 }
 766
 767 static void
 768 towers_by_area (void)
 769 {
 770   GtkWidget *dialog = hildon_picker_dialog_new (GTK_WINDOW (window));
 771   GtkWidget *selector = hildon_touch_selector_new_text ();
 772   GHashTable *hash = g_hash_table_new_full (g_str_hash,
 773                                             g_str_equal,
 774                                             g_free,
 775                                             g_free);
 776   GSList *list = NULL, *cursor;
 777   gchar *result = NULL;
 778
 779   gtk_window_set_title (GTK_WINDOW (dialog), "Areas of the world");
 780
 781   parse_dove (get_countries_cb, NULL, hash);
 782
 783   g_hash_table_foreach (hash,
 784                         put_areas_into_list,
 785                         &list);
 786
 787   for (cursor=list; cursor; cursor=cursor->next)
 788     {
 789       hildon_touch_selector_append_text (HILDON_TOUCH_SELECTOR (selector),
 790                                          cursor->data);
 791     }
 792
 793   hildon_picker_dialog_set_selector (HILDON_PICKER_DIALOG (dialog),
 794                                      HILDON_TOUCH_SELECTOR (selector));
 795
 796   gtk_widget_show_all (GTK_WIDGET (dialog));
 797
 798   if (gtk_dialog_run (GTK_DIALOG (dialog))==GTK_RESPONSE_OK)
 799     {
 800       result = g_strdup (hildon_touch_selector_get_current_text (HILDON_TOUCH_SELECTOR (selector)));
 801     }
 802   g_hash_table_unref (hash);
 803   gtk_widget_destroy (GTK_WIDGET (dialog));
 804
 805   if (result)
 806     {
 807       towers_by_subarea (result);
 808       g_free (result);
 809     }
 810 }
 811
 812 static void
 813 show_bookmarks (void)
 814 {
 815   /* well, there are currently no bookmarks,
 816      because you can't set them. */
 817
 818   show_towers_from_list (NULL);
 819 }
 820
 821 static void
 822 tower_search (void)
 823 {
 824   GtkWidget *terms = gtk_dialog_new_with_buttons ("What are you looking for?",
 825                                                   GTK_WINDOW (window),
 826                                                   GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 827                                                   "Search",
 828                                                   GTK_RESPONSE_OK,
 829                                                   NULL);
 830   GtkWidget *entry = gtk_entry_new ();
 831   GSList *matches = NULL;
 832
 833   gtk_box_pack_end (GTK_BOX (GTK_DIALOG (terms)->vbox),
 834                     entry, TRUE, TRUE, 0);
 835
 836   gtk_widget_show_all (GTK_WIDGET (terms));
 837
 838   if (gtk_dialog_run (GTK_DIALOG (terms))==GTK_RESPONSE_OK)
 839     {
 840       GSList *matches = NULL;
 841
 842       parse_dove (get_towers_by_search_cb,
 843                   &matches,
 844                   (char*) gtk_entry_get_text (GTK_ENTRY (entry)));
 845
 846       show_towers_from_list (matches);
 847     }
 848
 849   gtk_widget_destroy (GTK_WIDGET (terms));
 850 }
 851
 852 static void
 853 recent_towers (void)
 854 {
 855   show_message ("This is not yet implemented.");
 856 }
 857
 858 static void
 859 grab_gps (void)
 860 {
 861   gps_working = (device->fix->fields & LOCATION_GPS_DEVICE_LATLONG_SET)!=0;
 862
 863   if (gps_working)
 864     {
 865       current_lat = device->fix->latitude;
 866       current_long = device->fix->longitude;
 867     }
 868 }
 869
 870 int
 871 main(int argc, char **argv)
 872 {
 873   GtkWidget *bell, *button, *hbox;
 874   GdkPixbuf *bell_picture;
 875
 876   gtk_init (&argc, &argv);
 877   g_set_application_name ("Belltower");
 878
 879   device = g_object_new (LOCATION_TYPE_GPS_DEVICE, NULL);
 880   grab_gps ();
 881   /* FIXME and call that when the location changes, too */
 882
 883   window = hildon_stackable_window_new ();
 884   gtk_window_set_title (GTK_WINDOW (window), "Belltower");
 885   g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
 886
 887   bell_picture = gdk_pixbuf_new_from_file ("/usr/share/belltower/bells1.jpg", NULL);
 888
 889   buttons = gtk_vbox_new (TRUE, 0);
 890   menu = HILDON_APP_MENU (hildon_app_menu_new ());
 891
 892   add_button ("Nearby", nearby_towers);
 893   add_button ("Recent", recent_towers);
 894   add_button ("Bookmarks", show_bookmarks);
 895   add_button ("By area", towers_by_area);
 896   add_button ("Search", tower_search);
 897
 898   /* extra buttons for the app menu */
 899   button = gtk_button_new_with_label ("Credits");
 900   hildon_app_menu_append (menu, GTK_BUTTON (button));
 901   hildon_app_menu_append (menu, GTK_BUTTON (button));
 902
 903   gtk_widget_show_all (GTK_WIDGET (menu));
 904   hildon_window_set_app_menu (HILDON_WINDOW (window), menu);
 905
 906   hbox = gtk_hbox_new (FALSE, 0);
 907   gtk_box_pack_end (GTK_BOX (hbox), buttons, TRUE, TRUE, 0);
 908   gtk_box_pack_end (GTK_BOX (hbox),
 909                     gtk_image_new_from_pixbuf (bell_picture),
 910                     TRUE, TRUE, 0);
 911
 912   gtk_container_add (GTK_CONTAINER (window), hbox);
 913   gtk_widget_show_all (GTK_WIDGET (window));
 914
 915   gtk_main ();
 916
 917   return EXIT_SUCCESS;
 918 }