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