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