path: root/calendar/gui/e-week-view.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Damon Chaplin <damon@ximian.com>
 *      Rodrigo Moya <rodrigo@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

/*
 * EWeekView - displays the Week & Month views of the calendar.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "e-week-view.h"
#include "ea-calendar.h"

#include <math.h>
#include <gdk/gdkkeysyms.h>
#include <glib/gi18n.h>
#include <libgnomecanvas/libgnomecanvas.h>
#include <text/e-text.h>
#include <misc/e-canvas-utils.h>
#include <e-util/e-unicode.h>
#include <e-util/e-categories-config.h>
#include <e-util/e-dialog-utils.h>
#include <e-util/e-util.h>
#include "dialogs/delete-comp.h"
#include "dialogs/delete-error.h"
#include "dialogs/send-comp.h"
#include "dialogs/cancel-comp.h"
#include "dialogs/recur-comp.h"
#include "dialogs/goto-dialog.h"
#include "calendar-config.h"
#include "comp-util.h"
#include "itip-utils.h"
#include "calendar-config.h"
#include "print.h"
#include "e-cal-model-calendar.h"
#include "e-week-view-event-item.h"
#include "e-week-view-layout.h"
#include "e-week-view-main-item.h"
#include "e-week-view-titles-item.h"
#include "misc.h"
#include <e-util/e-icon-factory.h>

/* Images */
#include "art/jump.xpm"

#define E_WEEK_VIEW_SMALL_FONT_PTSIZE 7

#define E_WEEK_VIEW_JUMP_BUTTON_WIDTH   16
#define E_WEEK_VIEW_JUMP_BUTTON_HEIGHT  8

#define E_WEEK_VIEW_JUMP_BUTTON_X_PAD   3
#define E_WEEK_VIEW_JUMP_BUTTON_Y_PAD   3

#define E_WEEK_VIEW_JUMP_BUTTON_NO_FOCUS -1

/* The timeout before we do a layout, so we don't do a layout for each event
 * we get from the server. */
#define E_WEEK_VIEW_LAYOUT_TIMEOUT  100

typedef struct {
    EWeekView *week_view;
    ECalModelComponent *comp_data;
} AddEventData;

static void e_week_view_dispose (GObject *object);
static void e_week_view_realize (GtkWidget *widget);
static void e_week_view_set_colors (EWeekView *week_view, GtkWidget *widget);
static void e_week_view_unrealize (GtkWidget *widget);
static void e_week_view_style_set (GtkWidget *widget,
                   GtkStyle  *previous_style);
static void e_week_view_size_allocate (GtkWidget *widget,
                       GtkAllocation *allocation);
static void e_week_view_recalc_cell_sizes (EWeekView *week_view);
static gint e_week_view_focus_in (GtkWidget *widget,
                  GdkEventFocus *event);
static gint e_week_view_focus_out (GtkWidget *widget,
                   GdkEventFocus *event);
static gboolean e_week_view_get_next_tab_event (EWeekView *week_view,
                        GtkDirectionType direction,
                        gint current_event_num,
                        gint current_span_num,
                        gint *next_event_num,
                        gint *next_span_num);
static gboolean e_week_view_focus (GtkWidget *widget,
                   GtkDirectionType direction);
static GList *e_week_view_get_selected_events (ECalendarView *cal_view);
static gboolean e_week_view_get_selected_time_range (ECalendarView *cal_view, time_t *start_time, time_t *end_time);
static void e_week_view_set_selected_time_range (ECalendarView *cal_view, time_t start_time, time_t end_time);
static gboolean e_week_view_get_visible_time_range (ECalendarView *cal_view, time_t *start_time, time_t *end_time);
static void e_week_view_paste_text (ECalendarView *week_view);
static void e_week_view_update_query (EWeekView *week_view);

static gboolean e_week_view_on_button_press (GtkWidget *widget,
                         GdkEventButton *event,
                         EWeekView *week_view);
static gboolean e_week_view_on_button_release (GtkWidget *widget,
                           GdkEventButton *event,
                           EWeekView *week_view);
static gboolean e_week_view_on_scroll (GtkWidget *widget,
                       GdkEventScroll *scroll,
                       EWeekView *week_view);
static gboolean e_week_view_on_motion (GtkWidget *widget,
                       GdkEventMotion *event,
                       EWeekView *week_view);
static gint e_week_view_convert_position_to_day (EWeekView *week_view,
                         gint x,
                         gint y);
static void e_week_view_update_selection (EWeekView *week_view,
                      gint day);

static void e_week_view_free_events (EWeekView *week_view);
static gboolean e_week_view_add_event (ECalComponent *comp,
                       time_t     start,
                       time_t     end,
                       gboolean prepend,
                       gpointer   data);
static void e_week_view_check_layout (EWeekView *week_view);
static void e_week_view_ensure_events_sorted (EWeekView *week_view);
static void e_week_view_reshape_events (EWeekView *week_view);
static void e_week_view_reshape_event_span (EWeekView *week_view,
                        gint event_num,
                        gint span_num);
static void e_week_view_recalc_day_starts (EWeekView *week_view,
                       time_t lower);
static void e_week_view_on_editing_started (EWeekView *week_view,
                        GnomeCanvasItem *item);
static void e_week_view_on_editing_stopped (EWeekView *week_view,
                        GnomeCanvasItem *item);
static gboolean e_week_view_find_event_from_uid (EWeekView    *week_view,
                         ECalClient             *client,
                         const gchar      *uid,
                         const gchar      *rid,
                         gint         *event_num_return);
typedef gboolean (* EWeekViewForeachEventCallback) (EWeekView *week_view,
                            gint event_num,
                            gpointer data);
static void e_week_view_foreach_event_with_uid (EWeekView *week_view,
                        const gchar *uid,
                        EWeekViewForeachEventCallback callback,
                        gpointer data);
static gboolean e_week_view_on_text_item_event (GnomeCanvasItem *item,
                        GdkEvent *event,
                        EWeekView *week_view);
static gboolean e_week_view_event_move (ECalendarView *cal_view, ECalViewMoveDirection direction);
static gint e_week_view_get_day_offset_of_event (EWeekView *week_view, time_t event_time);
static void e_week_view_change_event_time (EWeekView *week_view, time_t start_dt, time_t end_dt, gboolean is_all_day);
static gboolean e_week_view_on_jump_button_event (GnomeCanvasItem *item,
                          GdkEvent *event,
                          EWeekView *week_view);
static gboolean e_week_view_key_press (GtkWidget *widget, GdkEventKey *event);
static gboolean e_week_view_do_key_press (GtkWidget *widget,
                      GdkEventKey *event);
static gint e_week_view_get_adjust_days_for_move_up (EWeekView *week_view, gint
current_day);
static gint e_week_view_get_adjust_days_for_move_down (EWeekView *week_view,gint current_day);
static gint e_week_view_get_adjust_days_for_move_left (EWeekView *week_view,gint current_day);
static gint e_week_view_get_adjust_days_for_move_right (EWeekView *week_view,gint current_day);
static gboolean e_week_view_popup_menu (GtkWidget *widget);

static gboolean e_week_view_remove_event_cb (EWeekView *week_view,
                         gint event_num,
                         gpointer data);
static gboolean e_week_view_recalc_display_start_day    (EWeekView  *week_view);

static void e_week_view_queue_layout (EWeekView *week_view);
static void e_week_view_cancel_layout (EWeekView *week_view);
static gboolean e_week_view_layout_timeout_cb (gpointer data);

G_DEFINE_TYPE (EWeekView, e_week_view, E_TYPE_CALENDAR_VIEW)

enum {
    PROP_0,
    PROP_COMPRESS_WEEKEND,
    PROP_SHOW_EVENT_END_TIMES
};

static gint map_left[] = {0, 1, 2, 0, 1, 2, 2};
static gint map_right[] = {3, 4, 5, 3, 4, 5, 6};

static void
week_view_process_component (EWeekView *week_view,
                             ECalModelComponent *comp_data)
{
    ECalComponent *comp = NULL;
    AddEventData add_event_data;
    /* rid is never used in this function? */
    const gchar *uid;
    gchar *rid = NULL;

    /* If we don't have a valid date set yet, just return. */
    if (!g_date_valid (&week_view->first_day_shown))
        return;

    comp = e_cal_component_new ();
    if (!e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (comp_data->icalcomp))) {
        g_object_unref (comp);

        g_message (G_STRLOC ": Could not set icalcomponent on ECalComponent");
        return;
    }

    e_cal_component_get_uid (comp, &uid);
    if (e_cal_component_is_instance (comp))
        rid = e_cal_component_get_recurid_as_string (comp);
    else
        rid = NULL;

    /* Add the object */
    add_event_data.week_view = week_view;
    add_event_data.comp_data = comp_data;
    e_week_view_add_event (comp, comp_data->instance_start, comp_data->instance_end, FALSE, &add_event_data);

    g_object_unref (comp);
    g_free (rid);
}

static void
week_view_update_row (EWeekView *week_view,
                      gint row)
{
    ECalModelComponent *comp_data;
    ECalModel *model;
    gint event_num;
    const gchar *uid;
    gchar *rid = NULL;

    model = e_calendar_view_get_model (E_CALENDAR_VIEW (week_view));
    comp_data = e_cal_model_get_component_at (model, row);
    g_return_if_fail (comp_data != NULL);

    uid = icalcomponent_get_uid (comp_data->icalcomp);
    if (e_cal_util_component_is_instance (comp_data->icalcomp)) {
        icalproperty *prop;

        prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_RECURRENCEID_PROPERTY);
        if (prop)
            rid = icaltime_as_ical_string_r (icalcomponent_get_recurrenceid (comp_data->icalcomp));
    }

    if (e_week_view_find_event_from_uid (week_view, comp_data->client, uid, rid, &event_num))
        e_week_view_remove_event_cb (week_view, event_num, NULL);

    g_free (rid);

    week_view_process_component (week_view, comp_data);

    gtk_widget_queue_draw (week_view->main_canvas);
    e_week_view_queue_layout (week_view);
}

static void
week_view_model_cell_changed_cb (EWeekView *week_view,
                                 gint col,
                                 gint row)
{
    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    week_view_update_row (week_view, row);
}

static void
week_view_model_comps_deleted_cb (EWeekView *week_view,
                                  gpointer data)
{
    GSList *l, *list = data;

    /* FIXME Stop editing? */
    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    for (l = list; l != NULL; l = g_slist_next (l)) {
        gint event_num;
        const gchar *uid;
        gchar *rid = NULL;
        ECalModelComponent *comp_data = l->data;

        uid = icalcomponent_get_uid (comp_data->icalcomp);
        if (e_cal_util_component_is_instance (comp_data->icalcomp)) {
            icalproperty *prop;

            prop = icalcomponent_get_first_property (comp_data->icalcomp, ICAL_RECURRENCEID_PROPERTY);
            if (prop)
                rid = icaltime_as_ical_string_r (icalcomponent_get_recurrenceid (comp_data->icalcomp));
        }

        if (e_week_view_find_event_from_uid (week_view, comp_data->client, uid, rid, &event_num))
            e_week_view_remove_event_cb (week_view, event_num, NULL);
        g_free (rid);
    }

    gtk_widget_queue_draw (week_view->main_canvas);
    e_week_view_queue_layout (week_view);
}

static void
week_view_model_row_changed_cb (EWeekView *week_view,
                                gint row)
{
    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    week_view_update_row (week_view, row);
}

static void
week_view_model_rows_inserted_cb (EWeekView *week_view,
                                  gint row,
                                  gint count)
{
    ECalModel *model;
    gint i;

    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    model = e_calendar_view_get_model (E_CALENDAR_VIEW (week_view));

    for (i = 0; i < count; i++) {
        ECalModelComponent *comp_data;

        comp_data = e_cal_model_get_component_at (model, row + i);
        if (comp_data == NULL) {
            g_warning ("comp_data is NULL\n");
            continue;
        }
        week_view_process_component (week_view, comp_data);
    }

    gtk_widget_queue_draw (week_view->main_canvas);
    e_week_view_queue_layout (week_view);
}

static void
week_view_time_range_changed_cb (EWeekView *week_view,
                                 time_t start_time,
                                 time_t end_time,
                                 ECalModel *model)
{
    GDate date, base_date;
    gint day_offset, weekday, week_start_offset;
    gboolean update_adjustment_value = FALSE;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    time_to_gdate_with_zone (&date, start_time, e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));

    /* Calculate the weekday of the given date, 0 = Mon. */
    weekday = g_date_get_weekday (&date) - 1;

    /* Convert it to an offset from the start of the display. */
    week_start_offset = (weekday + 7 - week_view->display_start_day) % 7;

    /* Set the day_offset to the result, so we move back to the
     * start of the week. */
    day_offset = week_start_offset;

    /* Calculate the base date, i.e. the first day shown when the
     * scrollbar adjustment value is 0. */
    base_date = date;
    g_date_subtract_days (&base_date, day_offset);

    /* See if we need to update the base date. */
    if (!g_date_valid (&week_view->base_date)
        || week_view->update_base_date) {
        week_view->base_date = base_date;
        update_adjustment_value = TRUE;
    }

    /* See if we need to update the first day shown. */
    if (!g_date_valid (&week_view->first_day_shown)
        || g_date_compare (&week_view->first_day_shown, &base_date)) {
        week_view->first_day_shown = base_date;
        start_time = time_add_day_with_zone (start_time, -day_offset,
                             e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
        start_time = time_day_begin_with_zone (start_time,
                               e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
        e_week_view_recalc_day_starts (week_view, start_time);
    }

    /* Reset the adjustment value to 0 if the base address has changed.
     * Note that we do this after updating first_day_shown so that our
     * signal handler will not try to reload the events. */
    if (update_adjustment_value) {
        GtkRange *range;
        GtkAdjustment *adjustment;

        range = GTK_RANGE (week_view->vscrollbar);
        adjustment = gtk_range_get_adjustment (range);
        gtk_adjustment_set_value (adjustment, 0);
    }

    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    gtk_widget_queue_draw (week_view->main_canvas);

    /* FIXME Preserve selection if possible */
    if (week_view->selection_start_day == -1 ||
        (week_view->multi_week_view ? week_view->weeks_shown * 7 : 7) <= week_view->selection_start_day)
        e_week_view_set_selected_time_range (E_CALENDAR_VIEW (week_view), start_time, start_time);
}

static void
timezone_changed_cb (ECalModel *cal_model,
                     icaltimezone *old_zone,
                     icaltimezone *new_zone,
                     gpointer user_data)
{
    ECalendarView *cal_view = (ECalendarView *) user_data;
    struct icaltimetype tt = icaltime_null_time ();
    time_t lower;
    EWeekView *week_view = (EWeekView *) cal_view;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    if (!cal_view->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    /* If we don't have a valid date set yet, just return. */
    if (!g_date_valid (&week_view->first_day_shown))
        return;

    /* Recalculate the new start of the first week. We just use exactly
     * the same time, but with the new timezone. */
    tt.year = g_date_get_year (&week_view->first_day_shown);
    tt.month = g_date_get_month (&week_view->first_day_shown);
    tt.day = g_date_get_day (&week_view->first_day_shown);

    lower = icaltime_as_timet_with_zone (tt, new_zone);

    e_week_view_recalc_day_starts (week_view, lower);
    e_week_view_update_query (week_view);
}

static void
week_view_notify_week_start_day_cb (EWeekView *week_view)
{
    GDate *first_day_shown;

    first_day_shown = &week_view->first_day_shown;

    e_week_view_recalc_display_start_day (week_view);

    /* Recalculate the days shown and reload if necessary. */
    if (g_date_valid (first_day_shown))
        e_week_view_set_first_day_shown (week_view, first_day_shown);

    gtk_widget_queue_draw (week_view->titles_canvas);
    gtk_widget_queue_draw (week_view->main_canvas);
}

static void
week_view_set_property (GObject *object,
                        guint property_id,
                        const GValue *value,
                        GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_COMPRESS_WEEKEND:
            e_week_view_set_compress_weekend (
                E_WEEK_VIEW (object),
                g_value_get_boolean (value));
            return;

        case PROP_SHOW_EVENT_END_TIMES:
            e_week_view_set_show_event_end_times (
                E_WEEK_VIEW (object),
                g_value_get_boolean (value));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
week_view_get_property (GObject *object,
                        guint property_id,
                        GValue *value,
                        GParamSpec *pspec)
{
    switch (property_id) {
        case PROP_COMPRESS_WEEKEND:
            g_value_set_boolean (
                value,
                e_week_view_get_compress_weekend (
                E_WEEK_VIEW (object)));
            return;

        case PROP_SHOW_EVENT_END_TIMES:
            g_value_set_boolean (
                value,
                e_week_view_get_show_event_end_times (
                E_WEEK_VIEW (object)));
            return;
    }

    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}

static void
week_view_constructed (GObject *object)
{
    ECalModel *model;
    ECalendarView *calendar_view;

    /* Chain up to parent's constructed() method. */
    G_OBJECT_CLASS (e_week_view_parent_class)->constructed (object);

    calendar_view = E_CALENDAR_VIEW (object);
    model = e_calendar_view_get_model (calendar_view);

    e_week_view_recalc_display_start_day (E_WEEK_VIEW (object));

    g_signal_connect_swapped (
        model, "notify::week-start-day",
        G_CALLBACK (week_view_notify_week_start_day_cb), object);

    g_signal_connect_swapped (
        model, "comps-deleted",
        G_CALLBACK (week_view_model_comps_deleted_cb), object);

    g_signal_connect_swapped (
        model, "model-cell-changed",
        G_CALLBACK (week_view_model_cell_changed_cb), object);

    g_signal_connect_swapped (
        model, "model-row-changed",
        G_CALLBACK (week_view_model_row_changed_cb), object);

    g_signal_connect_swapped (
        model, "model-rows-inserted",
        G_CALLBACK (week_view_model_rows_inserted_cb), object);

    g_signal_connect_swapped (
        model, "time-range-changed",
        G_CALLBACK (week_view_time_range_changed_cb), object);

}

static void
week_view_cursor_key_up (EWeekView *week_view)
{
    if (week_view->selection_start_day == -1)
        return;

    week_view->selection_start_day--;

    if (week_view->selection_start_day < 0) {
        e_week_view_scroll_a_step (week_view, E_CAL_VIEW_MOVE_UP);
        week_view->selection_start_day = 6;
    }

    week_view->selection_end_day = week_view->selection_start_day;
    g_signal_emit_by_name (week_view, "selected_time_changed");
    gtk_widget_queue_draw (week_view->main_canvas);
}

static void
week_view_cursor_key_down (EWeekView *week_view)
{
    if (week_view->selection_start_day == -1)
        return;

    week_view->selection_start_day++;

    if (week_view->selection_start_day > 6) {
        e_week_view_scroll_a_step (week_view, E_CAL_VIEW_MOVE_DOWN);
        week_view->selection_start_day = 0;
    }

    week_view->selection_end_day = week_view->selection_start_day;
    g_signal_emit_by_name (week_view, "selected_time_changed");
    gtk_widget_queue_draw (week_view->main_canvas);
}

static void
week_view_cursor_key_left (EWeekView *week_view)
{
    if (week_view->selection_start_day == -1)
        return;

    week_view->selection_start_day = map_left[week_view->selection_start_day];
    week_view->selection_end_day = week_view->selection_start_day;
    g_signal_emit_by_name (week_view, "selected_time_changed");
    gtk_widget_queue_draw (week_view->main_canvas);
}

static void
week_view_cursor_key_right (EWeekView *week_view)
{
    if (week_view->selection_start_day == -1)
        return;

    week_view->selection_start_day = map_right[week_view->selection_start_day];
    week_view->selection_end_day = week_view->selection_start_day;
    g_signal_emit_by_name (week_view, "selected_time_changed");
    gtk_widget_queue_draw (week_view->main_canvas);
}

static void
month_scrol_by_week_changed_cb (GSettings *settings,
                                const gchar *key,
                                gpointer user_data)
{
    EWeekView *week_view = user_data;

    g_return_if_fail (week_view != NULL);
    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    if (week_view->multi_week_view && week_view->month_scroll_by_week != calendar_config_get_month_scroll_by_week ()) {
        week_view->multi_week_view = FALSE;
        e_week_view_set_multi_week_view (week_view, TRUE);
    }
}

static void
e_week_view_class_init (EWeekViewClass *class)
{
    GObjectClass *object_class;
    GtkWidgetClass *widget_class;
    ECalendarViewClass *view_class;

    object_class = G_OBJECT_CLASS (class);
    object_class->set_property = week_view_set_property;
    object_class->get_property = week_view_get_property;
    object_class->constructed = week_view_constructed;
    object_class->dispose = e_week_view_dispose;

    widget_class = GTK_WIDGET_CLASS (class);
    widget_class->realize = e_week_view_realize;
    widget_class->unrealize = e_week_view_unrealize;
    widget_class->style_set = e_week_view_style_set;
    widget_class->size_allocate = e_week_view_size_allocate;
    widget_class->focus_in_event = e_week_view_focus_in;
    widget_class->focus_out_event = e_week_view_focus_out;
    widget_class->key_press_event = e_week_view_key_press;
    widget_class->popup_menu = e_week_view_popup_menu;
    widget_class->focus = e_week_view_focus;

    view_class = E_CALENDAR_VIEW_CLASS (class);
    view_class->get_selected_events = e_week_view_get_selected_events;
    view_class->get_selected_time_range = e_week_view_get_selected_time_range;
    view_class->set_selected_time_range = e_week_view_set_selected_time_range;
    view_class->get_visible_time_range = e_week_view_get_visible_time_range;
    view_class->paste_text = e_week_view_paste_text;

    class->cursor_key_up = week_view_cursor_key_up;
    class->cursor_key_down = week_view_cursor_key_down;
    class->cursor_key_left = week_view_cursor_key_left;
    class->cursor_key_right = week_view_cursor_key_right;

    /* XXX This property really belongs in EMonthView,
     *     but too much drawing code is tied to it. */
    g_object_class_install_property (
        object_class,
        PROP_COMPRESS_WEEKEND,
        g_param_spec_boolean (
            "compress-weekend",
            "Compress Weekend",
            NULL,
            TRUE,
            G_PARAM_READWRITE));

    g_object_class_install_property (
        object_class,
        PROP_SHOW_EVENT_END_TIMES,
        g_param_spec_boolean (
            "show-event-end-times",
            "Show Event End Times",
            NULL,
            TRUE,
            G_PARAM_READWRITE));

    /* init the accessibility support for e_week_view */
    e_week_view_a11y_init ();
}

static void
e_week_view_init (EWeekView *week_view)
{
    GnomeCanvasGroup *canvas_group;
    GtkAdjustment *adjustment;
    GdkPixbuf *pixbuf;
    gint i;

    gtk_widget_set_can_focus (GTK_WIDGET (week_view), TRUE);

    week_view->event_destroyed = FALSE;
    week_view->events = g_array_new (FALSE, FALSE,
                     sizeof (EWeekViewEvent));
    week_view->events_sorted = TRUE;
    week_view->events_need_layout = FALSE;
    week_view->events_need_reshape = FALSE;

    week_view->layout_timeout_id = 0;

    week_view->spans = NULL;

    week_view->multi_week_view = FALSE;
    week_view->month_scroll_by_week = FALSE;
    week_view->scroll_by_week_notif_id = 0;
    week_view->update_base_date = TRUE;
    week_view->weeks_shown = 6;
    week_view->rows = 6;
    week_view->columns = 2;
    week_view->compress_weekend = TRUE;
    week_view->show_event_end_times = TRUE;
    week_view->display_start_day = 0;   /* Monday. */

    g_date_clear (&week_view->base_date, 1);
    g_date_clear (&week_view->first_day_shown, 1);

    week_view->row_height = 10;
    week_view->rows_per_cell = 1;

    week_view->selection_start_day = -1;
    week_view->selection_drag_pos = E_WEEK_VIEW_DRAG_NONE;

    week_view->pressed_event_num = -1;
    week_view->editing_event_num = -1;

    week_view->last_edited_comp_string = NULL;

    /* Create the small font. */
    week_view->use_small_font = TRUE;

    week_view->small_font_desc =
        pango_font_description_copy (gtk_widget_get_style (GTK_WIDGET (week_view))->font_desc);
    pango_font_description_set_size (week_view->small_font_desc,
                     E_WEEK_VIEW_SMALL_FONT_PTSIZE * PANGO_SCALE);

    /* String to use in 12-hour time format for times in the morning. */
    week_view->am_string = _("am");

    /* String to use in 12-hour time format for times in the afternoon. */
    week_view->pm_string = _("pm");

    week_view->bc_event_time = 0;
    week_view->before_click_dtstart = 0;
    week_view->before_click_dtend = 0;

    /*
     * Titles Canvas. Note that we don't show it is only shown in the
     * Month view.
     */
    week_view->titles_canvas = e_canvas_new ();
    gtk_table_attach (GTK_TABLE (week_view), week_view->titles_canvas,
              1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);

    canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->titles_canvas)->root);

    week_view->titles_canvas_item =
        gnome_canvas_item_new (canvas_group,
                       e_week_view_titles_item_get_type (),
                       "EWeekViewTitlesItem::week_view", week_view,
                       NULL);

    /*
     * Main Canvas
     */
    week_view->main_canvas = e_canvas_new ();
    gtk_table_attach (GTK_TABLE (week_view), week_view->main_canvas,
              1, 2, 1, 2,
              GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 1, 1);
    gtk_widget_show (week_view->main_canvas);

    canvas_group = GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->main_canvas)->root);

    week_view->main_canvas_item =
        gnome_canvas_item_new (canvas_group,
                       e_week_view_main_item_get_type (),
                       "EWeekViewMainItem::week_view", week_view,
                       NULL);

    g_signal_connect_after (
        week_view->main_canvas, "button_press_event",
        G_CALLBACK (e_week_view_on_button_press), week_view);
    g_signal_connect (
        week_view->main_canvas, "button_release_event",
        G_CALLBACK (e_week_view_on_button_release), week_view);
    g_signal_connect (
        week_view->main_canvas, "scroll_event",
        G_CALLBACK (e_week_view_on_scroll), week_view);
    g_signal_connect (
        week_view->main_canvas, "motion_notify_event",
        G_CALLBACK (e_week_view_on_motion), week_view);

    /* Create the buttons to jump to each days. */
    pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) jump_xpm);

    for (i = 0; i < E_WEEK_VIEW_MAX_WEEKS * 7; i++) {
        week_view->jump_buttons[i] = gnome_canvas_item_new
            (canvas_group,
             gnome_canvas_pixbuf_get_type (),
             "GnomeCanvasPixbuf::pixbuf", pixbuf,
             NULL);

        g_signal_connect (
            week_view->jump_buttons[i], "event",
            G_CALLBACK (e_week_view_on_jump_button_event), week_view);
    }
    week_view->focused_jump_button = E_WEEK_VIEW_JUMP_BUTTON_NO_FOCUS;

    g_object_unref (pixbuf);

    /*
     * Scrollbar.
     */
    adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0, -52, 52, 1, 1, 1));

    week_view->vscrollbar = gtk_vscrollbar_new (adjustment);
    gtk_table_attach (GTK_TABLE (week_view), week_view->vscrollbar,
              2, 3, 1, 2, 0, GTK_EXPAND | GTK_FILL, 0, 0);
    gtk_widget_show (week_view->vscrollbar);

    /* Create the cursors. */
    week_view->normal_cursor = gdk_cursor_new (GDK_LEFT_PTR);
    week_view->move_cursor = gdk_cursor_new (GDK_FLEUR);
    week_view->resize_width_cursor = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
    week_view->last_cursor_set = NULL;

    week_view->requires_update = FALSE;
}

/**
 * e_week_view_new:
 * @Returns: a new #EWeekView.
 *
 * Creates a new #EWeekView.
 **/
ECalendarView *
e_week_view_new (ECalModel *model)
{
    ECalendarView *view;
    g_return_val_if_fail (E_IS_CAL_MODEL (model), NULL);

    view = g_object_new (E_TYPE_WEEK_VIEW, "model", model, NULL);

    g_signal_connect (
        model, "timezone_changed",
        G_CALLBACK (timezone_changed_cb), view);

    return view;
}

static void
e_week_view_dispose (GObject *object)
{
    EWeekView *week_view;

    week_view = E_WEEK_VIEW (object);

    e_week_view_cancel_layout (week_view);

    if (week_view->events) {
        e_week_view_free_events (week_view);
        g_array_free (week_view->events, TRUE);
        week_view->events = NULL;
    }

    if (week_view->small_font_desc) {
        pango_font_description_free (week_view->small_font_desc);
        week_view->small_font_desc = NULL;
    }

    if (week_view->normal_cursor) {
        g_object_unref (week_view->normal_cursor);
        week_view->normal_cursor = NULL;
    }
    if (week_view->move_cursor) {
        g_object_unref (week_view->move_cursor);
        week_view->move_cursor = NULL;
    }
    if (week_view->resize_width_cursor) {
        g_object_unref (week_view->resize_width_cursor);
        week_view->resize_width_cursor = NULL;
    }

    calendar_config_remove_notification (month_scrol_by_week_changed_cb, week_view);

    /* Chain up to parent's dispose() method. */
    G_OBJECT_CLASS (e_week_view_parent_class)->dispose (object);
}

static void
e_week_view_realize (GtkWidget *widget)
{
    EWeekView *week_view;

    if (GTK_WIDGET_CLASS (e_week_view_parent_class)->realize)
        (*GTK_WIDGET_CLASS (e_week_view_parent_class)->realize)(widget);

    week_view = E_WEEK_VIEW (widget);

    /* Allocate the colors. */
    e_week_view_set_colors (week_view, widget);

    /* Create the pixmaps. */
    week_view->reminder_icon = e_icon_factory_get_icon ("stock_bell", GTK_ICON_SIZE_MENU);
    week_view->recurrence_icon = e_icon_factory_get_icon ("view-refresh", GTK_ICON_SIZE_MENU);
    week_view->timezone_icon = e_icon_factory_get_icon ("stock_timezone", GTK_ICON_SIZE_MENU);
    week_view->attach_icon = e_icon_factory_get_icon ("mail-attachment", GTK_ICON_SIZE_MENU);
    week_view->meeting_icon = e_icon_factory_get_icon ("stock_people", GTK_ICON_SIZE_MENU);
}

static GdkColor
color_inc (GdkColor c,
           gint amount)
{
    #define dec(x)              \
        if (x + amount >= 0     \
            && x + amount <= 0xFFFF)    \
            x += amount;        \
        else if (amount <= 0)       \
            x = 0;          \
        else                \
            x = 0xFFFF;

    dec (c.red);
    dec (c.green);
    dec (c.blue);

    #undef dec

    return c;
}

static void
e_week_view_set_colors (EWeekView *week_view,
                        GtkWidget *widget)
{
    GtkStyle *style;

    style = gtk_widget_get_style (widget);

    week_view->colors[E_WEEK_VIEW_COLOR_EVEN_MONTHS] = style->base[GTK_STATE_INSENSITIVE];
    week_view->colors[E_WEEK_VIEW_COLOR_ODD_MONTHS] = style->base[GTK_STATE_NORMAL];
    week_view->colors[E_WEEK_VIEW_COLOR_EVENT_BACKGROUND] = style->base[GTK_STATE_NORMAL];
    week_view->colors[E_WEEK_VIEW_COLOR_EVENT_BORDER] = style->dark[GTK_STATE_NORMAL];
    week_view->colors[E_WEEK_VIEW_COLOR_EVENT_TEXT] = style->text[GTK_STATE_NORMAL];
    week_view->colors[E_WEEK_VIEW_COLOR_GRID] = style->dark[GTK_STATE_NORMAL];
    week_view->colors[E_WEEK_VIEW_COLOR_SELECTED] = style->base[GTK_STATE_SELECTED];
    week_view->colors[E_WEEK_VIEW_COLOR_SELECTED_UNFOCUSSED] = style->bg[GTK_STATE_SELECTED];
    week_view->colors[E_WEEK_VIEW_COLOR_DATES] = style->text[GTK_STATE_NORMAL];
    week_view->colors[E_WEEK_VIEW_COLOR_DATES_SELECTED] = style->text[GTK_STATE_SELECTED];
    week_view->colors[E_WEEK_VIEW_COLOR_TODAY] = style->base[GTK_STATE_SELECTED];
    week_view->colors[E_WEEK_VIEW_COLOR_TODAY_BACKGROUND] = get_today_background (week_view->colors[E_WEEK_VIEW_COLOR_EVENT_BACKGROUND]);
    week_view->colors[E_WEEK_VIEW_COLOR_MONTH_NONWORKING_DAY] = color_inc (week_view->colors[E_WEEK_VIEW_COLOR_EVEN_MONTHS], -0x0A0A);
}

static void
e_week_view_unrealize (GtkWidget *widget)
{
    EWeekView *week_view;

    week_view = E_WEEK_VIEW (widget);

    g_object_unref (week_view->reminder_icon);
    week_view->reminder_icon = NULL;
    g_object_unref (week_view->recurrence_icon);
    week_view->recurrence_icon = NULL;
    g_object_unref (week_view->timezone_icon);
    week_view->timezone_icon = NULL;
    g_object_unref (week_view->attach_icon);
    week_view->attach_icon = NULL;
    g_object_unref (week_view->meeting_icon);
    week_view->meeting_icon = NULL;

    if (GTK_WIDGET_CLASS (e_week_view_parent_class)->unrealize)
        (*GTK_WIDGET_CLASS (e_week_view_parent_class)->unrealize)(widget);
}

static gint
get_string_width (PangoLayout *layout,
                  const gchar *string)
{
    gint width;

    pango_layout_set_text (layout, string, -1);
    pango_layout_get_pixel_size (layout, &width, NULL);
    return width;
}

/* FIXME: This is also needed in e-day-view-time-item.c. We should probably use
 * pango's approximation function, but it needs a language tag. Find out how to
 * get one of those properly. */
static gint
get_digit_width (PangoLayout *layout)
{
    gint digit;
    gint max_digit_width = 1;

    for (digit = '0'; digit <= '9'; digit++) {
        gchar digit_char;
        gint  digit_width;

        digit_char = digit;

        pango_layout_set_text (layout, &digit_char, 1);
        pango_layout_get_pixel_size (layout, &digit_width, NULL);

        max_digit_width = MAX (max_digit_width, digit_width);
    }

    return max_digit_width;
}

static GdkColor
e_week_view_get_text_color (EWeekView *week_view,
                            EWeekViewEvent *event,
                            GtkWidget *widget)
{
    GtkStyle *style;
    GdkColor bg_color;
    guint16 red, green, blue;
    gdouble cc = 65535.0;

    red = week_view->colors[E_WEEK_VIEW_COLOR_EVENT_BACKGROUND].red;
    green = week_view->colors[E_WEEK_VIEW_COLOR_EVENT_BACKGROUND].green;
    blue = week_view->colors[E_WEEK_VIEW_COLOR_EVENT_BACKGROUND].blue;

    if (is_comp_data_valid (event) && gdk_color_parse (e_cal_model_get_color_for_component (e_calendar_view_get_model (E_CALENDAR_VIEW (week_view)), event->comp_data),
         &bg_color)) {
        red = bg_color.red;
        green = bg_color.green;
        blue = bg_color.blue;
    }

    style = gtk_widget_get_style (widget);

    if ((red / cc > 0.7) || (green / cc > 0.7) || (blue / cc > 0.7 ))
        return style->black;
    else
        return style->white;
}

static void
e_week_view_style_set (GtkWidget *widget,
                       GtkStyle *previous_style)
{
    EWeekView *week_view;
    GtkStyle *style;
    gint day, day_width, max_day_width, max_abbr_day_width;
    gint month, month_width, max_month_width, max_abbr_month_width;
    gint span_num;
    const gchar *name;
    PangoFontDescription *font_desc;
    PangoContext *pango_context;
    PangoFontMetrics *font_metrics;
    PangoLayout *layout;
    EWeekViewEventSpan *span;

    if (GTK_WIDGET_CLASS (e_week_view_parent_class)->style_set)
        (*GTK_WIDGET_CLASS (e_week_view_parent_class)->style_set)(widget, previous_style);

    week_view = E_WEEK_VIEW (widget);
    style = gtk_widget_get_style (widget);

    e_week_view_set_colors (week_view, widget);
    if (week_view->spans) {
        for (span_num = 0; span_num < week_view->spans->len;
                span_num++) {
            span = &g_array_index (week_view->spans,
                    EWeekViewEventSpan, span_num);
            if (span->text_item) {
                gnome_canvas_item_set (
                    span->text_item,
                    "fill_color_gdk", &style->text[GTK_STATE_NORMAL],
                    NULL);
            }
        }
    }

    /* Set up Pango prerequisites */
    font_desc = style->font_desc;
    pango_context = gtk_widget_get_pango_context (widget);
    font_metrics = pango_context_get_metrics (pango_context, font_desc,
                          pango_context_get_language (pango_context));
    layout = pango_layout_new (pango_context);

    /* Recalculate the height of each row based on the font size. */
    week_view->row_height = PANGO_PIXELS (pango_font_metrics_get_ascent (font_metrics)) +
        PANGO_PIXELS (pango_font_metrics_get_descent (font_metrics)) +
        E_WEEK_VIEW_EVENT_BORDER_HEIGHT * 2 + E_WEEK_VIEW_EVENT_TEXT_Y_PAD * 2;
    week_view->row_height = MAX (week_view->row_height, E_WEEK_VIEW_ICON_HEIGHT + E_WEEK_VIEW_ICON_Y_PAD + E_WEEK_VIEW_EVENT_BORDER_HEIGHT * 2);

    /* Check that the small font is smaller than the default font.
     * If it isn't, we won't use it. */
    if (week_view->small_font_desc) {
        if (PANGO_PIXELS (pango_font_metrics_get_ascent (font_metrics)) +
            PANGO_PIXELS (pango_font_metrics_get_descent (font_metrics))
            <= E_WEEK_VIEW_SMALL_FONT_PTSIZE)
            week_view->use_small_font = FALSE;
    }

    /* Set the height of the top canvas. */
    gtk_widget_set_size_request (
        week_view->titles_canvas, -1,
        PANGO_PIXELS (pango_font_metrics_get_ascent (font_metrics)) +
        PANGO_PIXELS (pango_font_metrics_get_descent (font_metrics)) + 5);

    /* Save the sizes of various strings in the font, so we can quickly
     * decide which date formats to use. */

    max_day_width = 0;
    max_abbr_day_width = 0;
    for (day = 0; day < 7; day++) {
        name = e_get_weekday_name (day + 1, FALSE);
        day_width = get_string_width (layout, name);
        week_view->day_widths[day] = day_width;
        max_day_width = MAX (max_day_width, day_width);

        name = e_get_weekday_name (day + 1, TRUE);
        day_width = get_string_width (layout, name);
        week_view->abbr_day_widths[day] = day_width;
        max_abbr_day_width = MAX (max_abbr_day_width, day_width);
    }

    max_month_width = 0;
    max_abbr_month_width = 0;
    for (month = 0; month < 12; month++) {
        name = e_get_month_name (month + 1, FALSE);
        month_width = get_string_width (layout, name);
        week_view->month_widths[month] = month_width;
        max_month_width = MAX (max_month_width, month_width);

        name = e_get_month_name (month + 1, TRUE);
        month_width = get_string_width (layout, name);
        week_view->abbr_month_widths[month] = month_width;
        max_abbr_month_width = MAX (max_abbr_month_width, month_width);
    }

    week_view->space_width = get_string_width (layout, " ");
    week_view->colon_width = get_string_width (layout, ":");
    week_view->slash_width = get_string_width (layout, "/");
    week_view->digit_width = get_digit_width (layout);
    if (week_view->small_font_desc) {
        pango_layout_set_font_description (layout, week_view->small_font_desc);
        week_view->small_digit_width = get_digit_width (layout);
        pango_layout_set_font_description (layout, style->font_desc);
    }
    week_view->max_day_width = max_day_width;
    week_view->max_abbr_day_width = max_abbr_day_width;
    week_view->max_month_width = max_month_width;
    week_view->max_abbr_month_width = max_abbr_month_width;

    week_view->am_string_width = get_string_width (layout,
                               week_view->am_string);
    week_view->pm_string_width = get_string_width (layout,
                               week_view->pm_string);

    g_object_unref (layout);
    pango_font_metrics_unref (font_metrics);
}

/* This recalculates the sizes of each column. */
static void
e_week_view_size_allocate (GtkWidget *widget,
                           GtkAllocation *allocation)
{
    EWeekView *week_view;
    GtkAllocation canvas_allocation;
    gdouble old_x2, old_y2, new_x2, new_y2;

    week_view = E_WEEK_VIEW (widget);

    (*GTK_WIDGET_CLASS (e_week_view_parent_class)->size_allocate) (widget, allocation);

    e_week_view_recalc_cell_sizes (week_view);

    /* Set the scroll region of the top canvas to its allocated size. */
    gnome_canvas_get_scroll_region (
        GNOME_CANVAS (week_view->titles_canvas),
        NULL, NULL, &old_x2, &old_y2);
    gtk_widget_get_allocation (
        week_view->titles_canvas, &canvas_allocation);
    new_x2 = canvas_allocation.width - 1;
    new_y2 = canvas_allocation.height - 1;
    if (old_x2 != new_x2 || old_y2 != new_y2)
        gnome_canvas_set_scroll_region (
            GNOME_CANVAS (week_view->titles_canvas),
            0, 0, new_x2, new_y2);

    /* Set the scroll region of the main canvas to its allocated width,
     * but with the height depending on the number of rows needed. */
    gnome_canvas_get_scroll_region (
        GNOME_CANVAS (week_view->main_canvas),
        NULL, NULL, &old_x2, &old_y2);
    gtk_widget_get_allocation (
        week_view->main_canvas, &canvas_allocation);
    new_x2 = canvas_allocation.width - 1;
    new_y2 = canvas_allocation.height - 1;
    if (old_x2 != new_x2 || old_y2 != new_y2)
        gnome_canvas_set_scroll_region (
            GNOME_CANVAS (week_view->main_canvas),
            0, 0, new_x2, new_y2);

    /* Flag that we need to reshape the events. */
    if (old_x2 != new_x2 || old_y2 != new_y2) {
        week_view->events_need_reshape = TRUE;
        e_week_view_check_layout (week_view);
    }
}

static void
e_week_view_recalc_cell_sizes (EWeekView *week_view)
{
    gfloat canvas_width, canvas_height, offset;
    gint row, col;
    GtkAllocation allocation;
    GtkWidget *widget;
    GtkStyle *style;
    gint width, height, time_width;
    PangoFontDescription *font_desc;
    PangoContext *pango_context;
    PangoFontMetrics *font_metrics;

    if (week_view->multi_week_view) {
        week_view->rows = week_view->weeks_shown * 2;
        week_view->columns = week_view->compress_weekend ? 6 : 7;
    } else {
        week_view->rows = 6;
        week_view->columns = 2;
    }

    gtk_widget_get_allocation (week_view->main_canvas, &allocation);

    /* Calculate the column sizes, using floating point so that pixels
     * get divided evenly. Note that we use one more element than the
     * number of columns, to make it easy to get the column widths.
     * We also add one to the width so that the right border of the last
     * column is off the edge of the displayed area. */
    canvas_width = allocation.width + 1;
    canvas_width /= week_view->columns;
    offset = 0;
    for (col = 0; col <= week_view->columns; col++) {
        week_view->col_offsets[col] = floor (offset + 0.5);
        offset += canvas_width;
    }

    /* Calculate the cell widths based on the offsets. */
    for (col = 0; col < week_view->columns; col++) {
        week_view->col_widths[col] = week_view->col_offsets[col + 1]
            - week_view->col_offsets[col];
    }

    /* Now do the same for the row heights. */
    canvas_height = allocation.height + 1;
    canvas_height /= week_view->rows;
    offset = 0;
    for (row = 0; row <= week_view->rows; row++) {
        week_view->row_offsets[row] = floor (offset + 0.5);
        offset += canvas_height;
    }

    /* Calculate the cell heights based on the offsets. */
    for (row = 0; row < week_view->rows; row++) {
        week_view->row_heights[row] = week_view->row_offsets[row + 1]
            - week_view->row_offsets[row];
    }

    /* If the font hasn't been set yet just return. */
    widget = GTK_WIDGET (week_view);
    style = gtk_widget_get_style (widget);
    if (!style)
        return;
    font_desc = style->font_desc;
    if (!font_desc)
        return;

    pango_context = gtk_widget_get_pango_context (widget);
    font_metrics = pango_context_get_metrics (pango_context, font_desc,
                          pango_context_get_language (pango_context));

    /* Calculate the number of rows of events in each cell, for the large
     * cells and the compressed weekend cells. */
    if (week_view->multi_week_view) {
        week_view->events_y_offset = E_WEEK_VIEW_DATE_T_PAD +
            + PANGO_PIXELS (pango_font_metrics_get_ascent (font_metrics))
            + PANGO_PIXELS (pango_font_metrics_get_descent (font_metrics))
            + E_WEEK_VIEW_DATE_B_PAD;
    } else {
        week_view->events_y_offset = E_WEEK_VIEW_DATE_T_PAD
            + PANGO_PIXELS (pango_font_metrics_get_ascent (font_metrics))
            + PANGO_PIXELS (pango_font_metrics_get_descent (font_metrics))
            + E_WEEK_VIEW_DATE_LINE_T_PAD + 1
            + E_WEEK_VIEW_DATE_LINE_B_PAD;
    }

    height = week_view->row_heights[0];
    week_view->rows_per_cell = (height * 2 - week_view->events_y_offset)
        / (week_view->row_height + E_WEEK_VIEW_EVENT_Y_SPACING);
    week_view->rows_per_cell = MIN (week_view->rows_per_cell,
                    E_WEEK_VIEW_MAX_ROWS_PER_CELL);

    week_view->rows_per_compressed_cell =
        (height - week_view->events_y_offset)
        / (week_view->row_height + E_WEEK_VIEW_EVENT_Y_SPACING);
    week_view->rows_per_compressed_cell = MIN (week_view->rows_per_compressed_cell,
                           E_WEEK_VIEW_MAX_ROWS_PER_CELL);

    /* Determine which time format to use, based on the width of the cells.
     * We only allow the time to take up about half of the width. */
    width = week_view->col_widths[0];

    time_width = e_week_view_get_time_string_width (week_view);

    week_view->time_format = E_WEEK_VIEW_TIME_NONE;
    if (week_view->use_small_font && week_view->small_font_desc) {
        if (week_view->show_event_end_times
            && width / 2 > time_width * 2 + E_WEEK_VIEW_EVENT_TIME_SPACING)
            week_view->time_format = E_WEEK_VIEW_TIME_BOTH_SMALL_MIN;
        else if (width / 2 > time_width)
            week_view->time_format = E_WEEK_VIEW_TIME_START_SMALL_MIN;
    } else {
        if (week_view->show_event_end_times
            && width / 2 > time_width * 2 + E_WEEK_VIEW_EVENT_TIME_SPACING)
            week_view->time_format = E_WEEK_VIEW_TIME_BOTH;
        else if (width / 2 > time_width)
            week_view->time_format = E_WEEK_VIEW_TIME_START;
    }

    pango_font_metrics_unref (font_metrics);
}

static gint
e_week_view_focus_in (GtkWidget *widget,
                      GdkEventFocus *event)
{
    EWeekView *week_view;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (E_IS_WEEK_VIEW (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    week_view = E_WEEK_VIEW (widget);

    /* XXX Can't access flags directly anymore, but is it really needed?
     *     If so, could we call gtk_widget_send_focus_change() instead? */
#if 0
    GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
#endif

    if (E_CALENDAR_VIEW (week_view)->in_focus && week_view->requires_update) {
        time_t my_start = 0, my_end = 0, model_start = 0, model_end = 0;

        week_view->requires_update = FALSE;

        e_cal_model_get_time_range (e_calendar_view_get_model (E_CALENDAR_VIEW (week_view)), &model_start, &model_end);

        if (e_calendar_view_get_visible_time_range (E_CALENDAR_VIEW (week_view), &my_start, &my_end) &&
            model_start == my_start && model_end == my_end) {
            /* update only when the same time range is set in a view and in a model;
             * otherwise time range change invokes also query update */
            e_week_view_update_query (week_view);
        }
    }

    gtk_widget_queue_draw (week_view->main_canvas);

    return FALSE;
}

static gint
e_week_view_focus_out (GtkWidget *widget,
                       GdkEventFocus *event)
{
    EWeekView *week_view;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (E_IS_WEEK_VIEW (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    week_view = E_WEEK_VIEW (widget);

    /* XXX Can't access flags directly anymore, but is it really needed?
     *     If so, could we call gtk_widget_send_focus_change() instead? */
#if 0
    GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
#endif

    gtk_widget_queue_draw (week_view->main_canvas);

    return FALSE;
}

/**
 * e_week_view_get_next_tab_event
 * @week_view: the week_view widget operate on
 * @direction: GTK_DIR_TAB_BACKWARD or GTK_DIR_TAB_FORWARD.
 * @current_event_num and @current_span_num: current status.
 * @next_event_num: the event number focus should go next.
 *                  -1 indicates focus should go to week_view widget.
 * @next_span_num: always return 0.
 **/
static gboolean
e_week_view_get_next_tab_event (EWeekView *week_view,
                                GtkDirectionType direction,
                                gint current_event_num,
                                gint current_span_num,
                                gint *next_event_num,
                                gint *next_span_num)
{
    gint event_num;

    g_return_val_if_fail (week_view != NULL, FALSE);
    g_return_val_if_fail (next_event_num != NULL, FALSE);
    g_return_val_if_fail (next_span_num != NULL, FALSE);

    if (week_view->events->len <= 0)
        return FALSE;

    /* we only tab through events not spans */
    *next_span_num = 0;

    switch (direction) {
    case GTK_DIR_TAB_BACKWARD:
        event_num = current_event_num - 1;
        break;
    case GTK_DIR_TAB_FORWARD:
        event_num = current_event_num + 1;
        break;
    default:
        return FALSE;
    }

    if (event_num == -1)
        /* backward, out of event range, go to week view widget
         */
        *next_event_num = -1;
    else if (event_num < -1)
        /* backward from week_view, go to the last event
         */
        *next_event_num = week_view->events->len - 1;
    else if (event_num >= week_view->events->len)
        /* forward, out of event range, go to week view widget
         */
        *next_event_num = -1;
    else
        *next_event_num = event_num;
    return TRUE;
}

static gboolean
e_week_view_focus (GtkWidget *widget,
                   GtkDirectionType direction)
{
    EWeekView *week_view;
    gint new_event_num;
    gint new_span_num;
    gint event_loop;
    gboolean editable = FALSE;
    static gint last_focus_event_num = -1, last_focus_span_num = -1;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (E_IS_WEEK_VIEW (widget), FALSE);

    week_view = E_WEEK_VIEW (widget);

    e_week_view_check_layout (week_view);

    if (week_view->focused_jump_button == E_WEEK_VIEW_JUMP_BUTTON_NO_FOCUS) {
        last_focus_event_num = week_view->editing_event_num;
        last_focus_span_num = week_view->editing_span_num;
    }

    /* if there is not event, just grab week_view */
    if (week_view->events->len == 0) {
        gtk_widget_grab_focus (widget);
        return TRUE;
    }

    for (event_loop = 0; event_loop < week_view->events->len;
         ++event_loop) {
        if (!e_week_view_get_next_tab_event (week_view, direction,
                             last_focus_event_num,
                             last_focus_span_num,
                             &new_event_num,
                             &new_span_num))
            return FALSE;

        if (new_event_num == -1) {
            /* focus should go to week_view widget
             */
            gtk_widget_grab_focus (widget);
            return TRUE;
        }

        editable = e_week_view_start_editing_event (week_view,
                                new_event_num,
                                new_span_num,
                                NULL);
        last_focus_event_num = new_event_num;
        last_focus_span_num = new_span_num;

        if (editable)
            break;
        else {
            /* check if we should go to the jump button */

            EWeekViewEvent *event;
            EWeekViewEventSpan *span;
            gint current_day;

            if (!is_array_index_in_bounds (week_view->events, new_event_num))
                break;

            event = &g_array_index (week_view->events,
                        EWeekViewEvent,
                        new_event_num);

            if (!is_array_index_in_bounds (week_view->spans, event->spans_index + new_span_num))
                break;

            span = &g_array_index (week_view->spans,
                           EWeekViewEventSpan,
                           event->spans_index + new_span_num);
            current_day = span->start_day;

            if ((week_view->focused_jump_button != current_day) &&
                e_week_view_is_jump_button_visible (week_view, current_day)) {

                /* focus go to the jump button */
                e_week_view_stop_editing_event (week_view);
                gnome_canvas_item_grab_focus (week_view->jump_buttons[current_day]);
                return TRUE;
            }
        }
    }
    return editable;
}

/* Returns the currently-selected event, or NULL if none */
static GList *
e_week_view_get_selected_events (ECalendarView *cal_view)
{
    EWeekViewEvent *event = NULL;
    GList *list = NULL;
    EWeekView *week_view = (EWeekView *) cal_view;

    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), NULL);

    if (week_view->editing_event_num != -1) {
        if (!is_array_index_in_bounds (week_view->events, week_view->editing_event_num))
            return NULL;

        event = &g_array_index (week_view->events, EWeekViewEvent,
                    week_view->editing_event_num);
    } else if (week_view->popup_event_num != -1) {
        if (!is_array_index_in_bounds (week_view->events, week_view->popup_event_num))
            return NULL;

        event = &g_array_index (week_view->events, EWeekViewEvent,
                    week_view->popup_event_num);
    }

    if (event)
        list = g_list_prepend (list, event);

    return list;
}

/* Restarts a query for the week view */
static void
e_week_view_update_query (EWeekView *week_view)
{
    gint rows, r;

    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    gtk_widget_queue_draw (week_view->main_canvas);
    e_week_view_free_events (week_view);
    e_week_view_queue_layout (week_view);

    rows = e_table_model_row_count (E_TABLE_MODEL (e_calendar_view_get_model (E_CALENDAR_VIEW (week_view))));
    for (r = 0; r < rows; r++) {
        ECalModelComponent *comp_data;

        comp_data = e_cal_model_get_component_at (e_calendar_view_get_model (E_CALENDAR_VIEW (week_view)), r);
        if (comp_data == NULL) {
            g_warning ("comp_data is NULL\n");
            continue;
        }
        week_view_process_component (week_view, comp_data);
    }
}

/* This sets the selected time range. The EWeekView will show the corresponding
 * month and the days between start_time and end_time will be selected.
 * To select a single day, use the same value for start_time & end_time. */
static void
e_week_view_set_selected_time_range (ECalendarView *cal_view,
                                     time_t start_time,
                                     time_t end_time)
{
    GDate date, end_date;
    gint num_days;
    gboolean update_adjustment_value = FALSE;
    EWeekView *week_view = E_WEEK_VIEW (cal_view);

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    if (!g_date_valid (&week_view->base_date)) {
        /* This view has not been initialized/shown yet, thus skip this. */
        return;
    }

    time_to_gdate_with_zone (&date, start_time, e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));

    /* Set the selection to the given days. */
    week_view->selection_start_day = g_date_get_julian (&date)
        - g_date_get_julian (&week_view->base_date);
    if (end_time == start_time
        || end_time <= time_add_day_with_zone (start_time, 1,
                           e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view))))
        week_view->selection_end_day = week_view->selection_start_day;
    else {
        time_to_gdate_with_zone (&end_date, end_time - 60, e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
        week_view->selection_end_day = g_date_get_julian (&end_date)
            - g_date_get_julian (&week_view->base_date);
    }

    /* Make sure the selection is valid. */
    num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;
    num_days--;
    week_view->selection_start_day = CLAMP (week_view->selection_start_day,
                        0, num_days);
    week_view->selection_end_day = CLAMP (week_view->selection_end_day,
                          week_view->selection_start_day,
                          num_days);

    /* Reset the adjustment value to 0 if the base address has changed.
     * Note that we do this after updating first_day_shown so that our
     * signal handler will not try to reload the events. */
    if (update_adjustment_value) {
        GtkRange *range;
        GtkAdjustment *adjustment;

        range = GTK_RANGE (week_view->vscrollbar);
        adjustment = gtk_range_get_adjustment (range);
        gtk_adjustment_set_value (adjustment, 0);
    }

    gtk_widget_queue_draw (week_view->main_canvas);
}

void
e_week_view_set_selected_time_range_visible (EWeekView *week_view,
                                             time_t start_time,
                                             time_t end_time)
{
    GDate date, end_date;
    gint num_days;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    time_to_gdate_with_zone (&date, start_time, e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));

    /* Set the selection to the given days. */
    week_view->selection_start_day = g_date_get_julian (&date)
        - g_date_get_julian (&week_view->first_day_shown);
    if (end_time == start_time
        || end_time <= time_add_day_with_zone (start_time, 1,
                           e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view))))
        week_view->selection_end_day = week_view->selection_start_day;
    else {
        time_to_gdate_with_zone (&end_date, end_time - 60, e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
        week_view->selection_end_day = g_date_get_julian (&end_date)
            - g_date_get_julian (&week_view->first_day_shown);
    }

    /* Make sure the selection is valid. */
    num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;
    num_days--;
    week_view->selection_start_day = CLAMP (week_view->selection_start_day,
                        0, num_days);
    week_view->selection_end_day = CLAMP (week_view->selection_end_day,
                          week_view->selection_start_day,
                          num_days);

    gtk_widget_queue_draw (week_view->main_canvas);
}

/* Returns the selected time range. */
static gboolean
e_week_view_get_selected_time_range (ECalendarView *cal_view,
                                     time_t *start_time,
                                     time_t *end_time)
{
    gint start_day, end_day;
    EWeekView *week_view = E_WEEK_VIEW (cal_view);

    start_day = week_view->selection_start_day;
    end_day = week_view->selection_end_day;

    if (start_day == -1) {
        start_day = 0;
        end_day = 0;
    }

    if (start_time)
        *start_time = week_view->day_starts[start_day];

    if (end_time)
        *end_time = week_view->day_starts[end_day + 1];

    return  TRUE;
}

/* Gets the visible time range. Returns FALSE if no time range has been set. */
static gboolean
e_week_view_get_visible_time_range (ECalendarView *cal_view,
                                    time_t *start_time,
                                    time_t *end_time)
{
    gint num_days;
    EWeekView *week_view = E_WEEK_VIEW (cal_view);

    /* If we don't have a valid date set yet, return FALSE. */
    if (!g_date_valid (&week_view->first_day_shown))
        return FALSE;

    num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;
    *start_time = week_view->day_starts[0];
    *end_time = week_view->day_starts[num_days];

    return TRUE;
}

/* Note that the returned date may be invalid if no date has been set yet. */
void
e_week_view_get_first_day_shown (EWeekView *week_view,
                                 GDate *date)
{
    *date = week_view->first_day_shown;
}

/* This sets the first day shown in the view. It will be rounded down to the
 * nearest week. */
void
e_week_view_set_first_day_shown (EWeekView *week_view,
                                 GDate *date)
{
    GDate base_date;
    gint weekday, day_offset, num_days;
    gboolean update_adjustment_value = FALSE;
    guint32 old_selection_start_julian = 0, old_selection_end_julian = 0;
    struct icaltimetype start_tt = icaltime_null_time ();
    time_t start_time;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    /* Calculate the old selection range. */
    if (week_view->selection_start_day != -1) {
        old_selection_start_julian =
            g_date_get_julian (&week_view->base_date)
            + week_view->selection_start_day;
        old_selection_end_julian =
            g_date_get_julian (&week_view->base_date)
            + week_view->selection_end_day;
    }

    /* Calculate the weekday of the given date, 0 = Mon. */
    weekday = g_date_get_weekday (date) - 1;

    /* Convert it to an offset from the start of the display. */
    day_offset = (weekday + 7 - week_view->display_start_day) % 7;

    /* Calculate the base date, i.e. the first day shown when the
     * scrollbar adjustment value is 0. */
    base_date = *date;
    g_date_subtract_days (&base_date, day_offset);

    /* See if we need to update the base date. */
    if (!g_date_valid (&week_view->base_date)
        || g_date_compare (&week_view->base_date, &base_date)) {
        week_view->base_date = base_date;
        update_adjustment_value = TRUE;
    }

    /* See if we need to update the first day shown. */
    if (!g_date_valid (&week_view->first_day_shown)
        || g_date_compare (&week_view->first_day_shown, &base_date)) {
        week_view->first_day_shown = base_date;

        start_tt.year = g_date_get_year (&base_date);
        start_tt.month = g_date_get_month (&base_date);
        start_tt.day = g_date_get_day (&base_date);

        start_time = icaltime_as_timet_with_zone (start_tt,
                              e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));

        e_week_view_recalc_day_starts (week_view, start_time);
        e_week_view_update_query (week_view);
    }

    /* Try to keep the previous selection, but if it is no longer shown
     * just select the first day. */
    if (week_view->selection_start_day != -1) {
        week_view->selection_start_day = old_selection_start_julian
            - g_date_get_julian (&base_date);
        week_view->selection_end_day = old_selection_end_julian
            - g_date_get_julian (&base_date);

        /* Make sure the selection is valid. */
        num_days = week_view->multi_week_view
            ? week_view->weeks_shown * 7 : 7;
        num_days--;
        week_view->selection_start_day =
            CLAMP (week_view->selection_start_day, 0, num_days);
        week_view->selection_end_day =
            CLAMP (week_view->selection_end_day,
                   week_view->selection_start_day,
                   num_days);
    }

    /* Reset the adjustment value to 0 if the base address has changed.
     * Note that we do this after updating first_day_shown so that our
     * signal handler will not try to reload the events. */
    if (update_adjustment_value) {
        GtkRange *range;
        GtkAdjustment *adjustment;

        range = GTK_RANGE (week_view->vscrollbar);
        adjustment = gtk_range_get_adjustment (range);
        gtk_adjustment_set_value (adjustment, 0);
    }

    e_week_view_update_query (week_view);
    gtk_widget_queue_draw (week_view->main_canvas);
}

/* Recalculates the time_t corresponding to the start of each day. */
static void
e_week_view_recalc_day_starts (EWeekView *week_view,
                               time_t lower)
{
    gint num_days, day;
    time_t tmp_time;

    num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;

    tmp_time = lower;
    week_view->day_starts[0] = tmp_time;
    for (day = 1; day <= num_days; day++) {
        tmp_time = time_add_day_with_zone (tmp_time, 1,
                           e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
        week_view->day_starts[day] = tmp_time;
    }
}

gboolean
e_week_view_get_multi_week_view (EWeekView *week_view)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);

    return week_view->multi_week_view;
}

void
e_week_view_set_multi_week_view (EWeekView *week_view,
                                 gboolean multi_week_view)
{
    GtkRange *range;
    GtkAdjustment *adjustment;
    gint page_increment, page_size;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    if (week_view->multi_week_view == multi_week_view)
        return;

    week_view->multi_week_view = multi_week_view;

    if (multi_week_view) {
        gtk_widget_show (week_view->titles_canvas);
        week_view->month_scroll_by_week = calendar_config_get_month_scroll_by_week ();

        calendar_config_add_notification_month_scroll_by_week (month_scrol_by_week_changed_cb, week_view);

        if (week_view->month_scroll_by_week) {
            page_increment = 1;
            page_size = 1;
        } else {
            page_increment = 4;
            page_size = 5;
        }
    } else {
        gtk_widget_hide (week_view->titles_canvas);
        page_increment = page_size = 1;

        if (week_view->scroll_by_week_notif_id) {
            calendar_config_remove_notification (month_scrol_by_week_changed_cb, week_view);
            week_view->scroll_by_week_notif_id = 0;
        }
    }

    range = GTK_RANGE (week_view->vscrollbar);
    adjustment = gtk_range_get_adjustment (range);
    gtk_adjustment_set_page_increment (adjustment, page_increment);
    gtk_adjustment_set_page_size (adjustment, page_size);

    e_week_view_recalc_display_start_day (week_view);
    e_week_view_recalc_cell_sizes (week_view);

    if (g_date_valid (&week_view->first_day_shown))
        e_week_view_set_first_day_shown (week_view,
                         &week_view->first_day_shown);
}

gboolean
e_week_view_get_update_base_date (EWeekView *week_view)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);

    return week_view->update_base_date;
}

void
e_week_view_set_update_base_date (EWeekView *week_view,
                                  gboolean update_base_date)
{
    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    week_view->update_base_date = update_base_date;
}

gint
e_week_view_get_weeks_shown (EWeekView *week_view)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), 1);

    return week_view->weeks_shown;
}

void
e_week_view_set_weeks_shown (EWeekView *week_view,
                             gint weeks_shown)
{
    GtkRange *range;
    GtkAdjustment *adjustment;
    gint page_increment, page_size;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    weeks_shown = MIN (weeks_shown, E_WEEK_VIEW_MAX_WEEKS);

    if (week_view->weeks_shown == weeks_shown)
        return;

    week_view->weeks_shown = weeks_shown;

    if (week_view->multi_week_view) {
        if (week_view->month_scroll_by_week) {
            page_increment = 1;
            page_size = 1;
        } else {
            page_increment = 4;
            page_size = 5;
        }

        range = GTK_RANGE (week_view->vscrollbar);
        adjustment = gtk_range_get_adjustment (range);
        gtk_adjustment_set_page_increment (adjustment, page_increment);
        gtk_adjustment_set_page_size (adjustment, page_size);

        e_week_view_recalc_cell_sizes (week_view);

        if (g_date_valid (&week_view->first_day_shown))
            e_week_view_set_first_day_shown (week_view, &week_view->first_day_shown);

        e_week_view_update_query (week_view);
    }
}

gboolean
e_week_view_get_compress_weekend (EWeekView *week_view)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);

    return week_view->compress_weekend;
}

void
e_week_view_set_compress_weekend (EWeekView *week_view,
                                  gboolean compress_weekend)
{
    gboolean need_reload = FALSE;

    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    if ((week_view->compress_weekend ? 1 : 0) == (compress_weekend ? 1 : 0))
        return;

    week_view->compress_weekend = compress_weekend;

    /* The option only affects the month view. */
    if (!week_view->multi_week_view)
        return;

    e_week_view_recalc_cell_sizes (week_view);

    need_reload = e_week_view_recalc_display_start_day (week_view);

    /* If the display_start_day has changed we need to recalculate the
     * date range shown and reload all events, otherwise we only need to
     * do a reshape. */
    if (need_reload) {
        /* Recalculate the days shown and reload if necessary. */
        if (g_date_valid (&week_view->first_day_shown))
            e_week_view_set_first_day_shown (week_view, &week_view->first_day_shown);
    } else {
        week_view->events_need_reshape = TRUE;
        e_week_view_check_layout (week_view);
    }

    gtk_widget_queue_draw (week_view->titles_canvas);
    gtk_widget_queue_draw (week_view->main_canvas);

    g_object_notify (G_OBJECT (week_view), "compress-weekend");
}

/* Whether we display event end times. */
gboolean
e_week_view_get_show_event_end_times (EWeekView *week_view)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), TRUE);

    return week_view->show_event_end_times;
}

void
e_week_view_set_show_event_end_times (EWeekView *week_view,
                                      gboolean show_event_end_times)
{
    g_return_if_fail (E_IS_WEEK_VIEW (week_view));

    if ((week_view->show_event_end_times ? 1 : 0) == (show_event_end_times ? 1 : 0))
        return;

    week_view->show_event_end_times = show_event_end_times;
    e_week_view_recalc_cell_sizes (week_view);
    week_view->events_need_reshape = TRUE;
    e_week_view_check_layout (week_view);

    gtk_widget_queue_draw (week_view->titles_canvas);
    gtk_widget_queue_draw (week_view->main_canvas);

    g_object_notify (G_OBJECT (week_view), "show-event-end-times");
}

static gboolean
e_week_view_recalc_display_start_day (EWeekView *week_view)
{
    ECalModel *model;
    gint week_start_day;
    gint display_start_day;

    model = e_calendar_view_get_model (E_CALENDAR_VIEW (week_view));
    week_start_day = e_cal_model_get_week_start_day (model);

    /* The display start day defaults to week_start_day, but we have
     * to use Saturday if the weekend is compressed and week_start_day
     * is Sunday. */
    display_start_day = week_start_day;

    if (display_start_day == 6
        && (!week_view->multi_week_view || week_view->compress_weekend))
        display_start_day = 5;

    if (week_view->display_start_day != display_start_day) {
        week_view->display_start_day = display_start_day;
        return TRUE;
    }

    return FALSE;
}

/* Checks if the users participation status is NEEDS-ACTION and shows the summary as bold text */
static void
set_text_as_bold (EWeekViewEvent *event,
                  EWeekViewEventSpan *span,
                  ESourceRegistry *registry)
{
    ECalComponent *comp;
    GSList *attendees = NULL, *l;
    gchar *address;
    ECalComponentAttendee *at = NULL;

    if (!is_comp_data_valid (event))
        return;

    comp = e_cal_component_new ();
    e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
    address = itip_get_comp_attendee (
        registry, comp, event->comp_data->client);
    e_cal_component_get_attendee_list (comp, &attendees);
    for (l = attendees; l; l = l->next) {
        ECalComponentAttendee *attendee = l->data;

        if ((g_str_equal (itip_strip_mailto (attendee->value), address))
         || (attendee->sentby && g_str_equal (itip_strip_mailto (attendee->sentby), address))) {
            at = attendee;
            break;
        }
    }

    /* The attendee has not yet accepted the meeting, display the summary as bolded.
     * If the attendee is not present, it might have come through a mailing list.
     * In that case, we never show the meeting as bold even if it is unaccepted. */
    if (at && (at->status == ICAL_PARTSTAT_NEEDSACTION))
        gnome_canvas_item_set (span->text_item, "bold", TRUE, NULL);

    e_cal_component_free_attendee_list (attendees);
    g_free (address);
    g_object_unref (comp);
}

/* This calls a given function for each event instance that matches the given
 * uid. Note that it is safe for the callback to remove the event (since we
 * step backwards through the arrays). */
static void
e_week_view_foreach_event_with_uid (EWeekView *week_view,
                                    const gchar *uid,
                                    EWeekViewForeachEventCallback callback,
                                    gpointer data)
{
    EWeekViewEvent *event;
    gint event_num;

    for (event_num = week_view->events->len - 1;
         event_num >= 0;
         event_num--) {
        const gchar *u;

        event = &g_array_index (week_view->events, EWeekViewEvent,
                    event_num);

        if (!is_comp_data_valid (event))
            continue;

        u = icalcomponent_get_uid (event->comp_data->icalcomp);
        if (u && !strcmp (uid, u)) {
            if (!(*callback) (week_view, event_num, data))
                return;
        }
    }
}

static gboolean
e_week_view_remove_event_cb (EWeekView *week_view,
                             gint event_num,
                             gpointer data)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    gint span_num;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return TRUE;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);
    if (!event)
        return TRUE;

    /* If we were editing this event, set editing_event_num to -1 so
     * on_editing_stopped doesn't try to update the event. */
    if (week_view->editing_event_num == event_num)
        week_view->editing_event_num = -1;

    if (week_view->popup_event_num == event_num)
        week_view->popup_event_num = -1;

    if (is_comp_data_valid (event))
        g_object_unref (event->comp_data);
    event->comp_data = NULL;

    if (week_view->spans) {
        /* We leave the span elements in the array, but set the canvas item
         * pointers to NULL. */
        for (span_num = 0; span_num < event->num_spans; span_num++) {
            if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
                break;

            span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                           event->spans_index + span_num);

            if (span->text_item) {
                g_object_run_dispose (G_OBJECT (span->text_item));
                span->text_item = NULL;
            }
            if (span->background_item) {
                g_object_run_dispose (G_OBJECT (span->background_item));
                span->background_item = NULL;
            }
        }

        /* Update event_num numbers for already created spans with event_num higher than our event_num */
        for (span_num = 0; span_num < week_view->spans->len; span_num++) {
            span = &g_array_index (week_view->spans, EWeekViewEventSpan, span_num);

            if (span && span->background_item && E_IS_WEEK_VIEW_EVENT_ITEM (span->background_item)) {
                EWeekViewEventItem *wveitem = E_WEEK_VIEW_EVENT_ITEM (span->background_item);
                gint wveitem_event_num;

                wveitem_event_num =
                    e_week_view_event_item_get_event_num (wveitem);

                if (wveitem_event_num > event_num)
                    e_week_view_event_item_set_event_num (
                        wveitem, wveitem_event_num - 1);
            }
        }
    }

    g_array_remove_index (week_view->events, event_num);

    week_view->events_need_layout = TRUE;

    return TRUE;
}

void
e_week_view_get_day_position (EWeekView *week_view,
                              gint day,
                              gint *day_x,
                              gint *day_y,
                              gint *day_w,
                              gint *day_h)
{
    gint cell_x, cell_y, cell_h;

    e_week_view_layout_get_day_position (day,
                         week_view->multi_week_view,
                         week_view->weeks_shown,
                         week_view->display_start_day,
                         week_view->compress_weekend,
                         &cell_x, &cell_y, &cell_h);

    *day_x = week_view->col_offsets[cell_x];
    *day_y = week_view->row_offsets[cell_y];

    *day_w = week_view->col_widths[cell_x];
    *day_h = week_view->row_heights[cell_y];

    while (cell_h > 1) {
        *day_h += week_view->row_heights[cell_y + 1];
        cell_h--;
        cell_y++;
    }
}

/* Returns the bounding box for a span of an event. Usually this can easily
 * be determined by the start & end days and row of the span, which are set in
 * e_week_view_layout_event (). Though we need a special case for the weekends
 * when they are compressed, since the span may not fit.
 * The bounding box includes the entire width of the days in the view (but
 * not the vertical line down the right of the last day), though the displayed
 * event doesn't normally extend to the edges of the day.
 * It returns FALSE if the span isn't visible. */
gboolean
e_week_view_get_span_position (EWeekView *week_view,
                               gint event_num,
                               gint span_num,
                               gint *span_x,
                               gint *span_y,
                               gint *span_w)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    gint num_days;
    gint start_x, start_y, start_w, start_h;
    gint end_x, end_y, end_w, end_h;

    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);
    g_return_val_if_fail (event_num < week_view->events->len, FALSE);

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    g_return_val_if_fail (span_num < event->num_spans, FALSE);

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
        return FALSE;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   event->spans_index + span_num);

    if (!e_week_view_layout_get_span_position (event, span,
                           week_view->rows_per_cell,
                           week_view->rows_per_compressed_cell,
                           week_view->display_start_day,
                           week_view->multi_week_view,
                           week_view->compress_weekend,
                           &num_days)) {
        return FALSE;
    }

    e_week_view_get_day_position (week_view, span->start_day,
                      &start_x, &start_y, &start_w, &start_h);
    *span_y = start_y + week_view->events_y_offset
        + span->row * (week_view->row_height
                   + E_WEEK_VIEW_EVENT_Y_SPACING);
    if (num_days == 1) {
        *span_x = start_x;
        *span_w = start_w - 1;
    } else {
        e_week_view_get_day_position (week_view,
                          span->start_day + num_days - 1,
                          &end_x, &end_y, &end_w, &end_h);
        *span_x = start_x;
        *span_w = end_x + end_w - start_x - 1;
    }

    return TRUE;
}

static gboolean
ewv_pass_gdkevent_to_etext (EWeekView *week_view,
                            GdkEvent *gevent)
{
    g_return_val_if_fail (week_view != NULL, FALSE);
    g_return_val_if_fail (gevent != NULL, FALSE);

    if (week_view->editing_event_num != -1 && week_view->editing_span_num != -1) {
        EWeekViewEvent *event;
        EWeekViewEventSpan *span;

        if (!is_array_index_in_bounds (week_view->events, week_view->editing_event_num))
            return FALSE;

        event = &g_array_index (week_view->events, EWeekViewEvent, week_view->editing_event_num);

        if (!is_array_index_in_bounds (week_view->spans, event->spans_index + week_view->editing_span_num))
            return FALSE;

        span = &g_array_index (week_view->spans, EWeekViewEventSpan, event->spans_index + week_view->editing_span_num);

        if (span->text_item && E_IS_TEXT (span->text_item)) {
            GNOME_CANVAS_ITEM_GET_CLASS (span->text_item)->event (span->text_item, gevent);
            return TRUE;
        }
    }

    return FALSE;
}

static gboolean
e_week_view_on_button_press (GtkWidget *widget,
                             GdkEventButton *event,
                             EWeekView *week_view)
{
    gint x, y, day;

#if 0
    g_print ("In e_week_view_on_button_press\n");
    if (event->type == GDK_2BUTTON_PRESS)
        g_print (" is a double-click\n");
    if (week_view->pressed_event_num != -1)
        g_print (" item is pressed\n");
#endif

    /* Convert the mouse position to a week & day. */
    x = event->x;
    y = event->y;
    day = e_week_view_convert_position_to_day (week_view, x, y);
    if (day == -1)
        return FALSE;

    if (ewv_pass_gdkevent_to_etext (week_view, (GdkEvent *) event))
        return TRUE;

    /* If an event is pressed just return. */
    if (week_view->pressed_event_num != -1)
        return FALSE;

    if (event->button == 1 && event->type == GDK_2BUTTON_PRESS) {
        time_t dtstart, dtend;

        e_calendar_view_get_selected_time_range ((ECalendarView *) week_view, &dtstart, &dtend);
        if (dtstart < week_view->before_click_dtend && dtend > week_view->before_click_dtstart) {
            e_week_view_set_selected_time_range ((ECalendarView *) week_view, week_view->before_click_dtstart, week_view->before_click_dtend);
        }
        e_calendar_view_new_appointment_full (E_CALENDAR_VIEW (week_view), FALSE, FALSE, calendar_config_get_prefer_meeting ());
        return TRUE;
    }

    if (event->button == 1) {
        GdkWindow *window;

        /* Start the selection drag. */
        if (!gtk_widget_has_focus (GTK_WIDGET (week_view)) &&  !gtk_widget_has_focus (GTK_WIDGET (week_view->main_canvas)))
            gtk_widget_grab_focus (GTK_WIDGET (week_view));

        window = gtk_layout_get_bin_window (GTK_LAYOUT (widget));

        if (gdk_pointer_grab (window, FALSE,
                      GDK_POINTER_MOTION_MASK
                      | GDK_BUTTON_RELEASE_MASK,
                      NULL, NULL, event->time) == 0) {
            if (event->time - week_view->bc_event_time > 250)
                e_calendar_view_get_selected_time_range ((ECalendarView *) week_view, &week_view->before_click_dtstart, &week_view->before_click_dtend);
            week_view->bc_event_time = event->time;
            week_view->selection_start_day = day;
            week_view->selection_end_day = day;
            week_view->selection_drag_pos = E_WEEK_VIEW_DRAG_END;
            g_signal_emit_by_name (week_view, "selected_time_changed");

            /* FIXME: Optimise? */
            gtk_widget_queue_draw (week_view->main_canvas);
        }
    } else if (event->button == 3) {
        if (!gtk_widget_has_focus (GTK_WIDGET (week_view)))
            gtk_widget_grab_focus (GTK_WIDGET (week_view));

        if (day < week_view->selection_start_day || day > week_view->selection_end_day) {
            week_view->selection_start_day = day;
            week_view->selection_end_day = day;
            week_view->selection_drag_pos = E_WEEK_VIEW_DRAG_NONE;

            /* FIXME: Optimise? */
            gtk_widget_queue_draw (week_view->main_canvas);
        }

        e_week_view_show_popup_menu (week_view, event, -1);
    }

    return TRUE;
}

static gboolean
e_week_view_on_button_release (GtkWidget *widget,
                               GdkEventButton *event,
                               EWeekView *week_view)
{
#if 0
    g_print ("In e_week_view_on_button_release\n");
#endif

    if (week_view->selection_drag_pos != E_WEEK_VIEW_DRAG_NONE) {
        week_view->selection_drag_pos = E_WEEK_VIEW_DRAG_NONE;
        gdk_pointer_ungrab (event->time);
    } else {
        ewv_pass_gdkevent_to_etext (week_view, (GdkEvent *) event);
    }

    return FALSE;
}

static gboolean
e_week_view_on_scroll (GtkWidget *widget,
                       GdkEventScroll *scroll,
                       EWeekView *week_view)
{
    GtkRange *range;
    GtkAdjustment *adjustment;
    gdouble page_increment;
    gdouble new_value;
    gdouble page_size;
    gdouble lower;
    gdouble upper;
    gdouble value;
    GtkWidget *tool_window = g_object_get_data (G_OBJECT (week_view), "tooltip-window");
    guint timeout;

    timeout = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (week_view), "tooltip-timeout"));
    if (timeout) {
        g_source_remove (timeout);
        g_object_set_data (G_OBJECT (week_view), "tooltip-timeout", NULL);
    }

    if (tool_window) {
        gtk_widget_destroy (tool_window);
        g_object_set_data (G_OBJECT (week_view), "tooltip-window", NULL);
    }

    range = GTK_RANGE (week_view->vscrollbar);
    adjustment = gtk_range_get_adjustment (range);

    page_increment = gtk_adjustment_get_page_increment (adjustment);
    page_size = gtk_adjustment_get_page_size (adjustment);
    lower = gtk_adjustment_get_lower (adjustment);
    upper = gtk_adjustment_get_upper (adjustment);
    value = gtk_adjustment_get_value (adjustment);

    switch (scroll->direction) {
        case GDK_SCROLL_UP:
            new_value = value - page_increment;
            break;
        case GDK_SCROLL_DOWN:
            new_value = value + page_increment;
            break;
        #if GTK_CHECK_VERSION(3,3,18)
        case GDK_SCROLL_SMOOTH:
            if (scroll->delta_y < -0.001 || scroll->delta_y > 0.001) {
                new_value = value + scroll->delta_y * page_increment;
                break;
            }
            return FALSE;
        #endif
        default:
            return FALSE;
    }

    new_value = CLAMP (new_value, lower, upper - page_size);
    gtk_adjustment_set_value (adjustment, new_value);

    return TRUE;
}

static gboolean
e_week_view_on_motion (GtkWidget *widget,
                       GdkEventMotion *mevent,
                       EWeekView *week_view)
{
    gint x, y, day;

#if 0
    g_print ("In e_week_view_on_motion\n");
#endif

    /* Convert the mouse position to a week & day. */
    x = mevent->x;
    y = mevent->y;
    day = e_week_view_convert_position_to_day (week_view, x, y);
    if (day == -1)
        return FALSE;

    if (week_view->selection_drag_pos != E_WEEK_VIEW_DRAG_NONE) {
        e_week_view_update_selection (week_view, day);
        return TRUE;
    }

    ewv_pass_gdkevent_to_etext (week_view, (GdkEvent *) mevent);

    return FALSE;
}

/* Converts a position in the canvas window to a day offset from the first
 * day displayed. Returns -1 if the position is outside the grid. */
static gint
e_week_view_convert_position_to_day (EWeekView *week_view,
                                     gint x,
                                     gint y)
{
    gint col, row, grid_x = -1, grid_y = -1, week, day;
    gint weekend_col;

    /* First we convert it to a grid position. */
    for (col = 0; col <= week_view->columns; col++) {
        if (x < week_view->col_offsets[col]) {
            grid_x = col - 1;
            break;
        }
    }

    for (row = 0; row <= week_view->rows; row++) {
        if (y < week_view->row_offsets[row]) {
            grid_y = row - 1;
            break;
        }
    }

    /* If the mouse is outside the grid return FALSE. */
    if (grid_x == -1 || grid_y == -1)
        return -1;

    /* Now convert the grid position to a week and day. */
    if (week_view->multi_week_view) {
        week = grid_y / 2;
        day = grid_x;

        if (week_view->compress_weekend) {
            weekend_col = (5 + 7 - week_view->display_start_day) % 7;
            if (grid_x > weekend_col
                || (grid_x == weekend_col && grid_y % 2 == 1))
                day++;
        }
    } else {
        week = 0;

        for (day = 0; day < 7; day++) {
            gint day_x = 0, day_y = 0, rows = 0;
            e_week_view_layout_get_day_position (day, FALSE, 1, week_view->display_start_day, week_view->compress_weekend,
                                &day_x, &day_y, &rows);

            if (grid_x == day_x && grid_y >= day_y && grid_y < day_y + rows)
                break;
        }

        if (day == 7)
            return -1;
    }

    return week * 7 + day;
}

static void
e_week_view_update_selection (EWeekView *week_view,
                              gint day)
{
    gint tmp_day;
    gboolean need_redraw = FALSE;

#if 0
    g_print ("Updating selection %i,%i\n", week, day);
#endif

    if (week_view->selection_drag_pos == E_WEEK_VIEW_DRAG_START) {
        if (day != week_view->selection_start_day) {
            need_redraw = TRUE;
            week_view->selection_start_day = day;
        }
    } else {
        if (day != week_view->selection_end_day) {
            need_redraw = TRUE;
            week_view->selection_end_day = day;
        }
    }

    /* Switch the drag position if necessary. */
    if (week_view->selection_start_day > week_view->selection_end_day) {
        tmp_day = week_view->selection_start_day;
        week_view->selection_start_day = week_view->selection_end_day;
        week_view->selection_end_day = tmp_day;
        if (week_view->selection_drag_pos == E_WEEK_VIEW_DRAG_START)
            week_view->selection_drag_pos = E_WEEK_VIEW_DRAG_END;
        else
            week_view->selection_drag_pos = E_WEEK_VIEW_DRAG_START;
    }

    /* FIXME: Optimise? */
    if (need_redraw) {
        gtk_widget_queue_draw (week_view->main_canvas);
    }
}

static void
e_week_view_free_events (EWeekView *week_view)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    gint event_num, span_num, num_days, day;

    /* Reset all our indices. */
    week_view->pressed_event_num = -1;
    week_view->pressed_span_num = -1;
    week_view->editing_event_num = -1;
    week_view->editing_span_num = -1;
    week_view->popup_event_num = -1;

    for (event_num = 0; event_num < week_view->events->len; event_num++) {
        event = &g_array_index (week_view->events, EWeekViewEvent,
                    event_num);

        if (is_comp_data_valid (event))
            g_object_unref (event->comp_data);
    }

    g_array_set_size (week_view->events, 0);

    /* Destroy all the old canvas items. */
    if (week_view->spans) {
        for (span_num = 0; span_num < week_view->spans->len;
             span_num++) {
            span = &g_array_index (week_view->spans,
                           EWeekViewEventSpan, span_num);
            if (span->background_item)
                g_object_run_dispose (G_OBJECT (span->background_item));
            if (span->text_item)
                g_object_run_dispose (G_OBJECT (span->text_item));
        }
        g_array_free (week_view->spans, TRUE);
        week_view->spans = NULL;
    }

    /* Clear the number of rows used per day. */
    num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;
    for (day = 0; day <= num_days; day++) {
        week_view->rows_per_day[day] = 0;
    }

    /* Hide all the jump buttons. */
    for (day = 0; day < E_WEEK_VIEW_MAX_WEEKS * 7; day++) {
        gnome_canvas_item_hide (week_view->jump_buttons[day]);
    }
}

/* This adds one event to the view, adding it to the appropriate array. */
static gboolean
e_week_view_add_event (ECalComponent *comp,
                       time_t start,
                       time_t end,
                       gboolean prepend,
                       gpointer data)

{
    AddEventData *add_event_data;
    EWeekViewEvent event;
    gint num_days;
    struct icaltimetype start_tt, end_tt;

    add_event_data = data;

    /* Check that the event times are valid. */
    num_days = add_event_data->week_view->multi_week_view ? add_event_data->week_view->weeks_shown * 7 : 7;

    /*if (start > end || start >= add_event_data->week_view->day_starts[num_days] || end <= add_event_data->week_view->day_starts[0]) {
        g_print ("%s: week_view:%p\n", G_STRFUNC, add_event_data->week_view);
        g_print ("\tstart: %s", ctime (&start));
        g_print ("\tend: %s", ctime (&end));
        g_print ("\tday_starts[0]: %s", ctime (&add_event_data->week_view->day_starts[0]));
        g_print ("\tday_starts[%d]: %s\n", num_days, ctime (&add_event_data->week_view->day_starts[num_days]));
    }*/

    g_return_val_if_fail (start <= end, TRUE);
    g_return_val_if_fail (start < add_event_data->week_view->day_starts[num_days], TRUE);
    g_return_val_if_fail (end > add_event_data->week_view->day_starts[0], TRUE);

    start_tt = icaltime_from_timet_with_zone (start, FALSE,
                          e_calendar_view_get_timezone (E_CALENDAR_VIEW (add_event_data->week_view)));
    end_tt = icaltime_from_timet_with_zone (end, FALSE,
                        e_calendar_view_get_timezone (E_CALENDAR_VIEW (add_event_data->week_view)));

    if (add_event_data->comp_data) {
        event.comp_data = g_object_ref (add_event_data->comp_data);
    } else {
        event.comp_data = g_object_new (E_TYPE_CAL_MODEL_COMPONENT, NULL);

        event.comp_data->client = g_object_ref (e_cal_model_get_default_client (e_calendar_view_get_model (E_CALENDAR_VIEW (add_event_data->week_view))));
        e_cal_component_abort_sequence (comp);
        event.comp_data->icalcomp = icalcomponent_new_clone (e_cal_component_get_icalcomponent (comp));
    }
    event.start = start;
    event.end = end;
    event.tooltip = NULL;
    event.timeout = -1;
    event.color = NULL;
    event.spans_index = 0;
    event.num_spans = 0;
    event.comp_data->instance_start = start;
    event.comp_data->instance_end = end;

    event.start_minute = start_tt.hour * 60 + start_tt.minute;
    event.end_minute = end_tt.hour * 60 + end_tt.minute;
    if (event.end_minute == 0 && start != end)
        event.end_minute = 24 * 60;

    event.different_timezone = FALSE;
    if (!cal_comp_util_compare_event_timezones (
            comp,
            event.comp_data->client,
            e_calendar_view_get_timezone (E_CALENDAR_VIEW (add_event_data->week_view))))
        event.different_timezone = TRUE;

    if (prepend)
        g_array_prepend_val (add_event_data->week_view->events, event);
    else
        g_array_append_val (add_event_data->week_view->events, event);
    add_event_data->week_view->events_sorted = FALSE;
    add_event_data->week_view->events_need_layout = TRUE;

    return TRUE;
}

/* This lays out the events, or reshapes them, as necessary. */
static void
e_week_view_check_layout (EWeekView *week_view)
{
    /* Don't bother if we aren't visible. */
    if (!E_CALENDAR_VIEW (week_view)->in_focus) {
        e_week_view_free_events (week_view);
        week_view->requires_update = TRUE;
        return;
    }

    /* Make sure the events are sorted (by start and size). */
    e_week_view_ensure_events_sorted (week_view);

    if (week_view->events_need_layout)
        week_view->spans = e_week_view_layout_events
            (week_view->events, week_view->spans,
             week_view->multi_week_view,
             week_view->weeks_shown,
             week_view->compress_weekend,
             week_view->display_start_day,
             week_view->day_starts,
             week_view->rows_per_day);

    if (week_view->events_need_layout || week_view->events_need_reshape)
        e_week_view_reshape_events (week_view);

    week_view->events_need_layout = FALSE;
    week_view->events_need_reshape = FALSE;
}

static void
e_week_view_ensure_events_sorted (EWeekView *week_view)
{
    if (!week_view->events_sorted) {
        qsort (week_view->events->data,
               week_view->events->len,
               sizeof (EWeekViewEvent),
               e_week_view_event_sort_func);
        week_view->events_sorted = TRUE;
    }
}

gint
e_week_view_event_sort_func (gconstpointer arg1,
                             gconstpointer arg2)
{
    EWeekViewEvent *event1, *event2;

    event1 = (EWeekViewEvent *) arg1;
    event2 = (EWeekViewEvent *) arg2;

    if (event1->start < event2->start)
        return -1;
    if (event1->start > event2->start)
        return 1;

    if (event1->end > event2->end)
        return -1;
    if (event1->end < event2->end)
        return 1;

    return 0;
}

static void
e_week_view_reshape_events (EWeekView *week_view)
{
    EWeekViewEvent *event;
    gint event_num, span_num;
    gint num_days, day, day_x, day_y, day_w, day_h, max_rows;
    gboolean is_weekend;

    for (event_num = 0; event_num < week_view->events->len; event_num++) {
        event = &g_array_index (week_view->events, EWeekViewEvent,
                    event_num);
        if (!is_comp_data_valid (event))
            continue;

        for (span_num = 0; span_num < event->num_spans; span_num++) {
            gchar *current_comp_string;

            e_week_view_reshape_event_span (week_view, event_num,
                            span_num);
            if (week_view->last_edited_comp_string == NULL)
                continue;
            current_comp_string = icalcomponent_as_ical_string_r (event->comp_data->icalcomp);
            if (strncmp (current_comp_string, week_view->last_edited_comp_string,50) == 0) {
                EWeekViewEventSpan *span;

                if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num)) {
                    g_free (current_comp_string);
                    continue;
                }

                span = &g_array_index (week_view->spans, EWeekViewEventSpan, event->spans_index + span_num);
                e_canvas_item_grab_focus (span->text_item, TRUE);
                g_free (week_view->last_edited_comp_string);
                week_view->last_edited_comp_string = NULL;
            }
            g_free (current_comp_string);
        }
    }

    /* Reshape the jump buttons and show/hide them as appropriate. */
    num_days = week_view->multi_week_view ? week_view->weeks_shown * 7 : 7;
    for (day = 0; day < num_days; day++) {

        is_weekend = ((week_view->display_start_day + day) % 7 >= 5) ? TRUE : FALSE;
        if (!is_weekend || (week_view->multi_week_view
                    && !week_view->compress_weekend))
            max_rows = week_view->rows_per_cell;
        else
            max_rows = week_view->rows_per_compressed_cell;

        /* Determine whether the jump button should be shown. */
        if (week_view->rows_per_day[day] <= max_rows) {
            gnome_canvas_item_hide (week_view->jump_buttons[day]);
        } else {
            cairo_matrix_t matrix;

            e_week_view_get_day_position (week_view, day,
                              &day_x, &day_y,
                              &day_w, &day_h);

            cairo_matrix_init_translate (&matrix,
                           day_x + day_w - E_WEEK_VIEW_JUMP_BUTTON_X_PAD - E_WEEK_VIEW_JUMP_BUTTON_WIDTH,
                           day_y + day_h - E_WEEK_VIEW_JUMP_BUTTON_Y_PAD - E_WEEK_VIEW_JUMP_BUTTON_HEIGHT);
            gnome_canvas_item_set_matrix (week_view->jump_buttons[day], &matrix);

            gnome_canvas_item_show (week_view->jump_buttons[day]);
            gnome_canvas_item_raise_to_top (week_view->jump_buttons[day]);
        }
    }

    for (day = num_days; day < E_WEEK_VIEW_MAX_WEEKS * 7; day++) {
        gnome_canvas_item_hide (week_view->jump_buttons[day]);
    }
}

static EWeekViewEvent *
tooltip_get_view_event (EWeekView *week_view,
                        gint day,
                        gint event_num)
{
    EWeekViewEvent *pevent;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return NULL;

    pevent = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    return pevent;
}

static void
tooltip_destroy (EWeekView *week_view,
                 GnomeCanvasItem *item)
{
    gint event_num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "event-num"));
    EWeekViewEvent *pevent;
    guint timeout;

    timeout = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (week_view), "tooltip-timeout"));
    if (timeout) {
        g_source_remove (timeout);
        g_object_set_data (G_OBJECT (week_view), "tooltip-timeout", NULL);
    }

    pevent = tooltip_get_view_event (week_view, -1, event_num);
    if (pevent) {
        if (pevent->tooltip && g_object_get_data (G_OBJECT (week_view), "tooltip-window")) {
            gtk_widget_destroy (pevent->tooltip);
            pevent->tooltip = NULL;
        }

        g_object_set_data (G_OBJECT (week_view), "tooltip-window", NULL);
    }
}

static gboolean
tooltip_event_cb (GnomeCanvasItem *item,
                  GdkEvent *event,
                  EWeekView *view)
{
    gint event_num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "event-num"));
    EWeekViewEvent *pevent;

    pevent = tooltip_get_view_event (view, -1, event_num);

    switch (event->type) {
        case GDK_ENTER_NOTIFY:
        if (view->editing_event_num == -1) {
            ECalendarViewEventData *data;

            data = g_malloc (sizeof (ECalendarViewEventData));

            pevent->x = ((GdkEventCrossing *) event)->x_root;
            pevent->y = ((GdkEventCrossing *) event)->y_root;
            pevent->tooltip = NULL;

            data->cal_view = (ECalendarView *) view;
            data->day = -1;
            data->event_num = event_num;
            data->get_view_event = (ECalendarViewEvent * (*)(ECalendarView *, int, gint)) tooltip_get_view_event;
            pevent->timeout = g_timeout_add_full (
                G_PRIORITY_DEFAULT, 500,
                (GSourceFunc) e_calendar_view_get_tooltips,
                data, (GDestroyNotify) g_free);
            g_object_set_data ((GObject *)view, "tooltip-timeout", GUINT_TO_POINTER (pevent->timeout));

            return TRUE;
        } else {
            return FALSE;
        }
        case GDK_MOTION_NOTIFY:
            pevent->x = ((GdkEventMotion *) event)->x_root;
            pevent->y = ((GdkEventMotion *) event)->y_root;
            pevent->tooltip = (GtkWidget *)g_object_get_data (G_OBJECT (view), "tooltip-window");

            if (pevent->tooltip) {
                e_calendar_view_move_tip (pevent->tooltip, pevent->x + 16, pevent->y + 16);
            }

            return TRUE;
        case GDK_LEAVE_NOTIFY:
        case GDK_KEY_PRESS:
        case GDK_BUTTON_PRESS:
            tooltip_destroy (view, item);
        default:
            return FALSE;
    }
}

static const gchar *
get_comp_summary (ECalClient *client,
                  icalcomponent *icalcomp,
                  gboolean *free_text)
{
    const gchar *my_summary, *location;
    const gchar *summary;
    gboolean my_free_text = FALSE;

    g_return_val_if_fail (icalcomp != NULL && free_text != NULL, NULL);

    my_summary = e_calendar_view_get_icalcomponent_summary (client, icalcomp, &my_free_text);

    location = icalcomponent_get_location (icalcomp);
    if (location && *location) {
        *free_text = TRUE;
        summary = g_strdup_printf ("%s (%s)", my_summary, location);

        if (my_free_text)
            g_free ((gchar *) my_summary);
    } else {
        *free_text = my_free_text;
        summary = my_summary;
    }

    return summary;
}

static void
e_week_view_reshape_event_span (EWeekView *week_view,
                                gint event_num,
                                gint span_num)
{
    ECalendarView *cal_view;
    ECalModel *model;
    ESourceRegistry *registry;
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    gint span_x, span_y, span_w, num_icons, icons_width, time_width;
    gint min_text_x, max_text_w, width;
    gboolean show_icons = TRUE, use_max_width = FALSE;
    gboolean one_day_event;
    ECalComponent *comp;
    gdouble text_x, text_y, text_w, text_h;
    gchar *text, *end_of_line;
    gint line_len, text_width;
    PangoFontDescription *font_desc;
    PangoContext *pango_context;
    PangoFontMetrics *font_metrics;
    PangoLayout *layout;

    cal_view = E_CALENDAR_VIEW (week_view);
    model = e_calendar_view_get_model (cal_view);

    registry = e_cal_model_get_registry (model);

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (!is_comp_data_valid (event))
        return;

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
        return;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   event->spans_index + span_num);
    comp = e_cal_component_new ();
    e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));

    one_day_event = e_week_view_is_one_day_event (week_view, event_num);

    /* If the span will not be visible destroy the canvas items and
     * return. */
    if (!e_week_view_get_span_position (week_view, event_num, span_num,
                        &span_x, &span_y, &span_w)) {
        if (span->background_item)
            g_object_run_dispose (G_OBJECT (span->background_item));
        if (span->text_item)
            g_object_run_dispose (G_OBJECT (span->text_item));
        span->background_item = NULL;
        span->text_item = NULL;

        g_object_unref (comp);
        return;
    }

    /* Set up Pango prerequisites */
    font_desc = gtk_widget_get_style (GTK_WIDGET (week_view))->font_desc;
    pango_context = gtk_widget_get_pango_context (GTK_WIDGET (week_view));
    font_metrics = pango_context_get_metrics (pango_context, font_desc,
                          pango_context_get_language (pango_context));
    layout = pango_layout_new (pango_context);

    /* If we are editing a long event we don't show the icons and the EText
     * item uses the maximum width available. */
    if (!one_day_event && week_view->editing_event_num == event_num
        && week_view->editing_span_num == span_num) {
        show_icons = FALSE;
        use_max_width = TRUE;
    }

    /* Calculate how many icons we need to show. */
    num_icons = 0;
    if (show_icons) {
        if (e_cal_component_has_alarms (comp))
            num_icons++;
        if (e_cal_component_has_recurrences (comp) || e_cal_component_is_instance (comp))
            num_icons++;
        if (e_cal_component_has_attachments (comp))
            num_icons++;
        if (e_cal_component_has_attendees (comp))
            num_icons++;
        if (event->different_timezone)
            num_icons++;
        num_icons += cal_comp_util_get_n_icons (comp, NULL);
    }

    /* Create the background canvas item if necessary. */
    if (!span->background_item) {
        span->background_item =
            gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->main_canvas)->root),
                           e_week_view_event_item_get_type (),
                           NULL);
    }

    g_object_set_data ((GObject *)span->background_item, "event-num", GINT_TO_POINTER (event_num));
    g_signal_connect (
        span->background_item, "event",
        G_CALLBACK (tooltip_event_cb), week_view);

    gnome_canvas_item_set (span->background_item,
                   "event_num", event_num,
                   "span_num", span_num,
                   NULL);

    /* Create the text item if necessary. */
    if (!span->text_item) {
        const gchar *summary;
        GtkWidget *widget;
        GdkColor color;
        gboolean free_text = FALSE;

        widget = (GtkWidget *) week_view;

        color = e_week_view_get_text_color (week_view, event, widget);
        summary = get_comp_summary (event->comp_data->client, event->comp_data->icalcomp, &free_text);

        span->text_item =
            gnome_canvas_item_new (GNOME_CANVAS_GROUP (GNOME_CANVAS (week_view->main_canvas)->root),
                           e_text_get_type (),
                           "clip", TRUE,
                           "max_lines", 1,
                           "editable", TRUE,
                           "text", summary ? summary : "",
                           "use_ellipsis", TRUE,
                           "fill_color_gdk", &color,
                           "im_context", E_CANVAS (week_view->main_canvas)->im_context,
                           NULL);

        if (free_text)
            g_free ((gchar *) summary);

        if (e_client_check_capability (E_CLIENT (event->comp_data->client), CAL_STATIC_CAPABILITY_HAS_UNACCEPTED_MEETING)
                && e_cal_util_component_has_attendee (event->comp_data->icalcomp)) {
            set_text_as_bold (event, span, registry);
        }
        g_object_set_data (G_OBJECT (span->text_item), "event-num", GINT_TO_POINTER (event_num));
        g_signal_connect (
            span->text_item, "event",
            G_CALLBACK (e_week_view_on_text_item_event), week_view);
        g_signal_emit_by_name (G_OBJECT (week_view),
                       "event_added", event);

    }

    /* Calculate the position of the text item.
     * For events < 1 day it starts after the times & icons and ends at the
     * right edge of the span.
     * For events >= 1 day we need to determine whether times are shown at
     * the start and end of the span, then try to center the text item with
     * the icons in the middle, but making sure we don't go over the times.
    */

    /* Calculate the space necessary to display a time, e.g. "13:00". */
    time_width = e_week_view_get_time_string_width (week_view);

    /* Calculate the space needed for the icons. */
    icons_width = (E_WEEK_VIEW_ICON_WIDTH + E_WEEK_VIEW_ICON_X_PAD)
        * num_icons - E_WEEK_VIEW_ICON_X_PAD + E_WEEK_VIEW_ICON_R_PAD;

    /* The y position and height are the same for both event types. */
    text_y = span_y + E_WEEK_VIEW_EVENT_BORDER_HEIGHT
        + E_WEEK_VIEW_EVENT_TEXT_Y_PAD;

    text_h =
        PANGO_PIXELS (pango_font_metrics_get_ascent (font_metrics)) +
        PANGO_PIXELS (pango_font_metrics_get_descent (font_metrics));

    if (one_day_event) {
        /* Note that 1-day events don't have a border. Although we
         * still use the border height to position the events
         * vertically so they still line up neatly (see above),
         * we don't use the border width or edge padding at all. */
        text_x = span_x + E_WEEK_VIEW_EVENT_L_PAD;

        switch (week_view->time_format) {
        case E_WEEK_VIEW_TIME_BOTH_SMALL_MIN:
        case E_WEEK_VIEW_TIME_BOTH:
            /* These have 2 time strings with a small space between
             * them and some space before the EText item. */
            text_x += time_width * 2
                + E_WEEK_VIEW_EVENT_TIME_SPACING
                + E_WEEK_VIEW_EVENT_TIME_X_PAD;
            break;
        case E_WEEK_VIEW_TIME_START_SMALL_MIN:
        case E_WEEK_VIEW_TIME_START:
            /* These have just 1 time string with some space
             * before the EText item. */
            text_x += time_width + E_WEEK_VIEW_EVENT_TIME_X_PAD;
            break;
        case E_WEEK_VIEW_TIME_NONE:
            break;
        }

        /* The icons_width includes space on the right of the icons. */
        text_x += icons_width;

        /* The width of the EText item extends right to the edge of the
         * event, just inside the border. */
        text_w = span_x + span_w - E_WEEK_VIEW_EVENT_R_PAD - text_x;

    } else {
        if (use_max_width) {
            /* When we are editing the event we use all the
             * available width. */
            text_x = span_x + E_WEEK_VIEW_EVENT_L_PAD
                + E_WEEK_VIEW_EVENT_BORDER_WIDTH
                + E_WEEK_VIEW_EVENT_EDGE_X_PAD;
            text_w = span_x + span_w - E_WEEK_VIEW_EVENT_R_PAD
                - E_WEEK_VIEW_EVENT_BORDER_WIDTH
                - E_WEEK_VIEW_EVENT_EDGE_X_PAD - text_x;
        } else {
            text = NULL;
            /* Get the width of the text of the event. This is a
             * bit of a hack. It would be better if EText could
             * tell us this. */
            g_object_get (span->text_item, "text", &text, NULL);
            text_width = 0;
            if (text) {
                /* It should only have one line of text in it.
                 * I'm not sure we need this any more. */
                end_of_line = strchr (text, '\n');
                if (end_of_line)
                    line_len = end_of_line - text;
                else
                    line_len = strlen (text);

                pango_layout_set_text (layout, text, line_len);
                pango_layout_get_pixel_size (layout, &text_width, NULL);
                g_free (text);
            }

            /* Add on the width of the icons and find the default
             * position, which centers the icons + text. */
            width = text_width + icons_width;
            text_x = span_x + (span_w - width) / 2;

            /* Now calculate the left-most valid position, and make
             * sure we don't go to the left of that. */
            min_text_x = span_x + E_WEEK_VIEW_EVENT_L_PAD
                + E_WEEK_VIEW_EVENT_BORDER_WIDTH
                + E_WEEK_VIEW_EVENT_EDGE_X_PAD;
            /* See if we will want to display the start time, and
             * if so take that into account. */
            if (event->start > week_view->day_starts[span->start_day])
                min_text_x += time_width
                    + E_WEEK_VIEW_EVENT_TIME_X_PAD;

            /* Now make sure we don't go to the left of the minimum
             * position. */
            text_x = MAX (text_x, min_text_x);

            /* Now calculate the largest valid width, using the
             * calculated x position, and make sure we don't
             * exceed that. */
            max_text_w = span_x + span_w - E_WEEK_VIEW_EVENT_R_PAD
                - E_WEEK_VIEW_EVENT_BORDER_WIDTH
                - E_WEEK_VIEW_EVENT_EDGE_X_PAD - text_x;
            if (event->end < week_view->day_starts[span->start_day
                                  + span->num_days])
                max_text_w -= time_width
                    + E_WEEK_VIEW_EVENT_TIME_X_PAD;

            text_w = MIN (width, max_text_w);

            /* Now take out the space for the icons. */
            text_x += icons_width;
            text_w -= icons_width;
        }
    }

    /* Make sure we don't try to use a negative width. */
    text_w = MAX (text_w, 0);

    gnome_canvas_item_set (span->text_item,
                   "clip_width", (gdouble) text_w,
                   "clip_height", (gdouble) text_h,
                   NULL);
    e_canvas_item_move_absolute (span->text_item, text_x, text_y);

    g_object_unref (comp);
    g_object_unref (layout);
    pango_font_metrics_unref (font_metrics);
}

gboolean
e_week_view_start_editing_event (EWeekView *week_view,
                                 gint event_num,
                                 gint span_num,
                                 gchar *initial_text)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    ETextEventProcessor *event_processor = NULL;
    ETextEventProcessorCommand command;
    ECalModelComponent *comp_data;

    /* If we are already editing the event, just return. */
    if (event_num == week_view->editing_event_num
        && span_num == week_view->editing_span_num)
        return TRUE;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return FALSE;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (!is_comp_data_valid (event))
        return FALSE;

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
        return FALSE;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   event->spans_index + span_num);

    if (e_client_is_readonly (E_CLIENT (event->comp_data->client)))
        return FALSE;

    /* If the event is not shown, don't try to edit it. */
    if (!span->text_item)
        return FALSE;

    if (week_view->editing_event_num >= 0) {
        EWeekViewEvent *editing;

        if (!is_array_index_in_bounds (week_view->events, week_view->editing_event_num))
            return FALSE;

        editing = &g_array_index (week_view->events, EWeekViewEvent, week_view->editing_event_num);

        /* do not change to other part of same component - the event is spread into more days */
        if (editing && event && editing->comp_data == event->comp_data)
            return FALSE;
    }

    gnome_canvas_item_set (span->text_item,
                   "text", initial_text ? initial_text : icalcomponent_get_summary (event->comp_data->icalcomp),
                   NULL);

    /* Save the comp_data value because we use that as our invariant */
    comp_data = event->comp_data;

    e_canvas_item_grab_focus (span->text_item, TRUE);

    /* If the above focus caused things to redraw, then find the
     * the event and the span again */
    if (event_num < week_view->events->len)
        event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (event_num >= week_view->events->len || event->comp_data != comp_data) {
        /* When got in because of other comp_data, then be sure we go through all events */
        event_num = week_view->events->len;

        /* Unfocussing can cause a removal but not a new
         * addition so just run backwards through the
         * events */
        for (event_num--; event_num >= 0; event_num--) {
            event = &g_array_index (week_view->events, EWeekViewEvent, event_num);
            if (event->comp_data == comp_data)
                break;
        }
        g_return_val_if_fail (event_num >= 0, FALSE);
    }

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
        return FALSE;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,  event->spans_index + span_num);

    /* Try to move the cursor to the end of the text. */
    g_object_get (span->text_item, "event_processor", &event_processor, NULL);
    if (event_processor) {
        command.action = E_TEP_MOVE;
        command.position = E_TEP_END_OF_BUFFER;
        g_signal_emit_by_name (event_processor,
                       "command", &command);
    }
    return TRUE;
}

/* This stops any current edit. */
void
e_week_view_stop_editing_event (EWeekView *week_view)
{
    GtkWidget *toplevel;

    /* Check we are editing an event. */
    if (week_view->editing_event_num == -1)
        return;

    /* Set focus to the toplevel so the item loses focus. */
    toplevel = gtk_widget_get_toplevel (GTK_WIDGET (week_view));
    if (toplevel && GTK_IS_WINDOW (toplevel))
        gtk_window_set_focus (GTK_WINDOW (toplevel), NULL);
}

/* Cancels the current edition by resetting the appointment's text to its original value */
static void
cancel_editing (EWeekView *week_view)
{
    gint event_num, span_num;
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    const gchar *summary;

    event_num = week_view->editing_event_num;
    span_num = week_view->editing_span_num;

    g_return_if_fail (event_num != -1);

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (!is_comp_data_valid (event))
        return;

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
        return;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan, event->spans_index + span_num);

    /* Reset the text to what was in the component */

    summary = icalcomponent_get_summary (event->comp_data->icalcomp);
    g_object_set (span->text_item, "text", summary ? summary : "", NULL);

    /* Stop editing */
    e_week_view_stop_editing_event (week_view);
}

static gboolean
e_week_view_on_text_item_event (GnomeCanvasItem *item,
                                GdkEvent *gdkevent,
                                EWeekView *week_view)
{
    EWeekViewEvent *event;
    gint event_num, span_num;
    gint nevent = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "event-num"));
    EWeekViewEvent *pevent;

    pevent = tooltip_get_view_event (week_view, -1, nevent);

#if 0
    g_print ("In e_week_view_on_text_item_event\n");
#endif

    switch (gdkevent->type) {
    case GDK_KEY_PRESS:
        tooltip_destroy (week_view, item);
        if (!E_TEXT (item)->preedit_len && gdkevent && gdkevent->key.keyval == GDK_KEY_Return) {
            /* We set the keyboard focus to the EDayView, so the
             * EText item loses it and stops the edit. */
            gtk_widget_grab_focus (GTK_WIDGET (week_view));

            /* Stop the signal last or we will also stop any
             * other events getting to the EText item. */
            g_signal_stop_emission_by_name (G_OBJECT (item), "event");
            return TRUE;
        } else if (gdkevent->key.keyval == GDK_KEY_Escape) {
            cancel_editing (week_view);
            g_signal_stop_emission_by_name (G_OBJECT (item), "event");
            /* focus should go to week view when stop editing */
            gtk_widget_grab_focus (GTK_WIDGET (week_view));
            return TRUE;
        }
        break;
    case GDK_2BUTTON_PRESS:
        if (!e_week_view_find_event_from_item (week_view, item,
                               &event_num, &span_num))
            return FALSE;

        if (!is_array_index_in_bounds (week_view->events, event_num))
            return FALSE;

        event = &g_array_index (week_view->events, EWeekViewEvent,
                    event_num);

        if (!is_comp_data_valid (event))
            return FALSE;

        /* if we started to editing new item on the canvas, then do not open editing dialog until it's saved,
         * because the save of the event recalculates event numbers and you can edit different one */
        if (!is_icalcomp_on_the_server (event->comp_data->icalcomp, event->comp_data->client))
            return TRUE;

        e_calendar_view_edit_appointment (E_CALENDAR_VIEW (week_view),
                         event->comp_data->client,
                         event->comp_data->icalcomp, EDIT_EVENT_AUTODETECT);

        g_signal_stop_emission_by_name (G_OBJECT (item), "event");
        return TRUE;
    case GDK_BUTTON_PRESS:
        tooltip_destroy (week_view, item);
        if (!e_week_view_find_event_from_item (week_view, item,
                               &event_num, &span_num))
            return FALSE;

        if (gdkevent->button.button == 3) {
            EWeekViewEvent *e;

            if (E_TEXT (item)->editing) {
                e_week_view_stop_editing_event (week_view);
                gtk_widget_grab_focus (GTK_WIDGET (week_view));
                return FALSE;
            }

            if (!is_array_index_in_bounds (week_view->events, event_num))
                return FALSE;

            e = &g_array_index (week_view->events, EWeekViewEvent, event_num);

            if (!gtk_widget_has_focus (GTK_WIDGET (week_view)))
                gtk_widget_grab_focus (GTK_WIDGET (week_view));

            e_week_view_set_selected_time_range_visible (week_view, e->start, e->end);

            e_week_view_show_popup_menu (week_view,
                             (GdkEventButton *) gdkevent,
                             event_num);

            g_signal_stop_emission_by_name (G_OBJECT (item->canvas),
                            "button_press_event");
            return TRUE;
        }

        if (gdkevent->button.button != 3) {
            week_view->pressed_event_num = event_num;
            week_view->pressed_span_num = span_num;
        }

        /* Only let the EText handle the event while editing. */
        if (!E_TEXT (item)->editing) {
            g_signal_stop_emission_by_name (G_OBJECT (item), "event");

            if (gdkevent) {
                week_view->drag_event_x = gdkevent->button.x;
                week_view->drag_event_y = gdkevent->button.y;
            } else
                g_warning ("No GdkEvent");

            /* FIXME: Remember the day offset from the start of
             * the event, for DnD. */

            return TRUE;
        }
        break;
    case GDK_BUTTON_RELEASE:
        if (!E_TEXT (item)->editing) {
            /* This shouldn't ever happen. */
            if (!e_week_view_find_event_from_item (week_view,
                                   item,
                                   &event_num,
                                   &span_num))
                return FALSE;

            if (week_view->pressed_event_num != -1
                && week_view->pressed_event_num == event_num
                && week_view->pressed_span_num == span_num) {
                e_week_view_start_editing_event (week_view,
                                 event_num,
                                 span_num,
                                 NULL);
                week_view->pressed_event_num = -1;
            }

            /* Stop the signal last or we will also stop any
             * other events getting to the EText item. */
            g_signal_stop_emission_by_name (G_OBJECT (item), "event");
            return TRUE;
        }
        week_view->pressed_event_num = -1;
        break;
    case GDK_ENTER_NOTIFY:
    {
        ECalendarViewEventData *data;
        gint nspan;

        if (week_view->editing_event_num != -1
            || !e_week_view_find_event_from_item (week_view, item, &nevent, &nspan))
            return FALSE;

        g_object_set_data ((GObject *)item, "event-num", GINT_TO_POINTER (nevent));

        pevent = tooltip_get_view_event (week_view, -1, nevent);

        data = g_malloc (sizeof (ECalendarViewEventData));

        pevent->x = ((GdkEventCrossing *) gdkevent)->x_root;
        pevent->y = ((GdkEventCrossing *) gdkevent)->y_root;
        pevent->tooltip = NULL;

        data->cal_view = (ECalendarView *) week_view;
        data->day = -1;
        data->event_num = nevent;
        data->get_view_event = (ECalendarViewEvent * (*)(ECalendarView *, int, gint)) tooltip_get_view_event;
        pevent->timeout = g_timeout_add_full (
            G_PRIORITY_DEFAULT, 500,
            (GSourceFunc) e_calendar_view_get_tooltips,
            data, (GDestroyNotify) g_free);
        g_object_set_data ((GObject *)week_view, "tooltip-timeout", GUINT_TO_POINTER (pevent->timeout));

        return TRUE;
    }
    case GDK_LEAVE_NOTIFY:
        tooltip_destroy (week_view, item);

        return FALSE;
    case GDK_MOTION_NOTIFY:
        pevent->x = ((GdkEventMotion *) gdkevent)->x_root;
        pevent->y = ((GdkEventMotion *) gdkevent)->y_root;
        pevent->tooltip = (GtkWidget *)g_object_get_data (G_OBJECT (week_view), "tooltip-window");

        if (pevent->tooltip) {
            e_calendar_view_move_tip (pevent->tooltip, pevent->x + 16, pevent->y + 16);
        }
        return TRUE;
    case GDK_FOCUS_CHANGE:
        if (gdkevent->focus_change.in) {
            e_week_view_on_editing_started (week_view, item);
        } else {
            e_week_view_on_editing_stopped (week_view, item);
        }

        return FALSE;
    default:
        break;
    }

    return FALSE;
}

static gboolean e_week_view_event_move (ECalendarView *cal_view, ECalViewMoveDirection direction)
{
    EWeekViewEvent *event;
    gint event_num, adjust_days, current_start_day, current_end_day;
    time_t start_dt, end_dt;
    struct icaltimetype start_time,end_time;
    EWeekView *week_view = E_WEEK_VIEW (cal_view);
    gboolean is_all_day = FALSE;

    event_num = week_view->editing_event_num;
    adjust_days = 0;

    /* If no item is being edited, just return. */
    if (event_num == -1)
        return FALSE;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return FALSE;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (!is_comp_data_valid (event))
        return FALSE;

    end_dt = event->end;
    start_time = icalcomponent_get_dtstart (event->comp_data->icalcomp);
    end_time = icalcomponent_get_dtend (event->comp_data->icalcomp);

    if (start_time.is_date && end_time.is_date)
        is_all_day = TRUE;

    current_end_day = e_week_view_get_day_offset_of_event (week_view,end_dt);

    switch (direction) {
    case E_CAL_VIEW_MOVE_UP:
        adjust_days = e_week_view_get_adjust_days_for_move_up (week_view,current_end_day);
        break;
    case E_CAL_VIEW_MOVE_DOWN:
        adjust_days = e_week_view_get_adjust_days_for_move_down (week_view,current_end_day);
        break;
    case E_CAL_VIEW_MOVE_LEFT:
        adjust_days = e_week_view_get_adjust_days_for_move_left (week_view,current_end_day);
        break;
    case E_CAL_VIEW_MOVE_RIGHT:
        adjust_days = e_week_view_get_adjust_days_for_move_right (week_view,current_end_day);
        break;
    default:
        break;
    }

    icaltime_adjust (&start_time ,adjust_days,0,0,0);
    icaltime_adjust (&end_time ,adjust_days,0,0,0);
    start_dt = icaltime_as_timet_with_zone (start_time,
        e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
    end_dt = icaltime_as_timet_with_zone (end_time,
        e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));

    current_start_day = e_week_view_get_day_offset_of_event (week_view,start_dt);
    current_end_day = e_week_view_get_day_offset_of_event (week_view,end_dt);
    if (is_all_day)
        current_end_day--;

    if (current_start_day < 0) {
        return TRUE;
    }
    if (week_view->multi_week_view) {
        if (current_end_day >= week_view->weeks_shown * 7) {
            return TRUE;
        }
    }else {
        if (current_end_day >= 7) {
            return TRUE;
        }
    }

    e_week_view_change_event_time (week_view, start_dt, end_dt, is_all_day);
    return TRUE;
}

static gint
e_week_view_get_day_offset_of_event (EWeekView *week_view,
                                     time_t event_time)
{
    time_t first_day = week_view->day_starts[0];

    if (event_time - first_day < 0)
        return -1;
    else
        return (event_time - first_day) / (24 * 60 * 60);
}

void
e_week_view_scroll_a_step (EWeekView *week_view,
                           ECalViewMoveDirection direction)
{
    GtkAdjustment *adjustment;
    GtkRange *range;
    gdouble step_increment;
    gdouble page_size;
    gdouble new_value;
    gdouble lower;
    gdouble upper;
    gdouble value;

    range = GTK_RANGE (week_view->vscrollbar);
    adjustment = gtk_range_get_adjustment (range);

    step_increment = gtk_adjustment_get_step_increment (adjustment);
    page_size = gtk_adjustment_get_page_size (adjustment);
    lower = gtk_adjustment_get_lower (adjustment);
    upper = gtk_adjustment_get_upper (adjustment);
    value = gtk_adjustment_get_value (adjustment);

    switch (direction) {
        case E_CAL_VIEW_MOVE_UP:
            new_value = value - step_increment;
            break;
        case E_CAL_VIEW_MOVE_DOWN:
            new_value = value + step_increment;
            break;
        case E_CAL_VIEW_MOVE_PAGE_UP:
            new_value = value - page_size;
            break;
        case E_CAL_VIEW_MOVE_PAGE_DOWN:
            new_value = value + page_size;
            break;
        default:
            return;
    }

    new_value = CLAMP (new_value, lower, upper - page_size);
    gtk_adjustment_set_value (adjustment, new_value);
}

static void
e_week_view_change_event_time (EWeekView *week_view,
                               time_t start_dt,
                               time_t end_dt,
                               gboolean is_all_day)
{
    EWeekViewEvent *event;
    gint event_num;
    ECalComponent *comp;
    ECalComponentDateTime date;
    struct icaltimetype itt;
    ECalClient *client;
    CalObjModType mod = CALOBJ_MOD_ALL;
    GtkWindow *toplevel;

    event_num = week_view->editing_event_num;

    /* If no item is being edited, just return. */
    if (event_num == -1)
        return;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (!is_comp_data_valid (event))
        return;

    client = event->comp_data->client;

    /* We use a temporary shallow copy of the ico since we don't want to
     * change the original ico here. Otherwise we would not detect that
     * the event's time had changed in the "update_event" callback. */
    comp = e_cal_component_new ();
    e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
    date.value = &itt;
    /* FIXME: Should probably keep the timezone of the original start
     * and end times. */
    date.tzid = icaltimezone_get_tzid (e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));

    *date.value = icaltime_from_timet_with_zone (start_dt, is_all_day,
                             e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
    cal_comp_set_dtstart_with_oldzone (client, comp, &date);
    *date.value = icaltime_from_timet_with_zone (end_dt, is_all_day,
                             e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
    cal_comp_set_dtend_with_oldzone (client, comp, &date);

    e_cal_component_commit_sequence (comp);

    if (week_view->last_edited_comp_string != NULL) {
        g_free (week_view->last_edited_comp_string);
        week_view->last_edited_comp_string = NULL;
    }

    week_view->last_edited_comp_string = e_cal_component_get_as_string (comp);

    if (e_cal_component_has_recurrences (comp)) {
        if (!recur_component_dialog (client, comp, &mod, NULL, FALSE)) {
            gtk_widget_queue_draw (week_view->main_canvas);
            goto out;
        }

        if (mod == CALOBJ_MOD_ALL)
            comp_util_sanitize_recurrence_master (comp, client);

        if (mod == CALOBJ_MOD_THIS) {
            e_cal_component_set_rdate_list (comp, NULL);
            e_cal_component_set_rrule_list (comp, NULL);
            e_cal_component_set_exdate_list (comp, NULL);
            e_cal_component_set_exrule_list (comp, NULL);
        }
    } else if (e_cal_component_is_instance (comp))
        mod = CALOBJ_MOD_THIS;

    toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (week_view)));

    e_cal_component_commit_sequence (comp);

    e_calendar_view_modify_and_send (
        E_CALENDAR_VIEW (week_view),
        comp, client, mod, toplevel, TRUE);

out:
    g_object_unref (comp);
}

static void
e_week_view_on_editing_started (EWeekView *week_view,
                                GnomeCanvasItem *item)
{
    gint event_num, span_num;

    if (!e_week_view_find_event_from_item (week_view, item,
                           &event_num, &span_num))
        return;

#if 0
    g_print ("In e_week_view_on_editing_started event_num:%i span_num:%i\n", event_num, span_num);
#endif

    week_view->editing_event_num = event_num;
    week_view->editing_span_num = span_num;

    /* We need to reshape long events so the whole width is used while
     * editing. */
    if (!e_week_view_is_one_day_event (week_view, event_num)) {
        e_week_view_reshape_event_span (week_view, event_num,
                        span_num);
    }

    g_signal_emit_by_name (week_view, "selection_changed");
}

static void
e_week_view_on_editing_stopped (EWeekView *week_view,
                                GnomeCanvasItem *item)
{
    gint event_num, span_num;
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    gchar *text = NULL;
    ECalComponent *comp;
    ECalComponentText summary;
    ECalClient *client;
    const gchar *uid;
    gboolean on_server;

    /* Note: the item we are passed here isn't reliable, so we just stop
     * the edit of whatever item was being edited. We also receive this
     * event twice for some reason. */
    event_num = week_view->editing_event_num;
    span_num = week_view->editing_span_num;

    /* If no item is being edited, just return. */
    if (event_num == -1)
        return;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);

    if (!is_comp_data_valid (event))
        return;

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
        return;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   event->spans_index + span_num);

    /* Reset the edit fields. */
    week_view->editing_event_num = -1;

    /* Check that the event is still valid. */
    uid = icalcomponent_get_uid (event->comp_data->icalcomp);
    if (!uid)
        return;

    text = NULL;
    g_object_set (span->text_item, "handle_popup", FALSE, NULL);
    g_object_get (span->text_item, "text", &text, NULL);

    comp = e_cal_component_new ();
    e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));

    client = event->comp_data->client;
    on_server = cal_comp_is_on_server (comp, client);

    if (string_is_empty (text) && !on_server) {
        e_cal_component_get_uid (comp, &uid);
        g_signal_handlers_disconnect_by_func (item, e_week_view_on_text_item_event, week_view);
        e_week_view_foreach_event_with_uid (week_view, uid,
                            e_week_view_remove_event_cb, NULL);
        week_view->event_destroyed = TRUE;
        gtk_widget_queue_draw (week_view->main_canvas);
        e_week_view_check_layout (week_view);
        goto out;
    }

    /* Only update the summary if necessary. */
    e_cal_component_get_summary (comp, &summary);
    if (summary.value && !strcmp (text, summary.value)) {
        gboolean free_text = FALSE;
        const gchar *summary;

        summary = get_comp_summary (event->comp_data->client, event->comp_data->icalcomp, &free_text);
        g_object_set (span->text_item, "text", summary ? summary : "", NULL);

        if (free_text)
            g_free ((gchar *) summary);

        if (!e_week_view_is_one_day_event (week_view, event_num))
            e_week_view_reshape_event_span (week_view, event_num, span_num);
    } else if (summary.value || !string_is_empty (text)) {
        icalcomponent *icalcomp = e_cal_component_get_icalcomponent (comp);

        summary.value = text;
        summary.altrep = NULL;
        e_cal_component_set_summary (comp, &summary);
        e_cal_component_commit_sequence (comp);

        if (!on_server) {
            gchar *uid = NULL;
            GError *error = NULL;

            if (!e_cal_client_create_object_sync (client, icalcomp, &uid, NULL, &error)) {
                g_message (G_STRLOC ": Could not create the object! %s", error ? error->message : "Unknown error");
                uid = NULL;
            } else {
                if (uid)
                    icalcomponent_set_uid (icalcomp, uid);

                e_calendar_view_emit_user_created (
                    E_CALENDAR_VIEW (week_view));
            }

            if (uid)
                g_free (uid);
            if (error)
                g_error_free (error);

            /* we remove the object since we either got the update from the server or failed */
            e_week_view_remove_event_cb (week_view, event_num, NULL);
        } else {
            CalObjModType mod = CALOBJ_MOD_ALL;
            GtkWindow *toplevel;

            if (e_cal_component_has_recurrences (comp)) {
                if (!recur_component_dialog (client, comp, &mod, NULL, FALSE)) {
                    goto out;
                }

                if (mod == CALOBJ_MOD_ALL)
                    comp_util_sanitize_recurrence_master (comp, client);

                if (mod == CALOBJ_MOD_THIS) {
                    ECalComponentDateTime dt;
                    struct icaltimetype tt;
                    gchar *tzid;

                    e_cal_component_get_dtstart (comp, &dt);
                    if (dt.value->zone) {
                        tt = icaltime_from_timet_with_zone (
                            event->comp_data->instance_start,
                            dt.value->is_date,
                            dt.value->zone);
                    } else {
                        tt = icaltime_from_timet_with_zone (
                            event->comp_data->instance_start,
                            dt.value->is_date,
                            e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
                    }
                    tzid = g_strdup (dt.tzid);
                    e_cal_component_free_datetime (&dt);
                    dt.value = &tt;
                    dt.tzid = tzid;
                    e_cal_component_set_dtstart (comp, &dt);
                    g_free (tzid);

                    e_cal_component_get_dtend (comp, &dt);
                    if (dt.value->zone) {
                        tt = icaltime_from_timet_with_zone (
                            event->comp_data->instance_end,
                            dt.value->is_date,
                            dt.value->zone);
                    } else {
                        tt = icaltime_from_timet_with_zone (
                            event->comp_data->instance_end,
                            dt.value->is_date,
                            e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
                    }
                    tzid = g_strdup (dt.tzid);
                    e_cal_component_free_datetime (&dt);
                    dt.value = &tt;
                    dt.tzid = tzid;
                    e_cal_component_set_dtend (comp, &dt);
                    g_free (tzid);

                    e_cal_component_set_rdate_list (comp, NULL);
                    e_cal_component_set_rrule_list (comp, NULL);
                    e_cal_component_set_exdate_list (comp, NULL);
                    e_cal_component_set_exrule_list (comp, NULL);

                    e_cal_component_commit_sequence (comp);
                }
            } else if (e_cal_component_is_instance (comp))
                mod = CALOBJ_MOD_THIS;

            /* FIXME When sending here, what exactly should we send? */
            toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (week_view)));

            e_calendar_view_modify_and_send (
                E_CALENDAR_VIEW (week_view),
                comp, client, mod, toplevel, FALSE);
        }
    }

 out:

    g_free (text);
    g_object_unref (comp);

    g_signal_emit_by_name (week_view, "selection_changed");
}

gboolean
e_week_view_find_event_from_item (EWeekView *week_view,
                                  GnomeCanvasItem *item,
                                  gint *event_num_return,
                                  gint *span_num_return)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    gint event_num, span_num, num_events;

    num_events = week_view->events->len;
    for (event_num = 0; event_num < num_events; event_num++) {
        event = &g_array_index (week_view->events, EWeekViewEvent,
                    event_num);
        for (span_num = 0; span_num < event->num_spans; span_num++) {
            if (!is_array_index_in_bounds (week_view->spans, event->spans_index + span_num))
                continue;

            span = &g_array_index (week_view->spans,
                           EWeekViewEventSpan,
                           event->spans_index + span_num);
            if (span->text_item == item) {
                *event_num_return = event_num;
                *span_num_return = span_num;
                return TRUE;
            }
        }
    }

    return FALSE;
}

/* Finds the index of the event with the given uid.
 * Returns TRUE if an event with the uid was found.
 * Note that for recurring events there may be several EWeekViewEvents, one
 * for each instance, all with the same iCalObject and uid. So only use this
 * function if you know the event doesn't recur or you are just checking to
 * see if any events with the uid exist. */
static gboolean
e_week_view_find_event_from_uid (EWeekView *week_view,
                                 ECalClient *client,
                                 const gchar *uid,
                                 const gchar *rid,
                                 gint *event_num_return)
{
    EWeekViewEvent *event;
    gint event_num, num_events;

    *event_num_return = -1;
    if (!uid)
        return FALSE;

    num_events = week_view->events->len;
    for (event_num = 0; event_num < num_events; event_num++) {
        const gchar *u;
        gchar *r = NULL;

        event = &g_array_index (week_view->events, EWeekViewEvent,
                    event_num);

        if (!is_comp_data_valid (event))
            continue;

        if (event->comp_data->client != client)
            continue;

        u = icalcomponent_get_uid (event->comp_data->icalcomp);
        if (u && !strcmp (uid, u)) {
            if (rid && *rid) {
                r = icaltime_as_ical_string_r (icalcomponent_get_recurrenceid (event->comp_data->icalcomp));
                if (!r || !*r)
                    continue;
                if (strcmp (rid, r) != 0) {
                    g_free (r);
                    continue;
                }
                g_free (r);
            }

            *event_num_return = event_num;
            return TRUE;
        }
    }

    return FALSE;
}

gboolean
e_week_view_is_one_day_event (EWeekView *week_view,
                              gint event_num)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return FALSE;

    event = &g_array_index (week_view->events, EWeekViewEvent, event_num);
    if (event->num_spans != 1)
        return FALSE;

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index))
        return FALSE;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   event->spans_index);

    if (event->start == week_view->day_starts[span->start_day]
        && event->end == week_view->day_starts[span->start_day + 1])
        return FALSE;

    if (span->num_days == 1
        && event->start >= week_view->day_starts[span->start_day]
        && event->end <= week_view->day_starts[span->start_day + 1])
        return TRUE;

    return FALSE;
}

static void
e_week_view_cursor_key_up (EWeekView *week_view)
{
    EWeekViewClass *week_view_class;

    week_view_class = E_WEEK_VIEW_GET_CLASS (week_view);
    g_return_if_fail (week_view_class->cursor_key_up != NULL);

    week_view_class->cursor_key_up (week_view);
}

static void
e_week_view_cursor_key_down (EWeekView *week_view)
{
    EWeekViewClass *week_view_class;

    week_view_class = E_WEEK_VIEW_GET_CLASS (week_view);
    g_return_if_fail (week_view_class->cursor_key_down != NULL);

    week_view_class->cursor_key_down (week_view);
}

static void
e_week_view_cursor_key_left (EWeekView *week_view)
{
    EWeekViewClass *week_view_class;

    week_view_class = E_WEEK_VIEW_GET_CLASS (week_view);
    g_return_if_fail (week_view_class->cursor_key_left != NULL);

    week_view_class->cursor_key_left (week_view);
}

static void
e_week_view_cursor_key_right (EWeekView *week_view)
{
    EWeekViewClass *week_view_class;

    week_view_class = E_WEEK_VIEW_GET_CLASS (week_view);
    g_return_if_fail (week_view_class->cursor_key_right != NULL);

    week_view_class->cursor_key_right (week_view);
}

static gboolean
e_week_view_add_new_event_in_selected_range (EWeekView *week_view,
                                             const gchar *initial_text)
{
    ECalClient *client;
    ECalModel *model;
    ECalComponent *comp;
    icalcomponent *icalcomp;
    gint event_num;
    ECalComponentDateTime date;
    struct icaltimetype itt;
    time_t dtstart, dtend;
    const gchar *uid;
    AddEventData add_event_data;
    EWeekViewEvent *wvevent;
    EWeekViewEventSpan *span;

    /* Check if the client is read only */
    model = e_calendar_view_get_model (E_CALENDAR_VIEW (week_view));
    client = e_cal_model_get_default_client (model);
    if (e_client_is_readonly (E_CLIENT (client)))
        return FALSE;

    /* Add a new event covering the selected range. */
    icalcomp = e_cal_model_create_component_with_defaults (e_calendar_view_get_model (E_CALENDAR_VIEW (week_view)), TRUE);
    if (!icalcomp)
        return FALSE;
    uid = icalcomponent_get_uid (icalcomp);

    comp = e_cal_component_new ();
    e_cal_component_set_icalcomponent (comp, icalcomp);

    dtstart = week_view->day_starts[week_view->selection_start_day];
    dtend = week_view->day_starts[week_view->selection_end_day + 1];

    date.value = &itt;
    date.tzid = NULL;

    /* We use DATE values now, so we don't need the timezone. */
    /*date.tzid = icaltimezone_get_tzid (e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));*/

    *date.value = icaltime_from_timet_with_zone (dtstart, TRUE,
                             e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
    e_cal_component_set_dtstart (comp, &date);

    *date.value = icaltime_from_timet_with_zone (dtend, TRUE,
                             e_calendar_view_get_timezone (E_CALENDAR_VIEW (week_view)));
    e_cal_component_set_dtend (comp, &date);

    /* Editor default in week/month view */
    e_cal_component_set_transparency (comp, E_CAL_COMPONENT_TRANSP_TRANSPARENT);

    e_cal_component_set_categories (
        comp, e_calendar_view_get_default_category (E_CALENDAR_VIEW (week_view)));

    /* We add the event locally and start editing it. We don't send it
     * to the server until the user finishes editing it. */
    add_event_data.week_view = week_view;
    add_event_data.comp_data = NULL;
    e_week_view_add_event (comp, dtstart, dtend, TRUE, &add_event_data);
    e_week_view_check_layout (week_view);
    gtk_widget_queue_draw (week_view->main_canvas);

    if (!e_week_view_find_event_from_uid (week_view, client, uid, NULL, &event_num)) {
        g_warning ("Couldn't find event to start editing.\n");
        g_object_unref (comp);
        return FALSE;
    }

    if (!is_array_index_in_bounds (week_view->events, event_num))
        return FALSE;

    wvevent = &g_array_index (week_view->events, EWeekViewEvent,
                  event_num);

    if (!is_array_index_in_bounds (week_view->spans, wvevent->spans_index + 0))
        return FALSE;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   wvevent->spans_index + 0);

    /* If the event can't be fit on the screen, don't try to edit it. */
    if (!span->text_item) {
        e_week_view_foreach_event_with_uid (week_view, uid,
                e_week_view_remove_event_cb, NULL);
        g_object_unref (comp);
        return FALSE;
    } else {
        e_week_view_start_editing_event (week_view, event_num, 0,
                (gchar *) initial_text);
    }

    g_object_unref (comp);

    return TRUE;
}

static gboolean
e_week_view_do_key_press (GtkWidget *widget,
                          GdkEventKey *event)
{
    EWeekView *week_view;
    gchar *initial_text;
    guint keyval;
    gboolean stop_emission;
    gboolean ret_val;

    g_return_val_if_fail (widget != NULL, FALSE);
    g_return_val_if_fail (E_IS_WEEK_VIEW (widget), FALSE);
    g_return_val_if_fail (event != NULL, FALSE);

    week_view = E_WEEK_VIEW (widget);
    keyval = event->keyval;

    /* The Escape key aborts a resize operation. */
#if 0
    if (week_view->resize_drag_pos != E_CALENDAR_VIEW_POS_NONE) {
        if (event->keyval == GDK_KEY_Escape) {
            e_week_view_abort_resize (week_view, event->time);
        }
        return FALSE;
    }
#endif

    /* Handle the cursor keys for moving the selection */
    stop_emission = FALSE;
    if (!(event->state & GDK_SHIFT_MASK)
        && !(event->state & GDK_MOD1_MASK)) {
        stop_emission = TRUE;
        switch (keyval) {
        case GDK_KEY_Page_Up:
            if (!week_view->multi_week_view)
                e_week_view_scroll_a_step (week_view, E_CAL_VIEW_MOVE_UP);
            else
                e_week_view_scroll_a_step (week_view, E_CAL_VIEW_MOVE_PAGE_UP);
            break;
        case GDK_KEY_Page_Down:
            if (!week_view->multi_week_view)
                e_week_view_scroll_a_step (week_view, E_CAL_VIEW_MOVE_DOWN);
            else
                e_week_view_scroll_a_step (week_view, E_CAL_VIEW_MOVE_PAGE_DOWN);
            break;
        case GDK_KEY_Up:
            e_week_view_cursor_key_up (week_view);
            break;
        case GDK_KEY_Down:
            e_week_view_cursor_key_down (week_view);
            break;
        case GDK_KEY_Left:
            e_week_view_cursor_key_left (week_view);
            break;
        case GDK_KEY_Right:
            e_week_view_cursor_key_right (week_view);
            break;
        default:
            stop_emission = FALSE;
            break;
        }
    }
    if (stop_emission)
        return TRUE;

    /*Navigation through days with arrow keys*/
    if (((event->state & GDK_SHIFT_MASK) != GDK_SHIFT_MASK)
        &&((event->state & GDK_CONTROL_MASK) != GDK_CONTROL_MASK)
        &&((event->state & GDK_MOD1_MASK) == GDK_MOD1_MASK)) {
        if (keyval == GDK_KEY_Up || keyval == GDK_KEY_KP_Up)
            return e_week_view_event_move ((ECalendarView *) week_view, E_CAL_VIEW_MOVE_UP);
        else if (keyval == GDK_KEY_Down || keyval == GDK_KEY_KP_Down)
            return e_week_view_event_move ((ECalendarView *) week_view, E_CAL_VIEW_MOVE_DOWN);
        else if (keyval == GDK_KEY_Left || keyval == GDK_KEY_KP_Left)
            return e_week_view_event_move ((ECalendarView *) week_view, E_CAL_VIEW_MOVE_LEFT);
        else if (keyval == GDK_KEY_Right || keyval == GDK_KEY_KP_Right)
            return e_week_view_event_move ((ECalendarView *) week_view, E_CAL_VIEW_MOVE_RIGHT);
    }

    if (week_view->selection_start_day == -1)
        return FALSE;

    /* We only want to start an edit with a return key or a simple
     * character. */
    if (event->keyval == GDK_KEY_Return) {
        initial_text = NULL;
    } else if (((event->keyval >= 0x20) && (event->keyval <= 0xFF)
            && (event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)))
           || (event->length == 0)
           || (event->keyval == GDK_KEY_Tab)) {
        return FALSE;
    } else
        initial_text = e_utf8_from_gtk_event_key (widget, event->keyval, event->string);

    ret_val = e_week_view_add_new_event_in_selected_range (week_view, initial_text);

    if (initial_text)
        g_free (initial_text);

    return ret_val;
}

static gint
e_week_view_get_adjust_days_for_move_up (EWeekView *week_view,
                                         gint current_day)
{
       if (week_view->multi_week_view)
           return -7;
       else
           return 0;
}

static gint
e_week_view_get_adjust_days_for_move_down (EWeekView *week_view,
                                           gint current_day)
{
       if (week_view->multi_week_view)
           return 7;
       else
           return 0;
}

static gint
e_week_view_get_adjust_days_for_move_left (EWeekView *week_view,
                                           gint current_day)
{
    return -1;
}

static gint
e_week_view_get_adjust_days_for_move_right (EWeekView *week_view,
                                            gint current_day)
{
    return 1;
}

static gboolean
e_week_view_key_press (GtkWidget *widget,
                       GdkEventKey *event)
{
    gboolean handled = FALSE;
    handled = e_week_view_do_key_press (widget, event);

    /* if not handled, try key bindings */
    if (!handled)
        handled = GTK_WIDGET_CLASS (e_week_view_parent_class)->key_press_event (widget, event);
    return handled;
}

void
e_week_view_show_popup_menu (EWeekView *week_view,
                             GdkEventButton *bevent,
                             gint event_num)
{
    week_view->popup_event_num = event_num;

    e_calendar_view_popup_event (E_CALENDAR_VIEW (week_view), bevent);
}

static gboolean
e_week_view_popup_menu (GtkWidget *widget)
{
    EWeekView *week_view = E_WEEK_VIEW (widget);
    e_week_view_show_popup_menu (week_view, NULL,
                     week_view->editing_event_num);
    return TRUE;
}

void
e_week_view_jump_to_button_item (EWeekView *week_view,
                                 GnomeCanvasItem *item)
{
    gint day;
    GnomeCalendar *calendar;

    for (day = 0; day < E_WEEK_VIEW_MAX_WEEKS * 7; ++day) {
        if (item == week_view->jump_buttons[day]) {
            calendar = e_calendar_view_get_calendar (E_CALENDAR_VIEW (week_view));
            if (calendar)
                gnome_calendar_dayjump
                    (calendar,
                     week_view->day_starts[day]);
            else
                g_warning ("Calendar not set");
            return;
        }
    }
}

static gboolean
e_week_view_on_jump_button_event (GnomeCanvasItem *item,
                                  GdkEvent *event,
                                  EWeekView *week_view)
{
    gint day;

    if (event->type == GDK_BUTTON_PRESS) {
        e_week_view_jump_to_button_item (week_view, item);
        return TRUE;
    }
    else if (event->type == GDK_KEY_PRESS) {
        /* return, if Tab, Control or Alt is pressed */
        if ((event->key.keyval == GDK_KEY_Tab) ||
            (event->key.state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)))
            return FALSE;
        /* with a return key or a simple character (from 0x20 to 0xff),
         * jump to the day
         */
        if ((event->key.keyval == GDK_KEY_Return) ||
            ((event->key.keyval >= 0x20) &&
             (event->key.keyval <= 0xFF))) {
            e_week_view_jump_to_button_item (week_view, item);
            return TRUE;
        }
    }
    else if (event->type == GDK_FOCUS_CHANGE) {
        GdkEventFocus *focus_event = (GdkEventFocus *) event;
        GdkPixbuf *pixbuf = NULL;

        for (day = 0; day < E_WEEK_VIEW_MAX_WEEKS * 7; day++) {
            if (item == week_view->jump_buttons[day])
                break;
        }

        if (focus_event->in) {
            week_view->focused_jump_button = day;
            pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) jump_xpm_focused);
            gnome_canvas_item_set (week_view->jump_buttons[day],
                           "GnomeCanvasPixbuf::pixbuf",
                           pixbuf, NULL);
        }
        else {
            week_view->focused_jump_button = E_WEEK_VIEW_JUMP_BUTTON_NO_FOCUS;
            pixbuf = gdk_pixbuf_new_from_xpm_data ((const gchar **) jump_xpm);
            gnome_canvas_item_set (week_view->jump_buttons[day],
                           "GnomeCanvasPixbuf::pixbuf",
                           pixbuf, NULL);
        }
        if (pixbuf)
            g_object_unref (pixbuf);
    }

    return FALSE;
}

/* Converts an hour from 0-23 to the preferred time format, and returns the
 * suffix to add and the width of it in the normal font. */
void
e_week_view_convert_time_to_display (EWeekView *week_view,
                                     gint hour,
                                     gint *display_hour,
                                     const gchar **suffix,
                                     gint *suffix_width)
{
    ECalModel *model;

    model = e_calendar_view_get_model (E_CALENDAR_VIEW (week_view));

    /* Calculate the actual hour number to display. For 12-hour
     * format we convert 0-23 to 12-11am/12-11pm. */
    *display_hour = hour;
    if (e_cal_model_get_use_24_hour_format (model)) {
        *suffix = "";
        *suffix_width = 0;
    } else {
        if (hour < 12) {
            *suffix = week_view->am_string;
            *suffix_width = week_view->am_string_width;
        } else {
            *display_hour -= 12;
            *suffix = week_view->pm_string;
            *suffix_width = week_view->pm_string_width;
        }

        /* 12-hour uses 12:00 rather than 0:00. */
        if (*display_hour == 0)
            *display_hour = 12;
    }
}

gint
e_week_view_get_time_string_width (EWeekView *week_view)
{
    ECalModel *model;
    gint time_width;

    model = e_calendar_view_get_model (E_CALENDAR_VIEW (week_view));

    if (week_view->use_small_font && week_view->small_font_desc)
        time_width = week_view->digit_width * 2
            + week_view->small_digit_width * 2;
    else
        time_width = week_view->digit_width * 4
            + week_view->colon_width;

    if (!e_cal_model_get_use_24_hour_format (model))
        time_width += MAX (week_view->am_string_width,
                   week_view->pm_string_width);

    return time_width;
}

/* Queues a layout, unless one is already queued. */
static void
e_week_view_queue_layout (EWeekView *week_view)
{
    if (week_view->layout_timeout_id == 0) {
        week_view->layout_timeout_id = g_timeout_add (E_WEEK_VIEW_LAYOUT_TIMEOUT, e_week_view_layout_timeout_cb, week_view);
    }
}

/* Removes any queued layout. */
static void
e_week_view_cancel_layout (EWeekView *week_view)
{
    if (week_view->layout_timeout_id != 0) {
        g_source_remove (week_view->layout_timeout_id);
        week_view->layout_timeout_id = 0;
    }
}

static gboolean
e_week_view_layout_timeout_cb (gpointer data)
{
    EWeekView *week_view = E_WEEK_VIEW (data);

    gtk_widget_queue_draw (week_view->main_canvas);
    e_week_view_check_layout (week_view);

    week_view->layout_timeout_id = 0;
    return FALSE;
}

/* Returns the number of selected events (0 or 1 at present). */
gint
e_week_view_get_num_events_selected (EWeekView *week_view)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), 0);

    return (week_view->editing_event_num != -1) ? 1 : 0;
}

gboolean
e_week_view_is_jump_button_visible (EWeekView *week_view,
                                    gint day)
{
    g_return_val_if_fail (E_IS_WEEK_VIEW (week_view), FALSE);

    if ((day >= 0) && (day < E_WEEK_VIEW_MAX_WEEKS * 7))
        return week_view->jump_buttons[day]->flags & GNOME_CANVAS_ITEM_VISIBLE;
    return FALSE;
}

static void
e_week_view_paste_text (ECalendarView *cal_view)
{
    EWeekViewEvent *event;
    EWeekViewEventSpan *span;
    EWeekView *week_view;

    g_return_if_fail (E_IS_WEEK_VIEW (cal_view));

    week_view = E_WEEK_VIEW (cal_view);

    if (week_view->editing_event_num == -1 &&
        !e_week_view_add_new_event_in_selected_range (week_view, NULL))
        return;

    if (!is_array_index_in_bounds (week_view->events, week_view->editing_event_num))
        return;

    event = &g_array_index (week_view->events, EWeekViewEvent,
                week_view->editing_event_num);

    if (!is_array_index_in_bounds (week_view->spans, event->spans_index + week_view->editing_span_num))
        return;

    span = &g_array_index (week_view->spans, EWeekViewEventSpan,
                   event->spans_index + week_view->editing_span_num);

    if (span->text_item &&
        E_IS_TEXT (span->text_item) &&
        E_TEXT (span->text_item)->editing) {
        e_text_paste_clipboard (E_TEXT (span->text_item));
    }
}