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