~ubuntu-branches/ubuntu/lucid/evolution/lucid

/*

 * Evolution calendar - Main calendar view widget

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) version 3.

 *

 * 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with the program; if not, see <http://www.gnu.org/licenses/>

 *

 *

 * Authors:

 *		Miguel de Icaza <miguel@ximian.com>

 *      Federico Mena-Quintero <federico@ximian.com>

 *      Seth Alves <alves@hungry.com>

 *      Rodrigo Moya <rodrigo@ximian.com>

 *

 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <unistd.h>

#include <math.h>

#include <signal.h>

#include <fcntl.h>

#include <glib.h>

#include <gdk/gdkkeysyms.h>

#include <glib/gi18n.h>

#include <bonobo/bonobo-exception.h>

#include <libedataserver/e-categories.h>

#include <libedataserver/e-url.h>

#include <libedataserverui/e-passwords.h>

#include "shell/e-user-creatable-items-handler.h"

#include <libecal/e-cal-time-util.h>

#include <widgets/menus/gal-view-factory-etable.h>

#include <widgets/menus/gal-view-etable.h>

#include <widgets/menus/gal-define-views-dialog.h>

#include "widgets/menus/gal-view-menus.h"

#include "e-util/e-util.h"

#include "e-util/e-error.h"

#include "e-util/e-util-private.h"

#include "e-comp-editor-registry.h"

#include "dialogs/delete-error.h"

#include "dialogs/event-editor.h"

#include "dialogs/task-editor.h"

#include "comp-util.h"

#include "e-cal-model-calendar.h"

#include "e-day-view.h"

#include "e-day-view-config.h"

#include "e-day-view-time-item.h"

#include "e-week-view.h"

#include "e-week-view-config.h"

#include "e-cal-list-view.h"

#include "e-cal-list-view-config.h"

#include "e-mini-calendar-config.h"

#include "e-calendar-table-config.h"

#include "e-memo-table-config.h"

#include "evolution-calendar.h"

#include "gnome-cal.h"

#include "calendar-component.h"

#include "memos-component.h"

#include "cal-search-bar.h"

#include "calendar-commands.h"

#include "calendar-config.h"

#include "calendar-view.h"

#include "calendar-view-factory.h"

#include "tag-calendar.h"

#include "misc.h"

#include "ea-calendar.h"

#include "common/authentication.h"

#include "e-cal-popup.h"

#include "e-cal-menu.h"

#include "e-cal-model-tasks.h"

/* FIXME glib 2.4 and above has this */

#ifndef G_MAXINT32

#define G_MAXINT32	((gint32)  0x7fffffff)

#endif

#define d(x)

/* hash table define for non intrusive error dialog */

static GHashTable *non_intrusive_error_table = NULL;

/* Private part of the GnomeCalendar structure */

struct _GnomeCalendarPrivate {

	/* The clients for display */

	GHashTable *clients[E_CAL_SOURCE_TYPE_LAST];

	GList *clients_list[E_CAL_SOURCE_TYPE_LAST];

	ECal *default_client[E_CAL_SOURCE_TYPE_LAST];

	/*

	 * Fields for the calendar view

	 */

	/* This is the last time explicitly selected by the user */

	time_t base_view_time;

	/* Widgets */

	GtkWidget   *search_bar;

	GtkWidget   *hpane;

	GtkWidget   *notebook;

	GtkWidget   *vpane;

	ECalendar   *date_navigator;

	EMiniCalendarConfig *date_navigator_config;

	GtkWidget   *todo;

	ECalendarTableConfig *todo_config;

	GtkWidget   *memo;

	EMemoTableConfig *memo_config;

	GtkWidget   *day_view;

	GtkWidget   *work_week_view;

	GtkWidget   *week_view;

	GtkWidget   *month_view;

	GtkWidget   *list_view;

	/* Activity */

	EActivityHandler *activity_handler;

	/* plugin menu managers */

	ECalMenu    *calendar_menu;

	ECalMenu    *taskpad_menu;

	ECalMenu    *memopad_menu;

	/* Calendar query for the date navigator */

	GMutex      *dn_queries_lock; /* lock for dn_queries list */

	GList       *dn_queries; /* list of CalQueries */

	gchar        *sexp;

	gchar        *todo_sexp;

	gchar        *memo_sexp;

	guint        update_timeout;

	guint        update_marcus_bains_line_timeout;

	/* This is the view currently shown. We use it to keep track of the

	   positions of the panes. range_selected is TRUE if a range of dates

	   was selected in the date navigator to show the view. */

	ECalendarView    *views[GNOME_CAL_LAST_VIEW];

	GObject    *configs[GNOME_CAL_LAST_VIEW];

	GnomeCalendarViewType current_view_type;

	GList *notifications;

	gboolean range_selected;

	/* These are the saved positions of the panes. They are multiples of

	   calendar month widths & heights in the date navigator, so that they

	   will work OK after theme changes. */

	gint	     hpane_pos;

	gint	     hpane_pos_month_view;

	gint	     vpane_pos;

	gint	     vpane_pos_month_view;

	/* The signal handler id for our GtkCalendar "day_selected" handler. */

	guint	     day_selected_id;

	/* View instance and menus for the control */

	GalViewInstance *view_instance;

	GalViewMenus *view_menus;

	/* Our current week start */

	gint week_start;

	/* Our current timezone. */

	icaltimezone *zone;

	/* The dates currently shown. If they are -1 then we have no dates

	   shown. We only use these to check if we need to emit a

	   'dates-shown-changed' signal.*/

	time_t visible_start;

	time_t visible_end;

	gboolean updating;

	/* If this is true list view uses range of showing the events as the  dates selected in date navigator which is one month, else

	   it uses the date range set in search bar */

	gboolean lview_select_daten_range;

	/* We should know which calendar has been used to create object, so store it here

	   before emitting "user_created" signal and make it NULL just after the emit. */

	ECal *user_created_cal;

	/* used in update_todo_view, to prevent interleaving when called in separate thread */

	GMutex *todo_update_lock;

};

/* Signal IDs */

enum {

	DATES_SHOWN_CHANGED,

	CALENDAR_SELECTION_CHANGED,

	TASKPAD_SELECTION_CHANGED,

	MEMOPAD_SELECTION_CHANGED,

	CALENDAR_FOCUS_CHANGE,

	TASKPAD_FOCUS_CHANGE,

	MEMOPAD_FOCUS_CHANGE,

	GOTO_DATE,

	SOURCE_ADDED,

	SOURCE_REMOVED,

	CHANGE_VIEW,

	LAST_SIGNAL

};

/* Used to indicate who has the focus within the calendar view */

typedef enum {

	FOCUS_CALENDAR,

	FOCUS_TASKPAD,

	FOCUS_MEMOPAD,

	FOCUS_OTHER

} FocusLocation;

static guint gnome_calendar_signals[LAST_SIGNAL];

static void gnome_calendar_destroy (GtkObject *object);

static void gnome_calendar_goto_date (GnomeCalendar *gcal,

				      GnomeCalendarGotoDateType goto_date);

static void gnome_calendar_change_view (GnomeCalendar *gcal,

					 GnomeCalendarViewType view_type);

static void gnome_calendar_set_pane_positions	(GnomeCalendar	*gcal);

static void update_view_times (GnomeCalendar *gcal, time_t start_time);

static void gnome_calendar_update_date_navigator (GnomeCalendar *gcal);

static void gnome_calendar_hpane_realized (GtkWidget *w, GnomeCalendar *gcal);

static void gnome_calendar_date_navigator_scrolled (GtkWidget *widget, GdkEventScroll *event, gpointer user_data);

static gboolean gnome_calendar_hpane_resized (GtkWidget *w, GdkEventButton *e, GnomeCalendar *gcal);

static void gnome_calendar_vpane_realized (GtkWidget *w, GnomeCalendar *gcal);

static gboolean gnome_calendar_vpane_resized (GtkWidget *w, GdkEventButton *e, GnomeCalendar *gcal);

static void gnome_calendar_on_date_navigator_date_range_changed (ECalendarItem *calitem,

								 GnomeCalendar *gcal);

static void gnome_calendar_on_date_navigator_selection_changed (ECalendarItem    *calitem,

								GnomeCalendar    *gcal);

static void gnome_calendar_notify_dates_shown_changed (GnomeCalendar *gcal);

static void update_query (GnomeCalendar *gcal);

static void update_todo_view (GnomeCalendar *gcal);

static void update_memo_view (GnomeCalendar *gcal);

static void default_client_cal_opened_cb (ECal *ecal, ECalendarStatus status, GnomeCalendar *gcal);

static void client_cal_opened_cb (ECal *ecal, ECalendarStatus status, GnomeCalendar *gcal);

/* Simple asynchronous message dispatcher */

typedef struct _Message Message;

typedef void (*MessageFunc) (Message *msg);

struct _Message {

	MessageFunc func;

};

static void

message_proxy (Message *msg)

{

	g_return_if_fail (msg->func != NULL);

	msg->func (msg);

}

static gpointer

create_thread_pool (void)

{

	/* once created, run forever */

	return g_thread_pool_new ((GFunc) message_proxy, NULL, 1, FALSE, NULL);

}

static void

message_push (Message *msg)

{

	static GOnce once = G_ONCE_INIT;

	g_once (&once, (GThreadFunc) create_thread_pool, NULL);

	g_thread_pool_push ((GThreadPool *) once.retval, msg, NULL);

}

G_DEFINE_TYPE (GnomeCalendar, gnome_calendar, GTK_TYPE_VBOX)

/* Class initialization function for the gnome calendar */

static void

gnome_calendar_class_init (GnomeCalendarClass *class)

{

	GtkObjectClass *object_class;

	GtkBindingSet *binding_set;

	object_class = (GtkObjectClass *) class;

	gnome_calendar_signals[DATES_SHOWN_CHANGED] =

		g_signal_new ("dates_shown_changed",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_LAST,

				G_STRUCT_OFFSET (GnomeCalendarClass, dates_shown_changed),

				NULL, NULL,

				g_cclosure_marshal_VOID__VOID,

				G_TYPE_NONE, 0);

	gnome_calendar_signals[CALENDAR_SELECTION_CHANGED] =

		g_signal_new ("calendar_selection_changed",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_LAST,

				G_STRUCT_OFFSET (GnomeCalendarClass, calendar_selection_changed),

				NULL, NULL,

				g_cclosure_marshal_VOID__VOID,

				G_TYPE_NONE, 0);

	gnome_calendar_signals[TASKPAD_SELECTION_CHANGED] =

		g_signal_new ("taskpad_selection_changed",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_LAST,

				G_STRUCT_OFFSET (GnomeCalendarClass, taskpad_selection_changed),

				NULL, NULL,

				g_cclosure_marshal_VOID__VOID,

				G_TYPE_NONE, 0);

	gnome_calendar_signals[MEMOPAD_SELECTION_CHANGED] =

		g_signal_new ("memopad_selection_changed",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_LAST,

				G_STRUCT_OFFSET (GnomeCalendarClass, memopad_selection_changed),

				NULL, NULL,

				g_cclosure_marshal_VOID__VOID,

				G_TYPE_NONE, 0);

	gnome_calendar_signals[CALENDAR_FOCUS_CHANGE] =

		g_signal_new ("calendar_focus_change",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_FIRST,

				G_STRUCT_OFFSET (GnomeCalendarClass, calendar_focus_change),

				NULL, NULL,

				g_cclosure_marshal_VOID__BOOLEAN,

				G_TYPE_NONE, 1,

				G_TYPE_BOOLEAN);

	gnome_calendar_signals[TASKPAD_FOCUS_CHANGE] =

		g_signal_new ("taskpad_focus_change",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_FIRST,

				G_STRUCT_OFFSET (GnomeCalendarClass, taskpad_focus_change),

				NULL, NULL,

				g_cclosure_marshal_VOID__BOOLEAN,

				G_TYPE_NONE, 1,

				G_TYPE_BOOLEAN);

	gnome_calendar_signals[MEMOPAD_FOCUS_CHANGE] =

		g_signal_new ("memopad_focus_change",

				G_TYPE_FROM_CLASS (object_class),

				G_SIGNAL_RUN_FIRST,

				G_STRUCT_OFFSET (GnomeCalendarClass, memopad_focus_change),

				NULL, NULL,

				g_cclosure_marshal_VOID__BOOLEAN,

				G_TYPE_NONE, 1,

				G_TYPE_BOOLEAN);

	gnome_calendar_signals[SOURCE_ADDED] =

		g_signal_new ("source_added",

			      G_TYPE_FROM_CLASS (object_class),

			      G_SIGNAL_RUN_FIRST,

			      G_STRUCT_OFFSET (GnomeCalendarClass, source_added),

			      NULL, NULL,

			      e_marshal_VOID__INT_OBJECT,

			      G_TYPE_NONE,

			      2,

			      G_TYPE_INT, G_TYPE_OBJECT);

	gnome_calendar_signals[SOURCE_REMOVED] =

		g_signal_new ("source_removed",

			      G_TYPE_FROM_CLASS (object_class),

			      G_SIGNAL_RUN_FIRST,

			      G_STRUCT_OFFSET (GnomeCalendarClass, source_removed),

			      NULL, NULL,

			      e_marshal_VOID__INT_OBJECT,

			      G_TYPE_NONE,

			      2,

			      G_TYPE_INT, G_TYPE_OBJECT);

	gnome_calendar_signals[GOTO_DATE] =

		g_signal_new ("goto_date",

			      G_TYPE_FROM_CLASS (object_class),

			      G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

			      G_STRUCT_OFFSET (GnomeCalendarClass, goto_date),

			      NULL, NULL,

			      g_cclosure_marshal_VOID__INT,

			      G_TYPE_NONE,

			      1,

			      G_TYPE_INT);

	gnome_calendar_signals[CHANGE_VIEW] =

		g_signal_new ("change_view",

			      G_TYPE_FROM_CLASS (object_class),

			      G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,

			      G_STRUCT_OFFSET (GnomeCalendarClass, change_view),

			      NULL, NULL,

			      g_cclosure_marshal_VOID__INT,

			      G_TYPE_NONE,

			      1,

			      G_TYPE_INT);

	object_class->destroy = gnome_calendar_destroy;

	class->dates_shown_changed = NULL;

	class->calendar_selection_changed = NULL;

	class->taskpad_selection_changed = NULL;

	class->memopad_selection_changed = NULL;

	class->calendar_focus_change = NULL;

	class->taskpad_focus_change = NULL;

	class->memopad_focus_change = NULL;

	class->source_added = NULL;

	class->source_removed = NULL;

	class->goto_date = gnome_calendar_goto_date;

	class->change_view = gnome_calendar_change_view;

	/*

	 * Key bindings

	 */

	binding_set = gtk_binding_set_by_class (class);

	/* Alt+PageUp/PageDown, go to the first/last day of the month */

	gtk_binding_entry_add_signal (binding_set, GDK_Page_Up,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_FIRST_DAY_OF_MONTH);

	gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_FIRST_DAY_OF_MONTH);

	gtk_binding_entry_add_signal (binding_set, GDK_Page_Down,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_LAST_DAY_OF_MONTH);

	gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_LAST_DAY_OF_MONTH);

	/* Alt+Home/End, go to the first/last day of the week */

	gtk_binding_entry_add_signal (binding_set, GDK_Home,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_FIRST_DAY_OF_WEEK);

	gtk_binding_entry_add_signal (binding_set, GDK_End,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_LAST_DAY_OF_WEEK);

	gtk_binding_entry_add_signal (binding_set, GDK_KP_Home,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_FIRST_DAY_OF_WEEK);

	gtk_binding_entry_add_signal (binding_set, GDK_KP_End,

				      GDK_MOD1_MASK,

				      "goto_date", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_LAST_DAY_OF_WEEK);

	/*Alt+Left/Right, go to the same day of the previous/next week*/

	gtk_binding_entry_add_signal (binding_set,GDK_Left,

				      GDK_MOD1_MASK,

				      "goto_date",1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_SAME_DAY_OF_PREVIOUS_WEEK);

	gtk_binding_entry_add_signal (binding_set,GDK_KP_Left,

				      GDK_MOD1_MASK,

				      "goto_date",1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_SAME_DAY_OF_PREVIOUS_WEEK);

	gtk_binding_entry_add_signal (binding_set,GDK_Right,

				      GDK_MOD1_MASK,

				      "goto_date",1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_SAME_DAY_OF_NEXT_WEEK);

	gtk_binding_entry_add_signal (binding_set,GDK_KP_Right,

				      GDK_MOD1_MASK,

				      "goto_date",1,

				      G_TYPE_ENUM,

				      GNOME_CAL_GOTO_SAME_DAY_OF_NEXT_WEEK);

	/* Ctrl+Y/J/K/M/L to switch between

	 * DayView/WorkWeekView/WeekView/MonthView/ListView */

	gtk_binding_entry_add_signal (binding_set, GDK_y,

				      GDK_CONTROL_MASK,

				      "change_view", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_DAY_VIEW);

	gtk_binding_entry_add_signal (binding_set, GDK_j,

				      GDK_CONTROL_MASK,

				      "change_view", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_WORK_WEEK_VIEW);

	gtk_binding_entry_add_signal (binding_set, GDK_k,

				      GDK_CONTROL_MASK,

				      "change_view", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_WEEK_VIEW);

	gtk_binding_entry_add_signal (binding_set, GDK_m,

				      GDK_CONTROL_MASK,

				      "change_view", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_MONTH_VIEW);

	gtk_binding_entry_add_signal (binding_set, GDK_l,

				      GDK_CONTROL_MASK,

				      "change_view", 1,

				      G_TYPE_ENUM,

				      GNOME_CAL_LIST_VIEW);

	/* init the accessibility support for gnome_calendar */

	gnome_calendar_a11y_init ();

}

/* We do this check since the calendar items are downloaded from the server in the open_method,

   since the default timezone might not be set there */

static void

ensure_dates_are_in_default_zone (icalcomponent *icalcomp)

{

	icaltimetype dt;

	icaltimezone *zone = calendar_config_get_icaltimezone ();

	if (!zone)

		return;

	dt = icalcomponent_get_dtstart (icalcomp);

	if (dt.is_utc) {

		dt = icaltime_convert_to_zone (dt, zone);

		icalcomponent_set_dtstart (icalcomp, dt);

	}

	dt = icalcomponent_get_dtend (icalcomp);

	if (dt.is_utc) {

		dt = icaltime_convert_to_zone (dt, zone);

		icalcomponent_set_dtend (icalcomp, dt);

	}

}

/* Callback used when the calendar query reports of an updated object */

static void

dn_e_cal_view_objects_added_cb (ECalView *query, GList *objects, gpointer data)

{

	GnomeCalendar *gcal;

	GnomeCalendarPrivate *priv;

	GList *l;

	gcal = GNOME_CALENDAR (data);

	priv = gcal->priv;

	for (l = objects; l; l = l->next) {

		ECalComponent *comp = NULL;

		ensure_dates_are_in_default_zone (l->data);

		comp = e_cal_component_new ();

		if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (l->data))) {

			g_object_unref (comp);

			continue;

		}

		tag_calendar_by_comp (priv->date_navigator, comp, e_cal_view_get_client (query), NULL,

				      FALSE, TRUE);

		g_object_unref (comp);

	}

}

static void

dn_e_cal_view_objects_modified_cb (ECalView *query, GList *objects, gpointer data)

{

	GnomeCalendar *gcal;

	gcal = GNOME_CALENDAR (data);

	/* We have to retag the whole thing: an event may change dates

	 * and the tag_calendar_by_comp() below would not know how to

	 * untag the old dates.

	 */

	update_query (gcal);

}

/* Callback used when the calendar query reports of a removed object */

static void

dn_e_cal_view_objects_removed_cb (ECalView *query, GList *ids, gpointer data)

{

	GnomeCalendar *gcal;

	gcal = GNOME_CALENDAR (data);

	/* Just retag the whole thing */

	update_query (gcal);

}

/* Callback used when the calendar query is done */

static void

dn_e_cal_view_done_cb (ECalView *query, ECalendarStatus status, gpointer data)

{

	/* FIXME Better error reporting */

	if (status != E_CALENDAR_STATUS_OK)

		g_warning (G_STRLOC ": Query did not successfully complete");

}

/* Returns the current view widget, an EDayView, EWeekView or ECalListView. */

GtkWidget*

gnome_calendar_get_current_view_widget (GnomeCalendar *gcal)

{

	GnomeCalendarPrivate *priv;

	priv = gcal->priv;

	return GTK_WIDGET (priv->views[priv->current_view_type]);

}

static void

get_times_for_views (GnomeCalendar *gcal, GnomeCalendarViewType view_type, time_t *start_time, time_t *end_time, time_t *select_time)

{

	GnomeCalendarPrivate *priv;

	gint shown, display_start;

	GDate date;

	gint weekday, first_day, last_day, days_shown, i;

	gboolean has_working_days = FALSE;

	guint offset;

	struct icaltimetype tt = icaltime_null_time ();

	priv = gcal->priv;

	switch (view_type) {

	case GNOME_CAL_DAY_VIEW:

		shown  = e_day_view_get_days_shown (E_DAY_VIEW (priv->views[view_type]));

		*start_time = time_day_begin_with_zone (*start_time, priv->zone);

		*end_time = time_add_day_with_zone (*start_time, shown, priv->zone);

		break;

	case GNOME_CAL_WORK_WEEK_VIEW:

		/* FIXME Kind of gross, but it works */

		time_to_gdate_with_zone (&date, *start_time, priv->zone);

		/* The start of the work-week is the first working day after the

		   week start day. */

		/* Get the weekday corresponding to start_time, 0 (Sun) to 6 (Sat). */

		weekday = g_date_get_weekday (&date) % 7;

		/* Find the first working day in the week, 0 (Sun) to 6 (Sat). */

		first_day = (E_DAY_VIEW (priv->views[view_type])->week_start_day + 1) % 7;

		for (i = 0; i < 7; i++) {

			if (E_DAY_VIEW (priv->views[view_type])->working_days & (1 << first_day)) {

				has_working_days = TRUE;

				break;

			}

			first_day = (first_day + 1) % 7;

		}

		if (has_working_days) {

			/* Now find the last working day of the week, backwards. */

			last_day = E_DAY_VIEW (priv->views[view_type])->week_start_day % 7;

			for (i = 0; i < 7; i++) {

				if (E_DAY_VIEW (priv->views[view_type])->working_days & (1 << last_day))

					break;

				last_day = (last_day + 6) % 7;

			}

			/* Now calculate the days we need to show to include all the

			   working days in the week. Add 1 to make it inclusive. */

			days_shown = (last_day + 7 - first_day) % 7 + 1;

		} else {

			/* If no working days are set, just use 7. */

			days_shown = 7;

		}

		/* Calculate how many days we need to go back to the first workday. */

		if (weekday < first_day) {

			offset = (first_day - weekday) % 7;

			g_date_add_days (&date, offset);

		} else {

			offset = (weekday - first_day) % 7;

			g_date_subtract_days (&date, offset);

		}

		tt.year = g_date_get_year (&date);

		tt.month = g_date_get_month (&date);

		tt.day = g_date_get_day (&date);

		*start_time = icaltime_as_timet_with_zone (tt, priv->zone);

		*end_time = time_add_day_with_zone (*start_time, days_shown, priv->zone);

		if (select_time && E_DAY_VIEW (priv->views[view_type])->selection_start_day == -1)

			time (select_time);

		break;

	case GNOME_CAL_WEEK_VIEW:

		/* FIXME We should be using the same day of the week enum every where */

		display_start = (E_WEEK_VIEW (priv->views[view_type])->display_start_day + 1) % 7;

		*start_time = time_week_begin_with_zone (*start_time, display_start, priv->zone);

		*end_time = time_add_week_with_zone (*start_time, 1, priv->zone);

		if (select_time && E_WEEK_VIEW (priv->views[view_type])->selection_start_day == -1)

			time (select_time);

		break;

	case GNOME_CAL_MONTH_VIEW:

		shown = e_week_view_get_weeks_shown (E_WEEK_VIEW (priv->views[view_type]));

		/* FIXME We should be using the same day of the week enum every where */

		display_start = (E_WEEK_VIEW (priv->views[view_type])->display_start_day + 1) % 7;

		if (!priv->range_selected && (!E_WEEK_VIEW (priv->views[view_type])->multi_week_view || !E_WEEK_VIEW (priv->views[view_type])->month_scroll_by_week))

			*start_time = time_month_begin_with_zone (*start_time, priv->zone);

		*start_time = time_week_begin_with_zone (*start_time, display_start, priv->zone);

		*end_time = time_add_week_with_zone (*start_time, shown, priv->zone);

		if (select_time && E_WEEK_VIEW (priv->views[view_type])->selection_start_day == -1)

			time (select_time);

		break;

	case GNOME_CAL_LIST_VIEW:

		/* FIXME What to do here? */

		*start_time = time_month_begin_with_zone (*start_time, priv->zone);

		*end_time = time_add_month_with_zone (*start_time, 1, priv->zone);

		break;

	default:

		g_return_if_reached ();

	}

}

/* Gets the focus location based on who is the focused widget within the

 * calendar view.

 */

static FocusLocation

get_focus_location (GnomeCalendar *gcal)

{

	GnomeCalendarPrivate *priv;

	ETable *etable, *m_etable;

	priv = gcal->priv;

	etable = e_calendar_table_get_table (E_CALENDAR_TABLE (priv->todo));

	m_etable = e_memo_table_get_table (E_MEMO_TABLE (priv->memo));

	if (GTK_WIDGET_HAS_FOCUS (etable->table_canvas))

		return FOCUS_TASKPAD;

	else if (GTK_WIDGET_HAS_FOCUS (m_etable->table_canvas))

		return FOCUS_MEMOPAD;

	else {

		GtkWidget *widget;

		EDayView *dv;

		EWeekView *wv;

		ECalListView *lv;

		widget = gnome_calendar_get_current_view_widget (gcal);