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");
+}