Adding in basic EDS appointment support.

3 files changed, 492 insertions, 1 deletions

diff --git a/src/datetime-service.c b/src/datetime-service.c
index 9f795d1..9e3e938 100644
--- a/src/datetime-service.c
+++ b/src/datetime-service.c
@@ -23,9 +23,13 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <libindicator/indicator-service.h>
 #include <locale.h>
 
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
 #include <glib/gi18n.h>
 #include <gio/gio.h>
+#include <math.h>
 
+#include <libdbusmenu-gtk/menuitem.h>
 #include <libdbusmenu-glib/server.h>
 #include <libdbusmenu-glib/client.h>
 #include <libdbusmenu-glib/menuitem.h>
@@ -33,12 +37,23 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include <geoclue/geoclue-master.h>
 #include <geoclue/geoclue-master-client.h>
 
+#include <time.h>
+#include <libecal/e-cal.h>
+#include <libical/ical.h>
+#include <libecal/e-cal-time-util.h>
+#include <libedataserver/e-source.h>
+// Other users of ecal seem to also include these, not sure why they should be included by the above
+#include <libical/icaltime.h>
+#include <cairo/cairo.h>
+
+
 #include <oobs/oobs-timeconfig.h>
 
 #include "datetime-interface.h"
 #include "dbus-shared.h"
 
 static void geo_create_client (GeoclueMaster * master, GeoclueMasterClient * client, gchar * path, GError * error, gpointer user_data);
+static gboolean update_appointment_menu_items (gpointer user_data);
 static void setup_timer (void);
 static void geo_client_invalid (GeoclueMasterClient * client, gpointer user_data);
 static void geo_address_change (GeoclueMasterClient * client, gchar * a, gchar * b, gchar * c, gchar * d, gpointer user_data);
@@ -55,6 +70,12 @@ static DbusmenuMenuitem * date = NULL;
 static DbusmenuMenuitem * calendar = NULL;
 static DbusmenuMenuitem * settings = NULL;
 static DbusmenuMenuitem * tzchange = NULL;
+static DbusmenuMenuitem * add_appointment = NULL;
+static DbusmenuMenuitem * add_location = NULL;
+static GList			* appointments = NULL;
+static ECal				* ecal = NULL;
+static const gchar		* ecal_timezone = NULL;
+static icaltimezone     *tzone;
 
 /* Geoclue trackers */
 static GeoclueMasterClient * geo_master = NULL;
@@ -218,15 +239,270 @@ check_for_calendar (gpointer user_data)
 		g_debug("Found the calendar application: %s", evo);
 		dbusmenu_menuitem_property_set_bool(calendar, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE);
 		dbusmenu_menuitem_property_set_bool(calendar, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
+		dbusmenu_menuitem_property_set_bool(add_appointment, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE);
+		dbusmenu_menuitem_property_set_bool(add_appointment, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
+
+		GError *gerror = NULL;
+		// TODO: In reality we should iterate sources of calendar, but getting the local one doens't lag for > a minute
+		g_debug("Setting up ecal.");
+		if (!ecal)
+			ecal = e_cal_new_system_calendar();
+	
+		if (!ecal) {
+			g_debug("e_cal_new_system_calendar failed");
+			ecal = NULL;
+		}
+		g_debug("Open calendar.");
+		if (!e_cal_open(ecal, FALSE, &gerror) ) {
+			g_debug("e_cal_open: %s\n", gerror->message);
+			g_free(ecal);
+			ecal = NULL;
+		}
+		g_debug("Get calendar timezone.");
+		if (!e_cal_get_timezone(ecal, "UTC", &tzone, &gerror)) {
+			g_debug("failed to get time zone\n");
+			g_free(ecal);
+			ecal = NULL;
+		}
+	
+		/* This timezone represents the timezone of the calendar, this might be different to the current UTC offset.
+		 * this means we'll have some geoclue interaction going on, and possibly the user will be involved in setting
+		 * their location manually, case in point: trains have satellite links which often geoclue to sweden,
+		 * this shouldn't automatically set the location and mess up all the appointments for the user.
+		 */
+		if (ecal) ecal_timezone = icaltimezone_get_tzid(tzone);
+	
+		update_appointment_menu_items(NULL);
+		g_signal_connect(root, DBUSMENU_MENUITEM_SIGNAL_ABOUT_TO_SHOW, G_CALLBACK(update_appointment_menu_items), NULL);		
+
 		g_free(evo);
 	} else {
 		g_debug("Unable to find calendar app.");
 		dbusmenu_menuitem_property_set_bool(calendar, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE);
+		dbusmenu_menuitem_property_set_bool(add_appointment, DBUSMENU_MENUITEM_PROP_VISIBLE, FALSE);
 	}
 
 	return FALSE;
 }
 
+static gboolean
+update_timezone_menu_items(gpointer user_data) {
+	// Get the current location as specified by the user as a place name and time and add it,
+	// Get the location from geoclue as a place and time and add it,
+	// Get the evolution calendar timezone as a place and time and add it,
+	// Get the current timezone that the clock uses and select that
+	// Iterate over configured places and add any which aren't already listed
+	// Hook up each of these to setting the time/current timezone
+	return FALSE;
+}
+
+// Compare function for g_list_sort of ECalComponent objects
+static gint 
+compare_appointment_items (ECalComponent *a,
+                           ECalComponent *b) {
+                                       
+	ECalComponentDateTime datetime_a, datetime_b;
+	struct tm tm_a, tm_b;
+	time_t t_a, t_b;
+	gint retval = 0;
+	
+	ECalComponentVType vtype = e_cal_component_get_vtype (a);
+	if (vtype == E_CAL_COMPONENT_EVENT)
+		e_cal_component_get_dtstart (a, &datetime_a);
+	else
+	    e_cal_component_get_due (a, &datetime_a);
+	tm_a = icaltimetype_to_tm(datetime_a.value);
+	t_a = mktime(&tm_a);
+	
+	vtype = e_cal_component_get_vtype (b);
+	if (vtype == E_CAL_COMPONENT_EVENT)
+		e_cal_component_get_dtstart (b, &datetime_b);
+	else
+	    e_cal_component_get_due (b, &datetime_b);
+	tm_b = icaltimetype_to_tm(datetime_b.value);
+	t_b = mktime(&tm_b);
+
+	// Compare datetime_a and datetime_b, newest first in this sort.
+	if (t_a > t_b) retval = 1;
+	else if (t_a < t_b) retval = -1;
+	
+	e_cal_component_free_datetime (&datetime_a);
+	e_cal_component_free_datetime (&datetime_b);
+	return retval;
+}
+
+/* Populate the menu with todays, next 5 appointments. 
+ * we should hook into the ABOUT TO SHOW signal and use that to update the appointments.
+ * Experience has shown that caldav's and webcals can be slow to load from eds
+ * this is a problem mainly on the EDS side of things, not ours. 
+ */
+static gboolean
+update_appointment_menu_items (gpointer user_data) {
+	if (!ecal) return FALSE;
+	// FFR: we should take into account short term timers, for instance
+	// tea timers, pomodoro timers etc... that people may add, this is hinted to in the spec.
+	time_t t1, t2;
+	gchar *query, *is, *ie, *ad;
+	GList *objects = NULL, *l;
+	GError *gerror = NULL;
+	gint i;
+	gint width, height;
+	
+	time(&t1);
+	time(&t2);
+	t2 += (time_t) (7 * 24 * 60 * 60); /* 7 days ahead of now */
+
+	is = isodate_from_time_t(t1);
+	ie = isodate_from_time_t(t2);
+	
+	// FIXME can we put a limit on the number of results? Or if not complete, or is event/todo? Or sort it by date?
+	query = g_strdup_printf("(occur-in-time-range? (make-time\"%s\") (make-time\"%s\"))", is, ie);
+	g_debug("Getting objects with query: %s", query);
+	if (!e_cal_get_object_list_as_comp(ecal, query, &objects, &gerror)) {
+		g_debug("Failed to get objects\n");
+		g_free(ecal);
+		ecal = NULL;
+		return FALSE;
+	}
+	g_debug("Number of objects returned: %d", g_list_length(objects));
+	gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
+
+	/* Remove all of the previous appointments */
+	if (appointments != NULL) {
+		g_debug("Freeing old appointments");
+		while (appointments != NULL) {
+			DbusmenuMenuitem * litem =  DBUSMENU_MENUITEM(appointments->data);
+			g_debug("Freeing old appointment: %p", litem);
+			// Remove all the existing menu items which are in appointments.
+			appointments = g_list_remove(appointments, litem);
+			dbusmenu_menuitem_child_delete(root, DBUSMENU_MENUITEM(litem));
+			g_object_unref(G_OBJECT(litem));
+		}
+	}
+	
+	// Sort the list see above FIXME regarding queries
+	objects = g_list_sort(objects, (GCompareFunc) compare_appointment_items);
+	i = 0;
+	for (l = objects; l; l = l->next) {
+		ECalComponent *ecalcomp = l->data;
+		ECalComponentText valuetext;
+		ECalComponentDateTime datetime;
+		icaltimezone *appointment_zone = NULL;
+		icalproperty_status status;
+		gchar *summary, *cmd;
+		char right[20];
+		//const gchar *uri;
+		struct tm tmp_tm;
+		DbusmenuMenuitem * item;
+
+		ECalComponentVType vtype = e_cal_component_get_vtype (ecalcomp);
+
+		// See above FIXME regarding query result
+		// If it's not an event or todo, continue no-increment
+        if (vtype != E_CAL_COMPONENT_EVENT && vtype != E_CAL_COMPONENT_TODO)
+			continue;
+
+		// See above FIXME regarding query result
+		// if the status is completed, continue no-increment
+		e_cal_component_get_status (ecalcomp, &status);
+		if (status == ICAL_STATUS_COMPLETED || status == ICAL_STATUS_CANCELLED)
+			continue;
+
+		item = dbusmenu_menuitem_new();
+		dbusmenu_menuitem_property_set       (item, DBUSMENU_MENUITEM_PROP_TYPE, APPOINTMENT_MENUITEM_TYPE);
+		dbusmenu_menuitem_property_set_bool  (item, DBUSMENU_MENUITEM_PROP_ENABLED, TRUE);
+		dbusmenu_menuitem_property_set_bool  (item, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
+	
+		g_debug("Start Object");
+        // Label text        
+		e_cal_component_get_summary (ecalcomp, &valuetext);
+		summary = g_strdup (valuetext.value);
+
+		dbusmenu_menuitem_property_set (item, APPOINTMENT_MENUITEM_PROP_LABEL, summary);
+		g_debug("Summary: %s", summary);
+		g_free (summary);
+		
+		// Due text
+		if (vtype == E_CAL_COMPONENT_EVENT)
+			e_cal_component_get_dtstart (ecalcomp, &datetime);
+		else
+		    e_cal_component_get_due (ecalcomp, &datetime);
+		
+		// FIXME need to get the timezone of the above datetime, 
+		// and get the icaltimezone of the geoclue timezone/selected timezone (whichever is preferred)
+		if (!datetime.value) {
+			g_free(item);
+			continue;
+		}
+		
+		if (!appointment_zone || datetime.value->is_date) { // If it's today put in the current timezone?
+			appointment_zone = tzone;
+		}
+		tmp_tm = icaltimetype_to_tm_with_zone (datetime.value, appointment_zone, tzone);
+		
+		g_debug("Generate time string");
+		// Get today
+		time_t curtime = time(NULL);
+  		struct tm* today = localtime(&curtime);
+		if (today->tm_mday == tmp_tm.tm_mday && 
+		    today->tm_mon == tmp_tm.tm_mon && 
+		    today->tm_year == tmp_tm.tm_year)
+			strftime(right, 20, "%l:%M %P", &tmp_tm);
+		else
+			strftime(right, 20, "%a %l:%M %P", &tmp_tm);
+			
+		g_debug("Appointment time: %s", right);
+		dbusmenu_menuitem_property_set (item, APPOINTMENT_MENUITEM_PROP_RIGHT, right);
+		
+		e_cal_component_free_datetime (&datetime);
+		
+		ad = is = isodate_from_time_t(mktime(&tmp_tm));
+		
+		// Now we pull out the URI for the calendar event and try to create a URI that'll work when we execute evolution
+		// FIXME Because the URI stuff is really broken, we're going to open the calendar at todays date instead
+		
+		//e_cal_component_get_uid(ecalcomp, &uri);
+		cmd = g_strconcat("evolution calendar:///?startdate=", ad, NULL);
+		g_signal_connect (G_OBJECT(item), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
+						  G_CALLBACK (activate_cb), cmd);
+		
+		g_debug("Command to Execute: %s", cmd);
+		
+		ESource *source = e_cal_get_source (ecal);
+        //e_source_get_color (source, &source_color); api has been changed
+        const gchar *color_spec = e_source_peek_color_spec(source);
+        GdkColor color;
+        g_debug("Colour to use: %s", color_spec);
+			
+		// Draw the correct icon for the appointment type and then tint it using mask fill.
+		// For now we'll create a circle
+        if (color_spec != NULL) {
+        	gdk_color_parse (color_spec, &color);
+        	
+			cairo_surface_t *cs = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+			cairo_t *cr = cairo_create(cs);
+			cairo_arc (cr, width/2, height/2, width/2, 0, 2 * M_PI);
+			gdk_cairo_set_source_color(cr, &color);
+			cairo_fill(cr);
+		
+			GdkPixbuf * pixbuf = gdk_pixbuf_get_from_drawable(NULL, (GdkDrawable*)cs, 
+				gdk_colormap_new(gdk_drawable_get_visual((GdkDrawable*)cs), TRUE), 0,0,0,0, width, height);
+			cairo_destroy(cr);
+			
+			dbusmenu_menuitem_property_set_image (item, APPOINTMENT_MENUITEM_PROP_ICON, pixbuf);
+		}
+		dbusmenu_menuitem_child_add_position (root, item, 4+i);
+		appointments = g_list_append         (appointments, item); // Keep track of the items here to make them east to remove
+		g_debug("Adding appointment: %p", item);
+		
+		if (i == 4) break; // See above FIXME regarding query result limit
+		i++;
+	}
+	g_list_free(objects);
+	g_debug("End of objects");
+	return TRUE;
+}
+
 /* Looks for the time and date admin application and enables the
    item we have one */
 static gboolean
@@ -274,8 +550,20 @@ build_menus (DbusmenuMenuitem * root)
 
 		g_idle_add(check_for_calendar, NULL);
 	}
+	DbusmenuMenuitem * separator;
+	
+	separator = dbusmenu_menuitem_new();
+	dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
+	dbusmenu_menuitem_child_append(root, separator);
 
-	DbusmenuMenuitem * separator = dbusmenu_menuitem_new();
+	add_appointment = dbusmenu_menuitem_new();
+	dbusmenu_menuitem_property_set     (add_appointment, DBUSMENU_MENUITEM_PROP_LABEL, _("Add Appointment"));
+	dbusmenu_menuitem_property_set_bool(add_appointment, DBUSMENU_MENUITEM_PROP_ENABLED, FALSE);
+	dbusmenu_menuitem_property_set_bool(add_appointment, DBUSMENU_MENUITEM_PROP_VISIBLE, TRUE);
+	g_signal_connect(G_OBJECT(add_appointment), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(activate_cb), "evolution -c calendar");
+	dbusmenu_menuitem_child_add_position (root, add_appointment, 4);
+	
+	separator = dbusmenu_menuitem_new();
 	dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
 	dbusmenu_menuitem_child_append(root, separator);
 
@@ -286,6 +574,10 @@ build_menus (DbusmenuMenuitem * root)
 	dbusmenu_menuitem_child_append(root, tzchange);
 	check_timezone_sync();
 
+	separator = dbusmenu_menuitem_new();
+	dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
+	dbusmenu_menuitem_child_append(root, separator);
+
 	settings = dbusmenu_menuitem_new();
 	dbusmenu_menuitem_property_set     (settings, DBUSMENU_MENUITEM_PROP_LABEL, _("Time & Date Settings..."));
 	/* insensitive until we check for available apps */
@@ -566,6 +858,7 @@ main (int argc, char ** argv)
 	server = dbusmenu_server_new(MENU_OBJ);
 	root = dbusmenu_menuitem_new();
 	dbusmenu_server_set_root(server, root);
+	
 	build_menus(root);
 
 	/* Setup geoclue */
diff --git a/src/dbus-shared.h b/src/dbus-shared.h
index e6dc241..d13cb32 100644
--- a/src/dbus-shared.h
+++ b/src/dbus-shared.h
@@ -29,3 +29,12 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define  DBUSMENU_CALENDAR_MENUITEM_TYPE "x-canonical-calendar-item"
 
+#define APPOINTMENT_MENUITEM_TYPE          "appointment-item"	
+#define APPOINTMENT_MENUITEM_PROP_LABEL    "appointment-label"
+#define APPOINTMENT_MENUITEM_PROP_ICON     "appointment-icon"
+#define APPOINTMENT_MENUITEM_PROP_RIGHT    "appointment-time"
+
+#define TIMEZONE_MENUITEM_TYPE             "timezone-item"	
+#define TIMEZONE_MENUITEM_PROP_LABEL       "timezone-label"
+#define TIMEZONE_MENUITEM_PROP_RADIO       "timezone-radio"
+#define TIMEZONE_MENUITEM_PROP_RIGHT       "timezone-time"
diff --git a/src/indicator-datetime.c b/src/indicator-datetime.c
index 521c9e9..1f61864 100644
--- a/src/indicator-datetime.c
+++ b/src/indicator-datetime.c
@@ -41,6 +41,7 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* DBusMenu */
 #include <libdbusmenu-gtk/menu.h>
 #include <libido/idocalendarmenuitem.h>
+#include <libdbusmenu-gtk/menuitem.h>
 
 #include "dbus-shared.h"
 
@@ -102,6 +103,14 @@ enum {
 	PROP_CUSTOM_TIME_FORMAT
 };
 
+typedef struct _indicator_item_t indicator_item_t;
+struct _indicator_item_t {
+	GtkWidget * radio;
+	GtkWidget * icon;
+	GtkWidget * label;
+	GtkWidget * right;
+};
+
 #define PROP_TIME_FORMAT_S              "time-format"
 #define PROP_SHOW_SECONDS_S             "show-seconds"
 #define PROP_SHOW_DAY_S                 "show-day"
@@ -167,6 +176,7 @@ static void update_time                   (IndicatorDatetime * self);
 static void receive_signal                (GDBusProxy * proxy, gchar * sender_name, gchar * signal_name, GVariant * parameters, gpointer user_data);
 static void service_proxy_cb (GObject * object, GAsyncResult * res, gpointer user_data);
 static gint generate_strftime_bitmask     (const char *time_str);
+static GSList *location_group = NULL;
 
 /* Indicator Module Config */
 INDICATOR_SET_VERSION
@@ -174,6 +184,8 @@ INDICATOR_SET_TYPE(INDICATOR_DATETIME_TYPE)
 
 G_DEFINE_TYPE (IndicatorDatetime, indicator_datetime, INDICATOR_OBJECT_TYPE);
 
+static GtkSizeGroup * indicator_right_group = NULL;
+
 static void
 indicator_datetime_class_init (IndicatorDatetimeClass *klass)
 {
@@ -1055,6 +1067,129 @@ generate_format_string (IndicatorDatetime * self)
 	return g_strdup_printf(T_("%s, %s"), date_string, time_string);
 }
 
+/* Whenever we have a property change on a DbusmenuMenuitem
+   we need to be responsive to that. */
+static void
+indicator_prop_change_cb (DbusmenuMenuitem * mi, gchar * prop, gchar * value, indicator_item_t * mi_data)
+{
+	if (!g_strcmp0(prop, APPOINTMENT_MENUITEM_PROP_LABEL)) {
+		/* Set the main label */
+		gtk_label_set_text(GTK_LABEL(mi_data->label), value);
+	} else if (!g_strcmp0(prop, APPOINTMENT_MENUITEM_PROP_RIGHT)) {
+		/* Set the right label */
+		gtk_label_set_text(GTK_LABEL(mi_data->right), value);
+	} else if (!g_strcmp0(prop, APPOINTMENT_MENUITEM_PROP_ICON)) {
+		/* We don't use the value here, which is probably less efficient, 
+		   but it's easier to use the easy function.  And since th value
+		   is already cached, shouldn't be a big deal really.  */
+		GdkPixbuf * pixbuf = dbusmenu_menuitem_property_get_image(mi, APPOINTMENT_MENUITEM_PROP_ICON);
+		if (pixbuf != NULL) {
+			/* If we've got a pixbuf we need to make sure it's of a reasonable
+			   size to fit in the menu.  If not, rescale it. */
+			GdkPixbuf * resized_pixbuf;
+			gint width, height;
+			gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
+			if (gdk_pixbuf_get_width(pixbuf) > width ||
+					gdk_pixbuf_get_height(pixbuf) > height) {
+				g_debug("Resizing icon from %dx%d to %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), width, height);
+				resized_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
+				                                         width,
+				                                         height,
+				                                         GDK_INTERP_BILINEAR);
+			} else {
+				g_debug("Happy with icon sized %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
+				resized_pixbuf = pixbuf;
+			}
+			gtk_image_set_from_pixbuf(GTK_IMAGE(mi_data->icon), resized_pixbuf);
+			/* The other pixbuf should be free'd by the dbusmenu. */
+			if (resized_pixbuf != pixbuf) {
+				g_object_unref(resized_pixbuf);
+			}
+		}
+	} else {
+		g_warning("Indicator Item property '%s' unknown", prop);
+	}
+	return;
+}
+
+/* We have a small little menuitem type that handles all
+   of the fun stuff for indicators.  Mostly this is the
+   shifting over and putting the icon in with some right
+   side text that'll be determined by the service.  
+   Copied verbatim from an old revision (including comments) of indicator-messages   
+*/
+static gboolean
+new_appointment_item (DbusmenuMenuitem * newitem, DbusmenuMenuitem * parent, DbusmenuClient * client, gpointer user_data)
+{
+	g_return_val_if_fail(DBUSMENU_IS_MENUITEM(newitem), FALSE);
+	g_return_val_if_fail(DBUSMENU_IS_GTKCLIENT(client), FALSE);
+	/* Note: not checking parent, it's reasonable for it to be NULL */
+
+	indicator_item_t * mi_data = g_new0(indicator_item_t, 1);
+
+	GtkMenuItem * gmi = GTK_MENU_ITEM(gtk_menu_item_new());
+
+	GtkWidget * hbox = gtk_hbox_new(FALSE, 4);
+
+	/* Icon, probably someone's face or avatar on an IM */
+	mi_data->icon = gtk_image_new();
+	GdkPixbuf * pixbuf = dbusmenu_menuitem_property_get_image(newitem, APPOINTMENT_MENUITEM_PROP_ICON);
+
+	if (pixbuf != NULL) {
+		/* If we've got a pixbuf we need to make sure it's of a reasonable
+		   size to fit in the menu.  If not, rescale it. */
+		GdkPixbuf * resized_pixbuf;
+		gint width, height;
+		gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height);
+		if (gdk_pixbuf_get_width(pixbuf) > width ||
+		        gdk_pixbuf_get_height(pixbuf) > height) {
+			g_debug("Resizing icon from %dx%d to %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), width, height);
+			resized_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
+			                                         width,
+			                                         height,
+			                                         GDK_INTERP_BILINEAR);
+		} else {
+			g_debug("Happy with icon sized %dx%d", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
+			resized_pixbuf = pixbuf;
+		}
+  
+		gtk_image_set_from_pixbuf(GTK_IMAGE(mi_data->icon), resized_pixbuf);
+
+		/* The other pixbuf should be free'd by the dbusmenu. */
+		if (resized_pixbuf != pixbuf) {
+			g_object_unref(resized_pixbuf);
+		}
+	}
+	gtk_misc_set_alignment(GTK_MISC(mi_data->icon), 0.0, 0.5);
+	gtk_box_pack_start(GTK_BOX(hbox), mi_data->icon, FALSE, FALSE, 0);
+	gtk_widget_show(mi_data->icon);
+
+	/* Label, probably a username, chat room or mailbox name */
+	mi_data->label = gtk_label_new(dbusmenu_menuitem_property_get(newitem, APPOINTMENT_MENUITEM_PROP_LABEL));
+	gtk_misc_set_alignment(GTK_MISC(mi_data->label), 0.0, 0.5);
+	gtk_box_pack_start(GTK_BOX(hbox), mi_data->label, TRUE, TRUE, 0);
+	gtk_widget_show(mi_data->label);
+
+	/* Usually either the time or the count on the individual
+	   item. */
+	mi_data->right = gtk_label_new(dbusmenu_menuitem_property_get(newitem, APPOINTMENT_MENUITEM_PROP_RIGHT));
+	gtk_size_group_add_widget(indicator_right_group, mi_data->right);
+	gtk_misc_set_alignment(GTK_MISC(mi_data->right), 1.0, 0.5);
+	gtk_box_pack_start(GTK_BOX(hbox), mi_data->right, FALSE, FALSE, 0);
+	gtk_widget_show(mi_data->right);
+
+	gtk_container_add(GTK_CONTAINER(gmi), hbox);
+	gtk_widget_show(hbox);
+
+	dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, gmi, parent);
+
+	g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(indicator_prop_change_cb), mi_data);
+	g_signal_connect_swapped(G_OBJECT(newitem), "destroyed", G_CALLBACK(g_free), mi_data);
+
+	return TRUE;
+}
+
+
 static gboolean
 new_calendar_item (DbusmenuMenuitem * newitem,
 				   DbusmenuMenuitem * parent,
@@ -1082,6 +1217,58 @@ new_calendar_item (DbusmenuMenuitem * newitem,
 	return TRUE;
 }
 
+static gboolean
+new_timezone_item(DbusmenuMenuitem * newitem,
+				   DbusmenuMenuitem * parent,
+				   DbusmenuClient   * client,
+				   gpointer           user_data)
+{
+	g_return_val_if_fail(DBUSMENU_IS_MENUITEM(newitem), FALSE);
+	g_return_val_if_fail(DBUSMENU_IS_GTKCLIENT(client), FALSE);
+	/* Note: not checking parent, it's reasonable for it to be NULL */
+	
+	// Menu item with a radio button and a right aligned time
+	indicator_item_t * mi_data = g_new0(indicator_item_t, 1);
+
+	GtkMenuItem * gmi = GTK_MENU_ITEM(gtk_menu_item_new());
+
+	GtkWidget * hbox = gtk_hbox_new(FALSE, 4);
+
+	mi_data->radio = gtk_radio_button_new(location_group);
+	if (location_group == NULL)
+		location_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(mi_data->radio));
+	
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mi_data->radio),
+		dbusmenu_menuitem_property_get_bool(newitem, TIMEZONE_MENUITEM_PROP_RADIO));
+  
+	gtk_box_pack_start(GTK_BOX(hbox), mi_data->radio, FALSE, FALSE, 0);
+	gtk_widget_show(mi_data->radio);
+	
+  	/* Label, probably a username, chat room or mailbox name */
+	mi_data->label = gtk_label_new(dbusmenu_menuitem_property_get(newitem, APPOINTMENT_MENUITEM_PROP_LABEL));
+	gtk_misc_set_alignment(GTK_MISC(mi_data->label), 0.0, 0.5);
+	gtk_box_pack_start(GTK_BOX(hbox), mi_data->label, TRUE, TRUE, 0);
+	gtk_widget_show(mi_data->label);
+
+	/* Usually either the time or the count on the individual
+	   item. */
+	mi_data->right = gtk_label_new(dbusmenu_menuitem_property_get(newitem, APPOINTMENT_MENUITEM_PROP_RIGHT));
+	gtk_size_group_add_widget(indicator_right_group, mi_data->right);
+	gtk_misc_set_alignment(GTK_MISC(mi_data->right), 1.0, 0.5);
+	gtk_box_pack_start(GTK_BOX(hbox), mi_data->right, FALSE, FALSE, 0);
+	gtk_widget_show(mi_data->right);
+
+	gtk_container_add(GTK_CONTAINER(gmi), hbox);
+	gtk_widget_show(hbox);
+
+	dbusmenu_gtkclient_newitem_base(DBUSMENU_GTKCLIENT(client), newitem, gmi, parent);
+
+	g_signal_connect(G_OBJECT(newitem), DBUSMENU_MENUITEM_SIGNAL_PROPERTY_CHANGED, G_CALLBACK(indicator_prop_change_cb), mi_data);
+	g_signal_connect_swapped(G_OBJECT(newitem), "destroyed", G_CALLBACK(g_free), mi_data);
+
+	return TRUE;
+}
+
 /* Grabs the label.  Creates it if it doesn't
    exist already */
 static GtkLabel *
@@ -1121,6 +1308,8 @@ get_menu (IndicatorObject * io)
 	g_object_set_data (G_OBJECT (client), "indicator", io);
 
 	dbusmenu_client_add_type_handler(DBUSMENU_CLIENT(client), DBUSMENU_CALENDAR_MENUITEM_TYPE, new_calendar_item);
+	dbusmenu_client_add_type_handler(DBUSMENU_CLIENT(client), APPOINTMENT_MENUITEM_TYPE, new_appointment_item);
+	dbusmenu_client_add_type_handler(DBUSMENU_CLIENT(client), TIMEZONE_MENUITEM_TYPE, new_timezone_item);
 
 	return GTK_MENU(self->priv->menu);
 }