aboutsummaryrefslogblamecommitdiffstats
path: root/calendar/gui/e-cal-list-view.c
blob: 5cf64aebf7c42108402214604c8bd894681bdf5b (plain) (tree)
1
2
3
4
5
6
7
8
9
10
  
                                                       

                                                                


                                                               


                                                                  

                                                                    
  
                                                                   
                                                                             




                                                        

   
                    
                   
      

                            
                                                    



                     

                       
                        
                           
                             
                             




                                       
                              
                                   

                                       
                                  
 
                                    








                                  



                            
                                                                            
 
                                                                                  
                                                                                                                         
                                                                                                     





                                                                                               

                                                                                               

                                                                                              
                                                                                       
 
                                                                   





                                                     
                                       
 

                                                
                                                  






                                                                              
                                                                                      
                                                                                    






































                                                                        
                                                            


                                                        
                                           



                                 
                                                                              













                                                                      

                                                                         


                       


                                                              
 
                                                                                  
                                                                                                          

 

                                                                         
 


                                                              
 
                                                                                                  




                                           






                                 
 
                                                                            
 



















                                                                  







                                                       


                                                                 




                                                             


                                                                  
                                                                     
 
















                                                                              


                                                                       











                                                                       


                                                                


                                                                           
                                                                
                                                            
                            









                                                                                                         
                             
                                                                                     

                                                                                                             
                                                                                                           
                                                                                           
                                                                                                               







                                                                                                





                                 
               
                                      
 
                                     
 


                                                            
 

                               
                             




















                                                                                                









                                                                                
                                                                          

 


                                                                                            
                       
                      
 

                                                                                                                                                          
      










                                                                  

                                      



                                                                                   
 

                                  
 
               




                                                                                             
 

                                                                                                                    
                                                                                                   




                    








                                                                                            







                                                                          











































                                                                                                                           
              
                                                             











                                                                                                                      
                                          
 
                                                                                                  
                                  
                                                                                           

























                                                                                         
                                                                                                      




                                                 
                                                                                                




                                             
                                                                                              

























                                                                                                  
                                                                                                     

                             

                                                                                                                    



                                                                  
/*
 * ECalListView - display calendar events in an ETable.
 *
 * 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:
 *      Hans Petter Jansson  <hpj@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 */

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

#include "e-cal-list-view.h"
/*#include "a11y/ea-calendar.h"*/  /* KILL-BONOBO */

#include <math.h>
#include <time.h>
#include <sys/stat.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <glib/gstdio.h>
#include <gdk/gdkkeysyms.h>
#include <misc/e-gui-utils.h>
#include <e-util/e-binding.h>
#include <table/e-table-memory-store.h>
#include <table/e-cell-checkbox.h>
#include <table/e-cell-toggle.h>
#include <table/e-cell-text.h>
#include <table/e-cell-combo.h>
#include <misc/e-popup-menu.h>
#include <table/e-cell-date-edit.h>
#include <e-util/e-categories-config.h>
#include <e-util/e-dialog-utils.h>
#include <e-util/e-util-private.h>

#include <libecal/e-cal-time-util.h>
#include "e-cal-model-calendar.h"
#include "e-cell-date-edit-text.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 "comp-util.h"
#include "itip-utils.h"
#include "calendar-config.h"
#include "goto.h"
#include "misc.h"

static void      e_cal_list_view_destroy                (GtkObject *object);

static GList    *e_cal_list_view_get_selected_events    (ECalendarView *cal_view);
static gboolean  e_cal_list_view_get_selected_time_range (ECalendarView *cal_view, time_t *start_time, time_t *end_time);
static gboolean  e_cal_list_view_get_visible_time_range (ECalendarView *cal_view, time_t *start_time,
                             time_t *end_time);

static gboolean  e_cal_list_view_popup_menu             (GtkWidget *widget);

static void      e_cal_list_view_show_popup_menu        (ECalListView *cal_list_view, gint row,
                             GdkEvent *gdk_event);
static gboolean  e_cal_list_view_on_table_double_click   (GtkWidget *table, gint row, gint col,
                             GdkEvent *event, gpointer data);
static gboolean  e_cal_list_view_on_table_right_click   (GtkWidget *table, gint row, gint col,
                             GdkEvent *event, gpointer data);
static void e_cal_list_view_cursor_change_cb (ETable *etable, gint row, gpointer data);

G_DEFINE_TYPE (ECalListView, e_cal_list_view, E_TYPE_CALENDAR_VIEW)

static void
e_cal_list_view_class_init (ECalListViewClass *class)
{
    GtkObjectClass *object_class;
    GtkWidgetClass *widget_class;
    ECalendarViewClass *view_class;

    object_class = (GtkObjectClass *) class;
    widget_class = (GtkWidgetClass *) class;
    view_class = (ECalendarViewClass *) class;

    /* Method override */
    object_class->destroy       = e_cal_list_view_destroy;

    widget_class->popup_menu = e_cal_list_view_popup_menu;

    view_class->get_selected_events = e_cal_list_view_get_selected_events;
    view_class->get_selected_time_range = e_cal_list_view_get_selected_time_range;
    view_class->get_visible_time_range = e_cal_list_view_get_visible_time_range;
}

static gint
date_compare_cb (gconstpointer a, gconstpointer b)
{
    ECellDateEditValue *dv1 = (ECellDateEditValue *) a;
    ECellDateEditValue *dv2 = (ECellDateEditValue *) b;
    struct icaltimetype tt;

    /* First check if either is NULL. NULL dates sort last. */
    if (!dv1 || !dv2) {
        if (dv1 == dv2)
            return 0;
        else if (dv1)
            return -1;
        else
            return 1;
    }

    /* Copy the 2nd value and convert it to the same timezone as the
       first. */
    tt = dv2->tt;

    icaltimezone_convert_time (&tt, dv2->zone, dv1->zone);

    /* Now we can compare them. */

    return icaltime_compare (dv1->tt, tt);
}

static void
e_cal_list_view_init (ECalListView *cal_list_view)
{
    cal_list_view->query = NULL;
    cal_list_view->table_scrolled = NULL;
    cal_list_view->cursor_event = NULL;
    cal_list_view->set_table_id = 0;
}

/* Returns the current time, for the ECellDateEdit items. */
static struct tm
get_current_time_cb (ECellDateEdit *ecde, gpointer data)
{
    ECalListView *cal_list_view = data;
    icaltimezone *zone;
    struct tm tmp_tm = { 0 };
    struct icaltimetype tt;

    zone = e_calendar_view_get_timezone (E_CALENDAR_VIEW (cal_list_view));
    tt = icaltime_from_timet_with_zone (time (NULL), FALSE, zone);

    /* Now copy it to the struct tm and return it. */
    tmp_tm.tm_year  = tt.year - 1900;
    tmp_tm.tm_mon   = tt.month - 1;
    tmp_tm.tm_mday  = tt.day;
    tmp_tm.tm_hour  = tt.hour;
    tmp_tm.tm_min   = tt.minute;
    tmp_tm.tm_sec   = tt.second;
    tmp_tm.tm_isdst = -1;

    return tmp_tm;
}

void
e_cal_list_view_load_state (ECalListView *cal_list_view, gchar *filename)
{
    struct stat st;

    g_return_if_fail (cal_list_view != NULL);
    g_return_if_fail (E_IS_CAL_LIST_VIEW (cal_list_view));
    g_return_if_fail (filename != NULL);

    if (g_stat (filename, &st) == 0 && st.st_size > 0 && S_ISREG (st.st_mode))
        e_table_load_state (e_table_scrolled_get_table (cal_list_view->table_scrolled), filename);
}

void
e_cal_list_view_save_state (ECalListView *cal_list_view, gchar *filename)
{
    g_return_if_fail (cal_list_view != NULL);
    g_return_if_fail (E_IS_CAL_LIST_VIEW (cal_list_view));
    g_return_if_fail (filename != NULL);

    e_table_save_state (e_table_scrolled_get_table (cal_list_view->table_scrolled), filename);
}

static void
setup_e_table (ECalListView *cal_list_view)
{
    ECalModel *model;
    ETableExtras *extras;
    GList *strings;
    ECell *cell, *popup_cell;
    GnomeCanvas *canvas;
    GtkStyle *style;
    gchar *etspecfile;

    model = e_calendar_view_get_model (E_CALENDAR_VIEW (cal_list_view));

    /* Create the header columns */

    extras = e_table_extras_new();

    /* Normal string fields */

    cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
    g_object_set (G_OBJECT (cell),
              "bg_color_column", E_CAL_MODEL_FIELD_COLOR,
              NULL);

    e_table_extras_add_cell (extras, "calstring", cell);

    /* Date fields */

    cell = e_cell_date_edit_text_new (NULL, GTK_JUSTIFY_LEFT);
    g_object_set (G_OBJECT (cell),
              "bg_color_column", E_CAL_MODEL_FIELD_COLOR,
              NULL);

    e_mutual_binding_new (
        G_OBJECT (model), "timezone",
        G_OBJECT (cell), "timezone");

    e_mutual_binding_new (
        G_OBJECT (model), "use-24-hour-format",
        G_OBJECT (cell), "use-24-hour-format");

    popup_cell = e_cell_date_edit_new ();
    e_cell_popup_set_child (E_CELL_POPUP (popup_cell), cell);
    g_object_unref (cell);

    e_mutual_binding_new (
        G_OBJECT (model), "use-24-hour-format",
        G_OBJECT (popup_cell), "use-24-hour-format");

    e_table_extras_add_cell (extras, "dateedit", popup_cell);
    cal_list_view->dates_cell = E_CELL_DATE_EDIT (popup_cell);

    gtk_widget_hide (E_CELL_DATE_EDIT (popup_cell)->none_button);

    e_cell_date_edit_set_get_time_callback (E_CELL_DATE_EDIT (popup_cell),
                        get_current_time_cb,
                        cal_list_view, NULL);

    /* Combo fields */

    cell = e_cell_text_new (NULL, GTK_JUSTIFY_LEFT);
    g_object_set (G_OBJECT (cell),
              "bg_color_column", E_CAL_MODEL_FIELD_COLOR,
              "editable", FALSE,
              NULL);

    popup_cell = e_cell_combo_new ();
    e_cell_popup_set_child (E_CELL_POPUP (popup_cell), cell);
    g_object_unref (cell);

    strings = NULL;
    strings = g_list_append (strings, (gchar *) _("Public"));
    strings = g_list_append (strings, (gchar *) _("Private"));
    strings = g_list_append (strings, (gchar *) _("Confidential"));
    e_cell_combo_set_popdown_strings (E_CELL_COMBO (popup_cell),
                      strings);

    e_table_extras_add_cell (extras, "classification", popup_cell);

    /* Sorting */

    e_table_extras_add_compare (extras, "date-compare",
                    date_compare_cb);

    /* Create table view */

    etspecfile = g_build_filename (EVOLUTION_ETSPECDIR,
                       "e-cal-list-view.etspec",
                       NULL);
    cal_list_view->table_scrolled = E_TABLE_SCROLLED (
        e_table_scrolled_new_from_spec_file (E_TABLE_MODEL (model),
                             extras,
                             etspecfile,
                             NULL));
    g_free (etspecfile);

    /* Make sure text is readable on top of our color coding */

    canvas = GNOME_CANVAS (e_table_scrolled_get_table (cal_list_view->table_scrolled)->table_canvas);
    style = gtk_widget_get_style (GTK_WIDGET (canvas));

    style->fg [GTK_STATE_SELECTED] = style->text [GTK_STATE_NORMAL];
    style->fg [GTK_STATE_ACTIVE]   = style->text [GTK_STATE_NORMAL];
    gtk_widget_set_style (GTK_WIDGET (canvas), style);

    /* Connect signals */
    g_signal_connect (e_table_scrolled_get_table (cal_list_view->table_scrolled),
              "double_click", G_CALLBACK (e_cal_list_view_on_table_double_click), cal_list_view);
    g_signal_connect (e_table_scrolled_get_table (cal_list_view->table_scrolled),
              "right-click", G_CALLBACK (e_cal_list_view_on_table_right_click), cal_list_view);
    g_signal_connect_after (e_table_scrolled_get_table (cal_list_view->table_scrolled),
                "cursor_change", G_CALLBACK (e_cal_list_view_cursor_change_cb), cal_list_view);

    /* Attach and show widget */

    gtk_table_attach (GTK_TABLE (cal_list_view), GTK_WIDGET (cal_list_view->table_scrolled),
              0, 2, 0, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 1, 1);
    gtk_widget_show (GTK_WIDGET (cal_list_view->table_scrolled));
}

/**
 * e_cal_list_view_new:
 * @Returns: a new #ECalListView.
 *
 * Creates a new #ECalListView.
 **/
ECalendarView *
e_cal_list_view_new (ECalModel *model)
{
    ECalendarView *cal_list_view;

    cal_list_view = g_object_new (
        E_TYPE_CAL_LIST_VIEW, "model", model, NULL);
    setup_e_table (E_CAL_LIST_VIEW (cal_list_view));

    g_object_unref (model);

    return cal_list_view;
}

static void
e_cal_list_view_destroy (GtkObject *object)
{
    ECalListView *cal_list_view;

    cal_list_view = E_CAL_LIST_VIEW (object);

    if (cal_list_view->query) {
        g_signal_handlers_disconnect_matched (cal_list_view->query, G_SIGNAL_MATCH_DATA,
                              0, 0, NULL, NULL, cal_list_view);
        g_object_unref (cal_list_view->query);
        cal_list_view->query = NULL;
    }

    if (cal_list_view->set_table_id) {
        g_source_remove (cal_list_view->set_table_id);
        cal_list_view->set_table_id = 0;
    }

    if (cal_list_view->cursor_event) {
        g_free (cal_list_view->cursor_event);
        cal_list_view->cursor_event = NULL;
    }

    if (cal_list_view->table_scrolled) {
        gtk_widget_destroy (GTK_WIDGET (cal_list_view->table_scrolled));
        cal_list_view->table_scrolled = NULL;
    }

    GTK_OBJECT_CLASS (e_cal_list_view_parent_class)->destroy (object);
}

static void
e_cal_list_view_show_popup_menu (ECalListView *cal_list_view, gint row, GdkEvent *gdk_event)
{
#if 0 /* KILL-BONOBO */
    GtkMenu *menu;

    menu = e_calendar_view_create_popup_menu (E_CALENDAR_VIEW (cal_list_view));
    gtk_menu_popup(menu, NULL, NULL, NULL, NULL, gdk_event?gdk_event->button.button:0, gdk_event?gdk_event->button.time:gtk_get_current_event_time());
#endif
}

static gboolean
e_cal_list_view_popup_menu (GtkWidget *widget)
{
    ECalListView *cal_list_view = E_CAL_LIST_VIEW (widget);

    e_cal_list_view_show_popup_menu (cal_list_view, -1, NULL);
    return TRUE;
}

static gboolean
find_meeting (icalcomponent *icalcomp)
{
    icalproperty *prop = NULL;

    prop = icalcomponent_get_first_property (icalcomp, ICAL_ATTENDEE_PROPERTY);

    return prop ? TRUE: FALSE;
}

static gboolean
e_cal_list_view_on_table_double_click (GtkWidget *table, gint row, gint col, GdkEvent *event,
                      gpointer data)
{
    ECalListView *cal_list_view = E_CAL_LIST_VIEW (data);
    ECalModelComponent *comp_data;

    comp_data = e_cal_model_get_component_at (e_calendar_view_get_model (E_CALENDAR_VIEW (cal_list_view)), row);
    e_calendar_view_edit_appointment (E_CALENDAR_VIEW (cal_list_view), comp_data->client,
                      comp_data->icalcomp, find_meeting (comp_data->icalcomp));

    return TRUE;
}

static gboolean
e_cal_list_view_on_table_right_click (GtkWidget *table, gint row, gint col, GdkEvent *event,
                      gpointer data)
{
    ECalListView *cal_list_view = E_CAL_LIST_VIEW (data);

    e_cal_list_view_show_popup_menu (cal_list_view, row, event);
    return TRUE;
}

static void
e_cal_list_view_cursor_change_cb (ETable *etable, gint row, gpointer data)
{
    ECalListView *cal_list_view = E_CAL_LIST_VIEW (data);

    g_signal_emit_by_name (cal_list_view, "selection_changed");
}

static gboolean
e_cal_list_view_get_selected_time_range (ECalendarView *cal_view, time_t *start_time, time_t *end_time)
{
    GList *selected;
    icaltimezone *zone;

    selected = e_calendar_view_get_selected_events (cal_view);
    if (selected) {
        ECalendarViewEvent *event = (ECalendarViewEvent *) selected->data;
        ECalComponentDateTime dtstart, dtend;
        ECalComponent *comp;

        comp = e_cal_component_new ();
        e_cal_component_set_icalcomponent (comp, icalcomponent_new_clone (event->comp_data->icalcomp));
        if (start_time) {
            e_cal_component_get_dtstart (comp, &dtstart);
            if (dtstart.tzid) {
                zone = icalcomponent_get_timezone (e_cal_component_get_icalcomponent (comp), dtstart.tzid);
            } else {
                zone = NULL;
            }
            *start_time = icaltime_as_timet_with_zone (*dtstart.value, zone);
            e_cal_component_free_datetime (&dtstart);
        }
        if (end_time) {
            e_cal_component_get_dtend (comp, &dtend);
            if (dtend.tzid) {
                zone = icalcomponent_get_timezone (e_cal_component_get_icalcomponent (comp), dtend.tzid);
            } else {
                zone = NULL;
            }
            *end_time = icaltime_as_timet_with_zone (*dtend.value, zone);
            e_cal_component_free_datetime (&dtend);
        }

        g_object_unref (comp);
        g_list_free (selected);

        return TRUE;
    }

    return FALSE;
}

static GList *
e_cal_list_view_get_selected_events (ECalendarView *cal_view)
{
    GList *event_list = NULL;
    gint   cursor_row;

    if (E_CAL_LIST_VIEW (cal_view)->cursor_event) {
        g_free (E_CAL_LIST_VIEW (cal_view)->cursor_event);
        E_CAL_LIST_VIEW (cal_view)->cursor_event = NULL;
    }

    cursor_row = e_table_get_cursor_row (e_table_scrolled_get_table (E_CAL_LIST_VIEW (cal_view)->table_scrolled));

    if (cursor_row >= 0) {
        ECalendarViewEvent *event;

        event = E_CAL_LIST_VIEW (cal_view)->cursor_event = g_new0 (ECalendarViewEvent, 1);
        event->comp_data =
            e_cal_model_get_component_at (e_calendar_view_get_model (cal_view),
                              cursor_row);
        event_list = g_list_prepend (event_list, event);
    }

    return event_list;
}

static void
adjust_range (icaltimetype icaltime, time_t *earliest, time_t *latest, gboolean *set)
{
    time_t t;

    if (!icaltime_is_valid_time (icaltime))
        return;

    t = icaltime_as_timet (icaltime);
    *earliest = MIN (*earliest, t);
    *latest   = MAX (*latest, t);

    *set = TRUE;
}

/* NOTE: Time use for this function increases linearly with number of events. This is not
 * ideal, since it's used in a couple of places. We could probably be smarter about it,
 * and use do it less frequently... */
static gboolean
e_cal_list_view_get_visible_time_range (ECalendarView *cal_view, time_t *start_time, time_t *end_time)
{
    time_t   earliest = G_MAXINT, latest = 0;
    gboolean set = FALSE;
    gint     n_rows, i;

    n_rows = e_table_model_row_count (E_TABLE_MODEL (e_calendar_view_get_model (cal_view)));

    for (i = 0; i < n_rows; i++) {
        ECalModelComponent *comp;
        icalcomponent      *icalcomp;

        comp = e_cal_model_get_component_at (e_calendar_view_get_model (cal_view), i);
        if (!comp)
            continue;

        icalcomp = comp->icalcomp;
        if (!icalcomp)
            continue;

        adjust_range (icalcomponent_get_dtstart (icalcomp), &earliest, &latest, &set);
        adjust_range (icalcomponent_get_dtend (icalcomp), &earliest, &latest, &set);
    }

    if (set) {
        *start_time = earliest;
        *end_time   = latest;
        return TRUE;
    }

    return FALSE;
}

gboolean
e_cal_list_view_get_range_shown (ECalListView *cal_list_view, GDate *start_date, gint *days_shown)
{
    time_t  first, last;
    GDate   end_date;

    if (!e_cal_list_view_get_visible_time_range (E_CALENDAR_VIEW (cal_list_view), &first, &last))
        return FALSE;

    time_to_gdate_with_zone (start_date, first, e_calendar_view_get_timezone (E_CALENDAR_VIEW (cal_list_view)));
    time_to_gdate_with_zone (&end_date, last, e_calendar_view_get_timezone (E_CALENDAR_VIEW (cal_list_view)));

    *days_shown = g_date_days_between (start_date, &end_date);
    return TRUE;
}