moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 2125 insertions, 0 deletions

diff --git a/applets/clock/calendar-window.c b/applets/clock/calendar-window.c
new file mode 100644
index 00000000..d675f492
--- /dev/null
+++ b/applets/clock/calendar-window.c
@@ -0,0 +1,2125 @@
+/*
+ * calendar-window.c: toplevel window containing a calendar and
+ * tasks/appointments
+ *
+ * Copyright (C) 2007 Vincent Untz <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ *
+ * Authors:
+ *      Vincent Untz <[email protected]>
+ *
+ * Most of the original code comes from clock.c
+ */
+
+ /*
+  * Evolution calendar integration TODO:
+  *   + Fix treeview scrolling and sizing
+  *   + Tooltips for tasks/appointments
+  *   + Do everything backwards if the clock is on the bottom
+  *   + Double clicking appointments/tasks should open them in evo
+  *   + Consider using different colours for different sources
+  *   + Consider doing a GtkMenu tearoff type thing
+  */
+
+#include <config.h>
+
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <mateconf/mateconf-client.h>
+
+#define MATE_DESKTOP_USE_UNSTABLE_API
+#include <libmate/mate-desktop-utils.h>
+
+#include "calendar-window.h"
+
+#include "clock.h"
+#include "clock-utils.h"
+#include "clock-typebuiltins.h"
+#ifdef HAVE_LIBECAL
+#include "calendar-client.h"
+#endif
+
+#define CALENDAR_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CALENDAR_TYPE_WINDOW, CalendarWindowPrivate))
+
+#define KEY_LOCATIONS_EXPANDED      "expand_locations"
+#ifdef HAVE_LIBECAL
+/* For the following value, take into account the KEY_* that are not inside this #ifdef! */
+#  define N_CALENDAR_WINDOW_MATECONF_PREFS 5
+#  define KEY_APPOINTMENTS_EXPANDED "expand_appointments"
+#  define KEY_BIRTHDAYS_EXPANDED    "expand_birthdays"
+#  define KEY_TASKS_EXPANDED        "expand_tasks"
+#  define KEY_WEATHER_EXPANDED      "expand_weather"
+
+#  define KEY_CALENDAR_APP          "/desktop/mate/applications/calendar"
+#  define KEY_TASKS_APP             "/desktop/mate/applications/tasks"
+#else
+#  define N_CALENDAR_WINDOW_MATECONF_PREFS 1
+#endif
+
+enum {
+	EDIT_LOCATIONS,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+struct _CalendarWindowPrivate {
+	GtkWidget  *calendar;
+
+	char       *prefs_dir;
+
+	gboolean     invert_order;
+	gboolean     show_weeks;
+	time_t      *current_time;
+
+	GtkWidget *locations_list;
+
+#ifdef HAVE_LIBECAL
+	ClockFormat  time_format;
+
+        CalendarClient *client;
+
+        GtkWidget *appointment_list;
+        GtkWidget *birthday_list;
+        GtkWidget *weather_list;
+        GtkWidget *task_list;
+
+        GtkListStore *appointments_model;
+        GtkListStore *tasks_model;
+
+        GtkTreeSelection *previous_selection;
+
+        GtkTreeModelFilter *appointments_filter;
+        GtkTreeModelFilter *birthdays_filter;
+        GtkTreeModelFilter *tasks_filter;
+        GtkTreeModelFilter *weather_filter;
+
+	MateConfClient *mateconfclient;
+#endif /* HAVE_LIBECAL */
+};
+
+G_DEFINE_TYPE (CalendarWindow, calendar_window, GTK_TYPE_WINDOW)
+
+enum {
+	PROP_0,
+	PROP_INVERTORDER,
+	PROP_SHOWWEEKS,
+#ifdef HAVE_LIBECAL
+	PROP_TIMEFORMAT,
+#endif
+	PROP_CURRENTTIMEP,
+	PROP_PREFSDIR
+};
+
+static time_t *calendar_window_get_current_time_p (CalendarWindow *calwin);
+static void    calendar_window_set_current_time_p (CalendarWindow *calwin,
+						   time_t         *current_time);
+static const char *calendar_window_get_prefs_dir  (CalendarWindow *calwin);
+static void    calendar_window_set_prefs_dir      (CalendarWindow *calwin,
+						   const char     *prefs_dir);
+static GtkWidget * create_hig_frame 		  (CalendarWindow *calwin,
+		  				   const char *title,
+                  				   const char *button_label,
+		  				   const char *key,
+                  				   GCallback   callback);
+
+#ifdef HAVE_LIBECAL
+
+static void
+clock_launch_calendar_tasks_app (CalendarWindow *calwin,
+				 const char     *key_program,
+				 const char     *argument)
+{
+	char      **argv;
+	int         argc;
+	char       *key;
+	char       *program;
+	gboolean    terminal;
+	char       *command_line;
+	GdkScreen  *screen;
+	GError     *error;
+	gboolean    result;
+
+	key = g_strdup_printf ("%s%s", key_program, "/exec");
+	program = mateconf_client_get_string (calwin->priv->mateconfclient,
+					   key, NULL);
+	g_free (key);
+
+	key = g_strdup_printf ("%s%s", key_program, "/needs_term");
+	terminal = mateconf_client_get_bool (calwin->priv->mateconfclient,
+					  key, NULL);
+	g_free (key);
+
+	if (program == NULL) {
+		g_printerr ("Cannot launch calendar/tasks application: key not set\n");
+		return;
+	}
+
+	command_line = g_find_program_in_path (program);
+	if (command_line == NULL) {
+		g_printerr ("Cannot launch calendar/tasks application: %s in path\n", program);
+		g_free (program);
+		return;
+	}
+	g_free (command_line);
+
+	if (argument) {
+		argc = 2;
+		argv = g_new0 (char *, 3);
+		argv[1] = g_strdup (argument);
+	} else {
+		argc = 1;
+		argv = g_new0 (char *, 2);
+	}
+	argv[0] = program; /* no strdup, and it will get freed for free */
+
+	screen = gtk_widget_get_screen (calwin->priv->calendar);
+	error = NULL;
+
+	if (terminal)
+		mate_desktop_prepend_terminal_to_vector (&argc, &argv);
+
+	result = gdk_spawn_on_screen (screen,
+				      NULL, /* working directory */
+				      argv,
+				      NULL, /* envp */
+				      G_SPAWN_SEARCH_PATH,
+				      NULL, /* child setup func */
+				      NULL, /* user data */
+				      NULL, /* child pid */
+				      &error);
+
+	if (!result) {
+		g_printerr ("Cannot launch calendar/tasks application: %s\n",
+			    error->message);
+		g_error_free (error);
+	}
+
+	g_strfreev (argv);
+}
+
+static void
+clock_launch_calendar_app (CalendarWindow *calwin,
+			   const char     *argument)
+{
+	clock_launch_calendar_tasks_app (calwin, KEY_CALENDAR_APP, argument);
+}
+
+static void
+clock_launch_tasks_app (CalendarWindow *calwin,
+			const char     *argument)
+{
+	clock_launch_calendar_tasks_app (calwin, KEY_TASKS_APP, argument);
+}
+
+static void
+update_frame_visibility (GtkWidget    *frame,
+                         GtkTreeModel *model)
+{
+        GtkTreeIter iter;
+        gboolean    model_empty;
+
+        if (!frame)
+                return;
+
+        model_empty = !gtk_tree_model_get_iter_first (model, &iter);
+
+        if (model_empty)
+                gtk_widget_hide (frame);
+        else
+                gtk_widget_show (frame);
+}
+
+enum {
+        APPOINTMENT_COLUMN_UID,
+        APPOINTMENT_COLUMN_URI,
+        APPOINTMENT_COLUMN_SUMMARY,
+        APPOINTMENT_COLUMN_DESCRIPTION,
+        APPOINTMENT_COLUMN_START_TIME,
+        APPOINTMENT_COLUMN_START_TEXT,
+        APPOINTMENT_COLUMN_END_TIME,
+        APPOINTMENT_COLUMN_ALL_DAY,
+        APPOINTMENT_COLUMN_PIXBUF,
+        N_APPOINTMENT_COLUMNS
+};
+
+enum {
+        TASK_COLUMN_UID,
+        TASK_COLUMN_SUMMARY,
+        TASK_COLUMN_DESCRIPTION,
+        TASK_COLUMN_START_TIME,
+        TASK_COLUMN_DUE_TIME,
+        TASK_COLUMN_PERCENT_COMPLETE,
+        TASK_COLUMN_PERCENT_COMPLETE_TEXT,
+        TASK_COLUMN_COMPLETED,
+        TASK_COLUMN_COMPLETED_TIME,
+        TASK_COLUMN_OVERDUE_ATTR,
+        TASK_COLUMN_COLOR,
+        TASK_COLUMN_PRIORITY,
+        N_TASK_COLUMNS
+};
+
+static char *
+format_time (ClockFormat format,
+             time_t      t,
+             guint       year,
+             guint       month,
+             guint       day)
+{
+        struct tm *tm;
+        char      *time_format;
+        char       result [256] = { 0, };
+
+        if (!t)
+                return NULL;
+
+	tm = localtime (&t);
+        if (!tm)
+                return NULL;
+
+        if (year  == (tm->tm_year + 1900) &&
+            month == tm->tm_mon &&
+            day   == tm->tm_mday) {
+                if (format == CLOCK_FORMAT_12)
+			/* Translators: This is a strftime format string.
+			 * It is used to display the time in 12-hours format
+			 * (eg, like in the US: 8:10 am). The %p expands to
+			 * am/pm. */
+                        time_format = g_locale_from_utf8 (_("%l:%M %p"), -1, NULL, NULL, NULL);
+                else
+			/* Translators: This is a strftime format string.
+			 * It is used to display the time in 24-hours format
+			 * (eg, like in France: 20:10). */
+                        time_format = g_locale_from_utf8 (_("%H:%M"), -1, NULL, NULL, NULL);
+        }
+        else {
+		/* Translators: This is a strftime format string.
+		 * It is used to display the start date of an appointment, in
+		 * the most abbreviated way possible. */
+                time_format = g_locale_from_utf8 (_("%b %d"), -1, NULL, NULL, NULL);
+        }
+
+        strftime (result, sizeof (result), time_format, tm);
+        g_free (time_format);
+
+        return g_locale_to_utf8 (result, -1, NULL, NULL, NULL);
+}
+
+static void
+handle_tasks_changed (CalendarWindow *calwin)
+{
+        GSList *events, *l;
+
+        gtk_list_store_clear (calwin->priv->tasks_model);
+
+        events = calendar_client_get_events (calwin->priv->client,
+					     CALENDAR_EVENT_TASK);
+        for (l = events; l; l = l->next) {
+                CalendarTask *task = l->data;
+                GtkTreeIter   iter;
+                char         *percent_complete_text;
+
+                g_assert (CALENDAR_EVENT (task)->type == CALENDAR_EVENT_TASK);
+
+                /* FIXME: should this format be locale specific ? */
+                percent_complete_text = g_strdup_printf ("%d%%", task->percent_complete);
+
+                gtk_list_store_append (calwin->priv->tasks_model, &iter);
+                gtk_list_store_set (calwin->priv->tasks_model, &iter,
+                                    TASK_COLUMN_UID,                   task->uid,
+                                    TASK_COLUMN_SUMMARY,               task->summary,
+                                    TASK_COLUMN_DESCRIPTION,           task->description,
+                                    TASK_COLUMN_START_TIME,            (gint64)task->start_time,
+                                    TASK_COLUMN_DUE_TIME,              (gint64)task->due_time,
+                                    TASK_COLUMN_PERCENT_COMPLETE,      task->percent_complete,
+                                    TASK_COLUMN_PERCENT_COMPLETE_TEXT, percent_complete_text,
+                                    TASK_COLUMN_COMPLETED,             task->percent_complete == 100,
+                                    TASK_COLUMN_COMPLETED_TIME,        (gint64)task->completed_time,
+                                    TASK_COLUMN_COLOR,                 task->color_string,
+                                    TASK_COLUMN_PRIORITY,              task->priority,
+                                    -1);
+
+                g_free (percent_complete_text);
+                calendar_event_free (CALENDAR_EVENT (task));
+        }
+        g_slist_free (events);
+
+        update_frame_visibility (calwin->priv->task_list,
+				 GTK_TREE_MODEL (calwin->priv->tasks_filter));
+}
+
+static void
+handle_task_completed_toggled (CalendarWindow        *calwin,
+                               const char            *path_str,
+                               GtkCellRendererToggle *cell)
+{
+        GtkTreePath *child_path, *path;
+        GtkTreeIter  iter;
+        char        *uid;
+        gboolean     task_completed;
+        guint        percent_complete;
+
+        path       = gtk_tree_path_new_from_string (path_str);
+        child_path = gtk_tree_model_filter_convert_path_to_child_path (calwin->priv->tasks_filter, path);
+        gtk_tree_model_get_iter (GTK_TREE_MODEL (calwin->priv->tasks_model),
+				 &iter, child_path);
+        gtk_tree_model_get (GTK_TREE_MODEL (calwin->priv->tasks_model),
+			    &iter,
+                            TASK_COLUMN_UID,                  &uid,
+                            TASK_COLUMN_COMPLETED,            &task_completed,
+                            TASK_COLUMN_PERCENT_COMPLETE,     &percent_complete,
+                            -1);
+
+        task_completed   = !task_completed;
+        percent_complete = task_completed ? 100 : 0;
+
+        calendar_client_set_task_completed (calwin->priv->client,
+                                            uid,
+                                            task_completed,
+                                            percent_complete);
+
+        g_free (uid);
+        gtk_tree_path_free (path);
+        gtk_tree_path_free (child_path);
+}
+
+static void
+handle_task_percent_complete_edited (CalendarWindow      *calwin,
+                                     const char          *path_str,
+                                     const char          *text,
+                                     GtkCellRendererText *cell)
+{
+        GtkTreePath *child_path, *path;
+        GtkTreeIter  iter;
+        char        *uid;
+        int          percent_complete;
+        char        *error = NULL, *text_copy;
+
+        path       = gtk_tree_path_new_from_string (path_str);
+        child_path = gtk_tree_model_filter_convert_path_to_child_path (calwin->priv->tasks_filter, path);
+        gtk_tree_model_get_iter (GTK_TREE_MODEL (calwin->priv->tasks_model),
+				 &iter, child_path);
+        gtk_tree_model_get (GTK_TREE_MODEL (calwin->priv->tasks_model),
+			    &iter, TASK_COLUMN_UID, &uid,
+                            -1);
+
+        text_copy = g_strdup (text);
+        text_copy = g_strdelimit (text_copy, "%", ' ');
+        text_copy = g_strstrip (text_copy);
+        percent_complete = (int) g_strtod (text_copy, &error);
+        if (!error || !error [0]) {
+                gboolean task_completed;
+
+                percent_complete = CLAMP (percent_complete, 0, 100);
+                task_completed = (percent_complete == 100);
+
+                calendar_client_set_task_completed (calwin->priv->client,
+                                                    uid,
+                                                    task_completed,
+                                                    percent_complete);
+        }
+
+        g_free (uid);
+        g_free (text_copy);
+        gtk_tree_path_free (path);
+        gtk_tree_path_free (child_path);
+}
+
+static gboolean
+is_appointment (GtkTreeModel *model,
+		GtkTreeIter  *iter,
+		gpointer      data)
+{
+	gchar *uri;
+
+	gtk_tree_model_get (model, iter, APPOINTMENT_COLUMN_URI, &uri, -1);
+	if (uri)
+		return (g_ascii_strcasecmp (uri, "file")   == 0 ||
+			g_ascii_strcasecmp (uri, "webcal") == 0 ||
+			g_ascii_strcasecmp (uri, "caldav") == 0 ||
+			g_ascii_strcasecmp (uri, "exchange")  == 0 ||
+			g_ascii_strcasecmp (uri, "groupwise") == 0 ||
+			g_ascii_strcasecmp (uri, "google") == 0);
+	return FALSE;
+}
+
+static gboolean
+is_birthday (GtkTreeModel *model,
+	     GtkTreeIter  *iter,
+	     gpointer      data)
+{
+	gchar *uri;
+
+	gtk_tree_model_get (model, iter, APPOINTMENT_COLUMN_URI, &uri, -1);
+	if (uri)
+		return (g_ascii_strcasecmp (uri, "contacts") == 0);
+	return FALSE;
+}
+
+static gboolean
+is_weather (GtkTreeModel *model,
+	    GtkTreeIter  *iter,
+	    gpointer      data)
+{
+	gchar *uri;
+
+	gtk_tree_model_get (model, iter, APPOINTMENT_COLUMN_URI, &uri, -1);
+	if (uri)
+		return (g_ascii_strcasecmp (uri, "weather") == 0);
+	return FALSE;
+}
+
+static gboolean
+filter_out_tasks (GtkTreeModel   *model,
+                  GtkTreeIter    *iter,
+                  CalendarWindow *calwin)
+{
+        gint64   start_time64;
+        gint64   completed_time64;
+        time_t   start_time;
+        time_t   completed_time;
+        time_t   one_day_ago;
+        gboolean visible;
+
+        gtk_tree_model_get (model, iter,
+                            TASK_COLUMN_START_TIME,     &start_time64,
+                            TASK_COLUMN_COMPLETED_TIME, &completed_time64,
+                            -1);
+        start_time = start_time64;
+        completed_time = completed_time64;
+
+        one_day_ago = *(calwin->priv->current_time) - (24 * 60 * 60);
+
+        visible = !start_time || start_time <= *(calwin->priv->current_time);
+        if (visible)
+                visible = !completed_time || completed_time >= one_day_ago;
+
+        return visible;
+}
+
+static void
+modify_task_text_attributes (GtkTreeModel   *model,
+                             GtkTreeIter    *iter,
+                             GValue         *value,
+                             gint            column,
+                             CalendarWindow *calwin)
+{
+        gint64          due_time64;
+        time_t          due_time;
+        PangoAttrList  *attr_list;
+        PangoAttribute *attr;
+        GtkTreeIter     child_iter;
+
+        gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model),
+                                                          &child_iter,
+                                                          iter);
+
+        if (column != TASK_COLUMN_OVERDUE_ATTR) {
+                memset (value, 0, sizeof (GValue));
+                gtk_tree_model_get_value (GTK_TREE_MODEL (calwin->priv->tasks_model),
+                                          &child_iter, column, value);
+
+                return;
+        }
+
+        gtk_tree_model_get (GTK_TREE_MODEL (calwin->priv->tasks_model),
+			    &child_iter, TASK_COLUMN_DUE_TIME, &due_time64,
+                            -1);
+        due_time = due_time64;
+
+        if (due_time && due_time > *(calwin->priv->current_time))
+                return;
+
+        attr_list = pango_attr_list_new ();
+
+        attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
+        attr->start_index = 0;
+        attr->end_index = G_MAXINT;
+        pango_attr_list_insert (attr_list, attr);
+
+        g_value_take_boxed (value, attr_list);
+}
+
+static gboolean
+task_activated_cb (GtkTreeView       *view,
+                   GtkTreePath       *path,
+                   GtkTreeViewColumn *column,
+                   CalendarWindow    *calwin)
+{
+        GtkTreeIter  iter;
+        GtkTreePath *child_path;
+        char        *uid;
+	char        *argument;
+
+        child_path = gtk_tree_model_filter_convert_path_to_child_path (calwin->priv->tasks_filter,
+								       path);
+
+        gtk_tree_model_get_iter (GTK_TREE_MODEL (calwin->priv->tasks_model),
+				 &iter, child_path);
+        gtk_tree_model_get (GTK_TREE_MODEL (calwin->priv->tasks_model),
+			    &iter, TASK_COLUMN_UID, &uid, -1);
+
+	argument = g_strdup_printf ("task:%s", uid);
+
+	clock_launch_tasks_app (calwin, argument);
+
+	g_free (argument);
+        g_free (uid);
+        gtk_tree_path_free (child_path);
+
+        return TRUE;
+}
+
+static void
+set_renderer_pixbuf_color_by_column (GtkCellRenderer *renderer,
+                                     GtkTreeModel    *model,
+                                     GtkTreeIter     *iter,
+                                     gint             column_number)
+{
+        char      *color_string;
+        GdkPixbuf *pixbuf = NULL;
+        GdkColor   color;
+
+        gtk_tree_model_get (model, iter, column_number, &color_string, -1);
+
+        if (color_string && gdk_color_parse (color_string, &color)) {
+                pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 16, 16);
+                /* GdkColor has 16 bits per color, gdk_pixbuf only uses 8 bits
+                 * per color. So just drop the least significant parts */
+                gdk_pixbuf_fill (pixbuf,
+				 (color.red   & 0xff00) << 16 |
+				 (color.green & 0xff00) << 8  | 
+				 (color.blue  & 0xff00));
+
+                g_object_set (renderer, "visible", pixbuf != NULL, "pixbuf", pixbuf, NULL);
+
+                if (pixbuf)
+                        g_object_unref (pixbuf);
+
+                g_free (color_string);
+        }
+}
+
+static void
+set_renderer_pixbuf_pixmap (GtkCellRenderer *renderer,
+			    GtkTreeModel    *model,
+			    GtkTreeIter     *iter,
+			    const char      *iconpath)
+{
+	GdkPixbuf   *pixbuf = NULL;
+	GError      *error  = NULL;
+
+	if (!g_file_test (iconpath, G_FILE_TEST_IS_REGULAR)) {
+		g_printerr ("File '%s' does not exist.\n", iconpath);
+		return;
+	}
+
+	pixbuf = gdk_pixbuf_new_from_file (iconpath, &error);
+	if (error) {
+		g_printerr ("Cannot load '%s': %s\n",
+			    iconpath, error->message);
+		g_error_free (error);
+		return;
+	}
+
+	g_object_set (renderer,
+		      "visible", pixbuf != NULL,
+		      "pixbuf", pixbuf,
+		      NULL);
+
+	if (pixbuf)
+		g_object_unref (pixbuf);
+}
+
+static void
+set_renderer_pixbuf_pixmap_for_bday (GtkCellRenderer *renderer,
+				     GtkTreeModel    *model,
+				     GtkTreeIter     *iter,
+				     gint             data_column)
+{
+	const gchar *path   = NULL;
+	gchar       *type   = NULL;
+
+	gtk_tree_model_get (model, iter, data_column, &type, -1);
+	if (!type)
+		return;
+
+	/* type should be in format like this:
+	 * pas-id-4121A93E00000001-anniversary
+	 * pas-id-41112AF900000003-birthday
+	 * ...
+	 */
+	if (g_strrstr (type, "birthday") != NULL)
+		path = CLOCK_EDS_ICONDIR G_DIR_SEPARATOR_S "category_birthday_16.png";
+	else if (g_strrstr (type, "anniversary") != NULL)
+		path = CLOCK_EDS_ICONDIR G_DIR_SEPARATOR_S "category_gifts_16.png";
+	else
+		path = CLOCK_EDS_ICONDIR G_DIR_SEPARATOR_S "category_miscellaneous_16.png";
+
+	g_free (type);
+
+	set_renderer_pixbuf_pixmap (renderer, model, iter, path);
+}
+
+static void
+set_renderer_pixbuf_pixmap_for_weather (GtkCellRenderer *renderer,
+					GtkTreeModel    *model,
+					GtkTreeIter     *iter)
+{
+	set_renderer_pixbuf_pixmap (renderer, model, iter,
+				    CLOCK_EDS_ICONDIR G_DIR_SEPARATOR_S "category_holiday_16.png");
+}
+
+static void
+task_pixbuf_cell_data_func (GtkTreeViewColumn *column,
+                            GtkCellRenderer   *renderer,
+                            GtkTreeModel      *model,
+                            GtkTreeIter       *iter,
+                            gpointer           data)
+{
+        set_renderer_pixbuf_color_by_column (renderer,
+                                             model,
+                                             iter,
+                                             TASK_COLUMN_COLOR);
+}
+
+static void
+appointment_pixbuf_cell_data_func (GtkTreeViewColumn *column,
+                                   GtkCellRenderer   *renderer,
+                                   GtkTreeModel      *model,
+                                   GtkTreeIter       *iter,
+                                   gpointer           data)
+{
+        set_renderer_pixbuf_color_by_column (renderer,
+                                             model,
+                                             iter,
+                                             APPOINTMENT_COLUMN_PIXBUF);
+}
+static void
+birthday_pixbuf_cell_data_func (GtkTreeViewColumn   *column,
+				GtkCellRenderer     *renderer,
+				GtkTreeModel        *model,
+				GtkTreeIter         *iter,
+				gpointer             data)
+{
+
+	/* APPOINTMENT_COLUMN_UID contains data to select between
+	 * anniversary or birthday
+	 */
+	set_renderer_pixbuf_pixmap_for_bday (renderer,
+					     model,
+					     iter,
+					     APPOINTMENT_COLUMN_UID);
+}
+static void
+weather_pixbuf_cell_data_func (GtkTreeViewColumn   *column,
+			       GtkCellRenderer     *renderer,
+			       GtkTreeModel        *model,
+			       GtkTreeIter         *iter,
+			       gpointer             data)
+{
+
+	set_renderer_pixbuf_pixmap_for_weather (renderer,
+						model,
+						iter);
+}
+
+static int
+compare_tasks  (GtkTreeModel *model,
+                GtkTreeIter  *a,
+                GtkTreeIter  *b,
+                gpointer      user_data)
+{
+        gboolean done_a, done_b;
+        int priority_a, priority_b;
+
+        gtk_tree_model_get (model, a,
+                            TASK_COLUMN_COMPLETED, &done_a,
+                            TASK_COLUMN_PRIORITY, &priority_a,
+                            -1);
+        gtk_tree_model_get (model, b,
+                            TASK_COLUMN_COMPLETED, &done_b,
+                            TASK_COLUMN_PRIORITY, &priority_b,
+                            -1);
+
+        /* Always sort completed tasks last */
+        if (done_a != done_b)
+                return done_a ? -1 : 1;
+
+        /* We change undefined priorities so they appear as "Normal" */
+        if (priority_a <= 0)
+                priority_a = 5;
+        if (priority_b <= 0)
+                priority_b = 5;
+
+	/* We'll just use the ordering of the priority values. */
+	if (priority_a < priority_b)
+		return -1;
+	else if (priority_a > priority_b)
+		return 1;
+	else {
+                gint64 due_time_a64, due_time_b64;
+                time_t due_time_a, due_time_b;
+
+                gtk_tree_model_get (model, a,
+				    TASK_COLUMN_DUE_TIME, &due_time_a64, -1);
+                gtk_tree_model_get (model, b,
+				    TASK_COLUMN_DUE_TIME, &due_time_b64, -1);
+                due_time_a = due_time_a64;
+                due_time_b = due_time_b64;
+
+                if (due_time_a < due_time_b)
+                        return -1;
+                else if (due_time_a > due_time_b)
+                        return 1;
+                else {
+                        char *summary_a, *summary_b;
+                        int res;
+
+                        gtk_tree_model_get (model, a, TASK_COLUMN_SUMMARY, &summary_a, -1);
+                        gtk_tree_model_get (model, b, TASK_COLUMN_SUMMARY, &summary_b, -1);
+
+                        res = g_utf8_collate (summary_a ? summary_a: "",
+                                              summary_b ? summary_b: "");
+
+                        g_free (summary_a);
+                        g_free (summary_b);
+
+                        return res;
+                }
+        }
+}
+
+static void
+calendar_window_tree_selection_changed (GtkTreeSelection *selection,
+					CalendarWindow   *calwin)
+{
+	if (selection == calwin->priv->previous_selection)
+		return;
+
+	if (calwin->priv->previous_selection) {
+		g_signal_handlers_block_by_func (calwin->priv->previous_selection,
+						 calendar_window_tree_selection_changed,
+						 calwin);
+		gtk_tree_selection_unselect_all (calwin->priv->previous_selection);
+		g_signal_handlers_unblock_by_func (calwin->priv->previous_selection,
+						   calendar_window_tree_selection_changed,
+						   calwin);
+	}
+
+	calwin->priv->previous_selection = selection;
+}
+
+static void
+edit_tasks (CalendarWindow *calwin)
+{
+	clock_launch_tasks_app (calwin, NULL);
+}
+
+static GtkWidget *
+create_task_list (CalendarWindow *calwin,
+                  GtkWidget     **tree_view,
+                  GtkWidget     **scrolled_window)
+{
+        GtkWidget         *list;
+        GtkWidget         *view;
+        GtkWidget         *scrolled;
+        GtkCellRenderer   *cell;
+        GtkTreeViewColumn *column;
+        GtkTreeSelection  *selection;
+
+	list = create_hig_frame (calwin, 
+                                 _("Tasks"), _("Edit"),
+                                 KEY_TASKS_EXPANDED,
+                                 G_CALLBACK (edit_tasks)); 
+ 
+        *scrolled_window = scrolled = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+                                             GTK_SHADOW_IN);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+                                        GTK_POLICY_NEVER,
+                                        GTK_POLICY_AUTOMATIC);
+	/* we show the widget before adding to the container, since adding to
+	 * the container changes the visibility depending on the state of the
+	 * expander */
+        gtk_widget_show (scrolled);
+        gtk_container_add (GTK_CONTAINER (list), scrolled);
+
+        g_assert (calwin->priv->tasks_model != NULL);
+
+        *tree_view = view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (calwin->priv->tasks_filter));
+        gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
+
+        g_signal_connect (view, "row-activated",
+                          G_CALLBACK (task_activated_cb), calwin);
+
+        /* Source color */
+        column = gtk_tree_view_column_new ();
+        cell = gtk_cell_renderer_pixbuf_new ();
+        gtk_tree_view_column_pack_start (column, cell, TRUE);
+        gtk_tree_view_column_set_cell_data_func (column, cell,
+                                                 (GtkTreeCellDataFunc) task_pixbuf_cell_data_func,
+                                                 NULL, NULL);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+
+        /* Completed toggle */
+        column = gtk_tree_view_column_new ();
+        cell = gtk_cell_renderer_toggle_new ();
+        g_object_set (cell,
+                      "activatable", TRUE,
+                      NULL);
+        g_signal_connect_swapped (cell, "toggled",
+                                  G_CALLBACK (handle_task_completed_toggled),
+				  calwin);
+        gtk_tree_view_column_pack_start (column, cell, TRUE);
+        gtk_tree_view_column_add_attribute (column, cell,
+                                            "active", TASK_COLUMN_COMPLETED);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+
+        /* Percent complete */
+        column = gtk_tree_view_column_new ();
+        cell = gtk_cell_renderer_text_new ();
+        g_object_set (cell,
+                      "editable", TRUE,
+                      NULL);
+        g_signal_connect_swapped (cell, "edited",
+                                  G_CALLBACK (handle_task_percent_complete_edited),
+				  calwin);
+        gtk_tree_view_column_pack_start (column, cell, TRUE);
+        gtk_tree_view_column_add_attribute (column, cell,
+                                            "text", TASK_COLUMN_PERCENT_COMPLETE_TEXT);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+
+        /* Summary */
+        column = gtk_tree_view_column_new ();
+        cell = gtk_cell_renderer_text_new ();
+        g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+        gtk_tree_view_column_pack_start (column, cell, TRUE);
+        gtk_tree_view_column_set_attributes (column, cell,
+                                             "text", TASK_COLUMN_SUMMARY,
+                                             "strikethrough", TASK_COLUMN_COMPLETED,
+                                             "attributes", TASK_COLUMN_OVERDUE_ATTR,
+                                             NULL);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
+	g_signal_connect (selection, "changed",
+			  G_CALLBACK (calendar_window_tree_selection_changed),
+			  calwin);
+
+        gtk_container_add (GTK_CONTAINER (scrolled), view);
+
+        gtk_widget_show (view);
+
+        return list;
+}
+
+static void
+mark_day_on_calendar (CalendarClient *client,
+		      guint           day,
+		      CalendarWindow *calwin)
+{
+        gtk_calendar_mark_day (GTK_CALENDAR (calwin->priv->calendar), day);
+}
+
+static void
+handle_appointments_changed (CalendarWindow *calwin)
+{
+        GSList *events, *l;
+        guint   year, month, day;
+
+        if (calwin->priv->calendar) {
+                gtk_calendar_clear_marks (GTK_CALENDAR (calwin->priv->calendar));
+
+                calendar_client_foreach_appointment_day (calwin->priv->client,
+                                                         (CalendarDayIter) mark_day_on_calendar,
+                                                         calwin);
+        }
+
+        gtk_list_store_clear (calwin->priv->appointments_model);
+
+        calendar_client_get_date (calwin->priv->client, &year, &month, &day);
+
+        events = calendar_client_get_events (calwin->priv->client,
+					     CALENDAR_EVENT_APPOINTMENT);
+        for (l = events; l; l = l->next) {
+                CalendarAppointment *appointment = l->data;
+                GtkTreeIter          iter;
+                char                *start_text;
+
+                g_assert (CALENDAR_EVENT (appointment)->type == CALENDAR_EVENT_APPOINTMENT);
+
+                if (appointment->is_all_day)
+                        start_text = g_strdup (_("All Day"));
+                else
+                        start_text = format_time (calwin->priv->time_format,
+                                                  appointment->start_time,
+                                                  year, month, day);
+
+
+                gtk_list_store_append (calwin->priv->appointments_model,
+				       &iter);
+                gtk_list_store_set (calwin->priv->appointments_model, &iter,
+                                    APPOINTMENT_COLUMN_UID,         appointment->uid,
+                                    APPOINTMENT_COLUMN_URI,         appointment->uri,
+                                    APPOINTMENT_COLUMN_SUMMARY,     appointment->summary,
+                                    APPOINTMENT_COLUMN_DESCRIPTION, appointment->description,
+                                    APPOINTMENT_COLUMN_START_TIME,  (gint64)appointment->start_time,
+                                    APPOINTMENT_COLUMN_START_TEXT,  start_text,
+                                    APPOINTMENT_COLUMN_END_TIME,    (gint64)appointment->end_time,
+                                    APPOINTMENT_COLUMN_ALL_DAY,     appointment->is_all_day,
+                                    APPOINTMENT_COLUMN_PIXBUF,      appointment->color_string,
+                                    -1);
+
+                g_free (start_text);
+                calendar_event_free (CALENDAR_EVENT (appointment));
+        }
+        g_slist_free (events);
+
+        update_frame_visibility (calwin->priv->appointment_list,
+				 GTK_TREE_MODEL (calwin->priv->appointments_filter));
+        update_frame_visibility (calwin->priv->birthday_list,
+				 GTK_TREE_MODEL (calwin->priv->birthdays_filter));
+        update_frame_visibility (calwin->priv->weather_list,
+				 GTK_TREE_MODEL (calwin->priv->weather_filter));
+}
+
+static GtkWidget *
+create_list_for_appointment_model (CalendarWindow      *calwin,
+				   const char          *label,
+				   GtkTreeModelFilter **filter,
+				   GtkTreeModelFilterVisibleFunc is_for_filter,
+				   GtkTreeCellDataFunc  set_pixbuf_cell,
+				   gboolean             show_start,
+				   GtkWidget          **tree_view,
+				   GtkWidget          **scrolled_window,
+				   const char          *key,
+                                   GCallback            callback)
+{
+        GtkWidget         *list;
+        GtkWidget         *view;
+        GtkWidget         *scrolled;
+        GtkCellRenderer   *cell;
+        GtkTreeViewColumn *column;
+	GtkTreeSelection  *selection;
+
+	
+	list = create_hig_frame (calwin, label, _("Edit"), key, callback);
+
+        *scrolled_window = scrolled = gtk_scrolled_window_new (NULL, NULL);
+        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
+                                             GTK_SHADOW_IN);
+        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
+                                        GTK_POLICY_NEVER,
+                                        GTK_POLICY_AUTOMATIC);
+	/* we show the widget before adding to the container, since adding to
+	 * the container changes the visibility depending on the state of the
+	 * expander */
+        gtk_widget_show (scrolled);
+        gtk_container_add (GTK_CONTAINER (list), scrolled);
+
+	g_assert (calwin->priv->appointments_model != NULL);
+
+        if (!*filter) {
+		*filter =
+			GTK_TREE_MODEL_FILTER (
+				gtk_tree_model_filter_new (GTK_TREE_MODEL (calwin->priv->appointments_model),
+							   NULL));
+		gtk_tree_model_filter_set_visible_func (
+				*filter,
+				(GtkTreeModelFilterVisibleFunc) is_for_filter,
+				calwin,
+				NULL);
+        }
+
+        *tree_view = view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (*filter));
+        gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
+
+        /* Icon */
+        column = gtk_tree_view_column_new ();
+        cell = gtk_cell_renderer_pixbuf_new ();
+        gtk_tree_view_column_pack_start (column, cell, TRUE);
+        gtk_tree_view_column_set_cell_data_func (column, cell,
+                                                 (GtkTreeCellDataFunc) set_pixbuf_cell,
+                                                 NULL, NULL);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+
+	if (show_start) {
+		/* Start time */
+		column = gtk_tree_view_column_new ();
+		cell = gtk_cell_renderer_text_new ();
+		gtk_tree_view_column_pack_start (column, cell, TRUE);
+		gtk_tree_view_column_add_attribute (column, cell,
+						    "text", APPOINTMENT_COLUMN_START_TEXT);
+		gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+	}
+
+        /* Summary */
+        column = gtk_tree_view_column_new ();
+        cell = gtk_cell_renderer_text_new ();
+        g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+        gtk_tree_view_column_pack_start (column, cell, TRUE);
+        gtk_tree_view_column_add_attribute (column, cell,
+                                            "text", APPOINTMENT_COLUMN_SUMMARY);
+        gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
+
+	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
+	g_signal_connect (selection, "changed",
+			  G_CALLBACK (calendar_window_tree_selection_changed),
+			  calwin);
+
+        gtk_container_add (GTK_CONTAINER (scrolled), view);
+
+        gtk_widget_show (view);
+
+        return list;
+}
+
+static void
+edit_appointments (CalendarWindow *calwin)
+{
+	clock_launch_calendar_app (calwin, NULL);
+}
+
+static GtkWidget *
+create_appointment_list (CalendarWindow  *calwin,
+			 GtkWidget      **tree_view,
+			 GtkWidget      **scrolled_window)
+{
+	return create_list_for_appointment_model (
+					calwin,
+					_("Appointments"),
+					&calwin->priv->appointments_filter,
+					is_appointment,
+					appointment_pixbuf_cell_data_func,
+					TRUE,
+					tree_view,
+					scrolled_window,
+				        KEY_APPOINTMENTS_EXPANDED,
+					G_CALLBACK (edit_appointments));
+}
+
+static void
+edit_birthdays (CalendarWindow *calwin)
+{
+	clock_launch_calendar_app (calwin, NULL);
+}
+
+static GtkWidget *
+create_birthday_list (CalendarWindow  *calwin,
+		      GtkWidget      **tree_view,
+		      GtkWidget      **scrolled_window)
+{
+        /* FIXME: Figure out how to get rid of useless localized message in front of the summary */
+	return create_list_for_appointment_model (
+					calwin,
+					_("Birthdays and Anniversaries"),
+					&calwin->priv->birthdays_filter,
+					is_birthday,
+					birthday_pixbuf_cell_data_func,
+					FALSE,
+					tree_view,
+					scrolled_window,
+					KEY_BIRTHDAYS_EXPANDED,
+					G_CALLBACK (edit_birthdays));
+}
+
+static void
+edit_weather (CalendarWindow *calwin)
+{
+	clock_launch_calendar_app (calwin, NULL);
+}
+
+
+static GtkWidget *
+create_weather_list (CalendarWindow  *calwin,
+		     GtkWidget      **tree_view,
+		     GtkWidget      **scrolled_window)
+{
+	return create_list_for_appointment_model (
+					calwin,
+					_("Weather Information"),
+					&calwin->priv->weather_filter,
+					is_weather,
+					weather_pixbuf_cell_data_func,
+					FALSE,
+					tree_view,
+					scrolled_window,
+					KEY_WEATHER_EXPANDED,
+					G_CALLBACK (edit_weather));
+}
+
+static void
+calendar_window_create_tasks_model (CalendarWindow *calwin)
+{
+	GType column_types [N_TASK_COLUMNS] = {
+		G_TYPE_STRING,         /* uid                     */
+		G_TYPE_STRING,         /* summary                 */
+		G_TYPE_STRING,         /* description             */
+		G_TYPE_INT64,          /* start time              */
+		G_TYPE_INT64,          /* due time                */
+		G_TYPE_UINT,           /* percent complete        */
+		G_TYPE_STRING,         /* percent complete text   */
+		G_TYPE_BOOLEAN,        /* completed               */
+		G_TYPE_INT64,          /* completed time          */
+		PANGO_TYPE_ATTR_LIST,  /* summary text attributes */
+		G_TYPE_STRING,         /* color                   */
+		G_TYPE_INT             /* priority                */
+	};
+
+	calwin->priv->tasks_model = gtk_list_store_newv (N_TASK_COLUMNS,
+							 column_types);
+
+	gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (calwin->priv->tasks_model),
+					 TASK_COLUMN_PRIORITY,
+					 compare_tasks,
+					 NULL, NULL);
+
+	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (calwin->priv->tasks_model),
+					      TASK_COLUMN_PRIORITY,
+					      GTK_SORT_ASCENDING);
+
+	calwin->priv->tasks_filter = GTK_TREE_MODEL_FILTER (
+		gtk_tree_model_filter_new (GTK_TREE_MODEL (calwin->priv->tasks_model),
+					   NULL));
+	gtk_tree_model_filter_set_visible_func (
+		 calwin->priv->tasks_filter,
+		 (GtkTreeModelFilterVisibleFunc) filter_out_tasks,
+		 calwin,
+		 NULL);
+	gtk_tree_model_filter_set_modify_func (
+		 calwin->priv->tasks_filter,
+		 N_TASK_COLUMNS,
+		 column_types,
+		 (GtkTreeModelFilterModifyFunc) modify_task_text_attributes,
+		 calwin,
+		 NULL);
+}
+
+static void
+calendar_window_create_appointments_model (CalendarWindow *calwin)
+{
+	calwin->priv->appointments_model =
+		gtk_list_store_new (N_APPOINTMENT_COLUMNS,
+				    G_TYPE_STRING,   /* uid              */
+				    G_TYPE_STRING,   /* uri              */
+				    G_TYPE_STRING,   /* summary          */
+				    G_TYPE_STRING,   /* description      */
+				    G_TYPE_INT64,    /* start time       */
+				    G_TYPE_STRING,   /* start time text  */
+				    G_TYPE_INT64,    /* end time         */
+				    G_TYPE_BOOLEAN,  /* all day          */
+				    G_TYPE_STRING);  /* color            */
+
+	gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (calwin->priv->appointments_model),
+					      APPOINTMENT_COLUMN_START_TIME,
+					      GTK_SORT_ASCENDING);
+}
+
+static void
+calendar_day_activated (GtkCalendar    *calendar,
+			CalendarWindow *calwin)
+{
+	unsigned int  day;
+	unsigned int  month;
+	unsigned int  year;
+	time_t        date;
+	struct tm     utc_date_tm;
+	struct tm     local_date_tm = { 0, };
+	char         *argument;
+
+	gtk_calendar_get_date (calendar, &year, &month, &day);
+
+	local_date_tm.tm_mday  = (int) day;
+	local_date_tm.tm_mon   = (int) month;
+	local_date_tm.tm_year  = (int) year - 1900;
+	local_date_tm.tm_isdst = -1;
+
+	/* convert the local date picked in the calendar to broken-down UTC */
+	date = mktime (&local_date_tm);
+	gmtime_r (&date, &utc_date_tm);
+
+	/* FIXME: once bug 409200 is fixed, we'll have to make this hh:mm:ss
+	 * instead of hhmmss */
+	argument = g_strdup_printf ("calendar:///?startdate="
+				    "%.4d%.2d%.2dT%.2d%.2d%.2dZ",
+				    utc_date_tm.tm_year + 1900,
+				    utc_date_tm.tm_mon + 1,
+				    utc_date_tm.tm_mday,
+				    utc_date_tm.tm_hour,
+				    utc_date_tm.tm_min,
+				    0);
+
+	clock_launch_calendar_app (calwin, argument);
+
+	g_free (argument);
+}
+
+static void
+calendar_day_selected (GtkCalendar    *calendar,
+		       CalendarWindow *calwin)
+{
+        guint day;
+
+        gtk_calendar_get_date (calendar, NULL, NULL, &day);
+
+        calendar_client_select_day (calwin->priv->client, day);
+
+        handle_appointments_changed (calwin);
+        handle_tasks_changed (calwin);
+}
+
+static void
+calendar_month_selected (GtkCalendar    *calendar,
+			 CalendarWindow *calwin)
+{
+        guint year, month;
+
+        gtk_calendar_get_date (calendar, &year, &month, NULL);
+
+        calendar_client_select_month (calwin->priv->client, month, year);
+
+        handle_appointments_changed (calwin);
+        handle_tasks_changed (calwin);
+}
+
+typedef struct
+{
+        GtkWidget *calendar;
+        GtkWidget *tree;
+} ConstraintData;
+
+static void
+constrain_list_size (GtkWidget      *widget,
+                     GtkRequisition *requisition,
+                     ConstraintData *constraint)
+{
+        GtkRequisition req;
+        int            screen_h;
+        int            max_height;
+
+        /* constrain width to the calendar width */
+        gtk_widget_size_request (constraint->calendar, &req);
+        requisition->width = MIN (requisition->width, req.width);
+
+	screen_h = gdk_screen_get_height (gtk_widget_get_screen (widget));
+        /* constrain height to be the tree height up to a max */
+        max_height = (screen_h - req.height) / 3;
+        gtk_widget_size_request (constraint->tree, &req);
+
+        requisition->height = MIN (req.height, max_height);
+        requisition->height += 2 * gtk_widget_get_style (widget)->ythickness;
+}
+
+static void
+setup_list_size_constraint (GtkWidget *widget,
+                            GtkWidget *calendar,
+                            GtkWidget *tree)
+{
+        ConstraintData *constraint;
+
+        constraint           = g_new0 (ConstraintData, 1);
+        constraint->calendar = calendar;
+        constraint->tree     = tree;
+
+        g_signal_connect_data (widget, "size-request",
+                               G_CALLBACK (constrain_list_size), constraint,
+                               (GClosureNotify) g_free, 0);
+}
+
+static void
+expander_activated (GtkExpander    *expander,
+		    CalendarWindow *calwin)
+{
+	const char *key;
+
+	key = (const gchar*)g_object_get_data (G_OBJECT (expander), "mateconf-key");
+
+	if (mateconf_client_key_is_writable (calwin->priv->mateconfclient,
+					  key, NULL)) {
+		mateconf_client_set_bool (calwin->priv->mateconfclient, key,
+				       gtk_expander_get_expanded (expander),
+				       NULL);
+	}
+}
+
+static void
+expanded_changed (MateConfClient  *client,
+		  guint         cnxn_id,
+		  MateConfEntry   *entry,
+		  GtkExpander  *expander)
+{
+	gboolean value;
+
+	if (!entry->value || entry->value->type != MATECONF_VALUE_BOOL)
+		return;
+
+	value = mateconf_value_get_bool (entry->value);
+
+	gtk_expander_set_expanded (expander, value);
+}
+
+static void
+remove_listener (gpointer data)
+{
+	MateConfClient *client;
+
+	client = mateconf_client_get_default ();
+	mateconf_client_notify_remove (client, GPOINTER_TO_UINT (data));
+	g_object_unref (client);
+}
+
+static void
+connect_expander_with_mateconf (CalendarWindow *calwin,
+			     GtkWidget      *expander,
+			     const char     *relative_key)
+{
+	char     *key;
+	gboolean  expanded;
+	guint      listener;
+
+	key = g_strdup_printf ("%s/%s",
+			       calwin->priv->prefs_dir, relative_key);
+
+	g_object_set_data_full (G_OBJECT (expander), "mateconf-key", (gpointer)key, g_free);
+
+	expanded = mateconf_client_get_bool (calwin->priv->mateconfclient, key,
+					  NULL);
+	gtk_expander_set_expanded (GTK_EXPANDER (expander), expanded);
+
+	g_signal_connect_after (expander, "activate",
+				G_CALLBACK (expander_activated),
+				calwin);
+
+	listener = mateconf_client_notify_add (
+				calwin->priv->mateconfclient, key,
+				(MateConfClientNotifyFunc) expanded_changed,
+				expander, NULL, NULL);
+
+        g_object_set_data_full (G_OBJECT (expander), "listener-id",
+                                GUINT_TO_POINTER (listener), remove_listener);
+}
+#endif /* HAVE_LIBECAL */
+
+static void
+calendar_window_pack_pim (CalendarWindow *calwin,
+			  GtkWidget      *vbox)
+{
+#ifdef HAVE_LIBECAL
+	GtkWidget *list;
+        GtkWidget *tree_view;
+        GtkWidget *scrolled_window;
+        guint      year, month, day;
+
+	calendar_window_create_tasks_model (calwin);
+	calendar_window_create_appointments_model (calwin);
+
+        list = create_task_list (calwin, &tree_view, &scrolled_window);
+        setup_list_size_constraint (scrolled_window,
+				    calwin->priv->calendar, tree_view);
+        update_frame_visibility (list,
+				 GTK_TREE_MODEL (calwin->priv->tasks_model));
+        calwin->priv->task_list = list;
+
+	list = create_birthday_list (calwin, &tree_view, &scrolled_window);
+        setup_list_size_constraint (scrolled_window,
+				    calwin->priv->calendar, tree_view);
+        update_frame_visibility (list,
+				 GTK_TREE_MODEL (calwin->priv->birthdays_filter));
+        calwin->priv->birthday_list = list;
+
+        list = create_weather_list (calwin, &tree_view, &scrolled_window);
+        setup_list_size_constraint (scrolled_window,
+				    calwin->priv->calendar, tree_view);
+        update_frame_visibility (list,
+				 GTK_TREE_MODEL (calwin->priv->weather_filter));
+	calwin->priv->weather_list = list;
+
+        list = create_appointment_list (calwin, &tree_view, &scrolled_window);
+        setup_list_size_constraint (scrolled_window,
+				    calwin->priv->calendar, tree_view);
+        update_frame_visibility (list,
+				 GTK_TREE_MODEL (calwin->priv->appointments_filter));
+	calwin->priv->appointment_list = list;
+
+	if (!calwin->priv->invert_order) {
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->task_list,
+				    TRUE, TRUE, 0);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->appointment_list,
+				    TRUE, TRUE, 0);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->birthday_list,
+				    TRUE, TRUE, 0);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->weather_list,
+				    TRUE, TRUE, 0);
+	} else {
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->weather_list,
+				    TRUE, TRUE, 0);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->birthday_list,
+				    TRUE, TRUE, 0);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->appointment_list,
+				    TRUE, TRUE, 0);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->task_list,
+				    TRUE, TRUE, 0);
+        }
+
+        if (!calwin->priv->client) {
+                calwin->priv->client = calendar_client_new ();
+
+                g_signal_connect_swapped (calwin->priv->client,
+					  "tasks-changed",
+                                          G_CALLBACK (handle_tasks_changed),
+					  calwin);
+                g_signal_connect_swapped (calwin->priv->client,
+					  "appointments-changed",
+                                          G_CALLBACK (handle_appointments_changed),
+					  calwin);
+        }
+
+        gtk_calendar_get_date (GTK_CALENDAR (calwin->priv->calendar),
+			       &year, &month, &day);
+
+        calendar_client_select_day   (calwin->priv->client, day);
+        calendar_client_select_month (calwin->priv->client, month, year);
+
+        handle_tasks_changed (calwin);
+        handle_appointments_changed (calwin);
+
+        g_signal_connect (calwin->priv->calendar,
+			  "day-selected-double-click",
+			  G_CALLBACK (calendar_day_activated),
+			  calwin);
+        g_signal_connect (calwin->priv->calendar,
+			  "day-selected",
+			  G_CALLBACK (calendar_day_selected),
+			  calwin);
+        g_signal_connect (calwin->priv->calendar,
+			  "month-changed",
+			  G_CALLBACK (calendar_month_selected),
+			  calwin);
+#endif /* HAVE_LIBECAL */
+}
+
+static GtkWidget *
+calendar_window_create_calendar (CalendarWindow *calwin)
+{
+	GtkWidget                 *calendar;
+	GtkCalendarDisplayOptions  options;
+        struct tm                 *tm;
+
+	calendar = gtk_calendar_new ();
+	options = gtk_calendar_get_display_options (GTK_CALENDAR (calendar));
+	if (calwin->priv->show_weeks)
+		options |= GTK_CALENDAR_SHOW_WEEK_NUMBERS;
+	else
+		options &= ~(GTK_CALENDAR_SHOW_WEEK_NUMBERS);
+	gtk_calendar_set_display_options (GTK_CALENDAR (calendar), options);
+
+	tm = localtime (calwin->priv->current_time);
+
+        gtk_calendar_select_month (GTK_CALENDAR (calendar),
+                                   tm->tm_mon,
+                                   tm->tm_year + 1900);
+        gtk_calendar_select_day (GTK_CALENDAR (calendar), tm->tm_mday);
+
+	return calendar;
+}
+
+static void
+expand_collapse_child (GtkWidget *child,
+		       gpointer   data)
+{
+	gboolean expanded;
+
+	if (data == child || gtk_widget_is_ancestor (data, child))
+		return;
+
+	expanded = gtk_expander_get_expanded (GTK_EXPANDER (data));
+	g_object_set (child, "visible", expanded, NULL);
+}
+
+static void
+expand_collapse (GtkWidget  *expander,
+		 GParamSpec *pspec,
+                 gpointer    data)
+{
+	GtkWidget *box = data;
+
+	gtk_container_foreach (GTK_CONTAINER (box),
+			       (GtkCallback)expand_collapse_child,
+			       expander);
+}
+
+static void add_child (GtkContainer *container,
+                       GtkWidget    *child,
+                       GtkExpander  *expander)
+{
+	expand_collapse_child (child, expander);
+}
+
+static GtkWidget *
+create_hig_frame (CalendarWindow *calwin,
+		  const char *title,
+                  const char *button_label,
+		  const char *key,
+                  GCallback   callback)
+{
+        GtkWidget *vbox;
+        GtkWidget *alignment;
+        GtkWidget *label;
+        GtkWidget *hbox;
+        GtkWidget *button;
+        char      *bold_title;
+	char      *text;
+        GtkWidget *expander;
+
+        vbox = gtk_vbox_new (FALSE, 6);
+
+        bold_title = g_strdup_printf ("<b>%s</b>", title);
+	expander = gtk_expander_new (bold_title);
+        g_free (bold_title);
+	gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
+
+	hbox = gtk_hbox_new (FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+        gtk_box_pack_start (GTK_BOX (hbox), expander, FALSE, FALSE, 0);
+	gtk_widget_show_all (vbox);
+
+	g_signal_connect (expander, "notify::expanded",
+			  G_CALLBACK (expand_collapse), hbox);
+	g_signal_connect (expander, "notify::expanded",
+			  G_CALLBACK (expand_collapse), vbox);
+
+	/* FIXME: this doesn't really work, since "add" does not 
+	 * get emitted for e.g. gtk_box_pack_start
+	 */
+	g_signal_connect (vbox, "add", G_CALLBACK (add_child), expander);
+	g_signal_connect (hbox, "add", G_CALLBACK (add_child), expander);
+
+        if (button_label) {
+                button = gtk_button_new ();
+                text = g_markup_printf_escaped ("<small>%s</small>", button_label);
+                label = gtk_label_new (text);
+                g_free (text);
+                gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+                gtk_container_add (GTK_CONTAINER (button), label);
+
+		alignment = gtk_alignment_new (1, 0, 0, 0);
+                gtk_container_add (GTK_CONTAINER (alignment), button);
+        	gtk_widget_show_all (alignment);
+
+                gtk_container_add (GTK_CONTAINER (hbox), alignment);
+
+                g_signal_connect_swapped (button, "clicked", callback, calwin);
+        }
+
+#ifdef HAVE_LIBECAL
+	connect_expander_with_mateconf (calwin, expander, key);
+#endif
+
+        return vbox;
+}
+
+static void
+edit_locations (CalendarWindow *calwin)
+{
+	g_signal_emit (calwin, signals[EDIT_LOCATIONS], 0);
+}
+
+static void
+calendar_window_pack_locations (CalendarWindow *calwin, GtkWidget *vbox)
+{
+	calwin->priv->locations_list = create_hig_frame (calwin,
+							 _("Locations"), _("Edit"),
+							 KEY_LOCATIONS_EXPANDED,
+							 G_CALLBACK (edit_locations));
+
+	/* we show the widget before adding to the container, since adding to
+	 * the container changes the visibility depending on the state of the
+	 * expander */
+	gtk_widget_show (calwin->priv->locations_list);
+	gtk_container_add (GTK_CONTAINER (vbox), calwin->priv->locations_list);
+
+	//gtk_box_pack_start (GTK_BOX (vbox), calwin->priv->locations_list, TRUE, FALSE, 0);
+}
+
+static void
+calendar_window_fill (CalendarWindow *calwin)
+{
+        GtkWidget *frame;
+        GtkWidget *vbox;
+
+        frame = gtk_frame_new (NULL);
+        gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
+        gtk_container_add (GTK_CONTAINER (calwin), frame);
+        gtk_widget_show (frame);
+
+        vbox = gtk_vbox_new (FALSE, 6);
+        gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
+        gtk_container_add (GTK_CONTAINER (frame), vbox);
+        gtk_widget_show (vbox);
+
+	calwin->priv->calendar = calendar_window_create_calendar (calwin);
+        gtk_widget_show (calwin->priv->calendar);
+
+	if (!calwin->priv->invert_order) {
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->calendar, TRUE, FALSE, 0);
+                calendar_window_pack_pim (calwin, vbox);
+		calendar_window_pack_locations (calwin, vbox);
+	} else {
+		calendar_window_pack_locations (calwin, vbox);
+                calendar_window_pack_pim (calwin, vbox);
+                gtk_box_pack_start (GTK_BOX (vbox),
+				    calwin->priv->calendar, TRUE, FALSE, 0);
+	}
+}
+
+GtkWidget *
+calendar_window_get_locations_box (CalendarWindow *calwin)
+{
+	return calwin->priv->locations_list;
+}
+
+static GObject *
+calendar_window_constructor (GType                  type,
+			     guint                  n_construct_properties,
+			     GObjectConstructParam *construct_properties)
+{
+	GObject        *obj;
+	CalendarWindow *calwin;
+
+	obj = G_OBJECT_CLASS (calendar_window_parent_class)->constructor (type,
+									  n_construct_properties,
+									  construct_properties);
+
+	calwin = CALENDAR_WINDOW (obj);
+
+	g_assert (calwin->priv->current_time != NULL);
+	g_assert (calwin->priv->prefs_dir != NULL);
+
+	calendar_window_fill (calwin);
+
+	return obj;
+}
+
+static void
+calendar_window_get_property (GObject    *object,
+			      guint       prop_id,
+			      GValue     *value,
+			      GParamSpec *pspec)
+{
+	CalendarWindow *calwin;
+
+	g_return_if_fail (CALENDAR_IS_WINDOW (object));
+
+	calwin = CALENDAR_WINDOW (object);
+
+	switch (prop_id) {
+	case PROP_INVERTORDER:
+		g_value_set_boolean (value,
+				     calendar_window_get_invert_order (calwin));
+		break;
+	case PROP_SHOWWEEKS:
+		g_value_set_boolean (value,
+				     calendar_window_get_show_weeks (calwin));
+		break;
+#ifdef HAVE_LIBECAL
+	case PROP_TIMEFORMAT:
+		g_value_set_enum (value,
+				  calendar_window_get_time_format (calwin));
+		break;
+#endif
+	case PROP_CURRENTTIMEP:
+		g_value_set_pointer (value,
+				     calendar_window_get_current_time_p (calwin));
+		break;
+	case PROP_PREFSDIR:
+		g_value_set_string (value,
+				    calendar_window_get_prefs_dir (calwin));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+calendar_window_set_property (GObject       *object,
+			      guint          prop_id,
+			      const GValue  *value,
+			      GParamSpec    *pspec)
+{
+	CalendarWindow *calwin;
+
+	g_return_if_fail (CALENDAR_IS_WINDOW (object));
+
+	calwin = CALENDAR_WINDOW (object);
+
+	switch (prop_id) {
+	case PROP_INVERTORDER:
+		calendar_window_set_invert_order (calwin,
+						  g_value_get_boolean (value));
+		break;
+	case PROP_SHOWWEEKS:
+		calendar_window_set_show_weeks (calwin,
+						g_value_get_boolean (value));
+		break;
+#ifdef HAVE_LIBECAL
+	case PROP_TIMEFORMAT:
+		calendar_window_set_time_format (calwin,
+						 g_value_get_enum (value));
+		break;
+#endif
+	case PROP_CURRENTTIMEP:
+		calendar_window_set_current_time_p (calwin,
+						    g_value_get_pointer (value));
+		break;
+	case PROP_PREFSDIR:
+		calendar_window_set_prefs_dir (calwin,
+					       g_value_get_string (value));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+calendar_window_destroy (GtkObject *object)
+{
+#ifdef HAVE_LIBECAL
+	CalendarWindow *calwin;
+
+	calwin = CALENDAR_WINDOW (object);
+
+        if (calwin->priv->client)
+                g_object_unref (calwin->priv->client);
+        calwin->priv->client = NULL;
+
+        if (calwin->priv->appointments_model)
+                g_object_unref (calwin->priv->appointments_model);
+        calwin->priv->appointments_model = NULL;
+
+        if (calwin->priv->tasks_model)
+                g_object_unref (calwin->priv->tasks_model);
+        calwin->priv->tasks_model = NULL;
+
+        if (calwin->priv->appointments_filter)
+                g_object_unref (calwin->priv->appointments_filter);
+        calwin->priv->appointments_filter = NULL;
+
+        if (calwin->priv->birthdays_filter)
+                g_object_unref (calwin->priv->birthdays_filter);
+        calwin->priv->birthdays_filter = NULL;
+
+        if (calwin->priv->tasks_filter)
+                g_object_unref (calwin->priv->tasks_filter);
+        calwin->priv->tasks_filter = NULL;
+
+        if (calwin->priv->weather_filter)
+                g_object_unref (calwin->priv->weather_filter);
+        calwin->priv->weather_filter = NULL;
+
+	if (calwin->priv->mateconfclient)
+		g_object_unref (calwin->priv->mateconfclient);
+	calwin->priv->mateconfclient = NULL;
+#endif /* HAVE_LIBECAL */
+
+	GTK_OBJECT_CLASS (calendar_window_parent_class)->destroy (object);
+}
+
+static void
+calendar_window_class_init (CalendarWindowClass *klass)
+{
+	GObjectClass   *gobject_class   = G_OBJECT_CLASS (klass);
+	GtkObjectClass *gtkobject_class = GTK_OBJECT_CLASS (klass);
+
+	gobject_class->constructor = calendar_window_constructor;
+	gobject_class->get_property = calendar_window_get_property;
+        gobject_class->set_property = calendar_window_set_property;
+
+	gtkobject_class->destroy = calendar_window_destroy;
+
+	g_type_class_add_private (klass, sizeof (CalendarWindowPrivate));
+
+	signals[EDIT_LOCATIONS] = g_signal_new ("edit-locations",
+						G_TYPE_FROM_CLASS (gobject_class),
+						G_SIGNAL_RUN_FIRST,
+						G_STRUCT_OFFSET (CalendarWindowClass, edit_locations),
+						NULL,
+						NULL,
+						g_cclosure_marshal_VOID__VOID,
+						G_TYPE_NONE, 0);
+
+	g_object_class_install_property (
+		gobject_class,
+		PROP_INVERTORDER,
+		g_param_spec_boolean ("invert-order",
+				      "Invert Order",
+				      "Invert order of the calendar and tree views",
+				      FALSE,
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+
+	g_object_class_install_property (
+		gobject_class,
+		PROP_SHOWWEEKS,
+		g_param_spec_boolean ("show-weeks",
+				      "Show Weeks",
+				      "Show weeks in the calendar",
+				      FALSE,
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+
+#ifdef HAVE_LIBECAL
+	g_object_class_install_property (
+		gobject_class,
+		PROP_TIMEFORMAT,
+		g_param_spec_enum ("time-format",
+				   "Time Format",
+				   "Time format used to display time",
+				   CLOCK_TYPE_FORMAT,
+				   clock_locale_format (),
+				   G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+#endif
+
+	g_object_class_install_property (
+		gobject_class,
+		PROP_CURRENTTIMEP,
+		g_param_spec_pointer ("current-time",
+				      "Current Time",
+				      "Pointer to a variable containing the current time",
+				      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+	g_object_class_install_property (
+		gobject_class,
+		PROP_PREFSDIR,
+		g_param_spec_string ("prefs-dir",
+				     "Preferences Directory",
+				     "Preferences directory in MateConf",
+				     NULL,
+				     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+}
+
+static void
+calendar_window_init (CalendarWindow *calwin)
+{
+	GtkWindow *window;
+
+	calwin->priv = CALENDAR_WINDOW_GET_PRIVATE (calwin);
+
+	window = GTK_WINDOW (calwin);
+	gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_DOCK);
+	gtk_window_set_decorated (window, FALSE);
+	gtk_window_set_resizable (window, FALSE);
+	gtk_window_stick (window);
+	gtk_window_set_title (window, _("Calendar"));
+	gtk_window_set_icon_name (window, CLOCK_ICON);
+
+#ifdef HAVE_LIBECAL
+	calwin->priv->previous_selection = NULL;
+	calwin->priv->mateconfclient = mateconf_client_get_default ();
+#endif
+}
+
+GtkWidget *
+calendar_window_new (time_t     *static_current_time,
+		     const char *prefs_dir,
+		     gboolean    invert_order)
+{
+	CalendarWindow *calwin;
+
+	calwin = g_object_new (CALENDAR_TYPE_WINDOW,
+			       "type", GTK_WINDOW_TOPLEVEL,
+			       "current-time", static_current_time,
+			       "invert-order", invert_order,
+			       "prefs-dir", prefs_dir,
+			       NULL);
+
+	return GTK_WIDGET (calwin);
+}
+
+void
+calendar_window_refresh (CalendarWindow *calwin)
+{
+	g_return_if_fail (CALENDAR_IS_WINDOW (calwin));
+
+#ifdef HAVE_LIBECAL
+	if (calwin->priv->appointments_filter && calwin->priv->appointment_list)
+		gtk_tree_model_filter_refilter (calwin->priv->appointments_filter);
+	if (calwin->priv->birthdays_filter && calwin->priv->birthday_list)
+		gtk_tree_model_filter_refilter (calwin->priv->birthdays_filter);
+	if (calwin->priv->tasks_filter && calwin->priv->task_list)
+		gtk_tree_model_filter_refilter (calwin->priv->tasks_filter);
+	if (calwin->priv->weather_filter && calwin->priv->weather_list)
+		gtk_tree_model_filter_refilter (calwin->priv->weather_filter);
+#endif
+}
+
+gboolean
+calendar_window_get_invert_order (CalendarWindow *calwin)
+{
+	g_return_val_if_fail (CALENDAR_IS_WINDOW (calwin), FALSE);
+
+	return calwin->priv->invert_order;
+}
+
+void
+calendar_window_set_invert_order (CalendarWindow *calwin,
+				  gboolean        invert_order)
+{
+	g_return_if_fail (CALENDAR_IS_WINDOW (calwin));
+
+	if (invert_order == calwin->priv->invert_order)
+		return;
+
+	calwin->priv->invert_order = invert_order;
+	//FIXME: update the order of the content of the window
+
+	g_object_notify (G_OBJECT (calwin), "invert-order");
+}
+
+gboolean
+calendar_window_get_show_weeks (CalendarWindow *calwin)
+{
+	g_return_val_if_fail (CALENDAR_IS_WINDOW (calwin), FALSE);
+
+	return calwin->priv->show_weeks;
+}
+
+void
+calendar_window_set_show_weeks (CalendarWindow *calwin,
+				gboolean        show_weeks)
+{
+	GtkCalendarDisplayOptions options;
+
+	g_return_if_fail (CALENDAR_IS_WINDOW (calwin));
+
+	if (show_weeks == calwin->priv->show_weeks)
+		return;
+
+	calwin->priv->show_weeks = show_weeks;
+
+	if (calwin->priv->calendar) {
+		options = gtk_calendar_get_display_options (GTK_CALENDAR (calwin->priv->calendar));
+
+		if (show_weeks)
+			options |= GTK_CALENDAR_SHOW_WEEK_NUMBERS;
+		else
+			options &= ~(GTK_CALENDAR_SHOW_WEEK_NUMBERS);
+
+		gtk_calendar_set_display_options (GTK_CALENDAR (calwin->priv->calendar),
+						  options);
+	}
+
+	g_object_notify (G_OBJECT (calwin), "show-weeks");
+}
+
+ClockFormat
+calendar_window_get_time_format (CalendarWindow *calwin)
+{
+	g_return_val_if_fail (CALENDAR_IS_WINDOW (calwin),
+			      CLOCK_FORMAT_INVALID);
+
+#ifdef HAVE_LIBECAL
+	return calwin->priv->time_format;
+#else
+	return CLOCK_FORMAT_INVALID;
+#endif
+}
+
+void
+calendar_window_set_time_format (CalendarWindow *calwin,
+				 ClockFormat     time_format)
+{
+	g_return_if_fail (CALENDAR_IS_WINDOW (calwin));
+
+#ifdef HAVE_LIBECAL
+	if (time_format != CLOCK_FORMAT_12 && time_format != CLOCK_FORMAT_24)
+		time_format = clock_locale_format ();
+
+	if (time_format == calwin->priv->time_format)
+		return;
+
+	calwin->priv->time_format = time_format;
+	/* Time to display for appointments has changed */
+	if (calwin->priv->appointments_model)
+		handle_appointments_changed (calwin);
+
+	g_object_notify (G_OBJECT (calwin), "time-format");
+#endif
+}
+
+static time_t *
+calendar_window_get_current_time_p (CalendarWindow *calwin)
+{
+	g_return_val_if_fail (CALENDAR_IS_WINDOW (calwin), NULL);
+
+	return calwin->priv->current_time;
+}
+
+static void
+calendar_window_set_current_time_p (CalendarWindow *calwin,
+				    time_t         *current_time)
+{
+	g_return_if_fail (CALENDAR_IS_WINDOW (calwin));
+
+	if (current_time == calwin->priv->current_time)
+		return;
+
+	calwin->priv->current_time = current_time;
+
+	g_object_notify (G_OBJECT (calwin), "current-time");
+}
+
+static const char *
+calendar_window_get_prefs_dir (CalendarWindow *calwin)
+{
+	g_return_val_if_fail (CALENDAR_IS_WINDOW (calwin), NULL);
+
+	return calwin->priv->prefs_dir;
+}
+
+static void
+calendar_window_set_prefs_dir (CalendarWindow *calwin,
+			       const char     *prefs_dir)
+{
+	g_return_if_fail (CALENDAR_IS_WINDOW (calwin));
+
+	if (!calwin->priv->prefs_dir && (!prefs_dir || !prefs_dir [0]))
+		return;
+
+	if (calwin->priv->prefs_dir && prefs_dir && prefs_dir [0] &&
+	    !strcmp (calwin->priv->prefs_dir, prefs_dir))
+		return;
+
+	if (calwin->priv->prefs_dir)
+		g_free (calwin->priv->prefs_dir);
+	calwin->priv->prefs_dir = NULL;
+
+	if (prefs_dir && prefs_dir [0])
+		calwin->priv->prefs_dir = g_strdup (prefs_dir);
+
+	g_object_notify (G_OBJECT (calwin), "prefs-dir");
+}