Federated_Computer/federated-calendar
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
21ab796fb3820bee69633e2e3cef4544ee1df906
federated-calendar/src/gcal-edit-dialog.c
T
Erick Pérez Castellanos 21ab796fb3 Added source change notification. 
Added support in GcalEditDialog to notify when the source
of an event has changed.
2012-12-01 15:28:53 -05:00

1312 lines
40 KiB
C
Raw Blame History

/* -*- mode: c; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
* gcal-ediat-dialog.c
* Copyright (C) 2012 Erick Pérez Castellanos <erickpc@gnome.org>
*
* gnome-calendar is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* gnome-calendar is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "gcal-edit-dialog.h"
#include "gcal-time-entry.h"
#include "gcal-date-entry.h"
#include "gcal-utils.h"
#include <libecal/libecal.h>
#include <glib/gi18n.h>
typedef struct _SimpleEventStore SimpleEventStore;
struct _SimpleEventStore
{
gchar *summary;
gboolean all_day;
icaltimetype *start_date;
icaltimetype *end_date;
icaltime_span *time_span;
gchar *location;
gchar *description;
};
struct _GcalEditDialogPrivate
{
gchar *source_uid;
gchar *event_uid;
gboolean writable;
GcalManager *manager;
GtkTreeIter *active_iter;
GtkWidget *edit_grid;
GtkWidget *readonly_box;
GtkWidget *delete_button;
GtkWidget *summary_entry;
GtkWidget *calendar_button;
GtkWidget *calendars_menu;
GtkWidget *start_date_entry;
GtkWidget *end_date_entry;
GtkWidget *all_day_check;
GtkWidget *start_time_entry;
GtkWidget *end_time_entry;
GtkWidget *location_entry;
GtkWidget *notes_text;
SimpleEventStore *ev_store;
gboolean setting_event;
};
static void gcal_edit_dialog_constructed (GObject *object);
static void gcal_edit_dialog_finalize (GObject *object);
static void gcal_edit_dialog_calendar_selected (GtkWidget *menu_item,
gpointer user_data);
static void gcal_edit_dialog_set_writable (GcalEditDialog *dialog,
gboolean writable);
static void gcal_edit_dialog_clear_data (GcalEditDialog *dialog);
static void gcal_edit_dialog_action_button_clicked (GtkWidget *widget,
gpointer user_data);
static void gcal_edit_dialog_button_toggled (GtkToggleButton *button,
gpointer user_data);
static void gcal_edit_dialog_all_day_changed (GtkWidget *widget,
gpointer user_data);
static gboolean gcal_edit_dialog_date_changed (GcalEditDialog *dialog,
gboolean start_date);
static void gcal_edit_dialog_date_entry_modified (GtkWidget *entry,
gpointer user_data);
static gboolean gcal_edit_dialog_source_changed (GcalEditDialog *dialog);
G_DEFINE_TYPE(GcalEditDialog, gcal_edit_dialog, GTK_TYPE_DIALOG)
static void
gcal_edit_dialog_class_init (GcalEditDialogClass *klass)
{
GObjectClass *object_class;
object_class = G_OBJECT_CLASS (klass);
object_class->constructed = gcal_edit_dialog_constructed;
object_class->finalize = gcal_edit_dialog_finalize;
g_type_class_add_private ((gpointer)klass, sizeof(GcalEditDialogPrivate));
}
static void
gcal_edit_dialog_init (GcalEditDialog *self)
{
GcalEditDialogPrivate *priv;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
GCAL_TYPE_EDIT_DIALOG,
GcalEditDialogPrivate);
priv = self->priv;
priv->source_uid = NULL;
priv->event_uid = NULL;
priv->writable = TRUE;
priv->setting_event = FALSE;
gtk_style_context_add_class (
gtk_widget_get_style_context (GTK_WIDGET (self)),
"edit-dialog");
}
static void
gcal_edit_dialog_constructed (GObject* object)
{
GcalEditDialogPrivate *priv;
GtkWidget *content_area;
GtkWidget *child;
GtkWidget *frame;
GtkSizeGroup *size_group;
GtkWidget *action_area;
GtkWidget *button;
priv = GCAL_EDIT_DIALOG (object)->priv;
/* chaining up */
G_OBJECT_CLASS (gcal_edit_dialog_parent_class)->constructed (object);
gtk_window_set_title (GTK_WINDOW (object), _("Event Details"));
content_area = gtk_dialog_get_content_area (GTK_DIALOG (object));
gtk_widget_push_composite_child ();
/* edit area, grid */
priv->edit_grid = gtk_grid_new ();
g_object_set (priv->edit_grid,
"row-spacing", 24,
"column-spacing", 12,
"border-width", 18,
NULL);
/* Summary, title */
child = gtk_label_new (_("Title"));
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 0, 0, 1, 1);
priv->summary_entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (priv->summary_entry), TRUE);
gtk_widget_set_hexpand (priv->summary_entry, TRUE);
gtk_grid_attach (GTK_GRID (priv->edit_grid),
priv->summary_entry,
1, 0, 1, 1);
/* Calendar, source */
priv->calendar_button = gtk_menu_button_new ();
child = gtk_image_new_from_icon_name ("x-office-calendar-symbolic",
GTK_ICON_SIZE_MENU);
priv->calendars_menu = gtk_menu_new ();
g_object_ref (priv->calendars_menu);
g_object_set (priv->calendar_button,
"vexpand", TRUE,
"always-show-image", TRUE,
"image", child,
"menu", priv->calendars_menu,
NULL);
gtk_grid_attach (GTK_GRID (priv->edit_grid),
priv->calendar_button,
2, 0, 1, 1);
/* Start date and time */
child = gtk_label_new (_("Starts"));
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 0, 2, 1, 1);
child = gtk_grid_new ();
g_object_set (child,
"orientation", GTK_ORIENTATION_HORIZONTAL,
"column-spacing", 12,
"column-homogeneous", FALSE,
NULL);
priv->start_date_entry = gcal_date_entry_new ();
gtk_container_add (GTK_CONTAINER (child), priv->start_date_entry);
priv->start_time_entry = gcal_time_entry_new ();
gtk_container_add (GTK_CONTAINER (child), priv->start_time_entry);
priv->all_day_check = gtk_check_button_new_with_label (_("All day"));
gtk_button_set_focus_on_click (GTK_BUTTON (priv->all_day_check), FALSE);
gtk_container_add (GTK_CONTAINER (child), priv->all_day_check);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 1, 2, 2, 1);
/* End date and time */
child = gtk_label_new (_("Ends"));
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 0, 3, 1, 1);
child = gtk_grid_new ();
g_object_set (child,
"orientation", GTK_ORIENTATION_HORIZONTAL,
"column-spacing", 12,
NULL);
priv->end_date_entry = gcal_date_entry_new ();
gtk_container_add (GTK_CONTAINER (child), priv->end_date_entry);
priv->end_time_entry = gcal_time_entry_new ();
gtk_container_add (GTK_CONTAINER (child), priv->end_time_entry);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 1, 3, 2, 1);
/* Location, location, location */
child = gtk_label_new (_("Location"));
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 0, 4, 1, 1);
priv->location_entry = gtk_entry_new ();
gtk_widget_set_hexpand (priv->location_entry, TRUE);
gtk_entry_set_icon_from_icon_name (GTK_ENTRY (priv->location_entry),
GTK_ENTRY_ICON_SECONDARY,
"find-location-symbolic");
gtk_grid_attach (GTK_GRID (priv->edit_grid),
priv->location_entry,
1, 4, 2, 1);
/* Notes, description */
child = gtk_label_new (_("Notes"));
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_START);
gtk_widget_set_margin_top (child, 4);
gtk_grid_attach (GTK_GRID (priv->edit_grid), child, 0, 5, 1, 1);
frame = gtk_frame_new (NULL);
child = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), child);
priv->notes_text = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (child), priv->notes_text);
gtk_widget_set_hexpand (child, TRUE);
gtk_widget_set_size_request (
gtk_bin_get_child (GTK_BIN (frame)),
-1, 80);
gtk_grid_attach (GTK_GRID (priv->edit_grid), frame, 1, 5, 2, 1);
gtk_container_add (GTK_CONTAINER (content_area), priv->edit_grid);
gtk_widget_show_all (content_area);
/* action area, buttons */
size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
action_area = gtk_dialog_get_action_area (GTK_DIALOG (object));
gtk_box_set_spacing (GTK_BOX (action_area), 6);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_size_group_add_widget (size_group, button);
g_object_set_data (G_OBJECT (button),
"response",
GINT_TO_POINTER (GTK_RESPONSE_CANCEL));
g_signal_connect (button,
"clicked",
G_CALLBACK (gcal_edit_dialog_action_button_clicked),
object);
gtk_box_pack_end (GTK_BOX (action_area), button, FALSE, TRUE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area),
button,
TRUE);
priv->delete_button = gtk_button_new ();
gtk_size_group_add_widget (size_group, priv->delete_button);
gtk_container_add (
GTK_CONTAINER (priv->delete_button),
gtk_image_new_from_icon_name ("user-trash-symbolic",
GTK_ICON_SIZE_MENU));
g_object_set_data (G_OBJECT (priv->delete_button),
"response",
GINT_TO_POINTER (GCAL_RESPONSE_DELETE_EVENT));
g_signal_connect (priv->delete_button,
"clicked",
G_CALLBACK (gcal_edit_dialog_action_button_clicked),
object);
gtk_box_pack_end (GTK_BOX (action_area), priv->delete_button, TRUE, TRUE, 0);
gtk_button_box_set_child_non_homogeneous (GTK_BUTTON_BOX (action_area),
priv->delete_button,
TRUE);
/* done button */
button = gtk_button_new_with_label (_("Done"));
gtk_size_group_add_widget (size_group, button);
gtk_widget_set_can_default (button, TRUE);
g_object_set_data (G_OBJECT (button),
"response",
GINT_TO_POINTER (GTK_RESPONSE_ACCEPT));
g_signal_connect (button,
"clicked",
G_CALLBACK (gcal_edit_dialog_action_button_clicked),
object);
gtk_style_context_add_class (
gtk_widget_get_style_context (button),
"suggested-action");
gtk_box_pack_end (GTK_BOX (action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default (button);
g_object_unref (size_group);
gtk_widget_show_all (action_area);
gtk_widget_pop_composite_child ();
/* signals handlers */
g_signal_connect (priv->calendar_button,
"toggled",
G_CALLBACK (gcal_edit_dialog_button_toggled),
object);
g_signal_connect (priv->all_day_check,
"toggled",
G_CALLBACK (gcal_edit_dialog_all_day_changed),
object);
g_signal_connect (priv->start_date_entry,
"modified",
G_CALLBACK (gcal_edit_dialog_date_entry_modified),
object);
g_signal_connect (priv->end_date_entry,
"modified",
G_CALLBACK (gcal_edit_dialog_date_entry_modified),
object);
g_signal_connect (priv->start_time_entry,
"modified",
G_CALLBACK (gcal_edit_dialog_date_entry_modified),
object);
g_signal_connect (priv->end_time_entry,
"modified",
G_CALLBACK (gcal_edit_dialog_date_entry_modified),
object);
}
static void
gcal_edit_dialog_finalize (GObject *object)
{
GcalEditDialogPrivate *priv;
priv = GCAL_EDIT_DIALOG (object)->priv;
if (priv->source_uid != NULL)
g_free (priv->source_uid);
if (priv->event_uid != NULL)
g_free (priv->event_uid);
if (priv->ev_store != NULL)
{
g_free (priv->ev_store->start_date);
g_free (priv->ev_store->end_date);
g_free (priv->ev_store->time_span);
g_free (priv->ev_store);
}
if (priv->calendars_menu != NULL)
g_object_unref (priv->calendars_menu);
G_OBJECT_CLASS (gcal_edit_dialog_parent_class)->finalize (object);
}
static void
gcal_edit_dialog_calendar_selected (GtkWidget *menu_item,
gpointer user_data)
{
GcalEditDialogPrivate *priv;
GtkListStore *sources_model;
GtkTreeIter *iter;
GdkColor *color;
GdkPixbuf *pix;
GtkWidget *cal_image;
priv = GCAL_EDIT_DIALOG (user_data)->priv;
iter = g_object_get_data (G_OBJECT (menu_item), "sources-iter");
sources_model = gcal_manager_get_sources_model (priv->manager);
gtk_tree_model_get (GTK_TREE_MODEL (sources_model), iter,
3, &color,
-1);
if (priv->active_iter != NULL)
gtk_tree_iter_free (priv->active_iter);
priv->active_iter = gtk_tree_iter_copy (iter);
pix = gcal_get_pixbuf_from_color (color);
cal_image = gtk_image_new_from_pixbuf (pix);
gtk_button_set_image (GTK_BUTTON (priv->calendar_button), cal_image);
gdk_color_free (color);
g_object_unref (pix);
}
static void
gcal_edit_dialog_set_calendar_selected (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
GtkListStore *sources_model;
gboolean valid;
GtkTreeIter iter;
priv = dialog->priv;
/* Loading calendars */
sources_model = gcal_manager_get_sources_model (priv->manager);
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (sources_model),
&iter);
while (valid)
{
/* Walk through the list, reading each row */
gchar *uid;
GdkColor *color;
GtkWidget *cal_image;
GdkPixbuf *pix;
gtk_tree_model_get (GTK_TREE_MODEL (sources_model), &iter,
0, &uid,
3, &color,
-1);
if (g_strcmp0 (priv->source_uid, uid) == 0)
{
if (priv->active_iter != NULL)
gtk_tree_iter_free (priv->active_iter);
priv->active_iter = gtk_tree_iter_copy (&iter);
pix = gcal_get_pixbuf_from_color (color);
cal_image = gtk_image_new_from_pixbuf (pix);
gtk_button_set_image (GTK_BUTTON (priv->calendar_button), cal_image);
gdk_color_free (color);
g_free (uid);
g_object_unref (pix);
return;
}
gdk_color_free (color);
g_free (uid);
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (sources_model),
&iter);
}
}
static void
gcal_edit_dialog_set_writable (GcalEditDialog *dialog,
gboolean writable)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
priv->writable = writable;
if (priv->readonly_box == NULL && ! writable)
{
GtkWidget *content_area;
GtkWidget *box;
GtkWidget *label;
GtkWidget *lock;
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
priv->readonly_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (priv->readonly_box),
TRUE);
gtk_style_context_add_class (
gtk_widget_get_style_context (priv->readonly_box),
"readonly");
gtk_box_pack_start (GTK_BOX (content_area),
priv->readonly_box,
TRUE, TRUE,
6);
gtk_box_reorder_child (GTK_BOX (content_area), priv->readonly_box, 0);
box = gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (box), 12);
gtk_container_add(GTK_CONTAINER (priv->readonly_box), box);
label = gtk_label_new ("Calendar is read only");
gtk_label_set_markup (GTK_LABEL (label),
"<span weight=\"bold\">Calendar is readonly</span>");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
gtk_container_add (GTK_CONTAINER (box), label);
lock = gtk_image_new_from_icon_name ("changes-prevent-symbolic",
GTK_ICON_SIZE_MENU);
gtk_widget_set_hexpand (lock, TRUE);
gtk_widget_set_vexpand (lock, TRUE);
gtk_widget_set_halign (lock, GTK_ALIGN_END);
gtk_container_add (GTK_CONTAINER (box), lock);
gtk_widget_show_all (priv->readonly_box);
}
else if (priv->readonly_box != NULL && writable)
{
gtk_widget_hide (priv->readonly_box);
}
gtk_editable_set_editable (GTK_EDITABLE (priv->summary_entry), writable);
gtk_editable_set_editable (GTK_EDITABLE (priv->start_date_entry), writable);
gtk_editable_set_editable (GTK_EDITABLE (priv->start_time_entry), writable);
gtk_editable_set_editable (GTK_EDITABLE (priv->end_time_entry), writable);
gtk_editable_set_editable (GTK_EDITABLE (priv->end_time_entry), writable);
gtk_editable_set_editable (GTK_EDITABLE (priv->location_entry), writable);
gtk_text_view_set_editable (GTK_TEXT_VIEW (priv->notes_text), writable);
if (! writable)
{
gtk_menu_button_set_popup (GTK_MENU_BUTTON (priv->calendar_button),
NULL);
}
else if (gtk_menu_button_get_popup (GTK_MENU_BUTTON (priv->calendar_button)) == NULL)
{
gtk_menu_button_set_popup (GTK_MENU_BUTTON (priv->calendar_button),
priv->calendars_menu);
}
/* add delete_button here */
gtk_widget_set_sensitive (priv->delete_button, writable);
}
static void
gcal_edit_dialog_clear_data (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
/* summary */
gtk_entry_set_text (GTK_ENTRY (priv->summary_entry), "");
/* calendar button */
if (priv->active_iter != NULL)
{
gtk_tree_iter_free (priv->active_iter);
priv->active_iter = NULL;
}
gtk_button_set_image (GTK_BUTTON (priv->calendar_button),
gtk_image_new_from_icon_name ("x-office-calendar-symbolic",
GTK_ICON_SIZE_MENU));
/* date and time */
gtk_entry_set_text (GTK_ENTRY (priv->start_date_entry), "");
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->start_time_entry), 0, 0);
gtk_entry_set_text (GTK_ENTRY (priv->end_date_entry), "");
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->end_time_entry), 0, 0);
/* location */
gtk_entry_set_text (GTK_ENTRY (priv->location_entry), "");
/* notes */
gtk_text_buffer_set_text (
gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->notes_text)),
"",
-1);
}
static void
gcal_edit_dialog_action_button_clicked (GtkWidget *widget,
gpointer user_data)
{
gint response;
response = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget),
"response"));
gtk_dialog_response (GTK_DIALOG (user_data), response);
}
static void
gcal_edit_dialog_button_toggled (GtkToggleButton *button,
gpointer user_data)
{
GcalEditDialogPrivate *priv;
gboolean active;
priv = GCAL_EDIT_DIALOG (user_data)->priv;
if (priv->writable)
return;
active = gtk_toggle_button_get_active (button);
g_debug ("active: %s", active ? "TRUE" : "FALSE");
g_signal_handlers_block_by_func (button,
gcal_edit_dialog_button_toggled,
user_data);
gtk_toggle_button_set_active (button, ! active);
g_signal_handlers_unblock_by_func (button,
gcal_edit_dialog_button_toggled,
user_data);
g_signal_stop_emission_by_name (button, "toggled");
}
static void
gcal_edit_dialog_all_day_changed (GtkWidget *widget,
gpointer user_data)
{
GcalEditDialogPrivate *priv;
priv = GCAL_EDIT_DIALOG (user_data)->priv;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->all_day_check)))
{
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->start_time_entry), 0, 0);
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->end_time_entry), 0, 0);
}
}
static gboolean
gcal_edit_dialog_date_changed (GcalEditDialog *dialog,
gboolean start_date)
{
GcalEditDialogPrivate *priv;
gint day;
gint month;
gint year;
gint hour;
gint minute;
GtkWidget *widget;
icaltimetype *old_date;
priv = dialog->priv;
if (start_date)
{
widget = priv->start_date_entry;
old_date = priv->ev_store->start_date;
}
else
{
widget = priv->end_date_entry;
old_date = priv->ev_store->end_date;
}
gcal_date_entry_get_date (GCAL_DATE_ENTRY (widget),
&day,
&month,
&year);
if (day != old_date->day ||
month != old_date->month ||
year != old_date->year)
{
return TRUE;
}
widget = start_date ? priv->start_time_entry : priv->end_time_entry;
gcal_time_entry_get_time (GCAL_TIME_ENTRY (widget),
&hour,
&minute);
if (hour != old_date->hour ||
minute != old_date->minute)
{
return TRUE;
}
return FALSE;
}
static void
gcal_edit_dialog_date_entry_modified (GtkWidget *entry,
gpointer user_data)
{
GcalEditDialogPrivate *priv;
icaltimetype start_date;
icaltimetype end_date;
priv = GCAL_EDIT_DIALOG (user_data)->priv;
if (priv->setting_event)
return;
gcal_date_entry_get_date (GCAL_DATE_ENTRY (priv->start_date_entry),
&(start_date.day),
&(start_date.month),
&(start_date.year));
gcal_date_entry_get_date (GCAL_DATE_ENTRY (priv->end_date_entry),
&(end_date.day),
&(end_date.month),
&(end_date.year));
start_date.is_date = 0;
end_date.is_date = 0;
gcal_time_entry_get_time (GCAL_TIME_ENTRY (priv->start_time_entry),
&(start_date.hour),
&(start_date.minute));
start_date.second = 0;
gcal_time_entry_get_time (GCAL_TIME_ENTRY (priv->end_time_entry),
&(end_date.hour),
&(end_date.minute));
end_date.second = 0;
if (start_date.hour == 0 &&
start_date.minute == 0 &&
end_date.hour == 0 &&
end_date.minute == 0)
{
start_date.is_date = 1;
end_date.is_date = 1;
/* block signaling */
g_signal_handlers_block_by_func (priv->all_day_check,
gcal_edit_dialog_all_day_changed,
user_data);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_day_check), TRUE);
g_signal_handlers_unblock_by_func (priv->all_day_check,
gcal_edit_dialog_all_day_changed,
user_data);
/* unblock signaling */
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_day_check), FALSE);
}
icaltime_set_timezone (&start_date,
gcal_manager_get_system_timezone (priv->manager));
icaltime_set_timezone (&end_date,
gcal_manager_get_system_timezone (priv->manager));
if (icaltime_compare (start_date, end_date) != -1)
{
g_signal_handlers_block_by_func (priv->start_date_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
g_signal_handlers_block_by_func (priv->start_time_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
g_signal_handlers_block_by_func (priv->end_date_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
g_signal_handlers_block_by_func (priv->end_time_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
if (entry == priv->start_date_entry ||
entry == priv->start_time_entry)
{
time_t to_end;
time_t from_start = icaltime_as_timet (start_date);
to_end = from_start + (priv->ev_store->time_span->end - priv->ev_store->time_span->start);
end_date = icaltime_from_timet (to_end, start_date.is_date);
gcal_date_entry_set_date (GCAL_DATE_ENTRY (priv->end_date_entry),
end_date.day,
end_date.month,
end_date.year);
if (start_date.is_date != 1)
{
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->end_time_entry),
end_date.hour,
end_date.minute);
}
}
else
{
time_t from_start;
time_t to_end = icaltime_as_timet (end_date);
from_start = to_end - (priv->ev_store->time_span->end - priv->ev_store->time_span->start);
start_date = icaltime_from_timet (from_start, end_date.is_date);
gcal_date_entry_set_date (GCAL_DATE_ENTRY (priv->start_date_entry),
start_date.day,
start_date.month,
start_date.year);
if (end_date.is_date != 1)
{
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->start_time_entry),
start_date.hour,
start_date.minute);
}
}
g_signal_handlers_unblock_by_func (priv->start_date_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
g_signal_handlers_unblock_by_func (priv->start_time_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
g_signal_handlers_unblock_by_func (priv->end_date_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
g_signal_handlers_unblock_by_func (priv->end_time_entry,
gcal_edit_dialog_date_entry_modified,
user_data);
}
}
static gboolean
gcal_edit_dialog_source_changed (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
GtkListStore *sources_model;
gchar* uid;
priv = dialog->priv;
sources_model = gcal_manager_get_sources_model (priv->manager);
gtk_tree_model_get (GTK_TREE_MODEL (sources_model), priv->active_iter,
0, &uid,
-1);
if (g_strcmp0 (priv->source_uid, uid) != 0)
{
g_free (uid);
return TRUE;
}
g_free (uid);
return FALSE;
}
/* Public API */
GtkWidget*
gcal_edit_dialog_new (void)
{
GtkWidget *dialog;
dialog = g_object_new (GCAL_TYPE_EDIT_DIALOG, NULL);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
return dialog;
}
void
gcal_edit_dialog_set_event (GcalEditDialog *dialog,
const gchar *source_uid,
const gchar *event_uid)
{
GcalEditDialogPrivate *priv;
const gchar *const_text;
gboolean all_day;
priv = dialog->priv;
all_day = FALSE;
priv->setting_event = TRUE;
if (priv->source_uid != NULL)
g_free (priv->source_uid);
priv->source_uid = g_strdup (source_uid);
if (priv->event_uid != NULL)
g_free (priv->event_uid);
priv->event_uid = g_strdup (event_uid);
/* Clear event data */
gcal_edit_dialog_clear_data (dialog);
if (priv->ev_store == NULL)
{
priv->ev_store = g_new0 (SimpleEventStore, 1);
priv->ev_store->time_span = g_new0 (icaltime_span, 1);
}
else
{
g_free (priv->ev_store->start_date);
g_free (priv->ev_store->end_date);
}
/* Load new event data */
/* summary */
priv->ev_store->summary = gcal_manager_get_event_summary (priv->manager,
priv->source_uid,
priv->event_uid);
gtk_entry_set_text (GTK_ENTRY (priv->summary_entry),
priv->ev_store->summary != NULL ?
priv->ev_store->summary : "");
/* calendar button */
/* FIXME: Add calendar to ev_store and edit-capabilities */
gcal_edit_dialog_set_calendar_selected (dialog);
/* start date */
priv->ev_store->start_date =
gcal_manager_get_event_start_date (priv->manager,
priv->source_uid,
priv->event_uid);
gcal_date_entry_set_date (GCAL_DATE_ENTRY (priv->start_date_entry),
priv->ev_store->start_date->day,
priv->ev_store->start_date->month,
priv->ev_store->start_date->year);
/* all_day */
priv->ev_store->all_day = gcal_manager_get_event_all_day (priv->manager,
priv->source_uid,
priv->event_uid);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_day_check),
priv->ev_store->all_day);
/* start time */
if (all_day)
{
priv->ev_store->start_date->hour = 0;
priv->ev_store->start_date->minute = 0;
}
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->start_time_entry),
priv->ev_store->start_date->hour,
priv->ev_store->start_date->minute);
/* end date */
priv->ev_store->end_date = gcal_manager_get_event_end_date (priv->manager,
priv->source_uid,
priv->event_uid);
gcal_date_entry_set_date (GCAL_DATE_ENTRY (priv->end_date_entry),
priv->ev_store->end_date->day,
priv->ev_store->end_date->month,
priv->ev_store->end_date->year);
/* end time */
if (all_day)
{
priv->ev_store->end_date->hour = 0;
priv->ev_store->end_date->minute = 0;
}
gcal_time_entry_set_time (GCAL_TIME_ENTRY (priv->end_time_entry),
priv->ev_store->end_date->hour,
priv->ev_store->end_date->minute);
/* getting span before going on */
*(priv->ev_store->time_span) = icaltime_span_new (*(priv->ev_store->start_date),
*(priv->ev_store->end_date),
0);
/* location */
const_text = gcal_manager_get_event_location (priv->manager,
priv->source_uid,
priv->event_uid);
gtk_entry_set_text (GTK_ENTRY (priv->location_entry),
const_text != NULL ? const_text : "");
priv->ev_store->location = g_strdup (const_text);
/* notes */
priv->ev_store->description =
gcal_manager_get_event_description (priv->manager,
priv->source_uid,
priv->event_uid);
if (priv->ev_store->description == NULL)
priv->ev_store->description = "";
gtk_text_buffer_set_text (
gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->notes_text)),
priv->ev_store->description,
-1);
gcal_edit_dialog_set_writable (
dialog,
! gcal_manager_get_source_readonly (priv->manager,
priv->source_uid));
priv->setting_event = FALSE;
}
void
gcal_edit_dialog_set_manager (GcalEditDialog *dialog,
GcalManager *manager)
{
GcalEditDialogPrivate *priv;
GtkMenu *menu;
GtkWidget *item;
GList *children;
GtkListStore *sources_model;
gboolean valid;
GtkTreeIter iter;
g_return_if_fail (GCAL_IS_MANAGER (manager));
priv = dialog->priv;
priv->manager = manager;
/* Loading calendars */
sources_model = gcal_manager_get_sources_model (priv->manager);
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (sources_model),
&iter);
if (! valid)
return;
menu = gtk_menu_button_get_popup (GTK_MENU_BUTTON (priv->calendar_button));
children = gtk_container_get_children (GTK_CONTAINER (menu));
g_list_foreach (children, (GFunc) gtk_widget_destroy, NULL);
while (valid)
{
gchar *uid;
gchar *name;
gboolean active;
GdkColor *color;
GtkWidget *cal_image;
GdkPixbuf *pix;
gtk_tree_model_get (GTK_TREE_MODEL (sources_model), &iter,
0, &uid,
1, &name,
2, &active,
3, &color,
-1);
if (! active ||
gcal_manager_get_source_readonly (priv->manager, uid))
{
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (sources_model),
&iter);
gdk_color_free (color);
g_free (name);
g_free (uid);
continue;
}
item = gtk_image_menu_item_new ();
g_object_set_data_full (G_OBJECT (item),
"sources-iter",
gtk_tree_iter_copy (&iter),
(GDestroyNotify) gtk_tree_iter_free);
g_signal_connect (item,
"activate",
G_CALLBACK (gcal_edit_dialog_calendar_selected),
dialog);
pix = gcal_get_pixbuf_from_color (color);
cal_image = gtk_image_new_from_pixbuf (pix);
g_object_set (item,
"always-show-image", TRUE,
"image", cal_image,
"label", name,
NULL);
gtk_container_add (GTK_CONTAINER (menu), item);
g_object_unref (pix);
gdk_color_free (color);
g_free (name);
g_free (uid);
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (sources_model),
&iter);
}
gtk_widget_show_all (GTK_WIDGET (menu));
}
const gchar*
gcal_edit_dialog_peek_source_uid (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
return priv->source_uid;
}
const gchar*
gcal_edit_dialog_peek_event_uid (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
return priv->event_uid;
}
gchar*
gcal_edit_dialog_get_event_uuid (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
if (priv->source_uid == NULL ||
priv->event_uid == NULL)
{
return NULL;
}
return g_strdup_printf ("%s:%s", priv->source_uid, priv->event_uid);
}
GList*
gcal_edit_dialog_get_modified_properties (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
gchar *desc;
GList *res;
priv = dialog->priv;
if (! priv->writable)
return NULL;
res = NULL;
if (g_strcmp0 (priv->ev_store->summary,
gtk_entry_get_text (GTK_ENTRY (priv->summary_entry))) != 0)
{
res = g_list_append (res, GINT_TO_POINTER (EVENT_SUMMARY));
}
if (gcal_edit_dialog_date_changed (dialog, TRUE))
{
res = g_list_append (res, GINT_TO_POINTER (EVENT_START_DATE));
}
if (gcal_edit_dialog_date_changed (dialog, FALSE))
{
res = g_list_append (res, GINT_TO_POINTER (EVENT_END_DATE));
}
if (g_strcmp0 (priv->ev_store->location,
gtk_entry_get_text (GTK_ENTRY (priv->location_entry))) != 0)
{
res = g_list_append (res, GINT_TO_POINTER (EVENT_LOCATION));
}
/* getting desc */
desc = gcal_edit_dialog_get_event_description (dialog);
if (g_strcmp0 (priv->ev_store->description, desc) != 0)
{
res = g_list_append (res, GINT_TO_POINTER (EVENT_DESCRIPTION));
}
g_free (desc);
/* and the bigger one is the calendar, the source switched */
if (gcal_edit_dialog_source_changed (dialog))
{
res = g_list_append (res, GINT_TO_POINTER (EVENT_SOURCE));
}
return res;
}
const gchar*
gcal_edit_dialog_peek_summary (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
return gtk_entry_get_text (GTK_ENTRY (priv->summary_entry));
}
const gchar*
gcal_edit_dialog_peek_location (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
priv = dialog->priv;
return gtk_entry_get_text (GTK_ENTRY (priv->location_entry));
}
gchar*
gcal_edit_dialog_get_event_description (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
GtkTextBuffer *buffer;
GtkTextIter start_iter;
GtkTextIter end_iter;
gchar *desc;
priv = dialog->priv;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->notes_text));
gtk_text_buffer_get_start_iter (buffer, &start_iter);
gtk_text_buffer_get_end_iter (buffer, &end_iter);
desc = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE);
return desc;
}
icaltimetype*
gcal_edit_dialog_get_start_date (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
icaltimetype *date;
gint value1;
gint value2;
gint value3;
priv = dialog->priv;
date = g_new0 (icaltimetype, 1);
icaltime_set_timezone (date,
gcal_manager_get_system_timezone (priv->manager));
gcal_date_entry_get_date (GCAL_DATE_ENTRY (priv->start_date_entry),
&value1,
&value2,
&value3);
date->day = value1;
date->month = value2;
date->year = value3;
value1 = value2 = 0;
gcal_time_entry_get_time (GCAL_TIME_ENTRY (priv->start_time_entry),
&value1,
&value2);
date->hour = value1;
date->minute = value2;
if (date->hour == 0 &&
date->minute == 0)
{
date->is_date = 1;
}
return date;
}
icaltimetype*
gcal_edit_dialog_get_end_date (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
icaltimetype *date;
gint value1;
gint value2;
gint value3;
priv = dialog->priv;
date = g_new0 (icaltimetype, 1);
icaltime_set_timezone (date,
gcal_manager_get_system_timezone (priv->manager));
gcal_date_entry_get_date (GCAL_DATE_ENTRY (priv->end_date_entry),
&value1,
&value2,
&value3);
date->day = value1;
date->month = value2;
date->year = value3;
value1 = value2 = 0;
gcal_time_entry_get_time (GCAL_TIME_ENTRY (priv->end_time_entry),
&value1,
&value2);
date->hour = value1;
date->minute = value2;
if (date->hour == 0 &&
date->minute == 0)
{
date->is_date = 1;
}
return date;
}
gchar*
gcal_edit_dialog_get_new_source_uid (GcalEditDialog *dialog)
{
GcalEditDialogPrivate *priv;
GtkListStore *sources_model;
gchar* uid;
priv = dialog->priv;
sources_model = gcal_manager_get_sources_model (priv->manager);
gtk_tree_model_get (GTK_TREE_MODEL (sources_model), priv->active_iter,
0, &uid,
-1);
return uid;
}
Reference in New Issue View Git Blame Copy Permalink