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