Merge lp:~mterry/timezonemap/ship-headers into lp:timezonemap

[Michael Terry]

Ships header files and a .pc file so that C-based libraries can use it.

Also fixes a crasher when freeing CcTimezoneLocation

[lp:~mterry/timezonemap/ship-headers]

19. By Michael Terry on 2012-01-09

and add in TimezoneCompletion from indicator-datetime

[Evan (ev)]

Looks good

review: Approve

[lp:~mterry/timezonemap/ship-headers]

20. By Michael Terry on 2012-01-09

and fix breaks/replaces version to be 0.3

21. By Michael Terry on 2012-01-09

add missing libjson-glib-dev dependency to debian/control

=== modified file 'configure.ac'
--- configure.ac	2011-07-29 08:36:49 +0000
+++ configure.ac	2012-01-09 14:43:24 +0000
@@ -52,7 +52,8 @@
 GIO_REQUIRED_VERSION=2.5.11
 
 PKG_CHECK_MODULES(LIBTIMEZONEMAP, gio-2.0 >= $GIO_REQUIRED_VERSION
-                                  gtk+-3.0 >= $GTK3_REQUIRED_VERSION)
+                                  gtk+-3.0 >= $GTK3_REQUIRED_VERSION
+                                  json-glib-1.0)
 
 GOBJECT_INTROSPECTION_CHECK([0.6.7])
 
@@ -76,6 +77,7 @@
 AC_CONFIG_FILES([
 Makefile
 src/Makefile
+src/timezonemap.pc
 ])
 AC_OUTPUT
 

=== modified file 'debian/changelog'
--- debian/changelog	2011-08-09 09:23:44 +0000
+++ debian/changelog	2012-01-09 14:43:24 +0000
@@ -1,4 +1,20 @@
-libtimezonemap (0.2) UNRELEASED; urgency=low
+libtimezonemap (0.3) precise; urgency=low
+
+  * Fix crash when freeing CcTimezoneLocation objects
+  * Ship a .pc file
+  * Ship include headers
+  * Move .gir file from gir1.2-* package to *-dev package
+  * Add CcTimezoneCompletion from indicator-datetime
+
+ -- Michael Terry <[e-mail]>  Mon, 09 Jan 2012 12:58:29 +0000
+
+libtimezonemap (0.2.1) precise; urgency=low
+
+  * Link with libm.
+
+ -- Matthias Klose <[e-mail]>  Sun, 04 Dec 2011 21:55:46 +0100
+
+libtimezonemap (0.2) oneiric; urgency=low
 
   * Expose TzLocations as GObjects.
 

=== modified file 'debian/control'
--- debian/control	2011-08-03 09:09:02 +0000
+++ debian/control	2012-01-09 14:43:24 +0000
@@ -12,6 +12,7 @@
                libglib2.0-dev (>= 2.25.0),
                libgtk-3-dev (>= 3.1.4),
                libcairo2-dev (>= 1.10),
+               libjson-glib-dev,
                dh-autoreconf
 Standards-Version: 3.9.2
 Vcs-Bzr: http://bazaar.launchpad.net/~timezonemap-team/timezonemap/trunk
@@ -41,6 +42,8 @@
 Depends: ${shlibs:Depends}, 
          ${misc:Depends},
          libtimezonemap1 (= ${binary:Version}),
+Replaces: gir1.2-timezonemap-1.0 (<< 0.3)
+Breaks: gir1.2-timezonemap-1.0 (<< 0.3)
 Description: GTK+3 timezone map widget - development files
  Timezone map widget for GTK+3
  .

=== modified file 'debian/gir1.2-timezonemap-1.0.install'
--- debian/gir1.2-timezonemap-1.0.install	2011-07-29 08:36:49 +0000
+++ debian/gir1.2-timezonemap-1.0.install	2012-01-09 14:43:24 +0000
@@ -1,2 +1,1 @@
 debian/tmp/usr/lib/girepository-1.0/* /usr/lib/girepository-1.0/
-debian/tmp/usr/share/gir-1.0/* /usr/share/gir-1.0/

=== modified file 'debian/libtimezonemap1-dev.install'
--- debian/libtimezonemap1-dev.install	2011-07-29 08:36:49 +0000
+++ debian/libtimezonemap1-dev.install	2012-01-09 14:43:24 +0000
@@ -1,2 +1,4 @@
-#debian/tmp/usr/lib/libtimezonemap.a /usr/lib/
-debian/tmp/usr/lib/libtimezonemap.so /usr/lib/
+debian/tmp/usr/lib/libtimezonemap.so
+debian/tmp/usr/share/gir-1.0
+debian/tmp/usr/include
+debian/tmp/usr/lib/pkgconfig

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-07-29 09:01:38 +0000
+++ src/Makefile.am	2012-01-09 14:43:24 +0000
@@ -48,6 +48,9 @@
 tzdatadir = $(pkgdatadir)/
 dist_tzdata_DATA = backward
 
+pkgconfigdir = $(libdir)/pkgconfig
+dist_pkgconfig_DATA = timezonemap.pc
+
 AM_CPPFLAGS =						\
 	$(LIBTIMEZONEMAP_CFLAGS)				\
 	-DGNOMELOCALEDIR="\"$(datadir)/locale\""	\
@@ -58,7 +61,7 @@
 noinst_PROGRAMS = test-timezone
 
 test_timezone_SOURCES = test-timezone.c tz.c tz.h
-test_timezone_LDADD = $(LIBTIMEZONEMAP_LIBS)
+test_timezone_LDADD = $(LIBTIMEZONEMAP_LIBS) -lm
 test_timezone_CFLAGS = $(LIBTIMEZONEMAP_CFLAGS)
 
 all-local: check-local
@@ -72,9 +75,20 @@
 libtimezonemap_la_SOURCES =	\
 	cc-timezone-map.c	\
 	cc-timezone-map.h	\
+	timezone-completion.c	\
+	timezone-completion.h	\
 	tz.c tz.h
 
-libtimezonemap_la_LIBADD = $(LIBTIMEZONEMAP_LIBS)
+# Specify 'timezonemap' twice: once for package (so we could eventually add
+# a timezonemap-gtk4 for example), and once for namespacing inside code so
+# that users do "#include <timezonemap/tz.h>" instead of "#include <tz.h>"
+timezonemapincludesdir = $(includedir)/timezonemap/timezonemap
+timezonemapincludes_HEADERS = \
+  cc-timezone-map.h \
+  timezone-completion.h \
+  tz.h
+
+libtimezonemap_la_LIBADD = $(LIBTIMEZONEMAP_LIBS) -lm
 libtimezonemap_la_LDFLAGS = \
 	-version-info 1:0:0 \
 	-no-undefined \
@@ -90,7 +104,7 @@
 introspection_sources = $(libtimezonemap_la_SOURCES)
 
 TimezoneMap-1.0.gir: libtimezonemap.la
-TimezoneMap_1_0_gir_INCLUDES = GObject-2.0 Gtk-3.0
+TimezoneMap_1_0_gir_INCLUDES = GObject-2.0 Gtk-3.0 Json-1.0
 TimezoneMap_1_0_gir_CFLAGS = $(INCLUDES) --identifier-prefix=Cc
 TimezoneMap_1_0_gir_LIBS = libtimezonemap.la
 TimezoneMap_1_0_gir_FILES = $(introspection_sources)

=== added file 'src/timezone-completion.c'
--- src/timezone-completion.c	1970-01-01 00:00:00 +0000
+++ src/timezone-completion.c	2012-01-09 14:43:24 +0000
@@ -0,0 +1,701 @@
+/* -*- Mode: C; coding: utf-8; indent-tabs-mode: nil; tab-width: 2 -*-
+
+Copyright 2011 Canonical Ltd.
+
+Authors:
+    Michael Terry <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of the GNU General Public License version 3, as published 
+by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along 
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <json-glib/json-glib.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <glib/gi18n.h>
+#include "timezone-completion.h"
+#include "tz.h"
+
+enum {
+  LAST_SIGNAL
+};
+
+/* static guint signals[LAST_SIGNAL] = { }; */
+
+struct _CcTimezoneCompletionPrivate
+{
+  GtkTreeModel * initial_model;
+  GtkEntry *     entry;
+  guint          queued_request;
+  guint          changed_id;
+  guint          keypress_id;
+  GCancellable * cancel;
+  gchar *        request_text;
+  GHashTable *   request_table;
+};
+
+#define GEONAME_URL "http://geoname-lookup.ubuntu.com/?query=%s&release=%s&lang=%s"
+
+/* Prototypes */
+static void cc_timezone_completion_class_init (CcTimezoneCompletionClass *klass);
+static void cc_timezone_completion_init       (CcTimezoneCompletion *self);
+static void cc_timezone_completion_dispose    (GObject *object);
+static void cc_timezone_completion_finalize   (GObject *object);
+
+G_DEFINE_TYPE (CcTimezoneCompletion, cc_timezone_completion, GTK_TYPE_ENTRY_COMPLETION);
+
+static gboolean
+match_func (GtkEntryCompletion *completion, const gchar *key,
+            GtkTreeIter *iter, gpointer user_data)
+{
+  // geonames does the work for us
+  return TRUE;
+}
+
+static void
+save_and_use_model (CcTimezoneCompletion * completion, GtkTreeModel * model)
+{
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+
+  g_hash_table_insert (priv->request_table, g_strdup (priv->request_text), g_object_ref_sink (model));
+
+  if (model == priv->initial_model)
+    gtk_entry_completion_set_match_func (GTK_ENTRY_COMPLETION (completion), NULL, NULL, NULL);
+  else
+    gtk_entry_completion_set_match_func (GTK_ENTRY_COMPLETION (completion), match_func, NULL, NULL);
+
+  gtk_entry_completion_set_model (GTK_ENTRY_COMPLETION (completion), model);
+
+  if (priv->entry != NULL) {
+    gtk_entry_completion_complete (GTK_ENTRY_COMPLETION (completion));
+
+    /* By this time, the changed signal has come and gone.  We didn't give a
+       model to use, so no popup appeared for user.  Poke the entry again to show
+       popup in 300ms. */
+    g_signal_emit_by_name (priv->entry, "changed");
+  }
+}
+
+static gint
+sort_zone (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b,
+           gpointer user_data)
+{
+  /* Anything that has text as a prefix goes first, in mostly sorted order.
+     Then everything else goes after, in mostly sorted order. */
+  const gchar *casefolded_text = (const gchar *)user_data;
+
+  const gchar *namea = NULL, *nameb = NULL;
+  gtk_tree_model_get (model, a, CC_TIMEZONE_COMPLETION_NAME, &namea, -1);
+  gtk_tree_model_get (model, b, CC_TIMEZONE_COMPLETION_NAME, &nameb, -1);
+
+  gchar *casefolded_namea = NULL, *casefolded_nameb = NULL;
+  casefolded_namea = g_utf8_casefold (namea, -1);
+  casefolded_nameb = g_utf8_casefold (nameb, -1);
+
+  gboolean amatches = FALSE, bmatches = FALSE;
+  amatches = strncmp (casefolded_text, casefolded_namea, strlen(casefolded_text)) == 0;
+  bmatches = strncmp (casefolded_text, casefolded_nameb, strlen(casefolded_text)) == 0;
+
+  gint rv;
+  if (amatches && !bmatches)
+    rv = -1;
+  else if (bmatches && !amatches)
+    rv = 1;
+  else
+    rv = g_utf8_collate (casefolded_namea, casefolded_nameb);
+
+  g_free (casefolded_namea);
+  g_free (casefolded_nameb);
+  return rv;
+}
+
+static void
+json_parse_ready (GObject *object, GAsyncResult *res, gpointer user_data)
+{
+  CcTimezoneCompletion * completion = CC_TIMEZONE_COMPLETION (user_data);
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+  GError * error = NULL;
+  const gchar * prev_name = NULL;
+  const gchar * prev_admin1 = NULL;
+  const gchar * prev_country = NULL;
+
+  json_parser_load_from_stream_finish (JSON_PARSER (object), res, &error);
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) && priv->cancel) {
+    g_cancellable_reset (priv->cancel);
+  }
+
+  if (error != NULL) {
+    if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+      save_and_use_model (completion, priv->initial_model);
+    g_warning ("Could not parse geoname JSON data: %s", error->message);
+    g_error_free (error);
+    return;
+  }
+
+  GtkListStore * store = gtk_list_store_new (CC_TIMEZONE_COMPLETION_LAST,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING);
+
+  JsonReader * reader = json_reader_new (json_parser_get_root (JSON_PARSER (object)));
+
+  if (!json_reader_is_array (reader)) {
+    g_warning ("Could not parse geoname JSON data");
+    save_and_use_model (completion, priv->initial_model);
+    g_object_unref (G_OBJECT (reader));
+    return;
+  }
+
+  gint i, count = json_reader_count_elements (reader);
+  for (i = 0; i < count; ++i) {
+    if (!json_reader_read_element (reader, i))
+      continue;
+
+    if (json_reader_is_object (reader)) {
+      const gchar * name = NULL;
+      const gchar * admin1 = NULL;
+      const gchar * country = NULL;
+      const gchar * longitude = NULL;
+      const gchar * latitude = NULL;
+      gboolean skip = FALSE;
+      if (json_reader_read_member (reader, "name")) {
+        name = json_reader_get_string_value (reader);
+        json_reader_end_member (reader);
+      }
+      if (json_reader_read_member (reader, "admin1")) {
+        admin1 = json_reader_get_string_value (reader);
+        json_reader_end_member (reader);
+      }
+      if (json_reader_read_member (reader, "country")) {
+        country = json_reader_get_string_value (reader);
+        json_reader_end_member (reader);
+      }
+      if (json_reader_read_member (reader, "longitude")) {
+        longitude = json_reader_get_string_value (reader);
+        json_reader_end_member (reader);
+      }
+      if (json_reader_read_member (reader, "latitude")) {
+        latitude = json_reader_get_string_value (reader);
+        json_reader_end_member (reader);
+      }
+
+      if (g_strcmp0(name, prev_name) == 0 &&
+          g_strcmp0(admin1, prev_admin1) == 0 &&
+          g_strcmp0(country, prev_country) == 0) {
+        // Sometimes the data will have duplicate entries that only differ
+        // in longitude and latitude.  e.g. "rio de janeiro", "wellington"
+        skip = TRUE;
+      }
+
+      if (!skip) {
+        GtkTreeIter iter;
+        gtk_list_store_append (store, &iter);
+        gtk_list_store_set (store, &iter,
+                            CC_TIMEZONE_COMPLETION_ZONE, NULL,
+                            CC_TIMEZONE_COMPLETION_NAME, name,
+                            CC_TIMEZONE_COMPLETION_ADMIN1, admin1,
+                            CC_TIMEZONE_COMPLETION_COUNTRY, country,
+                            CC_TIMEZONE_COMPLETION_LONGITUDE, longitude,
+                            CC_TIMEZONE_COMPLETION_LATITUDE, latitude,
+                            -1);
+        gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
+                                         CC_TIMEZONE_COMPLETION_NAME, sort_zone,
+                                         g_utf8_casefold(priv->request_text, -1),
+                                         g_free);
+        gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
+                                              CC_TIMEZONE_COMPLETION_NAME,
+                                              GTK_SORT_ASCENDING);
+      }
+
+      prev_name = name;
+      prev_admin1 = admin1;
+      prev_country = country;
+    }
+
+    json_reader_end_element (reader);
+  }
+
+  if (strlen (priv->request_text) < 4) {
+    gchar * lower_text = g_ascii_strdown (priv->request_text, -1);
+    if (g_strcmp0 (lower_text, "ut") == 0 ||
+        g_strcmp0 (lower_text, "utc") == 0) {
+      GtkTreeIter iter;
+      gtk_list_store_append (store, &iter);
+      gtk_list_store_set (store, &iter,
+                          CC_TIMEZONE_COMPLETION_ZONE, "UTC",
+                          CC_TIMEZONE_COMPLETION_NAME, "UTC",
+                          -1);
+    }
+    g_free (lower_text);
+  }
+
+  save_and_use_model (completion, GTK_TREE_MODEL (store));
+  g_object_unref (G_OBJECT (reader));
+}
+
+static void
+geonames_data_ready (GObject *object, GAsyncResult *res, gpointer user_data)
+{
+  CcTimezoneCompletion * completion = CC_TIMEZONE_COMPLETION (user_data);
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+  GError * error = NULL;
+  GFileInputStream * stream;
+
+  stream = g_file_read_finish (G_FILE (object), res, &error);
+
+  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) && priv->cancel) {
+    g_cancellable_reset (priv->cancel);
+  }
+
+  if (error != NULL) {
+    if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+      save_and_use_model (completion, priv->initial_model);
+    g_warning ("Could not connect to geoname lookup server: %s", error->message);
+    g_error_free (error);
+    return;
+  }
+
+  JsonParser * parser = json_parser_new ();
+  json_parser_load_from_stream_async (parser, G_INPUT_STREAM (stream), priv->cancel,
+                                      json_parse_ready, user_data);
+}
+
+/* Returns message locale, with possible country info too like en_US */
+static gchar *
+get_locale (void)
+{
+  /* Check LANGUAGE, LC_ALL, LC_MESSAGES, and LANG, treat as colon-separated */
+  const gchar *env_names[] = {"LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG", NULL};
+  const gchar *env = NULL;
+  gint i;
+
+  for (i = 0; env_names[i]; i++) {
+    env = g_getenv (env_names[i]);
+    if (env != NULL && env[0] != 0)
+      break;
+  }
+
+  if (env == NULL)
+    return NULL;
+
+  /* Now, we split on colons as expected, but also on . and @ to filter out
+     extra pieces of locale we don't care about as we only use first chunk. */
+  gchar **split = g_strsplit_set (env, ":.@", 2);
+  if (split == NULL)
+    return NULL;
+
+  if (split[0] == NULL) {
+    g_strfreev (split);
+    return NULL;
+  }
+
+  gchar *locale = g_strdup (split[0]);
+  g_strfreev (split);
+  return locale;
+}
+
+static gchar *
+get_version (void)
+{
+  static gchar *version = NULL;
+
+  if (version == NULL) {
+    gchar *stdout = NULL;
+    g_spawn_command_line_sync ("lsb_release -rs", &stdout, NULL, NULL, NULL);
+
+    if (stdout != NULL)
+      version = g_strstrip (stdout);
+    else
+      version = g_strdup("");
+  }
+
+  return version;
+}
+
+static gboolean
+request_zones (CcTimezoneCompletion * completion)
+{
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+
+  priv->queued_request = 0;
+
+  if (priv->entry == NULL) {
+    return FALSE;
+  }
+
+  /* Cancel any ongoing request */
+  if (priv->cancel) {
+    g_cancellable_cancel (priv->cancel);
+    g_cancellable_reset (priv->cancel);
+  }
+  g_free (priv->request_text);
+
+  const gchar * text = gtk_entry_get_text (priv->entry);
+  priv->request_text = g_strdup (text);
+
+  gchar * escaped = g_uri_escape_string (text, NULL, FALSE);
+  gchar * version = get_version ();
+  gchar * locale = get_locale ();
+  gchar * url = g_strdup_printf (GEONAME_URL, escaped, version, locale);
+  g_free (locale);
+  g_free (escaped);
+
+  GFile * file =  g_file_new_for_uri (url);
+  g_free (url);
+
+  g_file_read_async (file, G_PRIORITY_DEFAULT, priv->cancel,
+                     geonames_data_ready, completion);
+
+  return FALSE;
+}
+
+static void
+entry_changed (GtkEntry * entry, CcTimezoneCompletion * completion)
+{
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+
+  if (priv->queued_request) {
+    g_source_remove (priv->queued_request);
+    priv->queued_request = 0;
+  }
+
+  /* See if we've already got this one */
+  const gchar * text = gtk_entry_get_text (priv->entry);
+  gpointer data;
+  if (g_hash_table_lookup_extended (priv->request_table, text, NULL, &data)) {
+    gtk_entry_completion_set_model (GTK_ENTRY_COMPLETION (completion), GTK_TREE_MODEL (data));
+  }
+  else {
+    priv->queued_request = g_timeout_add (300, (GSourceFunc)request_zones, completion);
+    gtk_entry_completion_set_model (GTK_ENTRY_COMPLETION (completion), NULL);
+  }
+  gtk_entry_completion_complete (GTK_ENTRY_COMPLETION (completion));
+}
+
+static GtkWidget *
+get_descendent (GtkWidget * parent, GType type)
+{
+  if (g_type_is_a (G_OBJECT_TYPE (parent), type))
+    return parent;
+
+  if (GTK_IS_CONTAINER (parent)) {
+    GList * children = gtk_container_get_children (GTK_CONTAINER (parent));
+    GList * iter;
+    for (iter = children; iter; iter = iter->next) {
+      GtkWidget * found = get_descendent (GTK_WIDGET (iter->data), type);
+      if (found) {
+        g_list_free (children);
+        return found;
+      }
+    }
+    g_list_free (children);
+  }
+
+  return NULL;
+}
+
+/**
+ * The popup window and its GtkTreeView are private to our parent completion
+ * object.  We can't get access to discover if there is a highlighted item or
+ * even if the window is showing right now.  So this is a super hack to find
+ * it by looking through our toplevel's window group and finding a window with
+ * a GtkTreeView that points at our model.  There should be only one ever, so
+ * we'll use the first one we find.
+ */
+static GtkTreeView *
+find_popup_treeview (GtkWidget * widget, GtkTreeModel * model)
+{
+  GtkWidget * toplevel = gtk_widget_get_toplevel (widget);
+  if (!GTK_IS_WINDOW (toplevel))
+    return NULL;
+
+  GtkWindowGroup * group = gtk_window_get_group (GTK_WINDOW (toplevel)); 
+  GList * windows = gtk_window_group_list_windows (group);
+  GList * iter;
+  for (iter = windows; iter; iter = iter->next) {
+    if (iter->data == toplevel)
+      continue; // Skip our own window, we don't have it
+    GtkWidget * view = get_descendent (GTK_WIDGET (iter->data), GTK_TYPE_TREE_VIEW);
+    if (view != NULL) {
+      GtkTreeModel * tree_model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
+      if (GTK_IS_TREE_MODEL_FILTER (tree_model))
+        tree_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (tree_model));
+      if (tree_model == model) {
+        g_list_free (windows);
+        return GTK_TREE_VIEW (view);
+      }
+    }
+  }
+  g_list_free (windows);
+
+  return NULL;
+}
+
+static gboolean
+entry_keypress (GtkEntry * entry, GdkEventKey  *event, CcTimezoneCompletion * completion)
+{
+  if (event->keyval == GDK_KEY_ISO_Enter ||
+      event->keyval == GDK_KEY_KP_Enter ||
+	    event->keyval == GDK_KEY_Return) {
+    /* Make sure that user has a selection to choose, otherwise ignore */
+    GtkTreeModel * model = gtk_entry_completion_get_model (GTK_ENTRY_COMPLETION (completion));
+    GtkTreeView * view = find_popup_treeview (GTK_WIDGET (entry), model);
+    if (view == NULL) {
+      // Just beep if popup hasn't appeared yet.
+      gtk_widget_error_bell (GTK_WIDGET (entry));
+      return TRUE;
+    }
+
+    GtkTreeSelection * sel = gtk_tree_view_get_selection (view);
+    GtkTreeModel * sel_model = NULL;
+    if (!gtk_tree_selection_get_selected (sel, &sel_model, NULL)) {
+      // No selection, we should help them out and select first item in list
+      GtkTreeIter iter;
+      if (gtk_tree_model_get_iter_first (sel_model, &iter))
+        gtk_tree_selection_select_iter (sel, &iter);
+      // And fall through to normal handler code
+    }
+  }
+
+  return FALSE;
+}
+
+void
+cc_timezone_completion_watch_entry (CcTimezoneCompletion * completion, GtkEntry * entry)
+{
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+
+  if (priv->queued_request) {
+    g_source_remove (priv->queued_request);
+    priv->queued_request = 0;
+  }
+  if (priv->entry) {
+    g_signal_handler_disconnect (priv->entry, priv->changed_id);
+    priv->changed_id = 0;
+    g_signal_handler_disconnect (priv->entry, priv->keypress_id);
+    priv->keypress_id = 0;
+    g_object_remove_weak_pointer (G_OBJECT (priv->entry), (gpointer *)&priv->entry);
+    gtk_entry_set_completion (priv->entry, NULL);
+  }
+
+  priv->entry = entry;
+
+  if (entry) {
+    guint id = g_signal_connect (entry, "changed", G_CALLBACK (entry_changed), completion);
+    priv->changed_id = id;
+
+    id = g_signal_connect (entry, "key-press-event", G_CALLBACK (entry_keypress), completion);
+    priv->keypress_id = id;
+
+    g_object_add_weak_pointer (G_OBJECT (entry), (gpointer *)&priv->entry);
+
+    gtk_entry_set_completion (entry, GTK_ENTRY_COMPLETION (completion));
+  }
+}
+
+static GtkListStore *
+get_initial_model (void)
+{
+  TzDB * db = tz_load_db ();
+  GPtrArray * locations = tz_get_locations (db);
+
+  GtkListStore * store = gtk_list_store_new (CC_TIMEZONE_COMPLETION_LAST,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING,
+                                             G_TYPE_STRING);
+
+  gint i;
+  for (i = 0; i < locations->len; ++i) {
+    CcTimezoneLocation * loc = g_ptr_array_index (locations, i);
+    GtkTreeIter iter;
+    gtk_list_store_append (store, &iter);
+
+    gchar * zone;
+    gchar * country;
+    g_object_get (loc, "zone", &zone, "country", &country, NULL);
+
+    /* FIXME: need something better than below for non-English locales */
+    const gchar * last_bit = ((const gchar *)strrchr (zone, '/')) + 1;
+    if (last_bit == NULL)
+      last_bit = zone;
+    gchar * name = g_strdup (last_bit);
+    gchar * underscore;
+    while ((underscore = strchr (name, '_'))) {
+       *underscore = ' ';
+    }
+
+    gtk_list_store_set (store, &iter,
+                        CC_TIMEZONE_COMPLETION_ZONE, zone,
+                        CC_TIMEZONE_COMPLETION_NAME, name,
+                        CC_TIMEZONE_COMPLETION_COUNTRY, country,
+                        -1);
+
+    g_free (name);
+    g_free (zone);
+  }
+
+  GtkTreeIter iter;
+  gtk_list_store_append (store, &iter);
+  gtk_list_store_set (store, &iter,
+                      CC_TIMEZONE_COMPLETION_ZONE, "UTC",
+                      CC_TIMEZONE_COMPLETION_NAME, "UTC",
+                      -1);
+
+  tz_db_free (db);
+  return store;
+}
+
+static void
+data_func (GtkCellLayout *cell_layout, GtkCellRenderer *cell,
+           GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer user_data)
+{
+  const gchar * name, * admin1, * country;
+
+  gtk_tree_model_get (GTK_TREE_MODEL (tree_model), iter,
+                      CC_TIMEZONE_COMPLETION_NAME, &name,
+                      CC_TIMEZONE_COMPLETION_ADMIN1, &admin1,
+                      CC_TIMEZONE_COMPLETION_COUNTRY, &country,
+                      -1);
+
+  gchar * user_name;
+  if (country == NULL || country[0] == 0) {
+    user_name = g_strdup (name);
+  } else if (admin1 == NULL || admin1[0] == 0) {
+    user_name = g_strdup_printf ("%s <small>(%s)</small>", name, country);
+  } else {
+    user_name = g_strdup_printf ("%s <small>(%s, %s)</small>", name, admin1, country);
+  }
+
+  g_object_set (G_OBJECT (cell), "markup", user_name, NULL);
+}
+
+static void
+cc_timezone_completion_class_init (CcTimezoneCompletionClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  g_type_class_add_private (klass, sizeof (CcTimezoneCompletionPrivate));
+
+  object_class->dispose = cc_timezone_completion_dispose;
+  object_class->finalize = cc_timezone_completion_finalize;
+
+  return;
+}
+
+static void
+cc_timezone_completion_init (CcTimezoneCompletion * self)
+{
+  CcTimezoneCompletionPrivate *priv;
+
+  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+                                            CC_TIMEZONE_COMPLETION_TYPE,
+                                            CcTimezoneCompletionPrivate);
+  priv = self->priv;
+
+  priv->initial_model = GTK_TREE_MODEL (get_initial_model ());
+
+  g_object_set (G_OBJECT (self),
+                "text-column", CC_TIMEZONE_COMPLETION_NAME,
+                "popup-set-width", FALSE,
+                NULL);
+
+  priv->cancel = g_cancellable_new ();
+
+  priv->request_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
+
+  GtkCellRenderer * cell = gtk_cell_renderer_text_new ();
+  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (self), cell, TRUE);
+  gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (self), cell, data_func, NULL, NULL);
+
+  return;
+}
+
+static void
+cc_timezone_completion_dispose (GObject * object)
+{
+  G_OBJECT_CLASS (cc_timezone_completion_parent_class)->dispose (object);
+
+  CcTimezoneCompletion * completion = CC_TIMEZONE_COMPLETION (object);
+  CcTimezoneCompletionPrivate * priv = completion->priv;
+
+  if (priv->changed_id) {
+    if (priv->entry)
+      g_signal_handler_disconnect (priv->entry, priv->changed_id);
+    priv->changed_id = 0;
+  }
+
+  if (priv->keypress_id) {
+    if (priv->entry)
+      g_signal_handler_disconnect (priv->entry, priv->keypress_id);
+    priv->keypress_id = 0;
+  }
+
+  if (priv->entry != NULL) {
+    gtk_entry_set_completion (priv->entry, NULL);
+    g_object_remove_weak_pointer (G_OBJECT (priv->entry), (gpointer *)&priv->entry);
+    priv->entry = NULL;
+  }
+
+  if (priv->initial_model != NULL) {
+    g_object_unref (G_OBJECT (priv->initial_model));
+    priv->initial_model = NULL;
+  }
+
+  if (priv->queued_request) {
+    g_source_remove (priv->queued_request);
+    priv->queued_request = 0;
+  }
+
+  if (priv->cancel != NULL) {
+    g_cancellable_cancel (priv->cancel);
+    g_object_unref (priv->cancel);
+    priv->cancel = NULL;
+  }
+
+  if (priv->request_text != NULL) {
+    g_free (priv->request_text);
+    priv->request_text = NULL;
+  }
+
+  if (priv->request_table != NULL) {
+    g_hash_table_destroy (priv->request_table);
+    priv->request_table = NULL;
+  }
+
+  return;
+}
+
+static void
+cc_timezone_completion_finalize (GObject * object)
+{
+  G_OBJECT_CLASS (cc_timezone_completion_parent_class)->finalize (object);
+  return;
+}
+
+CcTimezoneCompletion *
+cc_timezone_completion_new ()
+{
+  CcTimezoneCompletion * self = g_object_new (CC_TIMEZONE_COMPLETION_TYPE, NULL);
+  return self;
+}
+

=== added file 'src/timezone-completion.h'
--- src/timezone-completion.h	1970-01-01 00:00:00 +0000
+++ src/timezone-completion.h	2012-01-09 14:43:24 +0000
@@ -0,0 +1,66 @@
+/* -*- Mode: C; coding: utf-8; indent-tabs-mode: nil; tab-width: 2 -*-
+
+Copyright 2011 Canonical Ltd.
+
+Authors:
+    Michael Terry <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of the GNU General Public License version 3, as published 
+by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along 
+with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __CC_TIMEZONE_COMPLETION_H__
+#define __CC_TIMEZONE_COMPLETION_H__
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define CC_TIMEZONE_COMPLETION_TYPE            (cc_timezone_completion_get_type ())
+#define CC_TIMEZONE_COMPLETION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TIMEZONE_COMPLETION_TYPE, CcTimezoneCompletion))
+#define CC_TIMEZONE_COMPLETION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TIMEZONE_COMPLETION_TYPE, CcTimezoneCompletionClass))
+#define IS_CC_TIMEZONE_COMPLETION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TIMEZONE_COMPLETION_TYPE))
+#define IS_CC_TIMEZONE_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TIMEZONE_COMPLETION_TYPE))
+#define CC_TIMEZONE_COMPLETION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TIMEZONE_COMPLETION_TYPE, CcTimezoneCompletionClass))
+
+typedef struct _CcTimezoneCompletion             CcTimezoneCompletion;
+typedef struct _CcTimezoneCompletionPrivate      CcTimezoneCompletionPrivate;
+typedef struct _CcTimezoneCompletionClass        CcTimezoneCompletionClass;
+
+struct _CcTimezoneCompletion {
+  GtkEntryCompletion parent;
+
+  CcTimezoneCompletionPrivate *priv;
+};
+
+struct _CcTimezoneCompletionClass {
+  GtkEntryCompletionClass parent_class;
+};
+
+#define CC_TIMEZONE_COMPLETION_ZONE      0
+#define CC_TIMEZONE_COMPLETION_NAME      1
+#define CC_TIMEZONE_COMPLETION_ADMIN1    2
+#define CC_TIMEZONE_COMPLETION_COUNTRY   3
+#define CC_TIMEZONE_COMPLETION_LONGITUDE 4
+#define CC_TIMEZONE_COMPLETION_LATITUDE  5
+#define CC_TIMEZONE_COMPLETION_LAST      6
+
+GType cc_timezone_completion_get_type (void) G_GNUC_CONST;
+CcTimezoneCompletion * cc_timezone_completion_new ();
+void cc_timezone_completion_watch_entry (CcTimezoneCompletion * completion, GtkEntry * entry);
+
+G_END_DECLS
+
+#endif /* __CC_TIMEZONE_COMPLETION_H__ */
+

=== added file 'src/timezonemap.pc.in'
--- src/timezonemap.pc.in	1970-01-01 00:00:00 +0000
+++ src/timezonemap.pc.in	2012-01-09 14:43:24 +0000
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PACKAGE_NAME@
+Description: GTK+3 timezone map widget
+Version: @VERSION@
+Libs: -L${libdir} -ltimezonemap -lm
+Cflags: -I${includedir}/timezonemap
+Requires: gio-2.0 gtk+-3.0 json-glib-1.0

=== modified file 'src/tz.c'
--- src/tz.c	2011-08-02 08:01:29 +0000
+++ src/tz.c	2012-01-09 14:43:24 +0000
@@ -138,19 +138,19 @@
 
   if (priv->country)
     {
-      g_object_unref (priv->country);
+      g_free (priv->country);
       priv->country = NULL;
     }
 
   if (priv->zone)
     {
-      g_object_unref (priv->zone);
+      g_free (priv->zone);
       priv->zone = NULL;
     }
 
   if (priv->comment)
     {
-      g_object_unref (priv->comment);
+      g_free (priv->comment);
       priv->comment = NULL;
     }