A page that shows the meeting time selector and free/busy data for

2001-09-18  JP Rosevear  <jpr@ximian.com>

	* gui/dialogs/schedule-page.*: A page that shows the meeting time
	selector and free/busy data for attendees

	* gui/dialogs/meeting-page.c: use the meeting model to track/edit
	attendees, remove table value conversion routines and simple table
	routines
	(set_attendees): take a pointer array
	(meeting_page_destroy): destroy the pointer array, save state
	(meeting_page_init): new pointer array
	(meeting_page_fill_widgets): don't null the deleted attendees
	field
	(popup_delegate_cb): array add
	(popup_delete_cb): array add
	(cleanup_attendees): iterate over the array to unref now
	(meeting_page_fill_widgets): don't null out fields, no need to add
	attendees here
	(invite_entry_changed): use e_meeting_attendee routines
	(popup_delegate_cb): ditto
	(popup_delete_cb): ditto
	(meeting_page_new): take new arg and pass it to construct
	(meeting_page_construct): take new arg, use e-meeting-model
	routines to construct table

	* gui/dialogs/task-editor.c (task_editor_init): new meeting model
	(task_editor_destroy): unref the model

	* gui/dialogs/event-editor.c (event_editor_init): make new model
	and pass it to meeting and schedule pages
	(event_editor_set_cal_client): virtual function, set meeting model
	client
	(event_editor_edit_comp): add the attendees to the model
	(event_editor_destroy): unref model

	* gui/dialogs/comp-editor.h: add virtual function

	* gui/dialogs/comp-editor.c (comp_editor_set_cal_client): make
	set_cal_client a virutal function

	* gui/e-meeting-types.h: generally useful type defines

	* gui/e-meeting-time-sel*.[hc]: Move here and use an e-table for
	the attendee list and extract display information from the new
	meeting model and attendees

	* gui/e-meeting-time-sel.etspec: spec for the table

	* gui/e-meeting-attendee.[hc]: meeting attendees for the model,
	with to/from conversions for CalComponentAttendee structure, emits
	changed signal and allows getting and setting of free busy
	periods

	* gui/e-meeting-model.[hc]: move the model out on its own

	* gui/e-itip-control.c (write_error_html): clean up warnings

svn path=/trunk/; revision=12968

1 files changed, 2622 insertions, 0 deletions

diff --git a/calendar/gui/e-meeting-time-sel.c b/calendar/gui/e-meeting-time-sel.c
new file mode 100644
index 0000000000..cfb87b5663
--- /dev/null
+++ b/calendar/gui/e-meeting-time-sel.c
@@ -0,0 +1,2622 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+/* 
+ * Author : 
+ *  Damon Chaplin <damon@gtk.org>
+ *
+ * Copyright 1999, Ximian, Inc.
+ *
+ * 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
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "e-meeting-time-sel.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <glib.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtkalignment.h>
+#include <gtk/gtkarrow.h>
+#include <gtk/gtkbutton.h>
+#include <gtk/gtkdrawingarea.h>
+#include <gtk/gtkentry.h>
+#include <gtk/gtkfixed.h>
+#include <gtk/gtkhbox.h>
+#include <gtk/gtkhscrollbar.h>
+#include <gtk/gtkhseparator.h>
+#include <gtk/gtklabel.h>
+#include <gtk/gtkmenu.h>
+#include <gtk/gtkradiomenuitem.h>
+#include <gtk/gtksignal.h>
+#include <gtk/gtkvbox.h>
+#include <gtk/gtkvscrollbar.h>
+#include <libgnomeui/gnome-dateedit.h>
+#include <libgnome/gnome-i18n.h>
+#include <libgnomeui/gnome-canvas-widget.h>
+
+#include <gal/widgets/e-canvas.h>
+#include <gal/widgets/e-canvas-utils.h>
+#include <gal/e-table/e-cell-combo.h>
+#include <gal/e-table/e-cell-text.h>
+#include <gal/e-table/e-table-simple.h>
+#include <gal/e-table/e-table-scrolled.h>
+
+#include <widgets/misc/e-dateedit.h>
+#include "component-factory.h"
+#include "calendar-config.h"
+#include "e-meeting-time-sel-item.h"
+
+/* An array of hour strings, "0:00" .. "23:00". */
+const gchar *EMeetingTimeSelectorHours[24] = {
+	"0:00", "1:00", "2:00", "3:00", "4:00", "5:00", "6:00", "7:00", 
+	"8:00", "9:00", "10:00", "11:00", "12:00", "13:00", "14:00", "15:00", 
+	"16:00", "17:00", "18:00", "19:00", "20:00", "21:00", "22:00", "23:00"
+};
+
+/* The number of days shown in the entire canvas. */
+#define E_MEETING_TIME_SELECTOR_DAYS_SHOWN		365
+
+/* This is the number of pixels between the mouse has to move before the
+   scroll speed is incremented. */
+#define E_MEETING_TIME_SELECTOR_SCROLL_INCREMENT_WIDTH	10
+
+/* This is the maximum scrolling speed. */
+#define E_MEETING_TIME_SELECTOR_MAX_SCROLL_SPEED	4
+
+
+static void e_meeting_time_selector_class_init (EMeetingTimeSelectorClass * klass);
+static void e_meeting_time_selector_init (EMeetingTimeSelector * mts);
+static void e_meeting_time_selector_destroy (GtkObject *object);
+static void e_meeting_time_selector_alloc_named_color (EMeetingTimeSelector * mts,
+						       const char *name, GdkColor *c);
+static void e_meeting_time_selector_add_key_color (EMeetingTimeSelector * mts,
+						   GtkWidget *hbox,
+						   gchar *label_text,
+						   GdkColor *color);
+static gint e_meeting_time_selector_expose_key_color (GtkWidget *darea,
+						      GdkEventExpose *event,
+						      GdkColor *color);
+static void e_meeting_time_selector_options_menu_detacher (GtkWidget *widget,
+							   GtkMenu   *menu);
+static void e_meeting_time_selector_autopick_menu_detacher (GtkWidget *widget,
+							    GtkMenu   *menu);
+static void e_meeting_time_selector_realize (GtkWidget *widget);
+static void e_meeting_time_selector_unrealize (GtkWidget *widget);
+static gint e_meeting_time_selector_expose_event (GtkWidget *widget,
+						  GdkEventExpose *event);
+static void e_meeting_time_selector_draw (GtkWidget    *widget,
+					  GdkRectangle *area);
+static void e_meeting_time_selector_draw_shadow (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_hadjustment_changed (GtkAdjustment *adjustment,
+							 EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_vadjustment_changed (GtkAdjustment *adjustment,
+							 EMeetingTimeSelector *mts);
+
+static void e_meeting_time_selector_on_canvas_realized (GtkWidget *widget,
+							EMeetingTimeSelector *mts);
+
+static gint e_meeting_time_selector_compare_times (EMeetingTime*time1,
+						   EMeetingTime*time2);
+static void e_meeting_time_selector_on_options_button_clicked (GtkWidget *button,
+							       EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_options_menu_position_callback (GtkMenu *menu,
+								    gint *x,
+								    gint *y,
+								    gpointer user_data);
+static void e_meeting_time_selector_on_zoomed_out_toggled (GtkWidget *button,
+							   EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_working_hours_toggled (GtkWidget *button,
+							      EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_invite_others_button_clicked (GtkWidget *button,
+								     EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_update_free_busy (GtkWidget *button,
+							 EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_autopick_button_clicked (GtkWidget *button,
+								EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_autopick_menu_position_callback (GtkMenu *menu,
+								     gint *x,
+								     gint *y,
+								     gpointer user_data);
+static void e_meeting_time_selector_on_autopick_option_toggled (GtkWidget *button,
+								EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_prev_button_clicked (GtkWidget *button,
+							    EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_next_button_clicked (GtkWidget *button,
+							    EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_autopick (EMeetingTimeSelector *mts,
+					      gboolean forward);
+static void e_meeting_time_selector_calculate_time_difference (EMeetingTime*start,
+							       EMeetingTime*end,
+							       gint *days,
+							       gint *hours,
+							       gint *minutes);
+static void e_meeting_time_selector_find_nearest_interval (EMeetingTimeSelector *mts,
+							   EMeetingTime*start_time,
+							   EMeetingTime*end_time,
+							   gint days, gint hours, gint mins);
+static void e_meeting_time_selector_find_nearest_interval_backward (EMeetingTimeSelector *mts,
+								    EMeetingTime *start_time,
+								    EMeetingTime *end_time,
+								    gint days, gint hours, gint mins);
+static void e_meeting_time_selector_adjust_time (EMeetingTime*mtstime,
+						 gint days, gint hours, gint minutes);
+static EMeetingFreeBusyPeriod* e_meeting_time_selector_find_time_clash (EMeetingTimeSelector *mts,
+									EMeetingAttendee *attendee,
+									EMeetingTime *start_time,
+									EMeetingTime *end_time);
+
+
+static void e_meeting_time_selector_recalc_grid (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_recalc_date_format (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_save_position (EMeetingTimeSelector *mts,
+						   EMeetingTime*mtstime);
+static void e_meeting_time_selector_restore_position (EMeetingTimeSelector *mts,
+						      EMeetingTime*mtstime);
+static void e_meeting_time_selector_on_start_time_changed (GtkWidget *widget,
+							   EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_end_time_changed (GtkWidget *widget,
+							 EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_update_date_popup_menus (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_on_canvas_size_allocate (GtkWidget *widget,
+							     GtkAllocation *allocation,
+							     EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_update_main_canvas_scroll_region (EMeetingTimeSelector *mts);
+static gboolean e_meeting_time_selector_timeout_handler (gpointer data);
+static void e_meeting_time_selector_update_start_date_edit (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_update_end_date_edit (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_ensure_meeting_time_shown (EMeetingTimeSelector *mts);
+static void e_meeting_time_selector_update_dates_shown (EMeetingTimeSelector *mts);
+
+static void row_count_changed_cb (ETableModel *etm, int row, int count, gpointer data);
+static void sort_info_changed_cb (ETableSortInfo *info, gpointer data);
+
+static GtkTableClass *parent_class;
+
+
+GtkType
+e_meeting_time_selector_get_type (void)
+{
+	static guint e_meeting_time_selector_type = 0;
+
+	if (!e_meeting_time_selector_type) {
+		GtkTypeInfo e_meeting_time_selector_info =
+		{
+			"EMeetingTimeSelector",
+			sizeof (EMeetingTimeSelector),
+			sizeof (EMeetingTimeSelectorClass),
+			(GtkClassInitFunc) e_meeting_time_selector_class_init,
+			(GtkObjectInitFunc) e_meeting_time_selector_init,
+				/* reserved_1 */ NULL,
+				/* reserved_2 */ NULL,
+			(GtkClassInitFunc) NULL,
+		};
+
+		e_meeting_time_selector_type = gtk_type_unique (GTK_TYPE_TABLE,
+								&e_meeting_time_selector_info);
+	}
+	return e_meeting_time_selector_type;
+}
+
+
+static void
+e_meeting_time_selector_class_init (EMeetingTimeSelectorClass * klass)
+{
+	GtkObjectClass *object_class;
+	GtkWidgetClass *widget_class;
+
+	parent_class = gtk_type_class (gtk_table_get_type());
+
+	object_class = (GtkObjectClass *) klass;
+	widget_class = (GtkWidgetClass *) klass;
+
+	object_class->destroy = e_meeting_time_selector_destroy;
+
+	widget_class->realize      = e_meeting_time_selector_realize;
+	widget_class->unrealize    = e_meeting_time_selector_unrealize;
+	widget_class->expose_event = e_meeting_time_selector_expose_event;
+	widget_class->draw	   = e_meeting_time_selector_draw;
+}
+
+
+static void
+e_meeting_time_selector_init (EMeetingTimeSelector * mts)
+{
+	/* The shadow is drawn in the border so it must be >= 2 pixels. */
+	gtk_container_set_border_width (GTK_CONTAINER (mts), 2);
+
+	mts->accel_group = gtk_accel_group_new ();
+
+	mts->working_hours_only = TRUE;
+	mts->day_start_hour = 9;
+	mts->day_start_minute = 0;
+	mts->day_end_hour = 18;
+	mts->day_end_minute = 0;
+	mts->zoomed_out = TRUE;
+	mts->dragging_position = E_MEETING_TIME_SELECTOR_POS_NONE;
+
+	mts->etable = NULL;
+}
+
+
+void
+e_meeting_time_selector_construct (EMeetingTimeSelector * mts, EMeetingModel *emm)
+{
+	GtkWidget *hbox, *vbox, *separator, *button, *label, *table;
+	GtkWidget *alignment, *child_hbox, *child_vbox, *arrow, *menuitem;
+	GSList *group;
+	GdkVisual *visual;
+	GdkColormap *colormap;
+	guint accel_key;
+	GtkAccelGroup *menu_accel_group;
+	time_t meeting_start_time;
+	struct tm *meeting_start_tm;
+	char *filename;
+	ETable *real_table;
+	guchar stipple_bits[] = {
+		0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+	};
+
+	/* The default meeting time is the nearest half-hour interval in the
+	   future, in working hours. */
+	meeting_start_time = time (NULL);
+	g_date_clear (&mts->meeting_start_time.date, 1);
+	g_date_set_time (&mts->meeting_start_time.date, meeting_start_time);
+	meeting_start_tm = localtime (&meeting_start_time);
+	mts->meeting_start_time.hour = meeting_start_tm->tm_hour;
+	mts->meeting_start_time.minute = meeting_start_tm->tm_min;
+
+	e_meeting_time_selector_find_nearest_interval (mts, &mts->meeting_start_time,
+						       &mts->meeting_end_time,
+						       0, 0, 30);
+
+	e_meeting_time_selector_update_dates_shown (mts);
+
+	mts->meeting_positions_valid = FALSE;
+
+	mts->row_height = 19;
+	mts->col_width = 50;
+	mts->day_width = 50 * 24 + 1;
+
+	mts->auto_scroll_timeout_id = 0;
+
+	vbox = gtk_vbox_new (FALSE, 0);
+	gtk_table_attach (GTK_TABLE (mts),
+			  vbox, 0, 1, 0, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
+	gtk_widget_show (vbox);
+
+	child_vbox = gtk_vbox_new (FALSE, 0);
+	gtk_widget_set_usize (child_vbox, 1, mts->row_height * 2 - 6);
+	gtk_box_pack_start (GTK_BOX (vbox), child_vbox, FALSE, FALSE, 0);
+	gtk_widget_show (child_vbox);
+	
+	mts->attendees_vbox = gtk_vbox_new (FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (vbox), mts->attendees_vbox, TRUE, TRUE, 0);
+	gtk_widget_show (mts->attendees_vbox);
+
+	/* build the etable */
+	filename = g_strdup_printf ("%s/config/et-header-meeting-time-sel", evolution_dir);
+	mts->model = emm;
+
+	gtk_signal_connect (GTK_OBJECT (mts->model), "model_rows_inserted",
+			    GTK_SIGNAL_FUNC (row_count_changed_cb), mts);
+	gtk_signal_connect (GTK_OBJECT (mts->model), "model_rows_deleted",
+			    GTK_SIGNAL_FUNC (row_count_changed_cb), mts);
+
+	mts->etable = GTK_WIDGET (e_meeting_model_etable_from_model (mts->model,
+								EVOLUTION_ETSPECDIR "/e-meeting-time-sel.etspec",
+								filename));
+
+	real_table = e_table_scrolled_get_table (E_TABLE_SCROLLED (mts->etable));
+	gtk_signal_connect (GTK_OBJECT (real_table->sort_info), "sort_info_changed",
+			    GTK_SIGNAL_FUNC (sort_info_changed_cb), mts);
+
+	gtk_box_pack_start (GTK_BOX (mts->attendees_vbox), mts->etable, TRUE, TRUE, 2);
+	gtk_widget_show (mts->etable);
+	g_free (filename);
+	
+	/* The free/busy information */
+	mts->display_top = gnome_canvas_new ();
+	gtk_widget_set_usize (mts->display_top, -1, mts->row_height * 3);
+	gnome_canvas_set_scroll_region (GNOME_CANVAS (mts->display_top),
+					0, 0,
+					mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN,
+					mts->row_height * 3);
+	/* Add some horizontal padding for the shadow around the display. */
+	gtk_table_attach (GTK_TABLE (mts), mts->display_top,
+			  1, 4, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
+	gtk_widget_show (mts->display_top);
+	gtk_signal_connect (GTK_OBJECT (mts->display_top), "realize",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_canvas_realized), mts);
+
+	mts->display_main = gnome_canvas_new ();
+	e_meeting_time_selector_update_main_canvas_scroll_region (mts);
+	/* Add some horizontal padding for the shadow around the display. */
+	gtk_table_attach (GTK_TABLE (mts), mts->display_main,
+			  1, 4, 1, 2,
+			  GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
+	gtk_widget_show (mts->display_main);
+	gtk_signal_connect (GTK_OBJECT (mts->display_main), "realize",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_canvas_realized), mts);
+	gtk_signal_connect (GTK_OBJECT (mts->display_main), "size_allocate",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_canvas_size_allocate), mts);
+
+	mts->hscrollbar = gtk_hscrollbar_new (GTK_LAYOUT (mts->display_main)->hadjustment);
+	GTK_LAYOUT (mts->display_main)->hadjustment->step_increment = mts->col_width;
+	gtk_table_attach (GTK_TABLE (mts), mts->hscrollbar,
+			  1, 4, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0);
+	gtk_widget_show (mts->hscrollbar);
+
+	mts->vscrollbar = gtk_vscrollbar_new (GTK_LAYOUT (mts->display_main)->vadjustment);
+	GTK_LAYOUT (mts->display_main)->vadjustment->step_increment = mts->row_height;
+	gtk_table_attach (GTK_TABLE (mts), mts->vscrollbar,
+			  4, 5, 1, 2, 0, GTK_EXPAND | GTK_FILL, 0, 0);
+	gtk_widget_show (mts->vscrollbar);
+
+	/* Create the item in the top canvas. */
+	gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (mts->display_top)->root),
+			       e_meeting_time_selector_item_get_type (),
+			       "EMeetingTimeSelectorItem::meeting_time_selector", mts,
+			       NULL);
+
+	/* Create the item in the main canvas. */
+	gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (mts->display_main)->root),
+			       e_meeting_time_selector_item_get_type (),
+			       "EMeetingTimeSelectorItem::meeting_time_selector", mts,
+			       NULL);
+
+	/* Create the hbox containing the color key. */
+	hbox = gtk_hbox_new (FALSE, 2);
+	gtk_table_attach (GTK_TABLE (mts), hbox,
+			  1, 4, 3, 4, GTK_FILL, 0, 0, 8);
+	gtk_widget_show (hbox);
+
+	e_meeting_time_selector_add_key_color (mts, hbox, _("Tentative"), &mts->busy_colors[E_MEETING_FREE_BUSY_TENTATIVE]);
+	e_meeting_time_selector_add_key_color (mts, hbox, _("Busy"), &mts->busy_colors[E_MEETING_FREE_BUSY_BUSY]);
+	e_meeting_time_selector_add_key_color (mts, hbox, _("Out of Office"), &mts->busy_colors[E_MEETING_FREE_BUSY_OUT_OF_OFFICE]);
+	e_meeting_time_selector_add_key_color (mts, hbox, _("No Information"),
+					       NULL);
+
+	separator = gtk_hseparator_new ();
+	gtk_table_attach (GTK_TABLE (mts), separator,
+			  0, 5, 4, 5, GTK_FILL, 0, 0, 0);
+	gtk_widget_show (separator);
+
+	/* Create the Invite Others & Options buttons on the left. */
+	hbox = gtk_hbox_new (FALSE, 4);
+	gtk_table_attach (GTK_TABLE (mts), hbox,
+			  0, 1, 3, 4, GTK_FILL, 0, 0, 0);
+	gtk_widget_show (hbox);
+
+	button = gtk_button_new_with_label ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (button)->child),
+					   _("_Invite Others..."));
+	gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+	gtk_widget_show (button);
+	gtk_widget_add_accelerator (button, "clicked", mts->accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_invite_others_button_clicked), mts);
+
+	mts->options_button = gtk_button_new ();
+	gtk_box_pack_start (GTK_BOX (hbox), mts->options_button, TRUE, TRUE, 0);
+	gtk_widget_show (mts->options_button);
+
+	gtk_signal_connect (GTK_OBJECT (mts->options_button), "clicked",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_options_button_clicked), mts);
+
+	child_hbox = gtk_hbox_new (FALSE, 2);
+	gtk_container_add (GTK_CONTAINER (mts->options_button), child_hbox);
+	gtk_widget_show (child_hbox);
+
+	label = gtk_label_new ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (label), _("_Options"));
+	gtk_box_pack_start (GTK_BOX (child_hbox), label, TRUE, TRUE, 0);
+	gtk_widget_show (label);
+	gtk_widget_add_accelerator (mts->options_button, "clicked", mts->accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+
+	arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+	gtk_box_pack_start (GTK_BOX (child_hbox), arrow, FALSE, FALSE, 2);
+	gtk_widget_show (arrow);
+
+	/* Create the Options menu. */
+	mts->options_menu = gtk_menu_new ();
+	gtk_menu_attach_to_widget (GTK_MENU (mts->options_menu), mts->options_button,
+				   e_meeting_time_selector_options_menu_detacher);
+	menu_accel_group = gtk_menu_ensure_uline_accel_group (GTK_MENU (mts->options_menu));
+
+	menuitem = gtk_check_menu_item_new_with_label ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("Show _Only Working Hours"));
+	gtk_menu_append (GTK_MENU (mts->options_menu), menuitem);
+	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
+					mts->working_hours_only);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "toggled",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_working_hours_toggled), mts);
+	gtk_widget_show (menuitem);
+
+	menuitem = gtk_check_menu_item_new_with_label ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("Show _Zoomed Out"));
+	gtk_menu_append (GTK_MENU (mts->options_menu), menuitem);
+	gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
+					mts->zoomed_out);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "toggled",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_zoomed_out_toggled), mts);
+	gtk_widget_show (menuitem);
+
+	menuitem = gtk_menu_item_new ();
+	gtk_menu_append (GTK_MENU (mts->options_menu), menuitem);
+	gtk_widget_set_sensitive (menuitem, FALSE);
+	gtk_widget_show (menuitem);
+
+	menuitem = gtk_menu_item_new_with_label ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("_Update Free/Busy"));
+	gtk_menu_append (GTK_MENU (mts->options_menu), menuitem);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_update_free_busy), mts);
+	gtk_widget_show (menuitem);
+
+	/* Create the 3 AutoPick buttons on the left. */
+	hbox = gtk_hbox_new (FALSE, 0);
+	gtk_table_attach (GTK_TABLE (mts), hbox,
+			  0, 1, 5, 6, GTK_FILL, 0, 0, 0);
+	gtk_widget_show (hbox);
+
+	button = gtk_button_new_with_label ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (button)->child),
+					   _("_<<"));
+	gtk_widget_add_accelerator (button, "clicked", mts->accel_group,
+				    accel_key, GDK_MOD1_MASK | GDK_SHIFT_MASK, 0);
+	gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+	gtk_widget_show (button);
+	gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_prev_button_clicked), mts);
+
+	mts->autopick_button = gtk_button_new ();
+	gtk_box_pack_start (GTK_BOX (hbox), mts->autopick_button, TRUE, TRUE, 0);
+	gtk_widget_show (mts->autopick_button);
+
+	child_hbox = gtk_hbox_new (FALSE, 2);
+	gtk_container_add (GTK_CONTAINER (mts->autopick_button), child_hbox);
+	gtk_widget_show (child_hbox);
+
+	label = gtk_label_new ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (label), _("_Autopick"));
+	gtk_box_pack_start (GTK_BOX (child_hbox), label, TRUE, TRUE, 0);
+	gtk_widget_show (label);
+	gtk_widget_add_accelerator (mts->autopick_button, "clicked", mts->accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (mts->autopick_button), "clicked",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_autopick_button_clicked), mts);
+
+	arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
+	gtk_box_pack_start (GTK_BOX (child_hbox), arrow, FALSE, FALSE, 2);
+	gtk_widget_show (arrow);
+
+	button = gtk_button_new_with_label ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (button)->child),
+					   _(">_>"));
+	gtk_widget_add_accelerator (button, "clicked", mts->accel_group,
+				    accel_key, GDK_MOD1_MASK | GDK_SHIFT_MASK, 0);
+	gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
+	gtk_widget_show (button);
+	gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_next_button_clicked), mts);
+
+	/* Create the Autopick menu. */
+	mts->autopick_menu = gtk_menu_new ();
+	gtk_menu_attach_to_widget (GTK_MENU (mts->autopick_menu), mts->autopick_button,
+				   e_meeting_time_selector_autopick_menu_detacher);
+	menu_accel_group = gtk_menu_ensure_uline_accel_group (GTK_MENU (mts->autopick_menu));
+
+	menuitem = gtk_radio_menu_item_new_with_label (NULL, "");
+	mts->autopick_all_item = menuitem;
+	group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("_All People and Resources"));
+	gtk_menu_append (GTK_MENU (mts->autopick_menu), menuitem);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "toggled",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_autopick_option_toggled), mts);
+	gtk_widget_show (menuitem);
+
+	menuitem = gtk_radio_menu_item_new_with_label (group, "");
+	mts->autopick_all_people_one_resource_item = menuitem;
+	group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("All _People and One Resource"));
+	gtk_menu_append (GTK_MENU (mts->autopick_menu), menuitem);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "toggled",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_autopick_option_toggled), mts);
+	gtk_widget_show (menuitem);
+
+	menuitem = gtk_radio_menu_item_new_with_label (group, "");
+	mts->autopick_required_people_item = menuitem;
+	group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("_Required People"));
+	gtk_menu_append (GTK_MENU (mts->autopick_menu), menuitem);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_autopick_option_toggled), mts);
+	gtk_widget_show (menuitem);
+
+	menuitem = gtk_radio_menu_item_new_with_label (group, "");
+	mts->autopick_required_people_one_resource_item = menuitem;
+	group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (menuitem));
+	accel_key = gtk_label_parse_uline (GTK_LABEL (GTK_BIN (menuitem)->child), _("Required People and _One Resource"));
+	gtk_menu_append (GTK_MENU (mts->autopick_menu), menuitem);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, 0, 0);
+	gtk_widget_add_accelerator (menuitem, "activate", menu_accel_group,
+				    accel_key, GDK_MOD1_MASK, 0);
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_autopick_option_toggled), mts);
+	gtk_widget_show (menuitem);
+
+	/* Create the date entry fields on the right. */
+	alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
+	gtk_table_attach (GTK_TABLE (mts), alignment,
+			  1, 4, 5, 6, GTK_FILL, 0, 0, 0);
+	gtk_widget_show (alignment);
+
+	table = gtk_table_new (2, 2, FALSE);
+	gtk_table_set_row_spacings (GTK_TABLE (table), 4);
+	gtk_container_add (GTK_CONTAINER (alignment), table);
+	gtk_widget_show (table);
+
+	label = gtk_label_new ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (label),
+					   _("Meeting _start time:"));
+	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+	gtk_table_attach (GTK_TABLE (table), label,
+			  0, 1, 0, 1, GTK_FILL, 0, 4, 0);
+	gtk_widget_show (label);
+
+	mts->start_date_edit = e_date_edit_new ();
+	e_date_edit_set_show_time (E_DATE_EDIT (mts->start_date_edit), TRUE);
+	e_date_edit_set_use_24_hour_format (E_DATE_EDIT (mts->start_date_edit),
+					    calendar_config_get_24_hour_format ());
+	
+	gtk_table_attach (GTK_TABLE (table), mts->start_date_edit,
+			  1, 2, 0, 1, GTK_FILL, 0, 0, 0);
+	gtk_widget_show (mts->start_date_edit);
+	gtk_signal_connect (GTK_OBJECT (mts->start_date_edit), "changed",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_start_time_changed), mts);
+
+	label = gtk_label_new ("");
+	accel_key = gtk_label_parse_uline (GTK_LABEL (label),
+					   _("Meeting _end time:"));
+	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+	gtk_table_attach (GTK_TABLE (table), label,
+			  0, 1, 1, 2, GTK_FILL, 0, 4, 0);
+	gtk_widget_show (label);
+
+	mts->end_date_edit = e_date_edit_new ();
+	e_date_edit_set_show_time (E_DATE_EDIT (mts->end_date_edit), TRUE);
+	e_date_edit_set_use_24_hour_format (E_DATE_EDIT (mts->end_date_edit),
+					    calendar_config_get_24_hour_format ());
+
+	gtk_table_attach (GTK_TABLE (table), mts->end_date_edit,
+			  1, 2, 1, 2, GTK_FILL, 0, 0, 0);
+	gtk_widget_show (mts->end_date_edit);
+	gtk_signal_connect (GTK_OBJECT (mts->end_date_edit), "changed",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_on_end_time_changed), mts);
+
+	gtk_table_set_col_spacing (GTK_TABLE (mts), 0, 4);
+	gtk_table_set_row_spacing (GTK_TABLE (mts), 4, 12);
+
+	/* Allocate the colors. */
+	visual = gtk_widget_get_visual (GTK_WIDGET (mts));
+	colormap = gtk_widget_get_colormap (GTK_WIDGET (mts));
+	mts->color_context = gdk_color_context_new (visual, colormap);
+	e_meeting_time_selector_alloc_named_color (mts, "gray75", &mts->bg_color);
+	e_meeting_time_selector_alloc_named_color (mts, "gray50", &mts->all_attendees_bg_color);
+	gdk_color_black (colormap, &mts->grid_color);
+	gdk_color_white (colormap, &mts->grid_shadow_color);
+	e_meeting_time_selector_alloc_named_color (mts, "gray50", &mts->grid_unused_color);
+	gdk_color_white (colormap, &mts->meeting_time_bg_color);
+	gdk_color_white (colormap, &mts->stipple_bg_color);
+	gdk_color_white (colormap, &mts->attendee_list_bg_color);
+
+	e_meeting_time_selector_alloc_named_color (mts, "LightSkyBlue2", &mts->busy_colors[E_MEETING_FREE_BUSY_TENTATIVE]);
+	e_meeting_time_selector_alloc_named_color (mts, "blue", &mts->busy_colors[E_MEETING_FREE_BUSY_BUSY]);
+	e_meeting_time_selector_alloc_named_color (mts, "HotPink3", &mts->busy_colors[E_MEETING_FREE_BUSY_OUT_OF_OFFICE]);
+
+	/* Create the stipple, for attendees with no data. */
+	mts->stipple = gdk_bitmap_create_from_data (NULL, (gchar*)stipple_bits,
+						    8, 8);
+
+	/* Connect handlers to the adjustments in the main canvas, so we can
+	   scroll the other 2 canvases. */
+	gtk_signal_connect (GTK_OBJECT (GTK_LAYOUT (mts->display_main)->hadjustment), "value_changed", GTK_SIGNAL_FUNC (e_meeting_time_selector_hadjustment_changed), mts);
+	gtk_signal_connect (GTK_OBJECT (GTK_LAYOUT (mts->display_main)->vadjustment), "value_changed", GTK_SIGNAL_FUNC (e_meeting_time_selector_vadjustment_changed), mts);
+	gtk_signal_connect (GTK_OBJECT (GTK_LAYOUT (mts->display_main)->vadjustment), "changed", GTK_SIGNAL_FUNC (e_meeting_time_selector_vadjustment_changed), mts);
+
+	e_meeting_time_selector_recalc_grid (mts);
+	e_meeting_time_selector_ensure_meeting_time_shown (mts);
+	e_meeting_time_selector_update_start_date_edit (mts);
+	e_meeting_time_selector_update_end_date_edit (mts);
+	e_meeting_time_selector_update_date_popup_menus (mts);
+}
+
+
+/* This adds a color to the color key beneath the main display. If color is
+   NULL, it displays the No Info stipple instead. */
+static void
+e_meeting_time_selector_add_key_color (EMeetingTimeSelector * mts,
+				       GtkWidget *hbox,
+				       gchar *label_text, GdkColor *color)
+{
+	GtkWidget *child_hbox, *darea, *label;
+
+	child_hbox = gtk_hbox_new (FALSE, 4);
+	gtk_box_pack_start (GTK_BOX (hbox), child_hbox, TRUE, TRUE, 0);
+	gtk_widget_show (child_hbox);
+
+	darea = gtk_drawing_area_new ();
+	gtk_box_pack_start (GTK_BOX (child_hbox), darea, FALSE, FALSE, 0);
+	gtk_object_set_user_data (GTK_OBJECT (darea), mts);
+	gtk_widget_set_usize (darea, 14, 14);
+	gtk_widget_show (darea);
+
+	label = gtk_label_new (label_text);
+	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
+	gtk_box_pack_start (GTK_BOX (child_hbox), label, TRUE, TRUE, 0);
+	gtk_widget_show (label);
+
+	gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
+			    GTK_SIGNAL_FUNC (e_meeting_time_selector_expose_key_color),
+			    color);
+}
+
+static gint
+e_meeting_time_selector_expose_key_color (GtkWidget *darea,
+					  GdkEventExpose *event,
+					  GdkColor *color)
+{
+	EMeetingTimeSelector * mts;
+	GdkGC *gc;
+	gint width, height;
+
+	mts = gtk_object_get_user_data (GTK_OBJECT (darea));
+	gc = mts->color_key_gc;
+	width = darea->allocation.width;
+	height = darea->allocation.height;
+
+	gtk_draw_shadow (darea->style, darea->window, GTK_STATE_NORMAL,
+			 GTK_SHADOW_IN, 0, 0, width, height);
+
+	if (color) {
+		gdk_gc_set_foreground (gc, color);
+		gdk_draw_rectangle (darea->window, gc, TRUE, 1, 1,
+				    width - 2, height - 2);
+	} else {
+		gdk_gc_set_foreground (gc, &mts->grid_color);
+		gdk_gc_set_background (gc, &mts->stipple_bg_color);
+		gdk_gc_set_stipple (gc, mts->stipple);
+		gdk_gc_set_fill (gc, GDK_OPAQUE_STIPPLED);
+		gdk_draw_rectangle (darea->window, gc, TRUE, 1, 1,
+				    width - 2, height - 2);
+		gdk_gc_set_fill (gc, GDK_SOLID);
+	}
+
+	return TRUE;
+}
+
+
+static void
+e_meeting_time_selector_alloc_named_color (EMeetingTimeSelector * mts,
+					   const char *name, GdkColor *c)
+{
+	int failed;
+	
+	g_return_if_fail (name != NULL);
+	g_return_if_fail (c != NULL);
+
+	gdk_color_parse (name, c);
+	c->pixel = 0;
+	c->pixel = gdk_color_context_get_pixel (mts->color_context,
+						c->red, c->green, c->blue,
+						&failed);
+	if (failed)
+		g_warning ("Failed to allocate color: %s\n", name);
+}
+
+
+static void
+e_meeting_time_selector_options_menu_detacher (GtkWidget *widget,
+					       GtkMenu   *menu)
+{
+  EMeetingTimeSelector *mts;
+
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (widget));
+
+  mts = E_MEETING_TIME_SELECTOR (widget);
+  g_return_if_fail (mts->options_menu == (GtkWidget*) menu);
+
+  mts->options_menu = NULL;
+}
+
+
+static void
+e_meeting_time_selector_autopick_menu_detacher (GtkWidget *widget,
+						GtkMenu   *menu)
+{
+  EMeetingTimeSelector *mts;
+
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (widget));
+
+  mts = E_MEETING_TIME_SELECTOR (widget);
+  g_return_if_fail (mts->autopick_menu == (GtkWidget*) menu);
+
+  mts->autopick_menu = NULL;
+}
+
+
+GtkWidget *
+e_meeting_time_selector_new (EMeetingModel *emm)
+{
+	GtkWidget *mts;
+
+	mts = GTK_WIDGET (gtk_type_new (e_meeting_time_selector_get_type ()));
+
+	e_meeting_time_selector_construct (E_MEETING_TIME_SELECTOR (mts), emm);
+	
+	return mts;
+}
+
+
+static void
+e_meeting_time_selector_destroy (GtkObject *object)
+{
+	EMeetingTimeSelector *mts;
+	ETable *real_table;
+	char *filename;
+
+	mts = E_MEETING_TIME_SELECTOR (object);
+
+	e_meeting_time_selector_remove_timeout (mts);
+
+	gdk_color_context_free (mts->color_context);
+	gdk_bitmap_unref (mts->stipple);
+
+	filename = g_strdup_printf ("%s/config/et-header-meeting-time-sel",
+				    evolution_dir);
+	real_table = e_table_scrolled_get_table (E_TABLE_SCROLLED (mts->etable));
+	e_table_save_state (real_table, filename);
+	g_free (filename);
+		
+	if (GTK_OBJECT_CLASS (parent_class)->destroy)
+		(*GTK_OBJECT_CLASS (parent_class)->destroy)(object);
+}
+
+
+static void
+e_meeting_time_selector_realize (GtkWidget *widget)
+{
+	EMeetingTimeSelector *mts;
+
+	if (GTK_WIDGET_CLASS (parent_class)->realize)
+		(*GTK_WIDGET_CLASS (parent_class)->realize)(widget);
+
+	mts = E_MEETING_TIME_SELECTOR (widget);
+
+	mts->color_key_gc = gdk_gc_new (widget->window);
+}
+
+
+static void
+e_meeting_time_selector_unrealize (GtkWidget *widget)
+{
+	EMeetingTimeSelector *mts;
+
+	mts = E_MEETING_TIME_SELECTOR (widget);
+
+	gdk_gc_unref (mts->color_key_gc);
+	mts->color_key_gc = NULL;
+
+	if (GTK_WIDGET_CLASS (parent_class)->unrealize)
+		(*GTK_WIDGET_CLASS (parent_class)->unrealize)(widget);
+}
+
+/* This draws a shadow around the top display and main display. */
+static gint
+e_meeting_time_selector_expose_event (GtkWidget *widget,
+				      GdkEventExpose *event)
+{
+	EMeetingTimeSelector *mts;
+
+	mts = E_MEETING_TIME_SELECTOR (widget);
+
+	e_meeting_time_selector_draw_shadow (mts);
+
+	if (GTK_WIDGET_CLASS (parent_class)->expose_event)
+		(*GTK_WIDGET_CLASS (parent_class)->expose_event)(widget, event);
+
+	return FALSE;
+}
+
+
+static void
+e_meeting_time_selector_draw (GtkWidget    *widget,
+			      GdkRectangle *area)
+{
+	EMeetingTimeSelector *mts;
+
+	mts = E_MEETING_TIME_SELECTOR (widget);
+
+	e_meeting_time_selector_draw_shadow (mts);
+
+	if (GTK_WIDGET_CLASS (parent_class)->draw)
+		(*GTK_WIDGET_CLASS (parent_class)->draw)(widget, area);
+}
+
+
+static void
+e_meeting_time_selector_draw_shadow (EMeetingTimeSelector *mts)
+{
+	GtkWidget *widget;
+	gint x, y, w, h;
+
+	widget = GTK_WIDGET (mts);
+
+	/* Draw the shadow around the graphical displays. */
+	x = mts->display_top->allocation.x - 2;
+	y = mts->display_top->allocation.y - 2;
+	w = mts->display_top->allocation.width + 4;
+	h = mts->display_top->allocation.height + mts->display_main->allocation.height + 4;
+
+	gtk_draw_shadow (widget->style, widget->window, GTK_STATE_NORMAL,
+			 GTK_SHADOW_IN, x, y, w, h);
+}
+
+
+/* When the main canvas scrolls, we scroll the other canvases. */
+static void
+e_meeting_time_selector_hadjustment_changed (GtkAdjustment *adjustment,
+					     EMeetingTimeSelector *mts)
+{
+	GtkAdjustment *adj;
+
+	adj = GTK_LAYOUT (mts->display_top)->hadjustment;
+	if (adj->value != adjustment->value) {
+		adj->value = adjustment->value;
+		gtk_adjustment_value_changed (adj);
+	}
+}
+
+
+static void
+e_meeting_time_selector_vadjustment_changed (GtkAdjustment *adjustment,
+					     EMeetingTimeSelector *mts)
+{
+	GtkAdjustment *adj;
+
+	adj = e_scroll_frame_get_vadjustment (E_SCROLL_FRAME (mts->etable));
+	if (adj->value != adjustment->value) {
+		adj->value = adjustment->value;
+		gtk_adjustment_value_changed (adj);
+	}
+}
+
+
+void
+e_meeting_time_selector_get_meeting_time (EMeetingTimeSelector *mts,
+					  gint *start_year,
+					  gint *start_month,
+					  gint *start_day,
+					  gint *start_hour,
+					  gint *start_minute,
+					  gint *end_year,
+					  gint *end_month,
+					  gint *end_day,
+					  gint *end_hour,
+					  gint *end_minute)
+{
+	*start_year = g_date_year (&mts->meeting_start_time.date);
+	*start_month = g_date_month (&mts->meeting_start_time.date);
+	*start_day = g_date_day (&mts->meeting_start_time.date);
+	*start_hour = mts->meeting_start_time.hour;
+	*start_minute = mts->meeting_start_time.minute;
+
+	*end_year = g_date_year (&mts->meeting_end_time.date);
+	*end_month = g_date_month (&mts->meeting_end_time.date);
+	*end_day = g_date_day (&mts->meeting_end_time.date);
+	*end_hour = mts->meeting_end_time.hour;
+	*end_minute = mts->meeting_end_time.minute;
+}
+
+
+gboolean
+e_meeting_time_selector_set_meeting_time (EMeetingTimeSelector *mts,
+					  gint start_year,
+					  gint start_month,
+					  gint start_day,
+					  gint start_hour,
+					  gint start_minute,
+					  gint end_year,
+					  gint end_month,
+					  gint end_day,
+					  gint end_hour,
+					  gint end_minute)
+{
+	g_return_val_if_fail (IS_E_MEETING_TIME_SELECTOR (mts), FALSE);
+
+	/* Check the dates are valid. */
+	if (!g_date_valid_dmy (start_day, start_month, start_year)
+	    || !g_date_valid_dmy (end_day, end_month, end_year)
+	    || start_hour < 0 || start_hour > 23
+	    || end_hour < 0 || end_hour > 23
+	    || start_minute < 0 || start_minute > 59
+	    || end_minute < 0 || end_minute > 59)
+		return FALSE;
+
+	g_date_set_dmy (&mts->meeting_start_time.date, start_day, start_month,
+			start_year);
+	mts->meeting_start_time.hour = start_hour;
+	mts->meeting_start_time.minute = start_minute;
+	g_date_set_dmy (&mts->meeting_end_time.date, end_day, end_month,
+			end_year);
+	mts->meeting_end_time.hour = end_hour;
+	mts->meeting_end_time.minute = end_minute;
+
+	mts->meeting_positions_valid = FALSE;
+
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+
+	/* Set the times in the GnomeDateEdit widgets. */
+	e_meeting_time_selector_update_start_date_edit (mts);
+	e_meeting_time_selector_update_end_date_edit (mts);
+
+	return TRUE;
+}
+
+
+void
+e_meeting_time_selector_set_working_hours_only (EMeetingTimeSelector *mts,
+						gboolean working_hours_only)
+{
+	EMeetingTime saved_time;
+
+	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (mts));
+
+	if (mts->working_hours_only == working_hours_only)
+		return;
+
+	mts->working_hours_only = working_hours_only;
+
+	e_meeting_time_selector_save_position (mts, &saved_time);
+	e_meeting_time_selector_recalc_grid (mts);
+	e_meeting_time_selector_restore_position (mts, &saved_time);
+
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+	e_meeting_time_selector_update_date_popup_menus (mts);
+}
+
+
+void
+e_meeting_time_selector_set_working_hours (EMeetingTimeSelector *mts,
+					   gint day_start_hour,
+					   gint day_start_minute,
+					   gint day_end_hour,
+					   gint day_end_minute)
+{
+	EMeetingTime saved_time;
+
+	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (mts));
+
+	if (mts->day_start_hour == day_start_hour
+	    && mts->day_start_minute == day_start_minute
+	    && mts->day_end_hour == day_end_hour
+	    && mts->day_end_minute == day_end_minute)
+		return;
+
+	mts->day_start_hour = day_start_hour;
+	mts->day_start_minute = day_start_minute;
+	mts->day_end_hour = day_end_hour;
+	mts->day_end_minute = day_end_minute;
+
+	e_meeting_time_selector_save_position (mts, &saved_time);
+	e_meeting_time_selector_recalc_grid (mts);
+	e_meeting_time_selector_restore_position (mts, &saved_time);
+
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+	e_meeting_time_selector_update_date_popup_menus (mts);
+}
+
+
+void
+e_meeting_time_selector_set_zoomed_out (EMeetingTimeSelector *mts,
+					gboolean zoomed_out)
+{
+	EMeetingTime saved_time;
+
+	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (mts));
+
+	if (mts->zoomed_out == zoomed_out)
+		return;
+
+	mts->zoomed_out = zoomed_out;
+
+	e_meeting_time_selector_save_position (mts, &saved_time);
+	e_meeting_time_selector_recalc_grid (mts);
+	e_meeting_time_selector_restore_position (mts, &saved_time);
+
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+}
+
+
+EMeetingTimeSelectorAutopickOption
+e_meeting_time_selector_get_autopick_option (EMeetingTimeSelector *mts)
+{
+	if (GTK_CHECK_MENU_ITEM (mts->autopick_all_item)->active)
+		return E_MEETING_TIME_SELECTOR_ALL_PEOPLE_AND_RESOURCES;
+	if (GTK_CHECK_MENU_ITEM (mts->autopick_all_people_one_resource_item)->active)
+		return E_MEETING_TIME_SELECTOR_ALL_PEOPLE_AND_ONE_RESOURCE;
+	if (GTK_CHECK_MENU_ITEM (mts->autopick_required_people_item)->active)
+		return E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE;
+	return E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE_AND_ONE_RESOURCE;
+}
+
+
+void
+e_meeting_time_selector_set_autopick_option (EMeetingTimeSelector *mts,
+					     EMeetingTimeSelectorAutopickOption autopick_option)
+{
+	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (mts));
+
+	switch (autopick_option) {
+	case E_MEETING_TIME_SELECTOR_ALL_PEOPLE_AND_RESOURCES:
+		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mts->autopick_all_item), TRUE);
+		break;
+	case E_MEETING_TIME_SELECTOR_ALL_PEOPLE_AND_ONE_RESOURCE:
+		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mts->autopick_all_people_one_resource_item), TRUE);
+		break;
+	case E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE:
+		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mts->autopick_required_people_item), TRUE);
+		break;
+	case E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE_AND_ONE_RESOURCE:
+		gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mts->autopick_required_people_one_resource_item), TRUE);
+		break;
+	}
+}
+#if 0
+void
+e_meeting_time_selector_attendee_set_send_meeting_to (EMeetingTimeSelector *mts,
+						      gint row,
+						      gboolean send_meeting_to)
+{
+	EMeetingTimeSelectorAttendee *attendee;
+
+	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (mts));
+	g_return_if_fail (row >= 0);
+	g_return_if_fail (row < mts->attendees->len);
+
+	attendee = &g_array_index (mts->attendees,
+				   EMeetingTimeSelectorAttendee, row);
+	attendee->send_meeting_to = send_meeting_to;
+}
+#endif
+
+static gint
+e_meeting_time_selector_compare_times (EMeetingTime*time1,
+				       EMeetingTime*time2)
+{
+	gint day_comparison;
+
+	day_comparison = g_date_compare (&time1->date,
+					 &time2->date);
+	if (day_comparison != 0)
+		return day_comparison;
+
+	if (time1->hour < time2->hour)
+		return -1;
+	if (time1->hour > time2->hour)
+		return 1;
+
+	if (time1->minute < time2->minute)
+		return -1;
+	if (time1->minute > time2->minute)
+		return 1;
+
+	/* The start times are exactly the same. */
+	return 0;
+}
+
+
+/*
+ * DEBUGGING ROUTINES - functions to output various bits of data.
+ */
+
+#ifdef E_MEETING_TIME_SELECTOR_DEBUG
+
+/* Debugging function to dump information on all attendees. */
+void
+e_meeting_time_selector_dump (EMeetingTimeSelector *mts)
+{
+	EMeetingTimeSelectorAttendee *attendee;
+	EMeetingTimeSelectorPeriod *period;
+	gint row, period_num;
+	gchar buffer[128];
+
+	g_return_if_fail (IS_E_MEETING_TIME_SELECTOR (mts));
+
+	g_print ("\n\nAttendee Information:\n");
+
+	for (row = 0; row < mts->attendees->len; row++) {
+		attendee = &g_array_index (mts->attendees,
+					   EMeetingTimeSelectorAttendee, row);
+		g_print ("Attendee: %s\n", attendee->name);
+		g_print ("  Longest Busy Period: %i days\n",
+			 attendee->longest_period_in_days);
+
+		e_meeting_time_selector_attendee_ensure_periods_sorted (mts, attendee);
+#if 1
+		for (period_num = 0;
+		     period_num < attendee->busy_periods->len;
+		     period_num++) {
+			period = &g_array_index (attendee->busy_periods,
+						 EMeetingTimeSelectorPeriod,
+						 period_num);
+
+			/* These are just for debugging so don't need i18n. */
+			g_date_strftime (buffer, sizeof (buffer),
+					 "%A, %B %d, %Y", &period->start.date);
+			g_print ("  Start: %s %i:%02i\n", buffer,
+				 period->start.hour, period->start.minute);
+
+			g_date_strftime (buffer, sizeof (buffer),
+					 "%A, %B %d, %Y", &period->end.date);
+			g_print ("  End  : %s %i:%02i\n", buffer,
+				 period->end.hour, period->end.minute);
+		}
+#endif
+	}
+
+}
+
+
+/* This formats a EMeetingTimein a string and returns it.
+   Note that it uses a static buffer. */
+gchar*
+e_meeting_time_selector_dump_time (EMeetingTime*mtstime)
+{
+	static gchar buffer[128];
+
+	gchar buffer2[128];
+
+	/* This is just for debugging so doesn't need i18n. */
+	g_date_strftime (buffer, sizeof (buffer), "%A, %B %d, %Y",
+			 &mtstime->date);
+	sprintf (buffer2, " at %i:%02i", (gint) mtstime->hour,
+		 (gint) mtstime->minute);
+	strcat (buffer, buffer2);
+
+	return buffer;
+}
+
+
+/* This formats a GDate in a string and returns it.
+   Note that it uses a static buffer. */
+gchar*
+e_meeting_time_selector_dump_date (GDate *date)
+{
+	static gchar buffer[128];
+
+	/* This is just for debugging so doesn't need i18n. */
+	g_date_strftime (buffer, sizeof (buffer), "%A, %B %d, %Y", date);
+	return buffer;
+}
+
+#endif /* E_MEETING_TIME_SELECTOR_DEBUG */
+
+
+static void
+e_meeting_time_selector_on_invite_others_button_clicked (GtkWidget *button,
+							 EMeetingTimeSelector *mts)
+{
+
+
+}
+
+
+static void
+e_meeting_time_selector_on_options_button_clicked (GtkWidget *button,
+						   EMeetingTimeSelector *mts)
+{
+	gtk_menu_popup (GTK_MENU (mts->options_menu), NULL, NULL,
+			e_meeting_time_selector_options_menu_position_callback,
+			mts, 1, GDK_CURRENT_TIME);
+}
+
+
+static void
+e_meeting_time_selector_options_menu_position_callback (GtkMenu *menu,
+							gint *x,
+							gint *y,
+							gpointer user_data)
+{
+	EMeetingTimeSelector *mts;
+	GtkRequisition menu_requisition;
+	gint max_x, max_y;
+
+	mts = E_MEETING_TIME_SELECTOR (user_data);
+
+	/* Calculate our preferred position. */
+	gdk_window_get_origin (mts->options_button->window, x, y);
+	*y += mts->options_button->allocation.height;
+
+	/* Now make sure we are on the screen. */
+	gtk_widget_size_request (mts->options_menu, &menu_requisition);
+	max_x = MAX (0, gdk_screen_width () - menu_requisition.width);
+	max_y = MAX (0, gdk_screen_height () - menu_requisition.height);
+	*x = CLAMP (*x, 0, max_x);
+	*y = CLAMP (*y, 0, max_y);
+}
+
+static void
+e_meeting_time_selector_refresh_cb (EMeetingTimeSelector *mts) 
+{
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+}
+
+static void
+e_meeting_time_selector_on_update_free_busy (GtkWidget *button,
+					     EMeetingTimeSelector *mts)
+{
+
+	/* Make sure the menu pops down, which doesn't happen by default if
+	   keyboard accelerators are used. */
+	if (GTK_WIDGET_VISIBLE (mts->options_menu))
+		gtk_menu_popdown (GTK_MENU (mts->options_menu));
+
+	e_meeting_model_refresh_busy_periods (mts->model, e_meeting_time_selector_refresh_cb, mts);
+}
+
+
+static void
+e_meeting_time_selector_on_autopick_button_clicked (GtkWidget *button,
+						    EMeetingTimeSelector *mts)
+{
+	gtk_menu_popup (GTK_MENU (mts->autopick_menu), NULL, NULL,
+			e_meeting_time_selector_autopick_menu_position_callback,
+			mts, 1, GDK_CURRENT_TIME);
+}
+
+
+static void
+e_meeting_time_selector_autopick_menu_position_callback (GtkMenu *menu,
+							 gint *x,
+							 gint *y,
+							 gpointer user_data)
+{
+	EMeetingTimeSelector *mts;
+	GtkRequisition menu_requisition;
+	gint max_x, max_y;
+
+	mts = E_MEETING_TIME_SELECTOR (user_data);
+
+	/* Calculate our preferred position. */
+	gdk_window_get_origin (mts->autopick_button->window, x, y);
+	*y += mts->autopick_button->allocation.height;
+
+	/* Now make sure we are on the screen. */
+	gtk_widget_size_request (mts->autopick_menu, &menu_requisition);
+	max_x = MAX (0, gdk_screen_width () - menu_requisition.width);
+	max_y = MAX (0, gdk_screen_height () - menu_requisition.height);
+	*x = CLAMP (*x, 0, max_x);
+	*y = CLAMP (*y, 0, max_y);
+}
+
+
+static void
+e_meeting_time_selector_on_autopick_option_toggled (GtkWidget *button,
+						    EMeetingTimeSelector *mts)
+{
+	/* Make sure the menu pops down, which doesn't happen by default if
+	   keyboard accelerators are used. */
+	if (GTK_WIDGET_VISIBLE (mts->autopick_menu))
+		gtk_menu_popdown (GTK_MENU (mts->autopick_menu));
+}
+
+
+static void
+e_meeting_time_selector_on_prev_button_clicked (GtkWidget *button,
+						EMeetingTimeSelector *mts)
+{
+	e_meeting_time_selector_autopick (mts, FALSE);
+}
+
+
+static void
+e_meeting_time_selector_on_next_button_clicked (GtkWidget *button,
+						EMeetingTimeSelector *mts)
+{
+	e_meeting_time_selector_autopick (mts, TRUE);
+}
+
+
+/* This tries to find the previous or next meeting time for which all
+   attendees will be available. */
+static void
+e_meeting_time_selector_autopick (EMeetingTimeSelector *mts,
+				  gboolean forward)
+{
+	EMeetingTime start_time, end_time, *resource_free;
+	EMeetingAttendee *attendee;
+	EMeetingFreeBusyPeriod *period;
+	EMeetingTimeSelectorAutopickOption autopick_option;
+	gint duration_days, duration_hours, duration_minutes, row;
+	gboolean meeting_time_ok, skip_optional = FALSE;
+	gboolean need_one_resource = FALSE, found_resource;
+
+	/* Get the current meeting duration in days + hours + minutes. */
+	e_meeting_time_selector_calculate_time_difference (&mts->meeting_start_time, &mts->meeting_end_time, &duration_days, &duration_hours, &duration_minutes);
+
+	/* Find the first appropriate start time. */
+	start_time = mts->meeting_start_time;
+	if (forward)
+		e_meeting_time_selector_find_nearest_interval (mts, &start_time, &end_time, duration_days, duration_hours, duration_minutes);
+	else
+		e_meeting_time_selector_find_nearest_interval_backward (mts, &start_time, &end_time, duration_days, duration_hours, duration_minutes);
+
+	/* Determine if we can skip optional people and if we only need one
+	   resource based on the autopick option. */
+	autopick_option = e_meeting_time_selector_get_autopick_option (mts);
+	if (autopick_option == E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE
+	    || autopick_option == E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE_AND_ONE_RESOURCE)
+		skip_optional = TRUE;
+	if (autopick_option == E_MEETING_TIME_SELECTOR_ALL_PEOPLE_AND_ONE_RESOURCE
+	    || autopick_option == E_MEETING_TIME_SELECTOR_REQUIRED_PEOPLE_AND_ONE_RESOURCE)
+		need_one_resource = TRUE;
+
+	/* Keep moving forward or backward until we find a possible meeting
+	   time. */
+	for (;;) {
+		meeting_time_ok = TRUE;
+		found_resource = FALSE;
+		resource_free = NULL;
+
+		/* Step through each attendee, checking if the meeting time
+		   intersects one of the attendees busy periods. */
+		for (row = 0; row <  e_meeting_model_count_attendees (mts->model); row++) {
+			attendee = e_meeting_model_find_attendee_at_row (mts->model, row);
+
+			/* Skip optional people if they don't matter. */
+			if (skip_optional && e_meeting_attendee_get_atype (attendee) == E_MEETING_ATTENDEE_OPTIONAL_PERSON)
+				continue;
+
+			period = e_meeting_time_selector_find_time_clash (mts, attendee, &start_time, &end_time);
+
+			if (need_one_resource && e_meeting_attendee_get_atype (attendee) == E_MEETING_ATTENDEE_RESOURCE) {
+				if (period) {
+					/* We want to remember the closest
+					   prev/next time that one resource is
+					   available, in case we don't find any
+					   free resources. */
+					if (forward) {
+						if (!resource_free || e_meeting_time_selector_compare_times (resource_free, &period->end) > 0)
+							resource_free = &period->end;
+					} else {
+						if (!resource_free || e_meeting_time_selector_compare_times (resource_free, &period->start) < 0)
+							resource_free = &period->start;
+					}
+
+				} else {
+					found_resource = TRUE;
+				}
+			} else if (period) {
+				/* Skip the period which clashed. */
+				if (forward) {
+					start_time = period->end;
+				} else {
+					start_time = period->start;
+					e_meeting_time_selector_adjust_time (&start_time, -duration_days, -duration_hours, -duration_minutes);
+				}
+				meeting_time_ok = FALSE;
+				break;
+			}
+		}
+
+		/* Check that we found one resource if necessary. If not, skip
+		   to the closest time that a resource is free. Note that if
+		   there are no resources, resource_free will never get set,
+		   so we assume the meeting time is OK. */
+		if (meeting_time_ok && need_one_resource && !found_resource
+		    && resource_free) {
+			if (forward) {
+				start_time = *resource_free;
+			} else {
+				start_time = *resource_free;
+				e_meeting_time_selector_adjust_time (&start_time, -duration_days, -duration_hours, -duration_minutes);
+				}
+			meeting_time_ok = FALSE;
+		}
+
+		if (meeting_time_ok) {
+			mts->meeting_start_time = start_time;
+			mts->meeting_end_time = end_time;
+			mts->meeting_positions_valid = FALSE;
+			gtk_widget_queue_draw (mts->display_top);
+			gtk_widget_queue_draw (mts->display_main);
+
+			/* Make sure the time is shown. */
+			e_meeting_time_selector_ensure_meeting_time_shown (mts);
+
+			/* Set the times in the GnomeDateEdit widgets. */
+			e_meeting_time_selector_update_start_date_edit (mts);
+			e_meeting_time_selector_update_end_date_edit (mts);
+			return;
+		}
+
+		/* Move forward to the next possible interval. */
+		if (forward)
+			e_meeting_time_selector_find_nearest_interval (mts, &start_time, &end_time, duration_days, duration_hours, duration_minutes);
+		else
+			e_meeting_time_selector_find_nearest_interval_backward (mts, &start_time, &end_time, duration_days, duration_hours, duration_minutes);
+	}
+}
+
+
+static void
+e_meeting_time_selector_calculate_time_difference (EMeetingTime*start,
+						   EMeetingTime*end,
+						   gint *days,
+						   gint *hours,
+						   gint *minutes)
+{
+	*days = g_date_julian (&end->date) - g_date_julian (&start->date);
+	*hours = end->hour - start->hour;
+	*minutes = end->minute - start->minute;
+	if (*minutes < 0) {
+		*minutes += 60;
+		*hours = *hours - 1;
+	}
+	if (*hours < 0) {
+		*hours += 24;
+		*days = *days - 1;
+	}
+}
+
+
+/* This moves the given time forward to the next suitable start of a meeting.
+   If zoomed_out is set, this means every hour. If not every half-hour. */
+static void
+e_meeting_time_selector_find_nearest_interval (EMeetingTimeSelector *mts,
+					       EMeetingTime*start_time,
+					       EMeetingTime*end_time,
+					       gint days, gint hours, gint mins)
+{
+	gint minutes_shown;
+	gboolean set_to_start_of_working_day = FALSE;
+
+	if (mts->zoomed_out) {
+		start_time->hour++;
+		start_time->minute = 0;
+	} else {
+		start_time->minute += 30;
+		start_time->minute -= start_time->minute % 30;
+	}
+	e_meeting_time_selector_fix_time_overflows (start_time);
+
+	*end_time = *start_time;
+	e_meeting_time_selector_adjust_time (end_time, days, hours, mins);
+
+	/* Check if the interval is less than a day as seen in the display.
+	   If it isn't we don't worry about the working day. */
+	if (!mts->working_hours_only || days > 0)
+		return;
+	minutes_shown = (mts->day_end_hour - mts->day_start_hour) * 60;
+	minutes_shown += mts->day_end_minute - mts->day_start_minute;
+	if (hours * 60 + mins > minutes_shown)
+		return;
+
+	/* If the meeting time finishes past the end of the working day, move
+	   onto the start of the next working day. If the meeting time starts
+	   before the working day, move it on as well. */
+	if (start_time->hour > mts->day_end_hour
+	    || (start_time->hour == mts->day_end_hour
+		&& start_time->minute > mts->day_end_minute)
+	    || end_time->hour > mts->day_end_hour
+	    || (end_time->hour == mts->day_end_hour
+		&& end_time->minute > mts->day_end_minute)) {
+		g_date_add_days (&start_time->date, 1);
+		set_to_start_of_working_day = TRUE;
+	} else if (start_time->hour < mts->day_start_hour
+		   || (start_time->hour == mts->day_start_hour
+		       && start_time->minute < mts->day_start_minute)) {
+		set_to_start_of_working_day = TRUE;
+	}
+
+	if (set_to_start_of_working_day) {
+		start_time->hour = mts->day_start_hour;
+		start_time->minute = mts->day_start_minute;
+
+		if (mts->zoomed_out) {
+			if (start_time->minute > 0) {
+				start_time->hour++;
+				start_time->minute = 0;
+			}
+		} else {
+			start_time->minute += 29;
+			start_time->minute -= start_time->minute % 30;
+		}
+		e_meeting_time_selector_fix_time_overflows (start_time);
+
+		*end_time = *start_time;
+		e_meeting_time_selector_adjust_time (end_time, days, hours, mins);
+	}
+}
+
+
+/* This moves the given time backward to the next suitable start of a meeting.
+   If zoomed_out is set, this means every hour. If not every half-hour. */
+static void
+e_meeting_time_selector_find_nearest_interval_backward (EMeetingTimeSelector *mts,
+							EMeetingTime*start_time,
+							EMeetingTime*end_time,
+							gint days, gint hours, gint mins)
+{
+	gint new_hour, minutes_shown;
+	gboolean set_to_end_of_working_day = FALSE;
+
+	new_hour = start_time->hour;
+	if (mts->zoomed_out) {
+		if (start_time->minute == 0)
+			new_hour--;
+		start_time->minute = 0;
+	} else {
+		if (start_time->minute == 0) {
+			start_time->minute = 30;
+			new_hour--;
+		} else if (start_time->minute <= 30)
+			start_time->minute = 0;
+		else
+			start_time->minute = 30;
+	}
+	if (new_hour < 0) {
+		new_hour += 24;
+		g_date_subtract_days (&start_time->date, 1);
+	}
+	start_time->hour = new_hour;
+
+	*end_time = *start_time;
+	e_meeting_time_selector_adjust_time (end_time, days, hours, mins);
+
+	/* Check if the interval is less than a day as seen in the display.
+	   If it isn't we don't worry about the working day. */
+	if (!mts->working_hours_only || days > 0)
+		return;
+	minutes_shown = (mts->day_end_hour - mts->day_start_hour) * 60;
+	minutes_shown += mts->day_end_minute - mts->day_start_minute;
+	if (hours * 60 + mins > minutes_shown)
+		return;
+
+	/* If the meeting time finishes past the end of the working day, move
+	   back to the end of the working day. If the meeting time starts
+	   before the working day, move it back to the end of the previous
+	   working day. */
+	if (start_time->hour > mts->day_end_hour
+	    || (start_time->hour == mts->day_end_hour
+		&& start_time->minute > mts->day_end_minute)
+	    || end_time->hour > mts->day_end_hour
+	    || (end_time->hour == mts->day_end_hour
+		&& end_time->minute > mts->day_end_minute)) {
+		set_to_end_of_working_day = TRUE;
+	} else if (start_time->hour < mts->day_start_hour
+		   || (start_time->hour == mts->day_start_hour
+		       && start_time->minute < mts->day_start_minute)) {
+		g_date_subtract_days (&end_time->date, 1);
+		set_to_end_of_working_day = TRUE;
+	}
+
+	if (set_to_end_of_working_day) {
+		end_time->hour = mts->day_end_hour;
+		end_time->minute = mts->day_end_minute;
+		*start_time = *end_time;
+		e_meeting_time_selector_adjust_time (start_time, -days, -hours, -mins);
+
+		if (mts->zoomed_out) {
+			start_time->minute = 0;
+		} else {
+			start_time->minute -= start_time->minute % 30;
+		}
+
+		*end_time = *start_time;
+		e_meeting_time_selector_adjust_time (end_time, days, hours, mins);
+	}
+}
+
+
+/* This adds on the given days, hours & minutes to a EMeetingTimeSelectorTime.
+   It is used to calculate the end of a period given a start & duration.
+   Days, hours & minutes can be negative, to move backwards, but they should
+   be within normal ranges, e.g. hours should be between -23 and 23. */
+static void
+e_meeting_time_selector_adjust_time (EMeetingTime*mtstime,
+				     gint days, gint hours, gint minutes)
+{
+	gint new_hours, new_minutes;
+
+	/* We have to handle negative values for hous and minutes here, since
+	   EMeetingTimeuses guint8s to store them. */
+	new_minutes = mtstime->minute + minutes;
+	if (new_minutes < 0) {
+		new_minutes += 60;
+		hours -= 1;
+	}
+
+	new_hours = mtstime->hour + hours;
+	if (new_hours < 0) {
+		new_hours += 24;
+		days -= 1;
+	}
+
+	g_date_add_days (&mtstime->date, days);
+	mtstime->hour = new_hours;
+	mtstime->minute = new_minutes;
+
+	e_meeting_time_selector_fix_time_overflows (mtstime);
+}
+
+
+/* This looks for any busy period of the given attendee which clashes with
+   the start and end time. It uses a binary search. */
+static EMeetingFreeBusyPeriod *
+e_meeting_time_selector_find_time_clash (EMeetingTimeSelector *mts,
+					 EMeetingAttendee *attendee,
+					 EMeetingTime*start_time,
+					 EMeetingTime*end_time)
+{
+	EMeetingFreeBusyPeriod *period;
+	const GArray *busy_periods;
+	gint period_num;
+
+	busy_periods = e_meeting_attendee_get_busy_periods (attendee);
+	period_num = e_meeting_attendee_find_first_busy_period (attendee, &start_time->date);
+
+	if (period_num == -1)
+		return NULL;
+
+	/* Step forward through the busy periods until we find a clash or we
+	   go past the end_time. */
+	while (period_num < busy_periods->len) {
+		period = &g_array_index (busy_periods,  EMeetingFreeBusyPeriod, period_num);
+
+		/* If the period starts at or after the end time, there is no
+		   clash and we are finished. The busy periods are sorted by
+		   their start times, so all the rest will be later. */
+		if (e_meeting_time_selector_compare_times (&period->start, end_time) >= 0)
+			return NULL;
+
+		/* If the period ends after the start time, we have found a
+		   clash. From the above test we already know the busy period
+		   isn't completely after the meeting time. */
+		if (e_meeting_time_selector_compare_times (&period->end, start_time) > 0)
+			return period;
+
+		period_num++;
+	}
+
+	return NULL;
+}
+
+static void
+e_meeting_time_selector_on_zoomed_out_toggled (GtkWidget *menuitem,
+					       EMeetingTimeSelector *mts)
+{
+	/* Make sure the menu pops down, which doesn't happen by default if
+	   keyboard accelerators are used. */
+	if (GTK_WIDGET_VISIBLE (mts->options_menu))
+		gtk_menu_popdown (GTK_MENU (mts->options_menu));
+
+	e_meeting_time_selector_set_zoomed_out (mts, GTK_CHECK_MENU_ITEM (menuitem)->active);
+}
+
+
+static void
+e_meeting_time_selector_on_working_hours_toggled (GtkWidget *menuitem,
+						  EMeetingTimeSelector *mts)
+{
+	/* Make sure the menu pops down, which doesn't happen by default if
+	   keyboard accelerators are used. */
+	if (GTK_WIDGET_VISIBLE (mts->options_menu))
+		gtk_menu_popdown (GTK_MENU (mts->options_menu));
+
+	e_meeting_time_selector_set_working_hours_only (mts, GTK_CHECK_MENU_ITEM (menuitem)->active);
+}
+
+
+/* This recalculates day_width, first_hour_shown and last_hour_shown. */
+static void
+e_meeting_time_selector_recalc_grid (EMeetingTimeSelector *mts)
+{
+	if (mts->working_hours_only) {
+		mts->first_hour_shown = mts->day_start_hour;
+		mts->last_hour_shown = mts->day_end_hour;
+		if (mts->day_end_minute != 0)
+			mts->last_hour_shown += 1;
+	} else {
+		mts->first_hour_shown = 0;
+		mts->last_hour_shown = 24;
+	}
+
+	/* In the brief view we use the nearest hours divisible by 3. */
+	if (mts->zoomed_out) {
+		mts->first_hour_shown -= mts->first_hour_shown % 3;
+		mts->last_hour_shown += 2;
+		mts->last_hour_shown -= mts->last_hour_shown % 3;
+	}
+
+	mts->day_width = mts->col_width	* (mts->last_hour_shown - mts->first_hour_shown);
+	if (mts->zoomed_out)
+		mts->day_width /= 3;
+
+	/* Add one pixel for the extra vertical grid line. */
+	mts->day_width++;
+
+	gnome_canvas_set_scroll_region (GNOME_CANVAS (mts->display_top),
+					0, 0,
+					mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN,
+					mts->row_height * 3);
+	e_meeting_time_selector_update_main_canvas_scroll_region (mts);
+
+	e_meeting_time_selector_recalc_date_format (mts);
+	mts->meeting_positions_valid = FALSE;
+}
+
+
+/* This saves the first visible time in the given EMeetingTimeSelectorTime. */
+static void
+e_meeting_time_selector_save_position (EMeetingTimeSelector *mts,
+				       EMeetingTime*mtstime)
+{
+	gint scroll_x, scroll_y;
+
+	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+					 &scroll_x, &scroll_y);
+	e_meeting_time_selector_calculate_time (mts, scroll_x, mtstime);
+}
+
+
+/* This restores a saved position. */
+static void
+e_meeting_time_selector_restore_position (EMeetingTimeSelector *mts,
+					  EMeetingTime*mtstime)
+{
+	gint scroll_x, scroll_y, new_scroll_x;
+
+	new_scroll_x = e_meeting_time_selector_calculate_time_position (mts,
+								      mtstime);
+	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+					 &scroll_x, &scroll_y);
+	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_main),
+				new_scroll_x, scroll_y);
+}
+
+
+/* This returns the x pixel coords of the meeting time in the entire scroll
+   region. It recalculates them if they have been marked as invalid.
+   If it returns FALSE then no meeting time is set or the meeting time is
+   not visible in the current scroll area. */
+gboolean
+e_meeting_time_selector_get_meeting_time_positions (EMeetingTimeSelector *mts,
+						    gint *start_x,
+						    gint *end_x)
+{
+	if (mts->meeting_positions_valid) {
+		if (mts->meeting_positions_in_scroll_area) {
+			*start_x = mts->meeting_start_x;
+			*end_x = mts->meeting_end_x;
+			return TRUE;
+		} else {
+			return FALSE;
+		}
+	}
+
+	mts->meeting_positions_valid = TRUE;
+
+	/* Check if the days aren't in our current range. */
+	if (g_date_compare (&mts->meeting_start_time.date, &mts->last_date_shown) > 0
+	    || g_date_compare (&mts->meeting_end_time.date, &mts->first_date_shown) < 0) {
+		mts->meeting_positions_in_scroll_area = FALSE;
+		return FALSE;
+	}
+
+	mts->meeting_positions_in_scroll_area = TRUE;
+	*start_x = mts->meeting_start_x = e_meeting_time_selector_calculate_time_position (mts, &mts->meeting_start_time);
+	*end_x = mts->meeting_end_x = e_meeting_time_selector_calculate_time_position (mts, &mts->meeting_end_time);
+
+	return TRUE;
+}
+
+
+/* This recalculates the date format to used, by computing the width of the
+   longest date strings in the widget's font and seeing if they fit. */
+static void
+e_meeting_time_selector_recalc_date_format (EMeetingTimeSelector *mts)
+{
+	/* An array of dates, one for each month in the year 2000. They must
+	   all be Sundays. */
+	static const int days[12] = { 23, 20, 19, 23, 21, 18,
+				      23, 20, 17, 22, 19, 24 };
+	GDate date;
+	gint max_date_width, longest_weekday_width, longest_month_width, width;
+	gint day, longest_weekday, month, longest_month;
+	gchar buffer[128];
+	GdkFont *font;
+
+	font = GTK_WIDGET (mts)->style->font;
+
+	/* Calculate the maximum date width we can fit into the display. */
+	max_date_width = mts->day_width - 2;
+
+	/* Find the biggest full weekday name. We start on a particular
+	   Monday and go through seven days. */
+	g_date_clear (&date, 1);
+	g_date_set_dmy (&date, 3, 1, 2000);	/* Monday 3rd Jan 2000. */
+	longest_weekday_width = 0;
+	longest_weekday = G_DATE_MONDAY;
+	for (day = G_DATE_MONDAY; day <= G_DATE_SUNDAY; day++) {
+		g_date_strftime (buffer, sizeof (buffer), "%A", &date);
+		width = gdk_string_width (font, buffer);
+		if (width > longest_weekday_width) {
+			longest_weekday = day;
+			longest_weekday_width = width;
+		}
+		g_date_add_days (&date, 1);
+	}
+
+	/* Now find the biggest month name. */
+	longest_month_width = 0;
+	longest_month = G_DATE_JANUARY;
+	for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) {
+		g_date_set_month (&date, month);
+		g_date_strftime (buffer, sizeof (buffer), "%B", &date);
+		width = gdk_string_width (font, buffer);
+		if (width > longest_month_width) {
+			longest_month = month;
+			longest_month_width = width;
+		}
+	}
+
+	/* See if we can use the full date. We want to use a date with a
+	   month day > 20 and also the longest weekday. We use a
+	   pre-calculated array of days for each month and add on the
+	   weekday (which is 1 (Mon) to 7 (Sun). */
+	g_date_set_dmy (&date, days[longest_month - 1] + longest_weekday,
+			longest_month, 2000);
+	/* This is a strftime() format string %A = full weekday name,
+	   %B = full month name, %d = month day, %Y = full year. */
+	g_date_strftime (buffer, sizeof (buffer), _("%A, %B %d, %Y"), &date);
+
+	g_print ("longest_month: %i longest_weekday: %i date: %s\n",
+		 longest_month, longest_weekday, buffer);
+	
+	if (gdk_string_width (font, buffer) < max_date_width) {
+		mts->date_format = E_MEETING_TIME_SELECTOR_DATE_FULL;
+		return;
+	}
+
+	/* Now try it with abbreviated weekday names. */
+	longest_weekday_width = 0;
+	longest_weekday = G_DATE_MONDAY;
+	g_date_set_dmy (&date, 3, 1, 2000);	/* Monday 3rd Jan 2000. */
+	for (day = G_DATE_MONDAY; day <= G_DATE_SUNDAY; day++) {
+		g_date_strftime (buffer, sizeof (buffer), "%a", &date);
+		width = gdk_string_width (font, buffer);
+		if (width > longest_weekday_width) {
+			longest_weekday = day;
+			longest_weekday_width = width;
+		}
+		g_date_add_days (&date, 1);
+	}
+
+	g_date_set_dmy (&date, days[longest_month - 1] + longest_weekday,
+			longest_month, 2000);
+	/* This is a strftime() format string %a = abbreviated weekday name,
+	   %m = month number, %d = month day, %Y = full year. */
+	g_date_strftime (buffer, sizeof (buffer), _("%a %m/%d/%Y"), &date);
+
+	g_print ("longest_month: %i longest_weekday: %i date: %s\n",
+		 longest_month, longest_weekday, buffer);
+	
+	if (gdk_string_width (font, buffer) < max_date_width)
+		mts->date_format = E_MEETING_TIME_SELECTOR_DATE_ABBREVIATED_DAY;
+	else
+		mts->date_format = E_MEETING_TIME_SELECTOR_DATE_SHORT;
+}
+
+
+/* Turn off the background of the canvas windows. This reduces flicker
+   considerably when scrolling. (Why isn't it in GnomeCanvas?). */
+static void
+e_meeting_time_selector_on_canvas_realized (GtkWidget *widget,
+					    EMeetingTimeSelector *mts)
+{
+	gdk_window_set_back_pixmap (GTK_LAYOUT (widget)->bin_window,
+				    NULL, FALSE);
+}
+
+
+/* This is called when the meeting start time GnomeDateEdit is changed,
+   either via the "date_changed". "time_changed" or "activate" signals on one
+   of the GtkEntry widgets. So don't use the widget parameter since it may be
+   one of the child GtkEntry widgets. */
+static void
+e_meeting_time_selector_on_start_time_changed (GtkWidget *widget,
+					       EMeetingTimeSelector *mts)
+{
+	gint duration_days, duration_hours, duration_minutes;
+	EMeetingTime mtstime;
+	time_t newtime;
+	struct tm *newtime_tm;
+
+	newtime = e_date_edit_get_time (E_DATE_EDIT (mts->start_date_edit));
+	newtime_tm = localtime (&newtime);
+	g_date_clear (&mtstime.date, 1);
+	g_date_set_time (&mtstime.date, newtime);
+	mtstime.hour = newtime_tm->tm_hour;
+	mtstime.minute = newtime_tm->tm_min;
+
+	/* If the time hasn't changed, just return. */
+	if (e_meeting_time_selector_compare_times (&mtstime, &mts->meeting_start_time) == 0)
+		return;
+
+	/* Calculate the current meeting duration. */
+	e_meeting_time_selector_calculate_time_difference (&mts->meeting_start_time, &mts->meeting_end_time, &duration_days, &duration_hours, &duration_minutes);
+
+	/* Set the new start time. */
+	mts->meeting_start_time = mtstime;
+
+	/* Update the end time so the meeting duration stays the same. */
+	mts->meeting_end_time = mts->meeting_start_time;
+	e_meeting_time_selector_adjust_time (&mts->meeting_end_time, duration_days, duration_hours, duration_minutes);
+	e_meeting_time_selector_update_end_date_edit (mts);
+
+	mts->meeting_positions_valid = FALSE;
+	e_meeting_time_selector_ensure_meeting_time_shown (mts);
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+}
+
+
+/* This is called when the meeting end time GnomeDateEdit is changed,
+   either via the "date_changed", "time_changed" or "activate" signals on one
+   of the GtkEntry widgets. So don't use the widget parameter since it may be
+   one of the child GtkEntry widgets. */
+static void
+e_meeting_time_selector_on_end_time_changed (GtkWidget *widget,
+					     EMeetingTimeSelector *mts)
+{
+	EMeetingTime mtstime;
+	time_t newtime;
+	struct tm *newtime_tm;
+
+	newtime = e_date_edit_get_time (E_DATE_EDIT (mts->end_date_edit));
+	newtime_tm = localtime (&newtime);
+	g_date_clear (&mtstime.date, 1);
+	g_date_set_time (&mtstime.date, newtime);
+	mtstime.hour = newtime_tm->tm_hour;
+	mtstime.minute = newtime_tm->tm_min;
+
+	/* If the time hasn't changed, just return. */
+	if (e_meeting_time_selector_compare_times (&mtstime, &mts->meeting_end_time) == 0)
+		return;
+
+	/* Set the new end time. */
+	mts->meeting_end_time = mtstime;
+
+	/* If the start time is after the end time, set it to the same time. */
+	if (e_meeting_time_selector_compare_times (&mtstime, &mts->meeting_start_time) < 0) {
+		/* We set it first, before updating the widget, so the signal
+		   handler will just return. */
+		mts->meeting_start_time = mtstime;
+		e_meeting_time_selector_update_start_date_edit (mts);
+	}
+
+	mts->meeting_positions_valid = FALSE;
+	e_meeting_time_selector_ensure_meeting_time_shown (mts);
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+}
+
+
+/* This updates the ranges shown in the GnomeDateEdit popup menus, according
+   to working_hours_only etc. */
+static void
+e_meeting_time_selector_update_date_popup_menus (EMeetingTimeSelector *mts)
+{
+	EDateEdit *start_edit, *end_edit;
+	gint low_hour, high_hour;
+
+	start_edit = E_DATE_EDIT (mts->start_date_edit);
+	end_edit = E_DATE_EDIT (mts->end_date_edit);
+
+	if (mts->working_hours_only) {
+		low_hour = mts->day_start_hour;
+		high_hour = mts->day_end_hour;
+	} else {
+		low_hour = 0;
+		high_hour = 23;
+	}
+
+	e_date_edit_set_time_popup_range (start_edit, low_hour, high_hour);
+	e_date_edit_set_time_popup_range (end_edit, low_hour, high_hour);
+}
+
+
+static void
+e_meeting_time_selector_on_canvas_size_allocate (GtkWidget *widget,
+						 GtkAllocation *allocation,
+						 EMeetingTimeSelector *mts)
+{
+	e_meeting_time_selector_update_main_canvas_scroll_region (mts);
+
+	e_meeting_time_selector_ensure_meeting_time_shown (mts);
+}
+
+/* This updates the canvas scroll regions according to the number of attendees.
+   If the total height needed is less than the height of the canvas, we must
+   use the height of the canvas, or it causes problems. */
+static void
+e_meeting_time_selector_update_main_canvas_scroll_region (EMeetingTimeSelector *mts)
+{
+	gint height, canvas_height;
+
+	height = mts->row_height * (e_meeting_model_count_attendees (mts->model) + 1);
+	canvas_height = GTK_WIDGET (mts->display_main)->allocation.height;
+
+	height = MAX (height,  canvas_height);
+
+	gnome_canvas_set_scroll_region (GNOME_CANVAS (mts->display_main),
+					0, 0,
+					mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN,
+					height);
+}
+
+
+/* This changes the meeting time based on the given x coordinate and whether
+   we are dragging the start or end bar. It returns the new position, which
+   will be swapped if the start bar is dragged past the end bar or vice versa.
+   It make sure the meeting time is never dragged outside the visible canvas
+   area. */
+void
+e_meeting_time_selector_drag_meeting_time (EMeetingTimeSelector *mts,
+					   gint x)
+{
+	EMeetingTime first_time, last_time, drag_time, *time_to_set;
+	gint scroll_x, scroll_y, canvas_width;
+	gboolean set_both_times = FALSE;
+
+	/* Get the x coords of visible part of the canvas. */
+	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+					 &scroll_x, &scroll_y);
+	canvas_width = mts->display_main->allocation.width;
+
+	/* Save the x coordinate for the timeout handler. */
+	mts->last_drag_x = (x < scroll_x) ? x - scroll_x
+		: x - scroll_x - canvas_width + 1;
+
+	/* Check if the mouse is off the edge of the canvas. */
+	if (x < scroll_x || x > scroll_x + canvas_width) {
+		/* If we haven't added a timeout function, add one. */
+		if (mts->auto_scroll_timeout_id == 0) {
+			mts->auto_scroll_timeout_id = g_timeout_add (60, e_meeting_time_selector_timeout_handler, mts);
+			mts->scroll_count = 0;
+
+			/* Call the handler to start scrolling now. */
+			e_meeting_time_selector_timeout_handler (mts);
+			return;
+		}
+	} else {
+		e_meeting_time_selector_remove_timeout (mts);
+	}
+
+	/* Calculate the minimum & maximum times we can use, based on the
+	   scroll offsets and whether zoomed_out is set. */
+	e_meeting_time_selector_calculate_time (mts, scroll_x, &first_time);
+	e_meeting_time_selector_calculate_time (mts, scroll_x + canvas_width - 1,
+						&last_time);
+	if (mts->zoomed_out) {
+		if (first_time.minute > 30)
+			first_time.hour++;
+		first_time.minute = 0;
+		last_time.minute = 0;
+	} else {
+		first_time.minute += 15;
+		first_time.minute -= first_time.minute % 30;
+		last_time.minute -= last_time.minute % 30;
+	}
+	e_meeting_time_selector_fix_time_overflows (&first_time);
+	e_meeting_time_selector_fix_time_overflows (&last_time);
+
+	/* Calculate the time from x coordinate. */
+	e_meeting_time_selector_calculate_time (mts, x, &drag_time);
+
+	/* Calculate the nearest half-hour or hour, depending on whether
+	   zoomed_out is set. */
+	if (mts->zoomed_out) {
+		if (drag_time.minute > 30)
+			drag_time.hour++;
+		drag_time.minute = 0;
+	} else {
+		drag_time.minute += 15;
+		drag_time.minute -= drag_time.minute % 30;
+	}
+	e_meeting_time_selector_fix_time_overflows (&drag_time);
+
+	/* Now make sure we are between first_time & last_time. */
+	if (e_meeting_time_selector_compare_times (&drag_time, &first_time) < 0)
+		drag_time = first_time;
+	if (e_meeting_time_selector_compare_times (&drag_time, &last_time) > 0)
+		drag_time = last_time;
+
+	/* Set the meeting start or end time to drag_time. */
+	if (mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_START)
+		time_to_set = &mts->meeting_start_time;
+	else
+		time_to_set = &mts->meeting_end_time;
+
+	/* If the time is unchanged, just return. */
+	if (e_meeting_time_selector_compare_times (time_to_set, &drag_time) == 0)
+		return;
+
+	*time_to_set = drag_time;
+
+	/* Check if the start time and end time need to be switched. */
+	if (e_meeting_time_selector_compare_times (&mts->meeting_start_time,
+						 &mts->meeting_end_time) > 0) {
+		drag_time = mts->meeting_start_time;
+		mts->meeting_start_time = mts->meeting_end_time;
+		mts->meeting_end_time = drag_time;
+
+		if (mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_START)
+			mts->dragging_position = E_MEETING_TIME_SELECTOR_POS_END;
+		else
+			mts->dragging_position = E_MEETING_TIME_SELECTOR_POS_START;
+
+		set_both_times = TRUE;
+	}
+
+	/* Mark the calculated positions as invalid. */
+	mts->meeting_positions_valid = FALSE;
+
+	/* Redraw the canvases. */
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+
+	/* Set the times in the GnomeDateEdit widgets. */
+	if (set_both_times
+	    || mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_START)
+		e_meeting_time_selector_update_start_date_edit (mts);
+
+	if (set_both_times
+	    || mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_END)
+		e_meeting_time_selector_update_end_date_edit (mts);
+}
+
+
+/* This is the timeout function which handles auto-scrolling when the user is
+   dragging one of the meeting time vertical bars outside the left or right
+   edge of the canvas. */
+static gboolean
+e_meeting_time_selector_timeout_handler (gpointer data)
+{
+	EMeetingTimeSelector *mts;
+	EMeetingTime drag_time, *time_to_set;
+	gint scroll_x, max_scroll_x, scroll_y, canvas_width;
+	gint scroll_speed, scroll_offset;
+	gboolean set_both_times = FALSE;
+
+	mts = E_MEETING_TIME_SELECTOR (data);
+
+	GDK_THREADS_ENTER ();
+
+	/* Return if we don't need to scroll yet. */
+	if (mts->scroll_count-- > 0) {
+		GDK_THREADS_LEAVE ();
+		return TRUE;
+	}
+
+	/* Get the x coords of visible part of the canvas. */
+	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+					 &scroll_x, &scroll_y);
+	canvas_width = mts->display_main->allocation.width;
+
+	/* Calculate the scroll delay, between 0 and MAX_SCROLL_SPEED. */
+	scroll_speed = abs (mts->last_drag_x / E_MEETING_TIME_SELECTOR_SCROLL_INCREMENT_WIDTH);
+	scroll_speed = MIN (scroll_speed,
+			    E_MEETING_TIME_SELECTOR_MAX_SCROLL_SPEED);
+
+	/* Reset the scroll count. */
+	mts->scroll_count = E_MEETING_TIME_SELECTOR_MAX_SCROLL_SPEED - scroll_speed;
+
+	/* Calculate how much we need to scroll. */
+	if (mts->last_drag_x >= 0)
+		scroll_offset = mts->col_width;
+	else
+		scroll_offset = -mts->col_width;
+
+	scroll_x += scroll_offset;
+	max_scroll_x = (mts->day_width * E_MEETING_TIME_SELECTOR_DAYS_SHOWN)
+		- canvas_width;
+	scroll_x = CLAMP (scroll_x, 0, max_scroll_x);
+
+	/* Calculate the minimum or maximum visible time in the canvas, which
+	   we will now set the dragged time to. */
+	if (scroll_offset > 0) {
+		e_meeting_time_selector_calculate_time (mts,
+						      scroll_x + canvas_width - 1,
+						      &drag_time);
+		if (mts->zoomed_out) {
+			drag_time.minute = 0;
+		} else {
+			drag_time.minute -= drag_time.minute % 30;
+		}
+	} else {
+		e_meeting_time_selector_calculate_time (mts, scroll_x,
+							&drag_time);
+		if (mts->zoomed_out) {
+			if (drag_time.minute > 30)
+				drag_time.hour++;
+			drag_time.minute = 0;
+		} else {
+			drag_time.minute += 15;
+			drag_time.minute -= drag_time.minute % 30;
+		}
+	}
+	e_meeting_time_selector_fix_time_overflows (&drag_time);
+
+	/* Set the meeting start or end time to drag_time. */
+	if (mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_START)
+		time_to_set = &mts->meeting_start_time;
+	else
+		time_to_set = &mts->meeting_end_time;
+
+	/* If the time is unchanged, just return. */
+	if (e_meeting_time_selector_compare_times (time_to_set, &drag_time) == 0) {
+		GDK_THREADS_LEAVE ();
+		return TRUE;
+	}
+
+	*time_to_set = drag_time;
+
+	/* Check if the start time and end time need to be switched. */
+	if (e_meeting_time_selector_compare_times (&mts->meeting_start_time, &mts->meeting_end_time) > 0) {
+		drag_time = mts->meeting_start_time;
+		mts->meeting_start_time = mts->meeting_end_time;
+		mts->meeting_end_time = drag_time;
+
+		if (mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_START)
+			mts->dragging_position = E_MEETING_TIME_SELECTOR_POS_END;
+		else
+			mts->dragging_position = E_MEETING_TIME_SELECTOR_POS_START;
+
+		set_both_times = TRUE;
+	}
+
+	/* Mark the calculated positions as invalid. */
+	mts->meeting_positions_valid = FALSE;
+
+	/* Set the times in the GnomeDateEdit widgets. */
+	if (set_both_times
+	    || mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_START)
+		e_meeting_time_selector_update_start_date_edit (mts);
+
+	if (set_both_times
+	    || mts->dragging_position == E_MEETING_TIME_SELECTOR_POS_END)
+		e_meeting_time_selector_update_end_date_edit (mts);
+
+	/* Redraw the canvases. We freeze and thaw the layouts so that they
+	   get redrawn completely. Otherwise the pixels get scrolled left or
+	   right which is not good for us (since our vertical bars have been
+	   moved) and causes flicker. */
+	gtk_layout_freeze (GTK_LAYOUT (mts->display_main));
+	gtk_layout_freeze (GTK_LAYOUT (mts->display_top));
+	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_main),
+				scroll_x, scroll_y);
+	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_top),
+				scroll_x, scroll_y);
+	gtk_layout_thaw (GTK_LAYOUT (mts->display_main));
+	gtk_layout_thaw (GTK_LAYOUT (mts->display_top));
+
+	GDK_THREADS_LEAVE ();
+	return TRUE;
+}
+
+
+/* This removes our auto-scroll timeout function, if we have one installed. */
+void
+e_meeting_time_selector_remove_timeout (EMeetingTimeSelector *mts)
+{
+	if (mts->auto_scroll_timeout_id) {
+		g_source_remove (mts->auto_scroll_timeout_id);
+		mts->auto_scroll_timeout_id = 0;
+	}
+}
+
+
+/* This updates the GnomeDateEdit widget displaying the meeting start time. */
+static void
+e_meeting_time_selector_update_start_date_edit (EMeetingTimeSelector *mts)
+{
+	struct tm start_tm;
+	time_t start_time_t;
+
+	g_date_to_struct_tm (&mts->meeting_start_time.date, &start_tm);
+	start_tm.tm_hour = mts->meeting_start_time.hour;
+	start_tm.tm_min = mts->meeting_start_time.minute;
+	start_time_t = mktime (&start_tm);
+	e_date_edit_set_time (E_DATE_EDIT (mts->start_date_edit),
+			      start_time_t);
+}
+
+
+/* This updates the GnomeDateEdit widget displaying the meeting end time. */
+static void
+e_meeting_time_selector_update_end_date_edit (EMeetingTimeSelector *mts)
+{
+	struct tm end_tm;
+	time_t end_time_t;
+
+	g_date_to_struct_tm (&mts->meeting_end_time.date, &end_tm);
+	end_tm.tm_hour = mts->meeting_end_time.hour;
+	end_tm.tm_min = mts->meeting_end_time.minute;
+	end_time_t = mktime (&end_tm);
+	e_date_edit_set_time (E_DATE_EDIT (mts->end_date_edit),
+			      end_time_t);
+}
+
+
+/* This ensures that the meeting time is shown on screen, by scrolling the
+   canvas and possibly by changing the range of dates shown in the canvas. */
+static void
+e_meeting_time_selector_ensure_meeting_time_shown (EMeetingTimeSelector *mts)
+{
+	gint start_x, end_x, scroll_x, scroll_y, canvas_width;
+	gint new_scroll_x;
+	gboolean fits_in_canvas;
+
+	/* Check if we need to change the range of dates shown. */
+	if (g_date_compare (&mts->meeting_start_time.date,
+			    &mts->first_date_shown) < 0
+	    || g_date_compare (&mts->meeting_end_time.date,
+			       &mts->last_date_shown) > 0) {
+		e_meeting_time_selector_update_dates_shown (mts);
+		gtk_widget_queue_draw (mts->display_top);
+		gtk_widget_queue_draw (mts->display_main);
+	}
+
+	/* If all of the meeting time is visible, just return. */
+	e_meeting_time_selector_get_meeting_time_positions (mts, &start_x,
+							    &end_x);
+	gnome_canvas_get_scroll_offsets (GNOME_CANVAS (mts->display_main),
+					 &scroll_x, &scroll_y);
+	canvas_width = mts->display_main->allocation.width;
+	if (start_x > scroll_x && end_x <= scroll_x + canvas_width)
+		return;
+
+	fits_in_canvas = end_x - start_x < canvas_width ? TRUE : FALSE;
+
+	/* If the meeting is not entirely visible, either center it if it is
+	   smaller than the canvas, or show the start of it if it is big. */
+	if (fits_in_canvas) {
+		new_scroll_x = (start_x + end_x - canvas_width) / 2;
+	} else {
+		new_scroll_x = start_x;
+	}
+	gnome_canvas_scroll_to (GNOME_CANVAS (mts->display_main),
+				new_scroll_x, scroll_y);
+}
+
+
+/* This updates the range of dates shown in the canvas, to make sure that the
+   currently selected meeting time is in the range. */
+static void
+e_meeting_time_selector_update_dates_shown (EMeetingTimeSelector *mts)
+{
+	mts->first_date_shown = mts->meeting_start_time.date;
+	g_date_subtract_days (&mts->first_date_shown, 60);
+
+	mts->last_date_shown = mts->first_date_shown;
+	g_date_add_days (&mts->last_date_shown, E_MEETING_TIME_SELECTOR_DAYS_SHOWN - 1);
+}
+
+
+/* This checks if the time's hour is over 24 or its minute is over 60 and if
+   so it updates the day/hour appropriately. Note that hours and minutes are
+   stored in guint8's so they can't overflow by much. */
+void
+e_meeting_time_selector_fix_time_overflows (EMeetingTime*mtstime)
+{
+	gint hours_to_add, days_to_add;
+
+	hours_to_add = mtstime->minute / 60;
+	if (hours_to_add > 0) {
+		mtstime->minute -= hours_to_add * 60;
+		mtstime->hour += hours_to_add;
+	}
+
+	days_to_add = mtstime->hour / 24;
+	if (days_to_add > 0) {
+		mtstime->hour -= days_to_add * 24;
+		g_date_add_days (&mtstime->date, days_to_add);
+	}
+}
+
+/*
+ * CONVERSION ROUTINES - functions to convert between different coordinate
+ *			 spaces and dates.
+ */
+
+/* This takes an x pixel coordinate within the entire canvas scroll region and
+   returns the date in which it falls. If day_position is not NULL it also
+   returns the x coordinate within the date, relative to the visible part of
+   the canvas. It is used when painting the days in the item_draw function.
+   Note that it must handle negative x coordinates in case we are dragging off
+   the edge of the canvas. */
+void
+e_meeting_time_selector_calculate_day_and_position (EMeetingTimeSelector *mts,
+						    gint x,
+						    GDate *date,
+						    gint *day_position)
+{
+	gint days_from_first_shown;
+
+	*date = mts->first_date_shown;
+
+	if (x >= 0) {
+		days_from_first_shown = x / mts->day_width;
+		g_date_add_days (date, days_from_first_shown);
+		if (day_position)
+			*day_position = - x % mts->day_width;
+	} else {
+		days_from_first_shown = -x / mts->day_width + 1;
+		g_date_subtract_days (date, days_from_first_shown);
+		if (day_position)
+			*day_position = -mts->day_width - x % mts->day_width;
+	}
+}
+
+
+/* This takes an x pixel coordinate within a day, and converts it to hours
+   and minutes, depending on working_hours_only and zoomed_out. */
+void
+e_meeting_time_selector_convert_day_position_to_hours_and_mins (EMeetingTimeSelector *mts, gint day_position, guint8 *hours, guint8 *minutes)
+{
+	if (mts->zoomed_out)
+		day_position *= 3;
+
+	/* Calculate the hours & minutes from the first displayed. */
+	*hours = day_position / mts->col_width;
+	*minutes = (day_position % mts->col_width) * 60 / mts->col_width;
+
+	/* Now add on the first hour shown. */
+	*hours += mts->first_hour_shown;
+}
+
+
+/* This takes an x pixel coordinate within the entire canvas scroll region and
+   returns the time in which it falls. Note that it won't be extremely
+   accurate since hours may only be a few pixels wide in the display.
+   With zoomed_out set each pixel may represent 5 minutes or more, depending
+   on how small the font is. */
+void
+e_meeting_time_selector_calculate_time (EMeetingTimeSelector *mts,
+					gint x,
+					EMeetingTime*time)
+{
+	gint day_position;
+
+	/* First get the day and the x position within the day. */
+	e_meeting_time_selector_calculate_day_and_position (mts, x, &time->date,
+							    NULL);
+
+	/* Now convert the day_position into an hour and minute. */
+	if (x >= 0)
+		day_position = x % mts->day_width;
+	else
+		day_position = mts->day_width + x % mts->day_width;
+
+	e_meeting_time_selector_convert_day_position_to_hours_and_mins (mts, day_position, &time->hour, &time->minute);
+}
+
+
+/* This takes a EMeetingTime and calculates the x pixel coordinate
+   within the entire canvas scroll region. It is used to draw the selected
+   meeting time and all the busy periods. */
+gint
+e_meeting_time_selector_calculate_time_position (EMeetingTimeSelector *mts,
+						 EMeetingTime *mtstime)
+{
+	gint x, date_offset, day_offset;
+
+	/* Calculate the number of days since the first date shown in the
+	   entire canvas scroll region. */
+	date_offset = g_date_julian (&mtstime->date) - g_date_julian (&mts->first_date_shown);
+
+	/* Calculate the x pixel coordinate of the start of the day. */
+	x = date_offset * mts->day_width;
+
+	/* Add on the hours and minutes, depending on whether zoomed_out and
+	   working_hours_only are set. */
+	day_offset = (mtstime->hour - mts->first_hour_shown) * 60
+		+ mtstime->minute;
+	/* The day width includes an extra vertical grid line so subtract 1. */
+	day_offset *= (mts->day_width - 1);
+	day_offset /= (mts->last_hour_shown - mts->first_hour_shown) * 60;
+
+	/* Clamp the day_offset in case the time isn't actually visible. */
+	x += CLAMP (day_offset, 0, mts->day_width);
+
+	return x;
+}
+
+static void
+row_count_changed_cb (ETableModel *etm, int row, int count, gpointer data)
+{
+	EMeetingTimeSelector *mts = E_MEETING_TIME_SELECTOR (data);
+
+	/* Update the scroll region. */
+	e_meeting_time_selector_update_main_canvas_scroll_region (mts);
+
+	/* Redraw */
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+}
+
+static void
+sort_info_changed_cb (ETableSortInfo *info, gpointer data)
+{
+	EMeetingTimeSelector *mts = E_MEETING_TIME_SELECTOR (data);
+
+	/* Redraw */
+	gtk_widget_queue_draw (mts->display_top);
+	gtk_widget_queue_draw (mts->display_main);
+}