land the service implementation

2 files changed, 1290 insertions, 71 deletions

diff --git a/src/service.c b/src/service.c
index f5e16a0..7287336 100644
--- a/src/service.c
+++ b/src/service.c
@@ -3,6 +3,7 @@
  *
  * Authors:
  *   Charles Kerr <charles.kerr@canonical.com>
+ *   Ted Gould <ted@canonical.com>
  *
  * 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
@@ -17,25 +18,33 @@
  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <locale.h>
+#include "config.h"
+
+#include <string.h> /* strstr() */
 
 #include <glib/gi18n.h>
 #include <gio/gio.h>
 
+#include "planner-eds.h"
+#include "timezone-file.h"
+#include "timezone-geoclue.h"
 #include "service.h"
+#include "settings-shared.h"
+#include "utils.h"
 
-/* FIXME: remove -test */
-#define BUS_NAME "com.canonical.indicator.datetime-test"
+#define BUS_NAME "datetime.indicator"
 #define BUS_PATH "/com/canonical/indicator/datetime"
 
+#define SKEW_CHECK_INTERVAL_SEC 10
+#define SKEW_DIFF_THRESHOLD_USEC ((SKEW_CHECK_INTERVAL_SEC+5) * G_USEC_PER_SEC)
+
 G_DEFINE_TYPE (IndicatorDatetimeService,
                indicator_datetime_service,
                G_TYPE_OBJECT)
 
-/* signals enum */
 enum
 {
-  NAME_LOST,
+  SIGNAL_NAME_LOST,
   LAST_SIGNAL
 };
 
@@ -69,7 +78,7 @@ enum
 static const char * const menu_names[N_PROFILES] =
 {
   "desktop",
-  "desktop_greeter"
+  "greeter"
 };
 
 struct ProfileMenuInfo
@@ -85,15 +94,38 @@ struct ProfileMenuInfo
 
 struct _IndicatorDatetimeServicePrivate
 {
+  GCancellable * cancellable;
+
+  GSettings * settings;
+
+  IndicatorDatetimeTimezone * tz_file;
+  IndicatorDatetimeTimezone * tz_geoclue;
+  IndicatorDatetimePlanner * planner;
+
   guint own_id;
-  GSimpleActionGroup * actions;
   guint actions_export_id;
-  struct ProfileMenuInfo menus[N_PROFILES];
+  GDBusConnection * conn;
+
   guint rebuild_id;
   int rebuild_flags;
-  GDBusConnection * conn;
-  GCancellable * cancellable;
+  struct ProfileMenuInfo menus[N_PROFILES];
+
+  GDateTime * skew_time;
+  guint skew_timer;
+
+  guint header_timer;
+  guint timezone_timer;
+
+  /* Which year/month to show in the calendar,
+     and which day should get the cursor.
+     This value is reflected in the calendar action's state */
+  time_t calendar_date;
+
+  GSimpleActionGroup * actions;
   GSimpleAction * header_action;
+  GSimpleAction * calendar_action;
+
+  GDBusProxy * login1_manager;
 
   gboolean replace;
 };
@@ -104,6 +136,20 @@ typedef IndicatorDatetimeServicePrivate priv_t;
 ****
 ***/
 
+static void
+indicator_clear_timer (guint * tag)
+{
+  if (*tag)
+    {
+      g_source_remove (*tag);
+      *tag = 0;
+    }
+}
+
+/***
+****
+***/
+
 static void rebuild_now (IndicatorDatetimeService * self, int section);
 static void rebuild_soon (IndicatorDatetimeService * self, int section);
 
@@ -112,21 +158,25 @@ rebuild_header_soon (IndicatorDatetimeService * self)
 {
   rebuild_soon (self, SECTION_HEADER);
 }
+
 static inline void
-rebuild_calendar_soon (IndicatorDatetimeService * self)
+rebuild_calendar_section_soon (IndicatorDatetimeService * self)
 {
   rebuild_soon (self, SECTION_CALENDAR);
 }
+
 static inline void
 rebuild_appointments_section_soon (IndicatorDatetimeService * self)
 {
   rebuild_soon (self, SECTION_APPOINTMENTS);
 }
+
 static inline void
 rebuild_locations_section_soon (IndicatorDatetimeService * self)
 {
   rebuild_soon (self, SECTION_LOCATIONS);
 }
+
 static inline void
 rebuild_settings_section_soon (IndicatorDatetimeService * self)
 {
@@ -134,68 +184,976 @@ rebuild_settings_section_soon (IndicatorDatetimeService * self)
 }
 
 /***
-****
+****  TIMEZONE TIMER
 ***/
 
+/*
+ * Periodically rebuild the sections that have time format strings
+ * that are dependent on the current time:
+ *
+ * 1. appointment menuitems' time format strings depend on the
+ *    current time; for example, they don't show the day of week
+ *    if the appointment is today.
+ *
+ * 2. location menuitems' time format strings depend on the
+ *    current time; for example, they don't show the day of the week
+ *    if the local date and location date are the same.
+ *
+ * 3. the "local date" menuitem in the calendar section is,
+ *    obviously, dependent on the local time.
+ *
+ * In short, we want to update whenever the number of days between two zone
+ * might have changed. We do that by updating when the day changes in either zone.
+ *
+ * Since not all UTC offsets are evenly divisible by hours
+ * (examples: Newfoundland UTC-03:30, Nepal UTC+05:45), refreshing on the hour
+ * is not enough. We need to refresh at HH:00, HH:15, HH:30, and HH:45.
+ */
+
+static guint
+calculate_seconds_until_next_fifteen_minutes (void)
+{
+  char * str;
+  gint minute;
+  guint seconds;
+  GTimeSpan diff;
+  GDateTime * now;
+  GDateTime * next;
+  GDateTime * start_of_next;
+
+  now = g_date_time_new_now_local ();
+
+  minute = g_date_time_get_minute (now);
+  minute = 15 - (minute % 15);
+  next = g_date_time_add_minutes (now, minute);
+  start_of_next = g_date_time_new_local (g_date_time_get_year (next),
+                                         g_date_time_get_month (next),
+                                         g_date_time_get_day_of_month (next),
+                                         g_date_time_get_hour (next),
+                                         g_date_time_get_minute (next),
+                                         1);
+
+  str = g_date_time_format (start_of_next, "%F %T");
+  g_debug ("%s %s the next timestamp rebuild will be at %s", G_STRLOC, G_STRFUNC, str);
+  g_free (str);
+
+  diff = g_date_time_difference (start_of_next, now);
+  seconds = (diff + (G_TIME_SPAN_SECOND-1)) / G_TIME_SPAN_SECOND;
+
+  g_date_time_unref (start_of_next);
+  g_date_time_unref (next);
+  g_date_time_unref (now);
+
+  return seconds;
+}
+
+static void start_timezone_timer (IndicatorDatetimeService * self);
+
+static gboolean
+on_timezone_timer (gpointer gself)
+{
+  IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE (gself);
+
+  rebuild_soon (self, SECTION_CALENDAR |
+                      SECTION_APPOINTMENTS |
+                      SECTION_LOCATIONS);
+
+  /* Restarting the timer to recalculate the interval. This helps us to hit
+     our marks despite clock skew, suspend+resume, leap seconds, etc */
+  start_timezone_timer (self);
+  return G_SOURCE_REMOVE;
+}
+
 static void
-update_header_action (IndicatorDatetimeService * self)
+start_timezone_timer (IndicatorDatetimeService * self)
 {
-  GVariant * v;
-  gchar * a11y = g_strdup ("a11y");
-  const gchar * label = "Hello World";
-  const gchar * iconstr = "icon";
-  const priv_t * const p = self->priv;
+  priv_t * p = self->priv;
 
-  g_return_if_fail (p->header_action != NULL);
+  indicator_clear_timer (&p->timezone_timer);
 
-  v = g_variant_new ("(sssb)", label, iconstr, a11y, TRUE);
-  g_simple_action_set_state (p->header_action, v);
-  g_free (a11y);
+  p->timezone_timer = g_timeout_add_seconds (calculate_seconds_until_next_fifteen_minutes(),
+                                             on_timezone_timer,
+                                             self);
 }
 
 /***
+****  HEADER TIMER
+***/
+
+/*
+ * This is to periodically rebuild the header's action's state.
+ *
+ * If the label shows seconds, update when we reach the next second.
+ * Otherwise, update when we reach the next minute.
+ */
+
+static guint
+calculate_milliseconds_until_next_minute (void)
+{
+  GDateTime * now;
+  GDateTime * next;
+  GDateTime * start_of_next;
+  GTimeSpan interval_usec;
+  guint interval_msec;
+
+  now = g_date_time_new_now_local ();
+  next = g_date_time_add_minutes (now, 1);
+  start_of_next = g_date_time_new_local (g_date_time_get_year (next),
+                                         g_date_time_get_month (next),
+                                         g_date_time_get_day_of_month (next),
+                                         g_date_time_get_hour (next),
+                                         g_date_time_get_minute (next),
+                                         0);
+
+  interval_usec = g_date_time_difference (start_of_next, now);
+  interval_msec = (interval_usec + 999) / 1000;
+
+  g_date_time_unref (start_of_next);
+  g_date_time_unref (next);
+  g_date_time_unref (now);
+
+  return interval_msec;
+}
+
+static gint
+calculate_milliseconds_until_next_second (void)
+{
+  GDateTime * now;
+  gint interval_usec;
+  guint interval_msec;
+
+  now = g_date_time_new_now_local (); 
+
+  interval_usec = G_USEC_PER_SEC - g_date_time_get_microsecond (now);
+  interval_msec = (interval_usec + 999) / 1000;
+
+  g_date_time_unref (now);
+
+  return interval_msec;
+}
+
+static void start_header_timer (IndicatorDatetimeService * self);
+
+static gboolean
+on_header_timer (gpointer gself)
+{
+  IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE (gself);
+
+  rebuild_now (self, SECTION_HEADER);
+
+  /* Restarting the timer to recalculate the interval. This helps us to hit
+     our marks despite clock skew, suspend+resume, leap seconds, etc */
+  start_header_timer (self);
+  return G_SOURCE_REMOVE;
+}
+
+static char * get_header_label_format_string (IndicatorDatetimeService *);
+
+static void
+start_header_timer (IndicatorDatetimeService * self)
+{
+  guint interval_msec;
+  gboolean header_shows_seconds = FALSE;
+  priv_t * p = self->priv;
+ 
+  indicator_clear_timer (&p->header_timer);
+
+  if (g_settings_get_boolean (self->priv->settings, SETTINGS_SHOW_CLOCK_S))
+    {
+      char * fmt = get_header_label_format_string (self);
+      header_shows_seconds = fmt && (strstr(fmt,"%s") || strstr(fmt,"%S") ||
+                                     strstr(fmt,"%T") || strstr(fmt,"%X") ||
+                                     strstr(fmt,"%c"));
+      g_free (fmt);
+    }
+
+  if (header_shows_seconds)
+    interval_msec = calculate_milliseconds_until_next_second ();
+  else
+    interval_msec = calculate_milliseconds_until_next_minute ();
+
+  interval_msec += 50; /* add a small margin to ensure the callback
+                          fires /after/ next is reached */
+
+  p->header_timer = g_timeout_add_full (G_PRIORITY_HIGH,
+                                        interval_msec,
+                                        on_header_timer,
+                                        self,
+                                        NULL);
+}
+
+/**
+ * General purpose handler for rebuilding sections and restarting their timers
+ * when time jumps for whatever reason:
+ *
+ *  - clock skew
+ *  - laptop suspend + resume
+ *  - geoclue detects that we've changed timezones
+ *  - Unity is running inside a TARDIS
+ */
+static void
+on_local_time_jumped (IndicatorDatetimeService * self)
+{
+  g_debug ("%s %s", G_STRLOC, G_STRFUNC);
+
+  /* these calls accomplish two things:
+     1. rebuild the necessary states / menuitems when time jumps
+     2. restart the timers so their new wait interval is correct */
+
+  on_header_timer (self);
+  on_timezone_timer (self);
+}
+
+static gboolean
+skew_timer_func (gpointer gself)
+{
+  GDateTime * now = g_date_time_new_now_local ();
+  IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE (gself);
+  priv_t * p = self->priv;
+
+  /* check for clock skew: has too much time passed since the last check? */
+  if (p->skew_time != NULL)
+    {
+      const GTimeSpan diff = g_date_time_difference (now, p->skew_time);
+
+      if (diff > SKEW_DIFF_THRESHOLD_USEC)
+        on_local_time_jumped (self);
+    }
+
+  g_clear_pointer (&p->skew_time, g_date_time_unref);
+  p->skew_time = now;
+  return G_SOURCE_CONTINUE;
+}
+
+/***
+****
+****  HEADER SECTION
 ****
 ***/
 
-static GMenuModel *
-create_calendar_section (IndicatorDatetimeService * self G_GNUC_UNUSED)
+typedef enum 
 {
-  GMenu * menu;
+  TIME_FORMAT_MODE_LOCALE_DEFAULT,
+  TIME_FORMAT_MODE_12_HOUR,
+  TIME_FORMAT_MODE_24_HOUR,
+  TIME_FORMAT_MODE_CUSTOM
+}
+TimeFormatMode;
 
-  menu = g_menu_new ();
+/* gets the user's time-format from GSettings */
+static TimeFormatMode
+get_time_format_mode (IndicatorDatetimeService * self)
+{
+  char * str;
+  TimeFormatMode mode;
+
+  str = g_settings_get_string (self->priv->settings, SETTINGS_TIME_FORMAT_S);
+
+  if (!g_strcmp0 ("12-hour", str))
+    mode = TIME_FORMAT_MODE_12_HOUR;
+  else if (!g_strcmp0 ("24-hour", str))
+    mode = TIME_FORMAT_MODE_24_HOUR;
+  else if (!g_strcmp0 ("custom", str))
+    mode = TIME_FORMAT_MODE_CUSTOM;
+  else
+    mode = TIME_FORMAT_MODE_LOCALE_DEFAULT;
+
+  g_free (str);
+  return mode;
+}
+
+static gchar *
+get_header_label_format_string (IndicatorDatetimeService * self)
+{
+  char * fmt;
+  const TimeFormatMode mode = get_time_format_mode (self);
+  GSettings * s = self->priv->settings;
+
+  if (mode == TIME_FORMAT_MODE_CUSTOM)
+    {
+      fmt = g_settings_get_string (s, SETTINGS_CUSTOM_TIME_FORMAT_S);
+    }
+  else
+    {
+      gboolean show_day = g_settings_get_boolean (s, SETTINGS_SHOW_DAY_S);
+      gboolean show_date = g_settings_get_boolean (s, SETTINGS_SHOW_DATE_S);
+      fmt = generate_format_string_full (show_day, show_date);
+    }
+
+  return fmt;
+}
+
+static GVariant *
+create_header_state (IndicatorDatetimeService * self)
+{
+  GVariantBuilder b;
+  gchar * fmt;
+  gchar * str;
+  gboolean visible;
+  GDateTime * now_local;
+  priv_t * p = self->priv;
+
+  visible = g_settings_get_boolean (p->settings, SETTINGS_SHOW_CLOCK_S);
+
+  /* build the time string for the label & a11y */
+  fmt = get_header_label_format_string (self);
+  now_local = g_date_time_new_now_local ();
+  str = g_date_time_format (now_local, fmt);
+  if (str == NULL)
+    {
+      str = g_strdup (_("Unsupported date format"));
+      g_warning ("%s", str);
+    }
+
+  g_variant_builder_init (&b, G_VARIANT_TYPE("a{sv}"));
+  g_variant_builder_add (&b, "{sv}", "accessible-desc", g_variant_new_string (str));
+  g_variant_builder_add (&b, "{sv}", "label", g_variant_new_string (str));
+  g_variant_builder_add (&b, "{sv}", "visible", g_variant_new_boolean (visible));
+
+  /* cleanup */
+  g_date_time_unref (now_local);
+  g_free (str);
+  g_free (fmt);
+  return g_variant_builder_end (&b);
+}
+
+
+/***
+****
+****  CALENDAR SECTION
+****
+***/
+
+static GDateTime *
+get_calendar_date (IndicatorDatetimeService * self)
+{
+  GDateTime * date;
+  priv_t * p = self->priv;
+
+  if (p->calendar_date == 0)
+    date = g_date_time_new_now_local ();
+  else
+    date = g_date_time_new_from_unix_local ((gint64)p->calendar_date);
+
+  return date;
+}
+
+static GSList *
+get_all_appointments_this_month (IndicatorDatetimeService * self)
+{
+  GSList * appointments = NULL;
+  priv_t * p = self->priv;
+
+  if (p->planner != NULL)
+    {
+      GDateTime * calendar_date;
+      GDateTime * begin;
+      GDateTime * end;
+      int y, m, d;
+
+      calendar_date = get_calendar_date (self);
+      g_date_time_get_ymd (calendar_date, &y, &m, &d);
+      begin = g_date_time_new_local (y, m, 0,
+                                     0, 0, 0);
+      end = g_date_time_new_local (y, m, g_date_get_days_in_month(m,y),
+                                   23, 59, 0);
+
+      appointments = indicator_datetime_planner_get_appointments (p->planner,
+                                                                  begin,
+                                                                  end);
+
+      g_date_time_unref (end);
+      g_date_time_unref (begin);
+      g_date_time_unref (calendar_date);
+    }
+
+  return appointments;
+}
+
+static GVariant *
+create_calendar_state (IndicatorDatetimeService * self)
+{
+  guint i;
+  const char * key;
+  gboolean days[32] = { 0 };
+  GVariantBuilder dict_builder;
+  GVariantBuilder day_builder;
+  GDateTime * date;
+  GSList * l;
+  GSList * appts;
+  gboolean b;
+  priv_t * p = self->priv;
+
+  g_variant_builder_init (&dict_builder, G_VARIANT_TYPE_DICTIONARY);
+
+  key = "appointment-days";
+  appts = get_all_appointments_this_month (self);
+  for (l=appts; l!=NULL; l=l->next)
+    {
+      const struct IndicatorDatetimeAppt * appt = l->data;
+      days[g_date_time_get_day_of_month (appt->begin)] = TRUE;
+    }
+  g_variant_builder_init (&day_builder, G_VARIANT_TYPE("ai"));
+  for (i=0; i<G_N_ELEMENTS(days); i++)
+    if (days[i])
+      g_variant_builder_add (&day_builder, "i", i);
+  g_variant_builder_add (&dict_builder, "{sv}", key,
+                         g_variant_builder_end (&day_builder));
+  g_slist_free_full (appts, (GDestroyNotify)indicator_datetime_appt_free);
+
+  key = "calendar-day";
+  date = get_calendar_date (self);
+  g_variant_builder_add (&dict_builder, "{sv}", key,
+                         g_variant_new_int64 (g_date_time_to_unix (date)));
+  g_date_time_unref (date);
+
+  key = "show-week-numbers";
+  b = g_settings_get_boolean (p->settings, SETTINGS_SHOW_WEEK_NUMBERS_S);
+  g_variant_builder_add (&dict_builder, "{sv}", key, g_variant_new_boolean (b));
+
+  return g_variant_builder_end (&dict_builder);
+}
+
+static void
+update_calendar_action_state (IndicatorDatetimeService * self)
+{
+  g_simple_action_set_state (self->priv->calendar_action,
+                             create_calendar_state (self));
+}
+
+static GMenuModel *
+create_calendar_section (IndicatorDatetimeService * self)
+{
+  char * label;
+  GMenuItem * menu_item;
+  GDateTime * date_time;
+  GMenu * menu = g_menu_new ();
+
+  /* create the local date menuitem */
+  date_time = g_date_time_new_now_local ();
+  if (date_time == NULL)
+    {
+      label = g_strdup (_("Error getting time"));
+    }
+  else
+    {
+      label = g_date_time_format (date_time, _("%A, %e %B %Y"));
+      g_date_time_unref (date_time);
+    }
+  menu_item = g_menu_item_new (label, NULL);
+  g_menu_item_set_action_and_target_value (menu_item, "indicator.activate-planner",
+                                           g_variant_new_int64(0));
+  g_menu_append_item (menu, menu_item);
+  g_object_unref (menu_item);
+  g_free (label);
+
+  /* create the calendar menuitem */
+  if (g_settings_get_boolean (self->priv->settings, SETTINGS_SHOW_CALENDAR_S))
+    {
+      label = g_strdup ("[calendar]");
+      menu_item = g_menu_item_new ("[calendar]", NULL);
+      g_menu_item_set_action_and_target_value (menu_item,
+                                               "indicator.calendar",
+                                               g_variant_new_int64(0));
+      g_menu_item_set_attribute (menu_item, "x-canonical-type",
+                                 "s", "com.canonical.indicator.calendar");
+      g_menu_item_set_attribute (menu_item, "activation-action",
+                                 "s", "indicator.activate-planner");
+      g_menu_append_item (menu, menu_item);
+      g_object_unref (menu_item);
+      g_free (label);
+    }
 
   return G_MENU_MODEL (menu);
 }
 
+/***
+****
+****  APPOINTMENTS SECTION
+****
+***/
+
+/* gets the next MAX_APPTS appointments */
+static GSList *
+get_upcoming_appointments (IndicatorDatetimeService * self)
+{
+  const int MAX_APPTS = 5;
+  GSList * l;
+  GSList * appts = NULL;
+  priv_t * p = self->priv;
+
+  if (p->planner != NULL)
+    {
+      GDateTime * begin = get_calendar_date (self);
+      GDateTime * end = g_date_time_add_months (begin, 1);
+
+      appts = indicator_datetime_planner_get_appointments (p->planner,
+                                                           begin,
+                                                           end);
+
+      g_date_time_unref (end);
+      g_date_time_unref (begin);
+    }
+
+  /* truncate at MAX_APPTS */
+  if ((l = g_slist_nth (appts, MAX_APPTS-1)))
+    {
+      g_slist_free_full (l->next, (GDestroyNotify)indicator_datetime_appt_free);
+      l->next = NULL;
+    }
+
+  return appts;
+}
+
+static char *
+get_appointment_time_format (struct IndicatorDatetimeAppt  * appt)
+{
+  char * fmt;
+  gboolean full_day = g_date_time_difference (appt->end, appt->begin) == G_TIME_SPAN_DAY;
+
+  if (full_day)
+    {
+      /* TRANSLATORS: This is a strftime string for the day for full day events
+         in the menu.  It should most likely be either '%A' for a full text day
+         (Wednesday) or '%a' for a shortened one (Wed).  You should only need to
+         change for '%a' in the case of langauges with very long day names. */
+      fmt = g_strdup (_("%A"));
+    }
+  else
+    {
+      fmt = generate_format_string_at_time (appt->begin);
+    }
+
+  return fmt;
+}
+
 static GMenuModel *
-create_appointments_section (IndicatorDatetimeService * self G_GNUC_UNUSED)
+create_appointments_section (IndicatorDatetimeService * self)
 {
-  GMenu * menu;
+  priv_t * p = self->priv;
+  GMenu * menu = g_menu_new ();
 
-  menu = g_menu_new ();
+  if (g_settings_get_boolean (p->settings, SETTINGS_SHOW_EVENTS_S))
+    {
+      GSList * l;
+      GSList * appts;
+      GMenuItem * menu_item;
+
+      /* build appointment menuitems */
+      appts = get_upcoming_appointments (self);
+      for (l=appts; l!=NULL; l=l->next)
+        {
+          struct IndicatorDatetimeAppt * appt = l->data;
+          char * fmt = get_appointment_time_format (appt);
+          const gint64 unix_time = g_date_time_to_unix (appt->begin);
+
+          menu_item = g_menu_item_new (appt->summary, NULL);
+          g_menu_item_set_attribute (menu_item, "x-canonical-color",
+                                     "s", appt->color);
+          g_menu_item_set_attribute (menu_item, "x-canonical-time",
+                                     "x", unix_time);
+          g_menu_item_set_attribute (menu_item, "x-canonical-time-format",
+                                     "s", fmt);
+          g_menu_item_set_attribute (menu_item, "x-canonical-type",
+                                     "s", "com.canonical.indicator.appointment");
+          g_menu_item_set_action_and_target_value (menu_item,
+                                                   "indicator.activate-planner",
+                                                   g_variant_new_int64 (unix_time));
+          g_menu_append_item (menu, menu_item);
+          g_object_unref (menu_item);
+          g_free (fmt);
+        }
+
+      /* build 'add event' menuitem */
+      menu_item = g_menu_item_new (_("Add Event…"), NULL);
+      g_menu_item_set_action_and_target_value (menu_item,
+                                               "indicator.activate-planner",
+                                               g_variant_new_int64 (0));
+      g_menu_append_item (menu, menu_item);
+      g_object_unref (menu_item);
+
+      /* cleanup */
+      g_slist_free_full (appts, (GDestroyNotify)indicator_datetime_appt_free);
+    }
 
   return G_MENU_MODEL (menu);
 }
 
+
+/***
+****
+****  LOCATIONS SECTION
+****
+***/
+
+static void
+on_current_timezone_changed (IndicatorDatetimeService * self)
+{
+  on_local_time_jumped (self);
+}
+
+/* When the 'auto-detect timezone' boolean setting changes,
+   start or stop watching geoclue and /etc/timezone */
+static void
+set_detect_location_enabled (IndicatorDatetimeService * self, gboolean enabled)
+{
+  gboolean changed = FALSE;
+  priv_t * p = self->priv;
+
+  /* geoclue */
+
+  if (!p->tz_geoclue && enabled)
+    {
+      p->tz_geoclue = indicator_datetime_timezone_geoclue_new ();
+      g_signal_connect_swapped (p->tz_geoclue, "notify::timezone",
+                                G_CALLBACK(on_current_timezone_changed),
+                                self);
+      changed = TRUE;
+    }
+  else if (p->tz_geoclue && !enabled)
+    {
+      g_signal_handlers_disconnect_by_func (p->tz_geoclue,
+                                            on_current_timezone_changed,
+                                            self);
+      g_clear_object (&p->tz_geoclue);
+      changed = TRUE;
+    }
+
+  /* timezone file */
+
+  if (!p->tz_file && enabled)
+    {
+      p->tz_file = indicator_datetime_timezone_file_new (TIMEZONE_FILE);
+      g_signal_connect_swapped (p->tz_file, "notify::timezone",
+                                G_CALLBACK(on_current_timezone_changed),
+                                self);
+      changed = TRUE;
+    }
+  else if (p->tz_file && !enabled)
+    {
+      g_signal_handlers_disconnect_by_func (p->tz_file,
+                                            on_current_timezone_changed,
+                                            self);
+      g_clear_object (&p->tz_file);
+      changed = TRUE;
+    }
+
+  if (changed)
+    on_current_timezone_changed (self);
+}
+
+/* A temp struct used by create_locations_section()
+   for pruning duplicates and sorting. */
+struct TimeLocation
+{
+  gint32 offset;
+  gchar * zone;
+  gchar * name;
+  gboolean visible;
+  GDateTime * local_time;
+};
+
+static void
+time_location_free (struct TimeLocation * loc)
+{
+  g_date_time_unref (loc->local_time);
+  g_free (loc->name);
+  g_free (loc->zone);
+  g_free (loc);
+}
+
+static struct TimeLocation*
+time_location_new (const char * zone,
+                   const char * name,
+                   gboolean     visible,
+                   time_t       now)
+{
+  struct TimeLocation * loc = g_new (struct TimeLocation, 1);
+  GTimeZone * tz = g_time_zone_new (zone);
+  gint interval = g_time_zone_find_interval (tz, G_TIME_TYPE_UNIVERSAL, now);
+  loc->offset = g_time_zone_get_offset (tz, interval);
+  loc->zone = g_strdup (zone);
+  loc->name = g_strdup (name);
+  loc->visible = visible;
+  loc->local_time = g_date_time_new_now (tz);
+  g_time_zone_unref (tz);
+  return loc;
+}
+
+static int
+time_location_compare (const struct TimeLocation * a,
+                       const struct TimeLocation * b)
+{
+  int ret = a->offset - b->offset; /* primary key */
+
+  if (!ret)
+    ret = g_strcmp0 (a->name, b->name); /* secondary key */
+
+  if (!ret)
+    ret = a->visible - b->visible; /* tertiary key */
+
+  return ret;
+}
+
+static GSList*
+locations_add (GSList     * locations,
+               const char * zone,
+               const char * name,
+               gboolean     visible,
+               time_t       now)
+{
+  struct TimeLocation * loc = time_location_new (zone, name, visible, now);
+
+  if (g_slist_find_custom (locations, loc, (GCompareFunc)time_location_compare))
+    {
+      g_debug("%s Skipping duplicate zone '%s' name '%s'", G_STRLOC, zone, name);
+      time_location_free (loc);
+    }
+  else
+    {
+      g_debug ("%s Adding zone '%s', name '%s'", G_STRLOC, zone, name);
+      locations = g_slist_append (locations, loc);
+    }
+
+  return locations;
+}
+
 static GMenuModel *
-create_locations_section (IndicatorDatetimeService * self G_GNUC_UNUSED)
+create_locations_section (IndicatorDatetimeService * self)
 {
+  guint i;
   GMenu * menu;
+  GSList * l;
+  GSList * locations = NULL;
+  gchar ** user_locations;
+  gboolean visible;
+  const time_t now = time (NULL);
+  priv_t * p = self->priv;
+  IndicatorDatetimeTimezone * detected_timezones[2];
+
+  set_detect_location_enabled (self,
+                               g_settings_get_boolean (p->settings, SETTINGS_SHOW_DETECTED_S));
 
   menu = g_menu_new ();
 
+  /***
+  ****  Build a list of locations to add: use geo_timezone,
+  ****  current_timezone, and SETTINGS_LOCATIONS_S, but omit duplicates.
+  ***/
+
+  /* maybe add the auto-detected timezones */
+  detected_timezones[0] = p->tz_geoclue;
+  detected_timezones[1] = p->tz_file;
+  visible = g_settings_get_boolean (p->settings, SETTINGS_SHOW_DETECTED_S);
+  for (i=0; i<G_N_ELEMENTS(detected_timezones); i++)
+    {
+      if (detected_timezones[i] != NULL)
+        {
+          const char * tz = indicator_datetime_timezone_get_timezone (detected_timezones[i]);
+          if (tz && *tz)
+            {
+              gchar * name = get_current_zone_name (tz);
+              locations = locations_add (locations, tz, name, visible, now);
+              g_free (name);
+            }
+        }
+    }
+
+  /* maybe add the user-specified locations */
+  user_locations = g_settings_get_strv (p->settings, SETTINGS_LOCATIONS_S);
+  if (user_locations != NULL)
+    {
+      visible = g_settings_get_boolean (p->settings, SETTINGS_SHOW_LOCATIONS_S);
+
+      for (i=0; user_locations[i] != NULL; i++)
+        {
+          gchar * zone;
+          gchar * name;
+          split_settings_location (user_locations[i], &zone, &name);
+          locations = locations_add (locations, zone, name, visible, now);
+          g_free (name);
+          g_free (zone);
+        }
+
+      g_strfreev (user_locations);
+      user_locations = NULL;
+    }
+
+  /* now build menuitems for all the locations */
+  for (l=locations; l!=NULL; l=l->next)
+    {
+      struct TimeLocation * loc = l->data;
+      if (loc->visible)
+        {
+          char * label;
+          char * detailed_action;
+          char * fmt;
+          GMenuItem * menu_item;
+
+          label = g_strdup (loc->name);
+          detailed_action = g_strdup_printf ("indicator.set-location::%s %s",
+                                             loc->zone,
+                                             loc->name);
+          fmt = generate_format_string_at_time (loc->local_time);
+
+          menu_item = g_menu_item_new (label, detailed_action);
+          g_menu_item_set_attribute (menu_item, "x-canonical-type",
+                                     "s", "com.canonical.indicator.location");
+          g_menu_item_set_attribute (menu_item, "x-canonical-timezone",
+                                     "s", loc->zone);
+          g_menu_item_set_attribute (menu_item, "x-canonical-time-format",
+                                     "s", fmt);
+          g_menu_append_item (menu, menu_item);
+
+          g_object_unref (menu_item);
+          g_free (fmt);
+          g_free (detailed_action);
+          g_free (label);
+        }
+    }
+
+  g_slist_free_full (locations, (GDestroyNotify)time_location_free);
   return G_MENU_MODEL (menu);
 }
 
-static GMenuModel *
-create_settings_section (IndicatorDatetimeService * self G_GNUC_UNUSED)
+/***
+****
+***/
+
+struct settimezone_data
 {
-  GMenu * menu;
+  IndicatorDatetimeService * service;
+  char * timezone_id;
+  char * name;
+};
 
-  menu = g_menu_new ();
+static void
+settimezone_data_free (struct settimezone_data * data)
+{
+  g_free (data->timezone_id);
+  g_free (data->name);
+  g_free (data);
+}
 
-  g_menu_append (menu, _("Date and Time Settings\342\200\246"), "indicator.activateSettings");
+static void
+on_datetime1_set_timezone_response (GObject       * object,
+                                    GAsyncResult  * res,
+                                    gpointer        gdata)
+{
+  GError * err;
+  GVariant * answers;
+  struct settimezone_data * data = gdata;
+
+  err = NULL;
+  answers = g_dbus_proxy_call_finish (G_DBUS_PROXY(object), res, &err);
+  if (err != NULL)
+    {
+      g_warning ("Could not set new timezone: %s", err->message);
+      g_error_free (err);
+    }
+  else
+    {
+      char * timezone_name = g_strdup_printf ("%s %s",
+                                              data->timezone_id,
+                                              data->name);
+
+      g_settings_set_string (data->service->priv->settings,
+                             SETTINGS_TIMEZONE_NAME_S,
+                             timezone_name);
+
+      g_free (timezone_name);
+      g_variant_unref (answers);
+    }
+
+  settimezone_data_free (data);
+}
+
+static void
+on_datetime1_proxy_ready (GObject      * object G_GNUC_UNUSED,
+                          GAsyncResult * res,
+                          gpointer       gdata)
+{
+  GError * err;
+  GDBusProxy * proxy;
+  struct settimezone_data * data = gdata;
+
+  err = NULL;
+  proxy = g_dbus_proxy_new_for_bus_finish (res, &err);
+  if (err != NULL)
+    {
+      g_warning ("Could not grab DBus proxy for timedated: %s", err->message);
+      g_error_free (err);
+      settimezone_data_free (data);
+    }
+  else
+    {
+      g_dbus_proxy_call (proxy,
+                         "SetTimezone",
+                         g_variant_new ("(sb)", data->timezone_id, TRUE),
+                         G_DBUS_CALL_FLAGS_NONE,
+                         -1,
+                         data->service->priv->cancellable,
+                         on_datetime1_set_timezone_response,
+                         data);
+
+      g_object_unref (proxy);
+    }
+}
+
+static void
+indicator_datetime_service_set_location (IndicatorDatetimeService  * self,
+                                         const char                * timezone_id,
+                                         const char                * name)
+{
+  priv_t * p = self->priv;
+  struct settimezone_data * data;
+
+  g_return_if_fail (INDICATOR_IS_DATETIME_SERVICE (self));
+  g_return_if_fail (name && *name);
+  g_return_if_fail (timezone_id && *timezone_id);
+
+  data = g_new0 (struct settimezone_data, 1);
+  data->timezone_id = g_strdup (timezone_id);
+  data->name = g_strdup (name);
+  data->service = self;
+
+  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
+                            G_DBUS_PROXY_FLAGS_NONE,
+                            NULL,
+                            "org.freedesktop.timedate1",
+                            "/org/freedesktop/timedate1",
+                            "org.freedesktop.timedate1",
+                            p->cancellable,
+                            on_datetime1_proxy_ready,
+                            data);
+}
+
+static void
+on_set_location (GSimpleAction * a G_GNUC_UNUSED,
+                 GVariant      * param,
+                 gpointer        gself)
+{
+  char * zone;
+  char * name;
+  IndicatorDatetimeService * self;
+
+  self = INDICATOR_DATETIME_SERVICE (gself);
+  split_settings_location (g_variant_get_string (param, NULL), &zone, &name);
+  indicator_datetime_service_set_location (self, zone, name);
+
+  g_free (name);
+  g_free (zone);
+}
 
+/***
+****
+***/
+
+static GMenuModel *
+create_settings_section (IndicatorDatetimeService * self G_GNUC_UNUSED)
+{
+  GMenu * menu = g_menu_new ();
+  g_menu_append (menu, _("Date and Time Settings\342\200\246"), "indicator.activate-settings");
   return G_MENU_MODEL (menu);
 }
 
@@ -221,11 +1179,13 @@ create_menu (IndicatorDatetimeService * self, int profile)
     }
   else if (profile == PROFILE_GREETER)
     {
-      /* FIXME: what goes here? */
+      sections[n++] = create_calendar_section (self);
     }
 
   /* add sections to the submenu */
+
   submenu = g_menu_new ();
+
   for (i=0; i<n; ++i)
     {
       g_menu_append_section (submenu, NULL, sections[i]);
@@ -234,7 +1194,8 @@ create_menu (IndicatorDatetimeService * self, int profile)
 
   /* add submenu to the header */
   header = g_menu_item_new (NULL, "indicator._header");
-  g_menu_item_set_attribute (header, "x-canonical-type", "s", "com.canonical.indicator.root");
+  g_menu_item_set_attribute (header, "x-canonical-type",
+                             "s", "com.canonical.indicator.root");
   g_menu_item_set_submenu (header, G_MENU_MODEL (submenu));
   g_object_unref (submenu);
 
@@ -251,23 +1212,87 @@ create_menu (IndicatorDatetimeService * self, int profile)
 ****  GActions
 ***/
 
+/* Run a particular program based on an activation */
+static void
+execute_command (const gchar * cmd)
+{
+  GError * err = NULL;
+
+  g_debug ("Issuing command '%s'", cmd);
+
+  if (!g_spawn_command_line_async (cmd, &err))
+    {
+      g_warning ("Unable to start %s: %s", cmd, err->message);
+      g_error_free (err);
+    }
+}
+
+#ifdef HAVE_CCPANEL
+ #define SETTINGS_APP_INVOCATION "gnome-control-center indicator-datetime"
+#else
+ #define SETTINGS_APP_INVOCATION "gnome-control-center datetime"
+#endif
+
 static void
 on_settings_activated (GSimpleAction * a      G_GNUC_UNUSED,
                        GVariant      * param  G_GNUC_UNUSED,
                        gpointer        gself  G_GNUC_UNUSED)
 {
-  g_message ("settings activated");
+  execute_command (SETTINGS_APP_INVOCATION);
 }
 
 static void
+on_activate_planner (GSimpleAction * a         G_GNUC_UNUSED,
+                     GVariant      * param,
+                     gpointer        gself)
+{
+  priv_t * p = INDICATOR_DATETIME_SERVICE(gself)->priv;
+
+  if (p->planner != NULL)
+    {
+      const time_t t = g_variant_get_int64 (param);
+ 
+      if (t)
+        {
+          GDateTime * date_time = g_date_time_new_from_unix_local (t);
+          indicator_datetime_planner_activate_time (p->planner, date_time);
+          g_date_time_unref (date_time);
+        }
+      else /* no time specified... */
+        {
+          indicator_datetime_planner_activate (p->planner);
+        }
+    }
+}
+
+static void
+on_calendar_action_activated (GSimpleAction * action G_GNUC_UNUSED,
+                              GVariant      * state,
+                              gpointer        gself)
+{
+  IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE (gself);
+  priv_t * p = self->priv;
+  const time_t calendar_date = (time_t) g_variant_get_int64 (state);
+
+  if (p->calendar_date != calendar_date)
+    {
+      p->calendar_date = (time_t) g_variant_get_int64 (state);
+      update_calendar_action_state (self);
+      rebuild_appointments_section_soon (self);
+    }
+}
+
+
+static void
 init_gactions (IndicatorDatetimeService * self)
 {
-  GVariant * v;
   GSimpleAction * a;
   priv_t * p = self->priv;
 
   GActionEntry entries[] = {
-    { "activateSettings", on_settings_activated, NULL, NULL, NULL },
+    { "activate-settings", on_settings_activated },
+    { "activate-planner", on_activate_planner, "x", NULL },
+    { "set-location", on_set_location, "s" }
   };
 
   p->actions = g_simple_action_group_new ();
@@ -278,11 +1303,19 @@ init_gactions (IndicatorDatetimeService * self)
                                    self);
 
   /* add the header action */
-  v = g_variant_new ("(sssb)", "Hello World", "icon", "a11y", TRUE);
-  a = g_simple_action_new_stateful ("_header", NULL, v);
+  a = g_simple_action_new_stateful ("_header", NULL, create_header_state (self));
   g_simple_action_group_insert (p->actions, G_ACTION(a));
   p->header_action = a;
 
+  /* add the calendar action */
+  a = g_simple_action_new_stateful ("calendar",
+                                    G_VARIANT_TYPE_INT64,
+                                    create_calendar_state (self));
+  g_simple_action_group_insert (p->actions, G_ACTION(a));
+  g_signal_connect (a, "activate",
+                    G_CALLBACK(on_calendar_action_activated), self);
+  p->calendar_action = a;
+
   rebuild_now (self, SECTION_HEADER);
 }
 
@@ -308,16 +1341,17 @@ rebuild_now (IndicatorDatetimeService * self, int sections)
 {
   priv_t * p = self->priv;
   struct ProfileMenuInfo * desktop = &p->menus[PROFILE_DESKTOP];
-  //struct ProfileMenuInfo * greeter = &p->menus[PROFILE_GREETER];
+  struct ProfileMenuInfo * greeter = &p->menus[PROFILE_GREETER];
 
   if (sections & SECTION_HEADER)
     {
-      update_header_action (self);
+      g_simple_action_set_state (p->header_action, create_header_state (self));
     }
 
   if (sections & SECTION_CALENDAR)
     {
       rebuild_section (desktop->submenu, 0, create_calendar_section (self));
+      rebuild_section (greeter->submenu, 0, create_calendar_section (self));
     }
 
   if (sections & SECTION_APPOINTMENTS)
@@ -333,7 +1367,6 @@ rebuild_now (IndicatorDatetimeService * self, int sections)
   if (sections & SECTION_SETTINGS)
     {
       rebuild_section (desktop->submenu, 3, create_settings_section (self));
-      //rebuild_section (greeter->submenu, 0, create_datetime_section(self));
     }
 }
 
@@ -369,7 +1402,52 @@ rebuild_soon (IndicatorDatetimeService * self, int section)
 }
 
 /***
-**** GDBus
+****  org.freedesktop.login1.Manager
+***/
+
+static void
+on_login1_manager_signal (GDBusProxy  * proxy         G_GNUC_UNUSED,
+                          gchar       * sender_name   G_GNUC_UNUSED,
+                          gchar       * signal_name,
+                          GVariant    * parameters,
+                          gpointer      gself)
+{
+  if (!g_strcmp0 (signal_name, "PrepareForSleep"))
+    {
+      gboolean sleeping = FALSE;
+      g_variant_get (parameters, "(b)", &sleeping);
+      if (!sleeping)
+        on_local_time_jumped (INDICATOR_DATETIME_SERVICE (gself));
+    }
+}
+
+static void
+on_login1_manager_proxy_ready (GObject       * object  G_GNUC_UNUSED,
+                               GAsyncResult  * res,
+                               gpointer        gself)
+{
+  GError * err;
+  GDBusProxy * proxy;
+
+  err = NULL;
+  proxy = g_dbus_proxy_new_for_bus_finish (res, &err);
+
+  if (err != NULL)
+    {
+      g_warning ("Could not grab DBus proxy for logind: %s", err->message);
+      g_error_free (err);
+    }
+  else
+    {
+      IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE (gself);
+      self->priv->login1_manager = proxy;
+      g_signal_connect (proxy, "g-signal",
+                        G_CALLBACK(on_login1_manager_signal), self);
+    }
+}
+
+/***
+****  GDBus
 ***/
 
 static void
@@ -464,9 +1542,10 @@ on_name_lost (GDBusConnection * connection G_GNUC_UNUSED,
 
   unexport (self);
 
-  g_signal_emit (self, signals[NAME_LOST], 0, NULL);
+  g_signal_emit (self, signals[SIGNAL_NAME_LOST], 0, NULL);
 }
 
+
 /***
 ****  GObject virtual functions
 ***/
@@ -476,21 +1555,22 @@ my_constructed (GObject * o)
 {
   GBusNameOwnerFlags owner_flags;
   IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE(o);
+  priv_t * p = self->priv;
 
   /* own the name in constructed() instead of init() so that
      we'll know the value of the 'replace' property */
   owner_flags = G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT;
-  if (self->priv->replace)
+  if (p->replace)
     owner_flags |= G_BUS_NAME_OWNER_FLAGS_REPLACE;
 
-  self->priv->own_id = g_bus_own_name (G_BUS_TYPE_SESSION,
-                                       BUS_NAME,
-                                       owner_flags,
-                                       on_bus_acquired,
-                                       NULL,
-                                       on_name_lost,
-                                       self,
-                                       NULL);
+  p->own_id = g_bus_own_name (G_BUS_TYPE_SESSION,
+                              BUS_NAME,
+                              owner_flags,
+                              on_bus_acquired,
+                              NULL,
+                              on_name_lost,
+                              self,
+                              NULL);
 }
 
 static void
@@ -552,10 +1632,29 @@ my_dispose (GObject * o)
       g_clear_object (&p->cancellable);
     }
 
-  if (p->rebuild_id)
+  set_detect_location_enabled (self, FALSE);
+
+  if (p->planner != NULL)
     {
-      g_source_remove (p->rebuild_id);
-      p->rebuild_id = 0;
+      g_signal_handlers_disconnect_by_data (p->planner, self);
+      g_clear_object (&p->planner);
+    }
+
+  if (p->login1_manager != NULL)
+    {
+      g_signal_handlers_disconnect_by_data (p->login1_manager, self);
+      g_clear_object (&p->login1_manager);
+    }
+
+  indicator_clear_timer (&p->skew_timer);
+  indicator_clear_timer (&p->rebuild_id);
+  indicator_clear_timer (&p->timezone_timer);
+  indicator_clear_timer (&p->header_timer);
+
+  if (p->settings != NULL)
+    {
+      g_signal_handlers_disconnect_by_data (p->settings, self);
+      g_clear_object (&p->settings);
     }
 
   g_clear_object (&p->actions);
@@ -563,12 +1662,25 @@ my_dispose (GObject * o)
   for (i=0; i<N_PROFILES; ++i)
     g_clear_object (&p->menus[i].menu);
 
+  g_clear_object (&p->planner);
+  g_clear_object (&p->calendar_action);
   g_clear_object (&p->header_action);
   g_clear_object (&p->conn);
 
   G_OBJECT_CLASS (indicator_datetime_service_parent_class)->dispose (o);
 }
 
+static void
+my_finalize (GObject * o)
+{
+  IndicatorDatetimeService * self = INDICATOR_DATETIME_SERVICE(o);
+  priv_t * p = self->priv;
+
+  g_clear_pointer (&p->skew_time, g_date_time_unref);
+
+  G_OBJECT_CLASS (indicator_datetime_service_parent_class)->dispose (o);
+}
+
 /***
 ****  Instantiation
 ***/
@@ -576,18 +1688,125 @@ my_dispose (GObject * o)
 static void
 indicator_datetime_service_init (IndicatorDatetimeService * self)
 {
+  guint i, n;
   priv_t * p;
+  GString * gstr = g_string_new (NULL);
+
+  /* these are the settings that affect the
+     contents of the respective sections */
+  const char * const header_settings[] = {
+    SETTINGS_SHOW_CLOCK_S,
+    SETTINGS_TIME_FORMAT_S,
+    SETTINGS_SHOW_SECONDS_S,
+    SETTINGS_SHOW_DAY_S,
+    SETTINGS_SHOW_DATE_S,
+    SETTINGS_CUSTOM_TIME_FORMAT_S
+  };
+  const char * const calendar_settings[] = {
+    SETTINGS_SHOW_CALENDAR_S,
+    SETTINGS_SHOW_WEEK_NUMBERS_S
+  };
+  const char * const appointment_settings[] = {
+    SETTINGS_SHOW_EVENTS_S,
+    SETTINGS_TIME_FORMAT_S,
+    SETTINGS_SHOW_SECONDS_S
+  };
+  const char * const location_settings[] = {
+    SETTINGS_TIME_FORMAT_S,
+    SETTINGS_SHOW_SECONDS_S,
+    SETTINGS_CUSTOM_TIME_FORMAT_S,
+    SETTINGS_SHOW_LOCATIONS_S,
+    SETTINGS_LOCATIONS_S,
+    SETTINGS_SHOW_DETECTED_S,
+    SETTINGS_TIMEZONE_NAME_S
+  };
+  const char * const time_format_string_settings[] = {
+    SETTINGS_TIME_FORMAT_S,
+    SETTINGS_SHOW_SECONDS_S,
+    SETTINGS_CUSTOM_TIME_FORMAT_S
+  };
+    
+
+  /* init the priv pointer */
 
-  /* init our priv pointer */
   p = G_TYPE_INSTANCE_GET_PRIVATE (self,
                                    INDICATOR_TYPE_DATETIME_SERVICE,
                                    IndicatorDatetimeServicePrivate);
   self->priv = p;
 
-  /* init the backend objects */
   p->cancellable = g_cancellable_new ();
 
+  /***
+  ****  Create the planner and listen for changes
+  ***/
+
+  p->planner = indicator_datetime_planner_eds_new ();
+
+  g_signal_connect_swapped (p->planner, "appointments-changed",
+                            G_CALLBACK(rebuild_calendar_section_soon), self);
+
+
+  /***
+  ****  Create the settings object and listen for changes
+  ***/
+
+  p->settings = g_settings_new (SETTINGS_INTERFACE);
+  for (i=0, n=G_N_ELEMENTS(header_settings); i<n; i++)
+    {
+      g_string_printf (gstr, "changed::%s", header_settings[i]);
+      g_signal_connect_swapped (p->settings, gstr->str,
+                                G_CALLBACK(rebuild_header_soon), self);
+    }
+
+  for (i=0, n=G_N_ELEMENTS(calendar_settings); i<n; i++)
+    {
+      g_string_printf (gstr, "changed::%s", calendar_settings[i]);
+      g_signal_connect_swapped (p->settings, gstr->str,
+                                G_CALLBACK(rebuild_calendar_section_soon), self);
+    }
+
+  for (i=0, n=G_N_ELEMENTS(appointment_settings); i<n; i++)
+    {
+      g_string_printf (gstr, "changed::%s", appointment_settings[i]);
+      g_signal_connect_swapped (p->settings, gstr->str,
+                                G_CALLBACK(rebuild_appointments_section_soon), self);
+    }
+
+  for (i=0, n=G_N_ELEMENTS(location_settings); i<n; i++)
+    {
+      g_string_printf (gstr, "changed::%s", location_settings[i]);
+      g_signal_connect_swapped (p->settings, gstr->str,
+                                G_CALLBACK(rebuild_locations_section_soon), self);
+    }
+
+  /* The keys in time_format_string_settings affect the time format strings we build.
+     When these change, we need to rebuild everything that has a time format string. */
+  for (i=0, n=G_N_ELEMENTS(time_format_string_settings); i<n; i++)
+    {
+      g_string_printf (gstr, "changed::%s", time_format_string_settings[i]);
+      g_signal_connect_swapped (p->settings, gstr->str,
+                                G_CALLBACK(on_local_time_jumped), self);
+    }
+
   init_gactions (self);
+
+  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
+                            G_DBUS_PROXY_FLAGS_NONE,
+                            NULL,
+                            "org.freedesktop.login1",
+                            "/org/freedesktop/login1",
+                            "org.freedesktop.login1.Manager",
+                            p->cancellable,
+                            on_login1_manager_proxy_ready,
+                            self);
+
+  p->skew_timer = g_timeout_add_seconds (SKEW_CHECK_INTERVAL_SEC,
+                                         skew_timer_func,
+                                         self);
+
+  on_local_time_jumped (self);
+
+  g_string_free (gstr, TRUE);
 }
 
 static void
@@ -596,19 +1815,21 @@ indicator_datetime_service_class_init (IndicatorDatetimeServiceClass * klass)
   GObjectClass * object_class = G_OBJECT_CLASS (klass);
 
   object_class->dispose = my_dispose;
+  object_class->finalize = my_finalize;
   object_class->constructed = my_constructed;
   object_class->get_property = my_get_property;
   object_class->set_property = my_set_property;
 
   g_type_class_add_private (klass, sizeof (IndicatorDatetimeServicePrivate));
 
-  signals[NAME_LOST] = g_signal_new (INDICATOR_DATETIME_SERVICE_SIGNAL_NAME_LOST,
-                                     G_TYPE_FROM_CLASS(klass),
-                                     G_SIGNAL_RUN_LAST,
-                                     G_STRUCT_OFFSET (IndicatorDatetimeServiceClass, name_lost),
-                                     NULL, NULL,
-                                     g_cclosure_marshal_VOID__VOID,
-                                     G_TYPE_NONE, 0);
+  signals[SIGNAL_NAME_LOST] = g_signal_new (
+    INDICATOR_DATETIME_SERVICE_SIGNAL_NAME_LOST,
+    G_TYPE_FROM_CLASS(klass),
+    G_SIGNAL_RUN_LAST,
+    G_STRUCT_OFFSET (IndicatorDatetimeServiceClass, name_lost),
+    NULL, NULL,
+    g_cclosure_marshal_VOID__VOID,
+    G_TYPE_NONE, 0);
 
   properties[PROP_0] = NULL;
 
diff --git a/src/service.h b/src/service.h
index 594d7fe..47dd937 100644
--- a/src/service.h
+++ b/src/service.h
@@ -26,10 +26,8 @@
 G_BEGIN_DECLS
 
 /* standard GObject macros */
-#define INDICATOR_TYPE_DATETIME_SERVICE          (indicator_datetime_service_get_type())
 #define INDICATOR_DATETIME_SERVICE(o)            (G_TYPE_CHECK_INSTANCE_CAST ((o), INDICATOR_TYPE_DATETIME_SERVICE, IndicatorDatetimeService))
-#define INDICATOR_DATETIME_SERVICE_GET_CLASS(o)  (G_TYPE_INSTANCE_GET_CLASS ((o), INDICATOR_TYPE_DATETIME_SERVICE, IndicatorDatetimeServiceClass))
-#define INDICATOR_DATETIME_SERVICE_CLASS(k)      (G_TYPE_CHECK_CLASS_CAST ((k), INDICATOR_TYPE_DATETIME_SERVICE, IndicatorDatetimeServiceClass))
+#define INDICATOR_TYPE_DATETIME_SERVICE          (indicator_datetime_service_get_type())
 #define INDICATOR_IS_DATETIME_SERVICE(o)         (G_TYPE_CHECK_INSTANCE_TYPE ((o), INDICATOR_TYPE_DATETIME_SERVICE))
 
 typedef struct _IndicatorDatetimeService         IndicatorDatetimeService;