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