diff --git a/src/Makefile.am b/src/Makefile.am index b9a7886c..d4cc577c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -41,22 +41,10 @@ gnome_calendar_SOURCES = \ gcal-week-view.h \ gcal-event-widget.c \ gcal-event-widget.h \ - gcal-event-view.c \ - gcal-event-view.h \ gcal-event-overlay.c \ gcal-event-overlay.h \ - gcal-editable.c \ - gcal-editable.h \ - gcal-editable-entry.c \ - gcal-editable-entry.h \ - gcal-editable-text.c \ - gcal-editable-text.h \ - gcal-editable-date.c \ - gcal-editable-date.h \ - gcal-editable-combo.c \ - gcal-editable-combo.h \ - gcal-editable-reminder.c \ - gcal-editable-reminder.h \ + gcal-edit-dialog.c \ + gcal-edit-dialog.h \ gcal-manager.c \ gcal-manager.h \ gcal-utils.c \ diff --git a/src/gcal-edit-dialog.c b/src/gcal-edit-dialog.c new file mode 100644 index 00000000..6fdfd7f0 --- /dev/null +++ b/src/gcal-edit-dialog.c @@ -0,0 +1,530 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ +/* + * gcal-ediat-dialog.c + * Copyright (C) 2012 Erick Pérez Castellanos + * + * 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 . + */ + +#include "gcal-edit-dialog.h" +#include "gcal-utils.h" + +#include + +struct _GcalEditDialogPrivate +{ + gchar *source_uid; + gchar *event_uid; + + GcalManager *manager; + GtkTreeIter *active_iter; + + GtkWidget *summary_entry; + GtkWidget *calendar_button; + 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; +}; + +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); + +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; +} + +static void +gcal_edit_dialog_constructed (GObject* object) +{ + GcalEditDialogPrivate *priv; + GtkWidget *content_area; + GtkWidget *grid; + GtkWidget *child; + 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), _("Edit Event")); + gtk_window_set_modal (GTK_WINDOW (object), TRUE); + gtk_window_set_destroy_with_parent (GTK_WINDOW (object), TRUE); + gtk_window_set_resizable (GTK_WINDOW (object), FALSE); + + gtk_container_set_border_width (GTK_CONTAINER (object), 6); + + content_area = gtk_dialog_get_content_area (GTK_DIALOG (object)); + + /* edit area, grid */ + grid = gtk_grid_new (); + g_object_set (grid, + "row-spacing", 12, + "column-spacing", 12, + "border-width", 6, + NULL); + + /* Summary, title */ + child = gtk_label_new (_("Title")); + gtk_widget_set_halign (child, GTK_ALIGN_END); + gtk_grid_attach (GTK_GRID (grid), child, 0, 0, 1, 1); + + priv->summary_entry = gtk_entry_new (); + gtk_widget_set_hexpand (priv->summary_entry, TRUE); + gtk_grid_attach (GTK_GRID (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); + g_object_set (priv->calendar_button, + "vexpand", TRUE, + "always-show-image", TRUE, + "image", child, + "menu", gtk_menu_new (), + NULL); + gtk_grid_attach (GTK_GRID (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 (grid), child, 0, 2, 1, 1); + + child = gtk_grid_new (); + g_object_set (child, + "orientation", GTK_ORIENTATION_HORIZONTAL, + "column-spacing", 12, + NULL); + priv->start_date_entry = gtk_entry_new (); + gtk_entry_set_icon_from_icon_name (GTK_ENTRY (priv->start_date_entry), + GTK_ENTRY_ICON_SECONDARY, + "x-office-calendar-symbolic"); + gtk_container_add (GTK_CONTAINER (child), priv->start_date_entry); + + priv->start_time_entry = gtk_entry_new (); + gtk_entry_set_icon_from_icon_name (GTK_ENTRY (priv->start_time_entry), + GTK_ENTRY_ICON_SECONDARY, + "preferences-system-time-symbolic"); + gtk_container_add (GTK_CONTAINER (child), priv->start_time_entry); + + priv->all_day_check = gtk_check_button_new_with_label (_("All day")); + gtk_container_add (GTK_CONTAINER (child), priv->all_day_check); + gtk_grid_attach (GTK_GRID (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 (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 = gtk_entry_new (); + gtk_entry_set_icon_from_icon_name (GTK_ENTRY (priv->end_date_entry), + GTK_ENTRY_ICON_SECONDARY, + "x-office-calendar-symbolic"); + gtk_container_add (GTK_CONTAINER (child), priv->end_date_entry); + + priv->end_time_entry = gtk_entry_new (); + gtk_entry_set_icon_from_icon_name (GTK_ENTRY (priv->end_time_entry), + GTK_ENTRY_ICON_SECONDARY, + "preferences-system-time-symbolic"); + gtk_container_add (GTK_CONTAINER (child), priv->end_time_entry); + gtk_grid_attach (GTK_GRID (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 (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 (grid), priv->location_entry, 1, 4, 2, 1); + + /* Notes, description */ + child = gtk_label_new (_("Notes")); + gtk_widget_set_halign (child, GTK_ALIGN_END); + gtk_grid_attach (GTK_GRID (grid), child, 0, 5, 1, 1); + + child = gtk_frame_new (NULL); + 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 (child)), + -1, 80); + gtk_grid_attach (GTK_GRID (grid), child, 1, 5, 2, 1); + + gtk_container_add (GTK_CONTAINER (content_area), grid); + gtk_widget_show_all (content_area); + + /* action area, buttons */ + 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_widget_set_can_default (button, TRUE); + 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); + + button = gtk_button_new (); + gtk_container_add ( + GTK_CONTAINER (button), + gtk_image_new_from_icon_name ("user-trash-symbolic", + GTK_ICON_SIZE_MENU)); + gtk_widget_set_can_default (button, TRUE); + g_object_set_data (G_OBJECT (button), + "response", + GINT_TO_POINTER (GCAL_RESPONSE_DELETE_EVENT)); + g_signal_connect (button, + "clicked", + G_CALLBACK (gcal_edit_dialog_action_button_clicked), + object); + gtk_box_pack_end (GTK_BOX (action_area), button, TRUE, TRUE, 0); + gtk_button_box_set_child_non_homogeneous (GTK_BUTTON_BOX (action_area), + button, + TRUE); + + /* done button */ + button = gtk_button_new_with_label (_("Done")); + 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_show_all (action_area); + + /* signals handlers */ +} + +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); + + 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_writable (GcalEditDialog *dialog, + gboolean writable) +{ + GcalEditDialogPrivate *priv; + + priv = dialog->priv; + + gtk_widget_set_sensitive (priv->summary_entry, writable); + gtk_widget_set_sensitive (priv->calendar_button, writable); + gtk_widget_set_sensitive (priv->start_date_entry, writable); + gtk_widget_set_sensitive (priv->start_time_entry, writable); + gtk_widget_set_sensitive (priv->all_day_check, writable); + gtk_widget_set_sensitive (priv->end_date_entry, writable); + gtk_widget_set_sensitive (priv->end_time_entry, writable); + gtk_widget_set_sensitive (priv->location_entry, writable); + gtk_widget_set_sensitive (priv->notes_text, writable); +} + +static void +gcal_edit_dialog_clear_data (GcalEditDialog *dialog) +{ + GcalEditDialogPrivate *priv; + + priv = dialog->priv; + + /* FIXME: add clear for the rest of the fields when I define loading code for + * those below */ + gtk_entry_set_text (GTK_ENTRY (priv->summary_entry), ""); + gtk_entry_set_text (GTK_ENTRY (priv->location_entry), ""); + + 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); +} + +/* Public API */ +GtkWidget* +gcal_edit_dialog_new (void) +{ + return g_object_new (GCAL_TYPE_EDIT_DIALOG, NULL); +} + +void +gcal_edit_dialog_set_event (GcalEditDialog *dialog, + const gchar *source_uid, + const gchar *event_uid) +{ + GcalEditDialogPrivate *priv; + + gchar *text; + const gchar *const_text; + gboolean all_day; + + priv = dialog->priv; + all_day = FALSE; + + 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); + + /* Load event data */ + gcal_edit_dialog_clear_data (dialog); + + /* summary */ + text = gcal_manager_get_event_summary (priv->manager, + priv->source_uid, + priv->event_uid); + gtk_entry_set_text (GTK_ENTRY (priv->summary_entry), + text != NULL ? text : ""); + g_free (text); + + /* start date */ + + /* all_day */ + 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), + all_day); + + /* start time */ + if (all_day) + { + /* FIXME: set time to 00:00 */ + } + + /* end date */ + + /* end time */ + if (all_day) + { + /* FIXME: set time to 00:00 */ + } + + /* 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 : ""); + + /* notes */ + text = gcal_manager_get_event_description (priv->manager, + priv->source_uid, + priv->event_uid); + gtk_text_buffer_set_text ( + gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->notes_text)), + text != NULL ? text : "", + -1); + g_free (text); + + /* FIXME: this is for now, I will have to ask GcalManager */ + gcal_edit_dialog_set_writable (dialog, 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) + { + /* Walk through the list, reading each row */ + gchar *name; + GdkColor *color; + GtkWidget *cal_image; + GdkPixbuf *pix; + + gtk_tree_model_get (GTK_TREE_MODEL (sources_model), &iter, + 1, &name, + 3, &color, + -1); + + 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); + g_free (name); + gdk_color_free (color); + + valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (sources_model), + &iter); + } + + gtk_widget_show_all (GTK_WIDGET (menu)); +} diff --git a/src/gcal-edit-dialog.h b/src/gcal-edit-dialog.h new file mode 100644 index 00000000..63dd28dd --- /dev/null +++ b/src/gcal-edit-dialog.h @@ -0,0 +1,69 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ +/* + * gcal-edit-dialog.h + * Copyright (C) 2012 Erick Pérez Castellanos + * + * 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 . + */ + +#ifndef __GCAL_EDIT_DIALOG_H__ +#define __GCAL_EDIT_DIALOG_H__ + +#include "gcal-manager.h" + +#include + +G_BEGIN_DECLS + +#define GCAL_RESPONSE_DELETE_EVENT 2 + + +#define GCAL_TYPE_EDIT_DIALOG (gcal_edit_dialog_get_type ()) +#define GCAL_EDIT_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDIT_DIALOG, GcalEditDialog)) +#define GCAL_EDIT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDIT_DIALOG, GcalEditDialogClass)) +#define GCAL_IS_EDIT_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDIT_DIALOG)) +#define GCAL_IS_EDIT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDIT_DIALOG)) +#define GCAL_EDIT_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDIT_DIALOG, GcalEditDialogClass)) + +typedef struct _GcalEditDialog GcalEditDialog; +typedef struct _GcalEditDialogClass GcalEditDialogClass; +typedef struct _GcalEditDialogPrivate GcalEditDialogPrivate; + +struct _GcalEditDialog +{ + GtkDialog parent; + + GcalEditDialogPrivate *priv; +}; + +struct _GcalEditDialogClass +{ + GtkDialogClass parent_class; +}; + + +GType gcal_edit_dialog_get_type (void); + +GtkWidget* gcal_edit_dialog_new (void); + +void gcal_edit_dialog_set_event (GcalEditDialog *dialog, + const gchar *source_uid, + const gchar *event_uid); + +void gcal_edit_dialog_set_manager (GcalEditDialog *dialog, + GcalManager *manager); + +G_END_DECLS + +#endif /* __GCAL_EDIT_DIALOG_H__ */ diff --git a/src/gcal-editable-combo.c b/src/gcal-editable-combo.c deleted file mode 100644 index bf063159..00000000 --- a/src/gcal-editable-combo.c +++ /dev/null @@ -1,242 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-editable-combo.c - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#include "gcal-editable-combo.h" - -struct _GcalEditableComboPrivate -{ - GtkWidget *view_widget; - GtkWidget *edit_widget; -}; - -static void gcal_editable_combo_constructed (GObject *object); - -static void gcal_editable_combo_size_allocate (GtkWidget *widget, - GtkAllocation *allocation); - -static void gcal_editable_combo_enter_edit_mode (GcalEditable *editable); - -static void gcal_editable_combo_leave_edit_mode (GcalEditable *editable); - -static void gcal_editable_combo_clear (GcalEditable *editable); - -G_DEFINE_TYPE (GcalEditableCombo, gcal_editable_combo, GCAL_TYPE_EDITABLE); - -static void gcal_editable_combo_class_init (GcalEditableComboClass *klass) -{ - GcalEditableClass *editable_class; - GtkWidgetClass *widget_class; - GObjectClass *object_class; - - editable_class = GCAL_EDITABLE_CLASS (klass); - editable_class->enter_edit_mode = gcal_editable_combo_enter_edit_mode; - editable_class->leave_edit_mode = gcal_editable_combo_leave_edit_mode; - editable_class->clear = gcal_editable_combo_clear; - - widget_class = GTK_WIDGET_CLASS (klass); - widget_class->size_allocate = gcal_editable_combo_size_allocate; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_editable_combo_constructed; - - g_type_class_add_private ((gpointer)klass, sizeof (GcalEditableComboPrivate)); -} - - - -static void gcal_editable_combo_init (GcalEditableCombo *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - GCAL_TYPE_EDITABLE_COMBO, - GcalEditableComboPrivate); -} - -static void -gcal_editable_combo_constructed (GObject *object) -{ - GcalEditableComboPrivate *priv; - - priv = GCAL_EDITABLE_COMBO (object)->priv; - - if (G_OBJECT_CLASS (gcal_editable_combo_parent_class)->constructed != NULL) - G_OBJECT_CLASS (gcal_editable_combo_parent_class)->constructed (object); - - priv->view_widget = gtk_label_new (NULL); - gtk_label_set_ellipsize (GTK_LABEL (priv->view_widget), - PANGO_ELLIPSIZE_END); - gtk_widget_show (priv->view_widget); - gtk_widget_set_valign (priv->view_widget, GTK_ALIGN_CENTER); - gtk_widget_set_halign (priv->view_widget, GTK_ALIGN_START); - gcal_editable_set_view_widget (GCAL_EDITABLE (object), priv->view_widget); - - priv->edit_widget = gtk_combo_box_new (); - gtk_widget_show (priv->edit_widget); - gcal_editable_set_edit_widget (GCAL_EDITABLE (object), priv->edit_widget); -} - -static void -gcal_editable_combo_size_allocate (GtkWidget *widget, - GtkAllocation *allocation) -{ - GcalEditableComboPrivate *priv; - GtkAllocation view_allocation; - gint minimum; - gint natural; - - g_return_if_fail (GCAL_IS_EDITABLE_COMBO (widget)); - priv = GCAL_EDITABLE_COMBO (widget)->priv; - - if (GTK_WIDGET_CLASS (gcal_editable_combo_parent_class)->size_allocate != NULL) - GTK_WIDGET_CLASS (gcal_editable_combo_parent_class)->size_allocate (widget, allocation); - - //FIXME: hack to keep the label thin - gtk_widget_get_preferred_height (priv->view_widget, &minimum, &natural); - gtk_widget_get_allocation (priv->view_widget, &view_allocation); - view_allocation.height = minimum; - gtk_widget_size_allocate (priv->view_widget, &view_allocation); -} - -static void -gcal_editable_combo_enter_edit_mode (GcalEditable *editable) -{ - GcalEditableComboPrivate *priv; - gchar *uid; - - g_return_if_fail (GCAL_IS_EDITABLE_COMBO (editable)); - priv = GCAL_EDITABLE_COMBO (editable)->priv; - - if (gtk_combo_box_get_model (GTK_COMBO_BOX (priv->edit_widget)) != NULL) - { - uid = gcal_get_source_uid ( - gtk_combo_box_get_model (GTK_COMBO_BOX (priv->edit_widget)), - gtk_label_get_text (GTK_LABEL (priv->view_widget))); - - gtk_combo_box_set_active_id (GTK_COMBO_BOX (priv->edit_widget), uid); - g_free (uid); - - gtk_widget_grab_focus (priv->edit_widget); - } -} - -static void -gcal_editable_combo_leave_edit_mode (GcalEditable *editable) -{ - GcalEditableComboPrivate *priv; - gchar *name; - - g_return_if_fail (GCAL_IS_EDITABLE_COMBO (editable)); - priv = GCAL_EDITABLE_COMBO (editable)->priv; - - if (gtk_combo_box_get_model (GTK_COMBO_BOX (priv->edit_widget)) == NULL) - { - gtk_label_set_text (GTK_LABEL (priv->view_widget), NULL); - } - else - { - name = gcal_get_source_name ( - gtk_combo_box_get_model (GTK_COMBO_BOX (priv->edit_widget)), - gtk_combo_box_get_active_id (GTK_COMBO_BOX (priv->edit_widget))); - - gtk_label_set_text (GTK_LABEL (priv->view_widget), name); - g_free (name); - } -} - -static void -gcal_editable_combo_clear (GcalEditable *editable) -{ - GcalEditableComboPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_COMBO (editable)); - priv = GCAL_EDITABLE_COMBO (editable)->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), NULL); - gtk_combo_box_set_active (GTK_COMBO_BOX (priv->edit_widget), -1); -} - -/** - * gcal_editable_combo_new: - * - * Init the combo in EDIT_MODE - * - * Since: 0.1 - * Returns: (transfer full): - **/ -GtkWidget* -gcal_editable_combo_new (void) -{ - GtkWidget *combo = g_object_new (GCAL_TYPE_EDITABLE_COMBO, NULL); - gcal_editable_enter_edit_mode (GCAL_EDITABLE (combo)); - return combo; -} - -/** - * gcal_editable_combo_new_with_content: - * - * Init the combo in VIEW_MODE - * - * Since 0.2 - * Returns: (transfer full) - */ -GtkWidget* -gcal_editable_combo_new_with_content (const gchar* content) -{ - GtkWidget *combo; - combo = g_object_new (GCAL_TYPE_EDITABLE_COMBO, NULL); - gcal_editable_combo_set_content (GCAL_EDITABLE_COMBO (combo), content); - gcal_editable_leave_edit_mode (GCAL_EDITABLE (combo)); - return combo; -} - -void -gcal_editable_combo_set_model (GcalEditableCombo *combo, - GtkTreeModel *model) -{ - GcalEditableComboPrivate *priv; - GtkCellRenderer *renderer; - - g_return_if_fail (GCAL_IS_EDITABLE_COMBO (combo)); - priv = combo->priv; - - gtk_combo_box_set_model (GTK_COMBO_BOX (priv->edit_widget), model); - gtk_combo_box_set_id_column (GTK_COMBO_BOX (priv->edit_widget), 0); - renderer = gtk_cell_renderer_text_new (); - gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->edit_widget), - renderer, - TRUE); - gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (priv->edit_widget), - renderer, - "text", - 1, - NULL); - gtk_combo_box_set_active (GTK_COMBO_BOX (priv->edit_widget), 0); -} - -void -gcal_editable_combo_set_content (GcalEditableCombo *combo, - const gchar *content) -{ - GcalEditableComboPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_COMBO (combo)); - priv = combo->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), content); -} diff --git a/src/gcal-editable-combo.h b/src/gcal-editable-combo.h deleted file mode 100644 index c951179d..00000000 --- a/src/gcal-editable-combo.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * gcal-editable-combo.h - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#ifndef __GCAL_EDITABLE_COMBO_H__ -#define __GCAL_EDITABLE_COMBO_H__ - -#include "gcal-editable.h" - -G_BEGIN_DECLS - -#define GCAL_TYPE_EDITABLE_COMBO (gcal_editable_combo_get_type ()) -#define GCAL_EDITABLE_COMBO(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDITABLE_COMBO, GcalEditableCombo)) -#define GCAL_EDITABLE_COMBO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDITABLE_COMBO, GcalEditableComboClass)) -#define GCAL_IS_EDITABLE_COMBO(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDITABLE_COMBO)) -#define GCAL_IS_EDITABLE_COMBO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDITABLE_COMBO)) -#define GCAL_EDITABLE_COMBO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDITABLE_COMBO, GcalEditableComboClass)) - -typedef struct _GcalEditableCombo GcalEditableCombo; -typedef struct _GcalEditableComboClass GcalEditableComboClass; -typedef struct _GcalEditableComboPrivate GcalEditableComboPrivate; - -struct _GcalEditableCombo -{ - GcalEditable parent; - - /* add your public declarations here */ - GcalEditableComboPrivate *priv; -}; - -struct _GcalEditableComboClass -{ - GcalEditableClass parent_class; -}; - -GType gcal_editable_combo_get_type (void); - -GtkWidget* gcal_editable_combo_new (void); - -GtkWidget* gcal_editable_combo_new_with_content (const gchar *content); - -void gcal_editable_combo_set_model (GcalEditableCombo *combo, - GtkTreeModel *model); - -void gcal_editable_combo_set_content (GcalEditableCombo *entry, - const gchar *content); -G_END_DECLS - -#endif /* __GCAL_EDITABLE_COMBO_H__ */ diff --git a/src/gcal-editable-date.c b/src/gcal-editable-date.c deleted file mode 100644 index 2c06f492..00000000 --- a/src/gcal-editable-date.c +++ /dev/null @@ -1,275 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-editable-date.c - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#include "gcal-editable-date.h" - -#include - -struct _GcalEditableDatePrivate -{ - GtkWidget *view_widget; - - GtkWidget *edit_widget; - GtkWidget *since_entry; - GtkWidget *until_entry; - GtkWidget *all_day_check; -}; - -static void gcal_editable_date_constructed (GObject *object); - -static void gcal_editable_date_enter_edit_mode (GcalEditable *editable); - -static void gcal_editable_date_leave_edit_mode (GcalEditable *editable); - -static void gcal_editable_date_clear (GcalEditable *editable); - -static void gcal_editable_date_split_set (GcalEditable *editable); - -G_DEFINE_TYPE (GcalEditableDate, gcal_editable_date, GCAL_TYPE_EDITABLE); - -static void gcal_editable_date_class_init (GcalEditableDateClass *klass) -{ - GcalEditableClass *editable_class; - GObjectClass *object_class; - - editable_class = GCAL_EDITABLE_CLASS (klass); - editable_class->enter_edit_mode = gcal_editable_date_enter_edit_mode; - editable_class->leave_edit_mode = gcal_editable_date_leave_edit_mode; - editable_class->clear = gcal_editable_date_clear; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_editable_date_constructed; - - g_type_class_add_private ((gpointer)klass, sizeof (GcalEditableDatePrivate)); -} - - - -static void gcal_editable_date_init (GcalEditableDate *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - GCAL_TYPE_EDITABLE_DATE, - GcalEditableDatePrivate); -} - -static void -gcal_editable_date_constructed (GObject *object) -{ - GcalEditableDatePrivate *priv; - - priv = GCAL_EDITABLE_DATE (object)->priv; - - if (G_OBJECT_CLASS (gcal_editable_date_parent_class)->constructed != NULL) - G_OBJECT_CLASS (gcal_editable_date_parent_class)->constructed (object); - - priv->view_widget = gtk_label_new (NULL); - gtk_widget_show (priv->view_widget); - gtk_widget_set_valign (priv->view_widget, GTK_ALIGN_START); - gtk_widget_set_halign (priv->view_widget, GTK_ALIGN_START); - gcal_editable_set_view_widget (GCAL_EDITABLE (object), priv->view_widget); - - priv->edit_widget = gtk_grid_new (); - - priv->since_entry = gtk_entry_new (); - priv->until_entry = gtk_entry_new (); - priv->all_day_check = gtk_check_button_new_with_label (_("All day")); - - gtk_grid_attach (GTK_GRID (priv->edit_widget), - priv->since_entry, - 0, 0, 1, 1); - gtk_grid_attach (GTK_GRID (priv->edit_widget), - gtk_label_new (_("to")), - 1, 0, 1, 1); - gtk_grid_attach (GTK_GRID (priv->edit_widget), - priv->until_entry, - 2, 0, 1, 1); - gtk_grid_attach (GTK_GRID (priv->edit_widget), - priv->all_day_check, - 0, 1, 3, 1); - - gtk_grid_set_column_spacing (GTK_GRID (priv->edit_widget), 6); - gtk_widget_show_all (priv->edit_widget); - - gcal_editable_set_edit_widget (GCAL_EDITABLE (object), priv->edit_widget); -} - -static void -gcal_editable_date_enter_edit_mode (GcalEditable *editable) -{ - GcalEditableDatePrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_DATE (editable)); - priv = GCAL_EDITABLE_DATE (editable)->priv; - - gcal_editable_date_split_set (editable); - gtk_widget_grab_focus (priv->since_entry); -} - -static void -gcal_editable_date_leave_edit_mode (GcalEditable *editable) -{ - GcalEditableDatePrivate *priv; - gchar *built; - - g_return_if_fail (GCAL_IS_EDITABLE_DATE (editable)); - priv = GCAL_EDITABLE_DATE (editable)->priv; - built = NULL; - - if (g_strcmp0 (gtk_entry_get_text (GTK_ENTRY (priv->since_entry)), "") != 0) - built = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->since_entry))); - - if (g_strcmp0 (gtk_entry_get_text (GTK_ENTRY (priv->until_entry)), "") != 0) - { - if (built != NULL) - { - gchar *c; - c = built; - built = g_strconcat (c, - " - ", - gtk_entry_get_text (GTK_ENTRY (priv->until_entry)), - NULL); - g_free (c); - } - else - { - built = g_strdup (gtk_entry_get_text (GTK_ENTRY (priv->until_entry))); - } - } - - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->all_day_check)) - && built != NULL) - { - gchar *c; - c = built; - built = g_strconcat (c, _(" (All day)"), NULL); - g_free (c); - } - - gtk_label_set_text (GTK_LABEL (priv->view_widget), built); - g_free (built); -} - -static void -gcal_editable_date_clear (GcalEditable *editable) -{ - GcalEditableDatePrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_DATE (editable)); - priv = GCAL_EDITABLE_DATE (editable)->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), ""); - gtk_entry_set_text (GTK_ENTRY (priv->since_entry), ""); - gtk_entry_set_text (GTK_ENTRY (priv->until_entry), ""); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_day_check), FALSE); -} - -static void -gcal_editable_date_split_set (GcalEditable *editable) -{ - GcalEditableDatePrivate *priv; - gchar **tokens; - - g_return_if_fail (GCAL_IS_EDITABLE_DATE (editable)); - priv = GCAL_EDITABLE_DATE (editable)->priv; - - if (g_strcmp0 (gtk_label_get_text (GTK_LABEL (priv->view_widget)), "") != 0) - { - gchar *label_text; - if (g_str_has_suffix ( - gtk_label_get_text (GTK_LABEL (priv->view_widget)), - _(" (All day)"))) - { - const gchar *c; - c = gtk_label_get_text (GTK_LABEL (priv->view_widget)); - label_text = g_strndup (c, g_strrstr (c, _(" (All day)")) - c); - - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_day_check), - TRUE); - } - else - { - label_text = - g_strdup (gtk_label_get_text (GTK_LABEL (priv->view_widget))); - gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->all_day_check), - FALSE); - } - - tokens = g_strsplit (label_text, "-", -1); - - if (tokens[0] != NULL) - { - tokens[0] = g_strstrip (tokens[0]); - gtk_entry_set_text (GTK_ENTRY (priv->since_entry), tokens[0]); - } - if (tokens[1] != NULL) - { - tokens[1] = g_strstrip (tokens[1]); - gtk_entry_set_text (GTK_ENTRY (priv->until_entry), tokens[1]); - } - - g_strfreev (tokens); - } -} - -/** - * gcal_editable_date_new: - * - * Init the date widget in EDIT_MODE - * - * Since: 0.1 - * Returns: (transfer full): - **/ -GtkWidget* -gcal_editable_date_new (void) -{ - GtkWidget *date = g_object_new (GCAL_TYPE_EDITABLE_DATE, NULL); - gcal_editable_enter_edit_mode (GCAL_EDITABLE (date)); - return date; -} - -/** - * gcal_editable_date_new_with_content: - * - * Init the date widget in VIEW_MODE - * - * Since 0.2 - * Returns: (transfer full) - */ -GtkWidget* -gcal_editable_date_new_with_content (const gchar* content) -{ - GtkWidget *date; - date = g_object_new (GCAL_TYPE_EDITABLE_DATE, NULL); - gcal_editable_date_set_content (GCAL_EDITABLE_DATE (date), content); - gcal_editable_leave_edit_mode (GCAL_EDITABLE (date)); - return date; -} - -void -gcal_editable_date_set_content (GcalEditableDate *date, - const gchar *content) -{ - GcalEditableDatePrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_DATE (date)); - priv = date->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), content); -} diff --git a/src/gcal-editable-date.h b/src/gcal-editable-date.h deleted file mode 100644 index f589b957..00000000 --- a/src/gcal-editable-date.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * gcal-editable-date.h - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#ifndef __GCAL_EDITABLE_DATE_H__ -#define __GCAL_EDITABLE_DATE_H__ - -#include "gcal-editable.h" - -G_BEGIN_DECLS - -#define GCAL_TYPE_EDITABLE_DATE (gcal_editable_date_get_type ()) -#define GCAL_EDITABLE_DATE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDITABLE_DATE, GcalEditableDate)) -#define GCAL_EDITABLE_DATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDITABLE_DATE, GcalEditableDateClass)) -#define GCAL_IS_EDITABLE_DATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDITABLE_DATE)) -#define GCAL_IS_EDITABLE_DATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDITABLE_DATE)) -#define GCAL_EDITABLE_DATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDITABLE_DATE, GcalEditableDateClass)) - -typedef struct _GcalEditableDate GcalEditableDate; -typedef struct _GcalEditableDateClass GcalEditableDateClass; -typedef struct _GcalEditableDatePrivate GcalEditableDatePrivate; - -struct _GcalEditableDate -{ - GcalEditable parent; - - /* add your public declarations here */ - GcalEditableDatePrivate *priv; -}; - -struct _GcalEditableDateClass -{ - GcalEditableClass parent_class; -}; - -GType gcal_editable_date_get_type (void); - -GtkWidget* gcal_editable_date_new (void); - -GtkWidget* gcal_editable_date_new_with_content (const gchar *content); - -void gcal_editable_date_set_content (GcalEditableDate *entry, - const gchar *content); -G_END_DECLS - -#endif /* __GCAL_EDITABLE_DATE_H__ */ diff --git a/src/gcal-editable-entry.c b/src/gcal-editable-entry.c deleted file mode 100644 index aeaa4353..00000000 --- a/src/gcal-editable-entry.c +++ /dev/null @@ -1,202 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-editable-entry.c - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#include "gcal-editable-entry.h" - -struct _GcalEditableEntryPrivate -{ - GtkWidget *view_widget; - GtkWidget *edit_widget; -}; - -static void gcal_editable_entry_constructed (GObject *object); - -static void gcal_editable_entry_size_allocate (GtkWidget *widget, - GtkAllocation *allocation); - -static void gcal_editable_entry_enter_edit_mode (GcalEditable *editable); - -static void gcal_editable_entry_leave_edit_mode (GcalEditable *editable); - -static void gcal_editable_entry_clear (GcalEditable *editable); - -G_DEFINE_TYPE (GcalEditableEntry, gcal_editable_entry, GCAL_TYPE_EDITABLE); - -static void gcal_editable_entry_class_init (GcalEditableEntryClass *klass) -{ - GcalEditableClass *editable_class; - GtkWidgetClass *widget_class; - GObjectClass *object_class; - - editable_class = GCAL_EDITABLE_CLASS (klass); - editable_class->enter_edit_mode = gcal_editable_entry_enter_edit_mode; - editable_class->leave_edit_mode = gcal_editable_entry_leave_edit_mode; - editable_class->clear = gcal_editable_entry_clear; - - widget_class = GTK_WIDGET_CLASS (klass); - widget_class->size_allocate = gcal_editable_entry_size_allocate; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_editable_entry_constructed; - - g_type_class_add_private ((gpointer)klass, sizeof (GcalEditableEntryPrivate)); -} - - - -static void gcal_editable_entry_init (GcalEditableEntry *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - GCAL_TYPE_EDITABLE_ENTRY, - GcalEditableEntryPrivate); -} - -static void -gcal_editable_entry_constructed (GObject *object) -{ - GcalEditableEntryPrivate *priv; - - priv = GCAL_EDITABLE_ENTRY (object)->priv; - - if (G_OBJECT_CLASS (gcal_editable_entry_parent_class)->constructed != NULL) - G_OBJECT_CLASS (gcal_editable_entry_parent_class)->constructed (object); - - priv->view_widget = gtk_label_new (NULL); - gtk_label_set_ellipsize (GTK_LABEL (priv->view_widget), - PANGO_ELLIPSIZE_END); - gtk_widget_show (priv->view_widget); - gtk_widget_set_valign (priv->view_widget, GTK_ALIGN_CENTER); - gtk_widget_set_halign (priv->view_widget, GTK_ALIGN_START); - gcal_editable_set_view_widget (GCAL_EDITABLE (object), priv->view_widget); - priv->edit_widget = gtk_entry_new (); - gtk_widget_show (priv->edit_widget); - gcal_editable_set_edit_widget (GCAL_EDITABLE (object), priv->edit_widget); -} - -static void -gcal_editable_entry_size_allocate (GtkWidget *widget, - GtkAllocation *allocation) -{ - GcalEditableEntryPrivate *priv; - GtkAllocation view_allocation; - gint minimum; - gint natural; - - g_return_if_fail (GCAL_IS_EDITABLE_ENTRY (widget)); - priv = GCAL_EDITABLE_ENTRY (widget)->priv; - - if (GTK_WIDGET_CLASS (gcal_editable_entry_parent_class)->size_allocate != NULL) - GTK_WIDGET_CLASS (gcal_editable_entry_parent_class)->size_allocate (widget, allocation); - - //FIXME: hack to keep the label thin - gtk_widget_get_preferred_height (priv->view_widget, &minimum, &natural); - gtk_widget_get_allocation (priv->view_widget, &view_allocation); - view_allocation.height = minimum; - gtk_widget_size_allocate (priv->view_widget, &view_allocation); -} - -static void -gcal_editable_entry_enter_edit_mode (GcalEditable *editable) -{ - GcalEditableEntryPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_ENTRY (editable)); - priv = GCAL_EDITABLE_ENTRY (editable)->priv; - - gtk_entry_set_text (GTK_ENTRY (priv->edit_widget), - gtk_label_get_text (GTK_LABEL (priv->view_widget))); - gtk_editable_select_region (GTK_EDITABLE (priv->edit_widget), 0, -1); - - gtk_widget_grab_focus (priv->edit_widget); -} - -static void -gcal_editable_entry_leave_edit_mode (GcalEditable *editable) -{ - GcalEditableEntryPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_ENTRY (editable)); - priv = GCAL_EDITABLE_ENTRY (editable)->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), - gtk_entry_get_text (GTK_ENTRY (priv->edit_widget))); -} - -static void -gcal_editable_entry_clear (GcalEditable *editable) -{ - GcalEditableEntryPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_ENTRY (editable)); - priv = GCAL_EDITABLE_ENTRY (editable)->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), ""); - gtk_entry_set_text (GTK_ENTRY (priv->edit_widget), ""); -} - -/** - * gcal_editable_entry_new: - * - * Init the entry in EDIT_MODE - * - * Since: 0.1 - * Returns: (transfer full): - **/ -GtkWidget* -gcal_editable_entry_new (void) -{ - GtkWidget *entry = g_object_new (GCAL_TYPE_EDITABLE_ENTRY, NULL); - gcal_editable_enter_edit_mode (GCAL_EDITABLE (entry)); - return entry; -} - -/** - * gcal_editable_entry_new_with_content: - * - * Init the entry in VIEW_MODE - * - * Since 0.2 - * Returns: (transfer full) - */ -GtkWidget* -gcal_editable_entry_new_with_content (const gchar* content) -{ - GtkWidget *entry; - entry = g_object_new (GCAL_TYPE_EDITABLE_ENTRY, NULL); - gcal_editable_entry_set_content (GCAL_EDITABLE_ENTRY (entry), content, FALSE); - gcal_editable_leave_edit_mode (GCAL_EDITABLE (entry)); - return entry; -} - -void -gcal_editable_entry_set_content (GcalEditableEntry *entry, - const gchar *content, - gboolean use_markup) -{ - GcalEditableEntryPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_ENTRY (entry)); - priv = entry->priv; - - if (use_markup) - gtk_label_set_markup (GTK_LABEL (priv->view_widget), content); - else - gtk_label_set_text (GTK_LABEL (priv->view_widget), content); -} diff --git a/src/gcal-editable-entry.h b/src/gcal-editable-entry.h deleted file mode 100644 index 3681ff6f..00000000 --- a/src/gcal-editable-entry.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * gcal-editable-entry.h - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#ifndef __GCAL_EDITABLE_ENTRY_H__ -#define __GCAL_EDITABLE_ENTRY_H__ - -#include "gcal-editable.h" - -G_BEGIN_DECLS - -#define GCAL_TYPE_EDITABLE_ENTRY (gcal_editable_entry_get_type ()) -#define GCAL_EDITABLE_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDITABLE_ENTRY, GcalEditableEntry)) -#define GCAL_EDITABLE_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDITABLE_ENTRY, GcalEditableEntryClass)) -#define GCAL_IS_EDITABLE_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDITABLE_ENTRY)) -#define GCAL_IS_EDITABLE_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDITABLE_ENTRY)) -#define GCAL_EDITABLE_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDITABLE_ENTRY, GcalEditableEntryClass)) - -typedef struct _GcalEditableEntry GcalEditableEntry; -typedef struct _GcalEditableEntryClass GcalEditableEntryClass; -typedef struct _GcalEditableEntryPrivate GcalEditableEntryPrivate; - -struct _GcalEditableEntry -{ - GcalEditable parent; - - /* add your public declarations here */ - GcalEditableEntryPrivate *priv; -}; - -struct _GcalEditableEntryClass -{ - GcalEditableClass parent_class; -}; - -GType gcal_editable_entry_get_type (void); - -GtkWidget* gcal_editable_entry_new (void); - -GtkWidget* gcal_editable_entry_new_with_content (const gchar *content); - -void gcal_editable_entry_set_content (GcalEditableEntry *entry, - const gchar *content, - gboolean use_markup); -G_END_DECLS - -#endif /* __GCAL_EDITABLE_ENTRY_H__ */ diff --git a/src/gcal-editable-reminder.c b/src/gcal-editable-reminder.c deleted file mode 100644 index 9c11f576..00000000 --- a/src/gcal-editable-reminder.c +++ /dev/null @@ -1,465 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-editable-reminder.c - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#include "gcal-editable-reminder.h" - -#include - -struct _GcalEditableReminderPrivate -{ - GtkWidget *view_widget; - GtkWidget *edit_widget; - - GtkWidget *left_box; - - GList *labels; - - GList *reminders; - GtkWidget *add_button; - - gboolean update_edit_mode; -}; - -static void gcal_editable_reminder_constructed (GObject *object); - -static void gcal_editable_reminder_finalize (GObject *object); - -static void gcal_editable_reminder_enter_edit_mode (GcalEditable *editable); - -static void gcal_editable_reminder_leave_edit_mode (GcalEditable *editable); - -static void gcal_editable_reminder_clear (GcalEditable *editable); - -static void gcal_editable_reminder_add_button_clicked (GtkButton *button, - gpointer user_data); - -static void gcal_editable_reminder_insert_content (GcalEditableReminder *editable, - const gchar *content); - -static void gcal_editable_reminder_insert_reminder (GcalEditableReminder *editable, - const gchar *type, - gint number, - const gchar *time); -static void gcal_editable_reminder_remove_reminder (GtkButton *button, - gpointer user_data); - -G_DEFINE_TYPE (GcalEditableReminder, gcal_editable_reminder, GCAL_TYPE_EDITABLE); - -static void gcal_editable_reminder_class_init (GcalEditableReminderClass *klass) -{ - GcalEditableClass *editable_class; - GObjectClass *object_class; - - editable_class = GCAL_EDITABLE_CLASS (klass); - editable_class->enter_edit_mode = gcal_editable_reminder_enter_edit_mode; - editable_class->leave_edit_mode = gcal_editable_reminder_leave_edit_mode; - editable_class->clear = gcal_editable_reminder_clear; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_editable_reminder_constructed; - object_class->finalize = gcal_editable_reminder_finalize; - - g_type_class_add_private ((gpointer)klass, sizeof (GcalEditableReminderPrivate)); -} - - - -static void gcal_editable_reminder_init (GcalEditableReminder *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - GCAL_TYPE_EDITABLE_REMINDER, - GcalEditableReminderPrivate); -} - -static void -gcal_editable_reminder_constructed (GObject *object) -{ - GcalEditableReminderPrivate *priv; - - priv = GCAL_EDITABLE_REMINDER (object)->priv; - - if (G_OBJECT_CLASS (gcal_editable_reminder_parent_class)->constructed != NULL) - G_OBJECT_CLASS (gcal_editable_reminder_parent_class)->constructed (object); - - priv->view_widget = gtk_grid_new (); - g_object_set (priv->view_widget, - "row-spacing", 6, - "valign", GTK_ALIGN_START, - "halign", GTK_ALIGN_START, - "orientation", GTK_ORIENTATION_VERTICAL, - NULL); - gtk_widget_show (priv->view_widget); - gcal_editable_set_view_widget (GCAL_EDITABLE (object), priv->view_widget); - - priv->edit_widget = gtk_grid_new (); - g_object_set (priv->edit_widget, - "orientation", GTK_ORIENTATION_VERTICAL, - "row-spacing", 6, - "column-spacing", 6, - "valign", GTK_ALIGN_START, - NULL); - priv->left_box = gtk_grid_new (); - g_object_set (priv->left_box, - "orientation", GTK_ORIENTATION_VERTICAL, - "row-spacing", 6, - "column-spacing", 6, - "valign", GTK_ALIGN_START, - NULL); - gtk_grid_attach (GTK_GRID (priv->edit_widget), priv->left_box, 0, 0, 1, 1); - gcal_editable_reminder_insert_reminder (GCAL_EDITABLE_REMINDER (object), - NULL, - 1, - NULL); - - priv->add_button = gtk_button_new_with_label (_("Add reminder")); - g_object_set (priv->add_button, - "halign", GTK_ALIGN_START, - "valign", GTK_ALIGN_START, - NULL); - gtk_grid_attach (GTK_GRID (priv->edit_widget), priv->add_button, 0, 1, 1, 1); - g_signal_connect (priv->add_button, - "clicked", - G_CALLBACK (gcal_editable_reminder_add_button_clicked), - object); - - gtk_widget_show_all (priv->edit_widget); - gcal_editable_set_edit_widget (GCAL_EDITABLE (object), priv->edit_widget); - - priv->update_edit_mode = FALSE; -} - -static void -gcal_editable_reminder_finalize (GObject *object) -{ - GcalEditableReminderPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (object)); - priv = GCAL_EDITABLE_REMINDER (object)->priv; - - if (priv->add_button != NULL) - g_clear_object (&(priv->add_button)); - - if (G_OBJECT_CLASS (gcal_editable_reminder_parent_class)->finalize != NULL) - G_OBJECT_CLASS (gcal_editable_reminder_parent_class)->finalize (object); -} - -static void -gcal_editable_reminder_enter_edit_mode (GcalEditable *editable) -{ - GcalEditableReminderPrivate *priv; - GList *l; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (editable)); - priv = GCAL_EDITABLE_REMINDER (editable)->priv; - - if (priv->update_edit_mode) - { - /* will parse everything */ - g_list_free_full (priv->reminders, (GDestroyNotify) gtk_widget_destroy); - priv->reminders = NULL; - - for (l = priv->labels; l != NULL; l = l->next) - { - gchar **tokens; - gchar *type; - gint number; - gchar *time; - - tokens = g_strsplit (gtk_label_get_text (GTK_LABEL (l->data)), " ", -1); - if (g_strcmp0 (_("Email"), tokens[0]) == 0) - type = g_strdup ("email"); - else - type = g_strdup ("notification"); - - number = g_strtod (tokens[1], NULL); - - if (g_str_has_prefix (tokens[2], _("minute"))) - time = g_strdup ("minutes"); - else if (g_str_has_prefix (tokens[2], _("hour"))) - time = g_strdup ("hours"); - else if (g_str_has_prefix (tokens[2], _("day"))) - time = g_strdup ("days"); - else - time = g_strdup ("weeks"); - - gcal_editable_reminder_insert_reminder ( - GCAL_EDITABLE_REMINDER (editable), - type, - number, - time); - - g_free (time); - g_free (type); - g_strfreev (tokens); - } - priv->update_edit_mode = FALSE; - } -} - -static void -gcal_editable_reminder_leave_edit_mode (GcalEditable *editable) -{ - GcalEditableReminderPrivate *priv; - GList *l; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (editable)); - priv = GCAL_EDITABLE_REMINDER (editable)->priv; - - /* clearing */ - g_list_free_full (priv->labels, (GDestroyNotify) gtk_widget_destroy); - priv->labels = NULL; - - for (l = priv->reminders; l != NULL; l = l->next) - { - gchar *text; - gchar *c, *c2; - GtkWidget *type_combo; - GtkWidget *number_spin; - GtkWidget *time_combo; - - type_combo = gtk_grid_get_child_at (GTK_GRID (l->data), 0, 0); - number_spin = gtk_grid_get_child_at (GTK_GRID (l->data), 1, 0); - time_combo = gtk_grid_get_child_at (GTK_GRID (l->data), 2, 0); - - text = - gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (type_combo)); - c = g_strdup_printf ( - "%s %d", - text, - gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (number_spin))); - g_free (text); - text = c; - c2 = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (time_combo)); - c = g_strdup_printf ("%s %s %s", - text, - c2, - _("before")); - g_free (c2); - g_free (text); - - gcal_editable_reminder_insert_content (GCAL_EDITABLE_REMINDER (editable), - c); - g_free (c); - } -} - -static void -gcal_editable_reminder_clear (GcalEditable *editable) -{ - GcalEditableReminderPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (editable)); - priv = GCAL_EDITABLE_REMINDER (editable)->priv; - - g_list_free_full (priv->reminders, (GDestroyNotify) gtk_widget_destroy); - priv->reminders = NULL; - - g_list_free_full (priv->labels, (GDestroyNotify) gtk_widget_destroy); - priv->labels = NULL; -} - -static void -gcal_editable_reminder_add_button_clicked (GtkButton *button, - gpointer user_data) -{ - gcal_editable_reminder_insert_reminder (GCAL_EDITABLE_REMINDER (user_data), - NULL, - 0, - NULL); -} - -static void -gcal_editable_reminder_insert_content (GcalEditableReminder *editable, - const gchar *content) -{ - GcalEditableReminderPrivate *priv; - GtkWidget *label; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (editable)); - priv = editable->priv; - - label = gtk_label_new (content); - gtk_widget_set_halign (label, GTK_ALIGN_START); - - gtk_container_add (GTK_CONTAINER (priv->view_widget), label); - gtk_widget_show_all (priv->view_widget); - - priv->labels = g_list_append (priv->labels, label); -} - -static void -gcal_editable_reminder_insert_reminder (GcalEditableReminder *editable, - const gchar *type, - gint number, - const gchar *time) -{ - GcalEditableReminderPrivate *priv; - - GtkWidget *hbox; - GtkWidget *type_combo; - GtkWidget *number_spin; - GtkWidget *time_combo; - GtkWidget *del_button; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (editable)); - priv = editable->priv; - - hbox = gtk_grid_new (); - g_object_set (hbox, - "orientation", GTK_ORIENTATION_HORIZONTAL, - "column-spacing", 6, - NULL); - - type_combo = gtk_combo_box_text_new (); - - number_spin = gtk_spin_button_new (gtk_adjustment_new (1, 1, 99, 1, 1, 0), - 1, - 0); - - time_combo = gtk_combo_box_text_new (); - - del_button = gtk_button_new (); - g_signal_connect (del_button, - "clicked", - G_CALLBACK (gcal_editable_reminder_remove_reminder), - editable); - gtk_button_set_relief (GTK_BUTTON (del_button), GTK_RELIEF_NONE); - gtk_container_add ( - GTK_CONTAINER (del_button), - gtk_image_new_from_icon_name ("list-remove-symbolic", - GTK_ICON_SIZE_MENU)); - - gtk_container_add (GTK_CONTAINER (hbox), type_combo); - gtk_container_add (GTK_CONTAINER (hbox), number_spin); - gtk_container_add (GTK_CONTAINER (hbox), time_combo); - gtk_container_add (GTK_CONTAINER (hbox), del_button); - - /* loading values and defaults */ - gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (type_combo), - "email", - _("Email")); - gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (type_combo), - "notification", - _("Notification")); - gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (time_combo), - "minutes", - _("minutes")); - gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (time_combo), - "hours", - _("hours")); - gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (time_combo), - "days", - _("days")); - gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (time_combo), - "weeks", - _("weeks")); - - gtk_combo_box_set_active_id (GTK_COMBO_BOX (type_combo), - type != NULL ? type : "email"); - gtk_spin_button_set_value (GTK_SPIN_BUTTON (number_spin), - number > 1 ? number : 1); - gtk_combo_box_set_active_id (GTK_COMBO_BOX (time_combo), - time != NULL ? time : "hours"); - - gtk_container_add (GTK_CONTAINER (priv->left_box), hbox); - - gtk_widget_show_all (hbox); - priv->reminders = g_list_append (priv->reminders, hbox); -} - -static void -gcal_editable_reminder_remove_reminder (GtkButton *button, - gpointer user_data) -{ - GcalEditableReminderPrivate *priv; - GtkWidget *parent; - gint index; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (user_data)); - priv = ((GcalEditableReminder*)user_data)->priv; - - parent = gtk_widget_get_parent (GTK_WIDGET (button)); - index = g_list_index (priv->reminders, parent); - if (index != -1) - { - priv->reminders = g_list_remove (priv->reminders, parent); - gtk_container_remove (GTK_CONTAINER (priv->left_box), parent); - } -} - -/** - * gcal_editable_reminder_new: - * - * Init the reminder in EDIT_MODE - * - * Since: 0.1 - * Returns: (transfer full): - **/ -GtkWidget* -gcal_editable_reminder_new (void) -{ - GtkWidget *reminder = g_object_new (GCAL_TYPE_EDITABLE_REMINDER, NULL); - gcal_editable_enter_edit_mode (GCAL_EDITABLE (reminder)); - return reminder; -} - -/** - * gcal_editable_reminder_new_with_content: - * - * Init the reminder in VIEW_MODE - * - * Since 0.2 - * Returns: (transfer full) - */ -GtkWidget* -gcal_editable_reminder_new_with_content (GList* content) -{ - GtkWidget *reminder; - reminder = g_object_new (GCAL_TYPE_EDITABLE_REMINDER, NULL); - gcal_editable_reminder_set_content (GCAL_EDITABLE_REMINDER (reminder), content); - gcal_editable_leave_edit_mode (GCAL_EDITABLE (reminder)); - return reminder; -} - -void -gcal_editable_reminder_set_content (GcalEditableReminder *reminder, - GList *content) -{ - GcalEditableReminderPrivate *priv; - GList *l; - - g_return_if_fail (GCAL_IS_EDITABLE_REMINDER (reminder)); - priv = reminder->priv; - - if (content != NULL) - { - g_list_free_full (priv->labels, (GDestroyNotify) gtk_widget_destroy); - priv->labels = NULL; - } - - for (l = content; l != NULL; l = l->next) - { - if (l->data != NULL) - { - priv->update_edit_mode = TRUE; - gcal_editable_reminder_insert_content (reminder, l->data); - } - } -} diff --git a/src/gcal-editable-reminder.h b/src/gcal-editable-reminder.h deleted file mode 100644 index a33ee49b..00000000 --- a/src/gcal-editable-reminder.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * gcal-editable-reminder.h - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#ifndef __GCAL_EDITABLE_REMINDER_H__ -#define __GCAL_EDITABLE_REMINDER_H__ - -#include "gcal-editable.h" - -G_BEGIN_DECLS - -#define GCAL_TYPE_EDITABLE_REMINDER (gcal_editable_reminder_get_type ()) -#define GCAL_EDITABLE_REMINDER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDITABLE_REMINDER, GcalEditableReminder)) -#define GCAL_EDITABLE_REMINDER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDITABLE_REMINDER, GcalEditableReminderClass)) -#define GCAL_IS_EDITABLE_REMINDER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDITABLE_REMINDER)) -#define GCAL_IS_EDITABLE_REMINDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDITABLE_REMINDER)) -#define GCAL_EDITABLE_REMINDER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDITABLE_REMINDER, GcalEditableReminderClass)) - -typedef struct _GcalEditableReminder GcalEditableReminder; -typedef struct _GcalEditableReminderClass GcalEditableReminderClass; -typedef struct _GcalEditableReminderPrivate GcalEditableReminderPrivate; - -struct _GcalEditableReminder -{ - GcalEditable parent; - - /* add your public declarations here */ - GcalEditableReminderPrivate *priv; -}; - -struct _GcalEditableReminderClass -{ - GcalEditableClass parent_class; -}; - -GType gcal_editable_reminder_get_type (void); - -GtkWidget* gcal_editable_reminder_new (void); - -GtkWidget* gcal_editable_reminder_new_with_content (GList *content); - -void gcal_editable_reminder_set_content (GcalEditableReminder *entry, - GList *content); -G_END_DECLS - -#endif /* __GCAL_EDITABLE_REMINDER_H__ */ diff --git a/src/gcal-editable-text.c b/src/gcal-editable-text.c deleted file mode 100644 index b8d81045..00000000 --- a/src/gcal-editable-text.c +++ /dev/null @@ -1,190 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-editable-text.c - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#include "gcal-editable-text.h" - -struct _GcalEditableTextPrivate -{ - GtkWidget *view_widget; - - GtkWidget *desc_frame; - GtkWidget *scrolled_win; - GtkWidget *edit_widget; -}; - -static void gcal_editable_text_constructed (GObject *object); - -static void gcal_editable_text_enter_edit_mode (GcalEditable *editable); - -static void gcal_editable_text_leave_edit_mode (GcalEditable *editable); - -static void gcal_editable_text_clear (GcalEditable *editable); - -G_DEFINE_TYPE (GcalEditableText, gcal_editable_text, GCAL_TYPE_EDITABLE); - -static void gcal_editable_text_class_init (GcalEditableTextClass *klass) -{ - GcalEditableClass *editable_class; - GObjectClass *object_class; - - editable_class = GCAL_EDITABLE_CLASS (klass); - editable_class->enter_edit_mode = gcal_editable_text_enter_edit_mode; - editable_class->leave_edit_mode = gcal_editable_text_leave_edit_mode; - editable_class->clear = gcal_editable_text_clear; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_editable_text_constructed; - - g_type_class_add_private ((gpointer)klass, sizeof (GcalEditableTextPrivate)); -} - - - -static void gcal_editable_text_init (GcalEditableText *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - GCAL_TYPE_EDITABLE_TEXT, - GcalEditableTextPrivate); -} - -static void -gcal_editable_text_constructed (GObject *object) -{ - GcalEditableTextPrivate *priv; - - priv = GCAL_EDITABLE_TEXT (object)->priv; - - if (G_OBJECT_CLASS (gcal_editable_text_parent_class)->constructed != NULL) - G_OBJECT_CLASS (gcal_editable_text_parent_class)->constructed (object); - - priv->view_widget = gtk_label_new (NULL); - gtk_label_set_ellipsize (GTK_LABEL (priv->view_widget), - PANGO_ELLIPSIZE_END); - gtk_widget_show (priv->view_widget); - gtk_widget_set_valign (priv->view_widget, GTK_ALIGN_START); - gtk_widget_set_halign (priv->view_widget, GTK_ALIGN_START); - gcal_editable_set_view_widget (GCAL_EDITABLE (object), priv->view_widget); - - priv->edit_widget = gtk_text_view_new (); - gtk_widget_show (priv->edit_widget); - - priv->scrolled_win = gtk_scrolled_window_new (NULL, NULL); - gtk_container_add (GTK_CONTAINER (priv->scrolled_win), priv->edit_widget); - - priv->desc_frame = gtk_frame_new (NULL); - gtk_container_add (GTK_CONTAINER (priv->desc_frame), priv->scrolled_win); - - gtk_widget_show (priv->desc_frame); - gcal_editable_set_edit_widget (GCAL_EDITABLE (object), priv->desc_frame); -} - -static void -gcal_editable_text_enter_edit_mode (GcalEditable *editable) -{ - GcalEditableTextPrivate *priv; - GtkTextBuffer *buffer; - - g_return_if_fail (GCAL_IS_EDITABLE_TEXT (editable)); - priv = GCAL_EDITABLE_TEXT (editable)->priv; - - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->edit_widget)); - gtk_text_buffer_set_text (buffer, - gtk_label_get_text (GTK_LABEL (priv->view_widget)), - -1); - - gtk_widget_grab_focus (priv->edit_widget); -} - -static void -gcal_editable_text_leave_edit_mode (GcalEditable *editable) -{ - GcalEditableTextPrivate *priv; - GtkTextBuffer *buffer; - GtkTextIter start, end; - gchar *text; - - g_return_if_fail (GCAL_IS_EDITABLE_TEXT (editable)); - priv = GCAL_EDITABLE_TEXT (editable)->priv; - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->edit_widget)); - gtk_text_buffer_get_start_iter (buffer, &start); - gtk_text_buffer_get_end_iter (buffer, &end); - text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE); - gtk_label_set_text (GTK_LABEL (priv->view_widget), text); - g_free (text); -} - -static void -gcal_editable_text_clear (GcalEditable *editable) -{ - GcalEditableTextPrivate *priv; - GtkTextBuffer *buffer; - - g_return_if_fail (GCAL_IS_EDITABLE_TEXT (editable)); - priv = GCAL_EDITABLE_TEXT (editable)->priv; - buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->edit_widget)); - gtk_text_buffer_set_text (buffer, "", -1); -} - -/* Public API */ -/** - * gcal_editable_text_new: - * - * Init the entry in EDIT_MODE - * - * Since: 0.1 - * Returns: (transfer full): - **/ -GtkWidget* -gcal_editable_text_new (void) -{ - GtkWidget *entry = g_object_new (GCAL_TYPE_EDITABLE_TEXT, NULL); - gcal_editable_enter_edit_mode (GCAL_EDITABLE (entry)); - return entry; -} - -/** - * gcal_editable_text_new_with_content: - * - * Init the entry in VIEW_MODE - * - * Since 0.2 - * Returns: (transfer full) - */ -GtkWidget* -gcal_editable_text_new_with_content (const gchar* content) -{ - GtkWidget *entry; - entry = g_object_new (GCAL_TYPE_EDITABLE_TEXT, NULL); - gcal_editable_text_set_content (GCAL_EDITABLE_TEXT (entry), content); - gcal_editable_leave_edit_mode (GCAL_EDITABLE (entry)); - return entry; -} - -void -gcal_editable_text_set_content (GcalEditableText *entry, - const gchar *content) -{ - GcalEditableTextPrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE_TEXT (entry)); - priv = entry->priv; - - gtk_label_set_text (GTK_LABEL (priv->view_widget), content); -} diff --git a/src/gcal-editable-text.h b/src/gcal-editable-text.h deleted file mode 100644 index 5b6f52ce..00000000 --- a/src/gcal-editable-text.h +++ /dev/null @@ -1,61 +0,0 @@ -/* - * gcal-editable-text.h - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#ifndef __GCAL_EDITABLE_TEXT_H__ -#define __GCAL_EDITABLE_TEXT_H__ - -#include "gcal-editable.h" - -G_BEGIN_DECLS - -#define GCAL_TYPE_EDITABLE_TEXT (gcal_editable_text_get_type ()) -#define GCAL_EDITABLE_TEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDITABLE_TEXT, GcalEditableText)) -#define GCAL_EDITABLE_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDITABLE_TEXT, GcalEditableTextClass)) -#define GCAL_IS_EDITABLE_TEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDITABLE_TEXT)) -#define GCAL_IS_EDITABLE_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDITABLE_TEXT)) -#define GCAL_EDITABLE_TEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDITABLE_TEXT, GcalEditableTextClass)) - -typedef struct _GcalEditableText GcalEditableText; -typedef struct _GcalEditableTextClass GcalEditableTextClass; -typedef struct _GcalEditableTextPrivate GcalEditableTextPrivate; - -struct _GcalEditableText -{ - GcalEditable parent; - - /* add your public declarations here */ - GcalEditableTextPrivate *priv; -}; - -struct _GcalEditableTextClass -{ - GcalEditableClass parent_class; -}; - -GType gcal_editable_text_get_type (void); - -GtkWidget* gcal_editable_text_new (void); - -GtkWidget* gcal_editable_text_new_with_content (const gchar *content); - -void gcal_editable_text_set_content (GcalEditableText *entry, - const gchar *content); -G_END_DECLS - -#endif /* __GCAL_EDITABLE_TEXT_H__ */ diff --git a/src/gcal-editable.c b/src/gcal-editable.c deleted file mode 100644 index 99e23be6..00000000 --- a/src/gcal-editable.c +++ /dev/null @@ -1,190 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-editable.c - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#include "gcal-editable.h" - -struct _GcalEditablePrivate -{ - gboolean locked; - GcalEditableMode mode : 1; -}; - -static void gcal_editable_constructed (GObject *object); - -G_DEFINE_TYPE (GcalEditable, gcal_editable, GTK_TYPE_NOTEBOOK); - -static void gcal_editable_class_init (GcalEditableClass *klass) -{ - GObjectClass *object_class; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_editable_constructed; - - klass->enter_edit_mode = gcal_editable_enter_edit_mode; - klass->leave_edit_mode = gcal_editable_leave_edit_mode; - - g_type_class_add_private ((gpointer)klass, sizeof (GcalEditablePrivate)); -} - - - -static void gcal_editable_init (GcalEditable *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, - GCAL_TYPE_EDITABLE, - GcalEditablePrivate); -} - -static void -gcal_editable_constructed (GObject *object) -{ - GcalEditablePrivate *priv; - - priv = GCAL_EDITABLE (object)->priv; - - priv->locked = FALSE; - priv->mode = GCAL_VIEW_MODE; - - gtk_notebook_set_show_tabs (GTK_NOTEBOOK (object), FALSE); -} - -/* Public API */ -void -gcal_editable_set_view_widget (GcalEditable *editable, - GtkWidget *widget) -{ - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - - if (gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 0) != NULL) - gtk_notebook_remove_page (GTK_NOTEBOOK (editable), 0); - - gtk_notebook_insert_page (GTK_NOTEBOOK (editable), widget, NULL, 0); -} - -void -gcal_editable_set_edit_widget (GcalEditable *editable, - GtkWidget *widget) -{ - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - - if (gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 1) != NULL) - gtk_notebook_remove_page (GTK_NOTEBOOK (editable), 1); - - gtk_notebook_insert_page (GTK_NOTEBOOK (editable), widget, NULL, 1); -} - -void -gcal_editable_enter_edit_mode (GcalEditable *editable) -{ - GcalEditablePrivate *priv; - GtkWidget *view_widget; - GtkWidget *edit_widget; - - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - priv = editable->priv; - - if (! priv->locked && priv->mode == GCAL_VIEW_MODE) - { - edit_widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 1); - gtk_widget_show_all (edit_widget); - view_widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 0); - gtk_widget_hide (view_widget); - - gtk_notebook_set_current_page (GTK_NOTEBOOK (editable), 1); - - if (GCAL_EDITABLE_GET_CLASS (editable)->enter_edit_mode != NULL) - GCAL_EDITABLE_GET_CLASS (editable)->enter_edit_mode (editable); - - priv->mode = GCAL_EDIT_MODE; - } -} - -void -gcal_editable_leave_edit_mode (GcalEditable *editable) -{ - GcalEditablePrivate *priv; - GtkWidget *view_widget; - GtkWidget *edit_widget; - - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - priv = editable->priv; - - if (! priv->locked && priv->mode == GCAL_EDIT_MODE) - { - edit_widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 1); - gtk_widget_hide (edit_widget); - view_widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (editable), 0); - gtk_widget_show_all (view_widget); - - gtk_notebook_set_current_page (GTK_NOTEBOOK (editable), 0); - - if (GCAL_EDITABLE_GET_CLASS (editable)->leave_edit_mode != NULL) - GCAL_EDITABLE_GET_CLASS (editable)->leave_edit_mode (editable); - - priv->mode = GCAL_VIEW_MODE; - } -} - -/** - * gcal_editable_clear: - * @editable: A GcalEditable widget - * - * Will clear the content of the widgets, and set it into GCAL_EDIT_MODE - */ -void -gcal_editable_clear (GcalEditable *editable) -{ - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - - if (GCAL_EDITABLE_GET_CLASS (editable)->clear != NULL) - GCAL_EDITABLE_GET_CLASS (editable)->clear (editable); - - GCAL_EDITABLE_GET_CLASS (editable)->enter_edit_mode (editable); -} - -GcalEditableMode -gcal_editable_get_mode (GcalEditable *editable) -{ - GcalEditablePrivate *priv; - - g_return_val_if_fail (GCAL_IS_EDITABLE (editable), GCAL_VIEW_MODE); - priv = editable->priv; - return priv->mode; -} - -void -gcal_editable_lock (GcalEditable *editable) -{ - GcalEditablePrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - priv = editable->priv; - priv->locked = TRUE; -} - -void -gcal_editable_unlock (GcalEditable *editable) -{ - GcalEditablePrivate *priv; - - g_return_if_fail (GCAL_IS_EDITABLE (editable)); - priv = editable->priv; - priv->locked = FALSE; -} diff --git a/src/gcal-editable.h b/src/gcal-editable.h deleted file mode 100644 index e17430d6..00000000 --- a/src/gcal-editable.h +++ /dev/null @@ -1,80 +0,0 @@ -/* - * gcal-editable.h - * - * Copyright (C) 2012 - Erick Pérez Castellanos - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -#ifndef __GCAL_EDITABLE_H__ -#define __GCAL_EDITABLE_H__ - -#include "gcal-utils.h" - -#include - -G_BEGIN_DECLS - -#define GCAL_TYPE_EDITABLE (gcal_editable_get_type ()) -#define GCAL_EDITABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EDITABLE, GcalEditable)) -#define GCAL_EDITABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EDITABLE, GcalEditableClass)) -#define GCAL_IS_EDITABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EDITABLE)) -#define GCAL_IS_EDITABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EDITABLE)) -#define GCAL_EDITABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EDITABLE, GcalEditableClass)) - -typedef struct _GcalEditable GcalEditable; -typedef struct _GcalEditableClass GcalEditableClass; -typedef struct _GcalEditablePrivate GcalEditablePrivate; - -struct _GcalEditable -{ - GtkNotebook parent; - - /* add your public declarations here */ - GcalEditablePrivate *priv; -}; - -struct _GcalEditableClass -{ - GtkNotebookClass parent_class; - - /* virtual methods */ - void (*enter_edit_mode) (GcalEditable *editable); - void (*leave_edit_mode) (GcalEditable *editable); - void (*clear) (GcalEditable *editable); -}; - -GType gcal_editable_get_type (void); - -void gcal_editable_set_view_widget (GcalEditable *editable, - GtkWidget *widget); - -void gcal_editable_set_edit_widget (GcalEditable *editable, - GtkWidget *widget); - -void gcal_editable_enter_edit_mode (GcalEditable *editable); - -void gcal_editable_leave_edit_mode (GcalEditable *editable); - -void gcal_editable_clear (GcalEditable *editable); - -GcalEditableMode gcal_editable_get_mode (GcalEditable *editable); - -void gcal_editable_lock (GcalEditable *editable); - -void gcal_editable_unlock (GcalEditable *editable); - -G_END_DECLS - -#endif /* __GCAL_EDITABLE_H__ */ diff --git a/src/gcal-event-overlay.c b/src/gcal-event-overlay.c index 86bf3607..51bf200e 100644 --- a/src/gcal-event-overlay.c +++ b/src/gcal-event-overlay.c @@ -67,8 +67,6 @@ static void gcal_event_overlay_close_button_clicked (GtkWidget * static void gcal_event_overlay_calendar_selected (GtkWidget *menu_item, gpointer user_data); -static GdkPixbuf* gcal_event_overlay_get_pixbuf_for_color (GdkColor *color); - G_DEFINE_TYPE(GcalEventOverlay, gcal_event_overlay, GTK_CLUTTER_TYPE_ACTOR) static void @@ -294,7 +292,7 @@ gcal_event_overlay_set_calendars_menu (GcalEventOverlay *widget) G_CALLBACK (gcal_event_overlay_calendar_selected), widget); - pix = gcal_event_overlay_get_pixbuf_for_color (color); + pix = gcal_get_pixbuf_from_color (color); cal_image = gtk_image_new_from_pixbuf (pix); g_object_set (item, @@ -409,7 +407,7 @@ gcal_event_overlay_calendar_selected (GtkWidget *menu_item, gtk_tree_iter_free (priv->active_iter); priv->active_iter = gtk_tree_iter_copy (iter); - pix = gcal_event_overlay_get_pixbuf_for_color (color); + 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); @@ -417,33 +415,6 @@ gcal_event_overlay_calendar_selected (GtkWidget *menu_item, g_object_unref (pix); } -static GdkPixbuf* -gcal_event_overlay_get_pixbuf_for_color (GdkColor *color) -{ - cairo_surface_t *surface; - cairo_t *cr; - gint width, height; - GdkPixbuf *pix; - - /* TODO: review size here, maybe not hardcoded */ - width = height = 10; - surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); - cr = cairo_create (surface); - - cairo_set_source_rgb (cr, - color->red / 65535.0, - color->green / 65535.0, - color->blue / 65535.0); - cairo_rectangle (cr, 0, 0, width, height); - cairo_fill (cr); - cairo_destroy (cr); - pix = gdk_pixbuf_get_from_surface (surface, - 0, 0, - width, height); - cairo_surface_destroy (surface); - return pix; -} - /* Public API */ ClutterActor* diff --git a/src/gcal-event-view.c b/src/gcal-event-view.c deleted file mode 100644 index 2721d964..00000000 --- a/src/gcal-event-view.c +++ /dev/null @@ -1,493 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-event-view.c - * Copyright (C) 2012 Erick Pérez Castellanos - * - * 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 . - */ - -#include "gcal-event-view.h" -#include "gcal-editable-entry.h" -#include "gcal-editable-text.h" -#include "gcal-editable-date.h" -#include "gcal-editable-combo.h" -#include "gcal-editable-reminder.h" - -#include - -struct _GcalEventViewPrivate -{ - GcalEditableMode edit_mode; - gchar *source_uid; - gchar *event_uid; - GSList *e_widgets; - - GtkWidget *e_what; - GtkWidget *e_host; - - GtkWidget *d_when; - - GtkWidget *e_where; - - GtkWidget *cb_cal; - - GtkWidget *t_desc; - - GtkWidget *reminders; - - GtkWidget *attending_yes; - GtkWidget *attending_maybe; - GtkWidget *attending_no; - - GtkWidget *delete_button; - - GcalManager *manager; -}; - -enum -{ - WILL_DELETE = 1, - - NUM_SIGNALS -}; - -static guint signals[NUM_SIGNALS] = { 0, }; - -static void gcal_event_view_constructed (GObject *object); - -static void gcal_event_view_finalize (GObject *object); - -static void gcal_event_view_set_combo_box (GcalEventView *view); - -static void gcal_event_view_update (GcalEventView *view); - -static void gcal_event_view_delete_event (GtkWidget *button, - gpointer user_data); - -G_DEFINE_TYPE(GcalEventView, gcal_event_view, GTK_TYPE_GRID) - -static void -gcal_event_view_class_init(GcalEventViewClass *klass) -{ - GObjectClass *object_class; - - object_class = G_OBJECT_CLASS (klass); - object_class->constructed = gcal_event_view_constructed; - object_class->finalize = gcal_event_view_finalize; - - signals[WILL_DELETE] = g_signal_new ("will-delete", - GCAL_TYPE_EVENT_VIEW, - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GcalEventViewClass, - will_delete), - NULL, NULL, - g_cclosure_marshal_VOID__STRING, - G_TYPE_NONE, - 1, - G_TYPE_STRING); - - g_type_class_add_private((gpointer)klass, sizeof(GcalEventViewPrivate)); -} - -static void gcal_event_view_init(GcalEventView *self) -{ - self->priv = G_TYPE_INSTANCE_GET_PRIVATE(self, - GCAL_TYPE_EVENT_VIEW, - GcalEventViewPrivate); - - gtk_style_context_add_class ( - gtk_widget_get_style_context (GTK_WIDGET (self)), - "event-details"); -} - -static void -gcal_event_view_constructed (GObject *object) -{ - GcalEventViewPrivate *priv; - GtkWidget *what; - GtkWidget *when; - GtkWidget *calendar; - GtkWidget *where; - GtkWidget *desc; - GtkWidget *rem; - GtkWidget *attending; - GtkWidget *attending_box; - - priv = GCAL_EVENT_VIEW (object)->priv; - if (G_OBJECT_CLASS (gcal_event_view_parent_class)->constructed != NULL) - G_OBJECT_CLASS (gcal_event_view_parent_class)->constructed (object); - - priv->edit_mode = GCAL_EDIT_MODE; - priv->source_uid = NULL; - priv->event_uid = NULL; - priv->e_widgets = NULL; - - priv->e_what = gcal_editable_entry_new (); - priv->e_widgets = g_slist_append (priv->e_widgets, priv->e_what); - - priv->d_when = gcal_editable_date_new (); - priv->e_widgets = g_slist_append (priv->e_widgets, priv->d_when); - - priv->e_where = gcal_editable_entry_new (); - priv->e_widgets = g_slist_append (priv->e_widgets, priv->e_where); - - priv->cb_cal = gcal_editable_combo_new (); - priv->e_widgets = g_slist_append (priv->e_widgets, priv->cb_cal); - gtk_widget_set_halign (priv->cb_cal, GTK_ALIGN_START); - - priv->t_desc = gcal_editable_text_new (); - priv->e_widgets = g_slist_append (priv->e_widgets, priv->t_desc); - - priv->reminders = gcal_editable_reminder_new (); - priv->e_widgets = g_slist_append (priv->e_widgets, priv->reminders); - - /* FIXME: do something with this to add it on the slist of widget - * something like, turning all the three into on widget - */ - priv->attending_yes = gtk_toggle_button_new_with_label (_("Yes")); - priv->attending_maybe = gtk_toggle_button_new_with_label (_("Maybe")); - priv->attending_no = gtk_toggle_button_new_with_label (_("No")); - - attending_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); - gtk_box_set_spacing (GTK_BOX (attending_box), 2); - gtk_button_box_set_layout (GTK_BUTTON_BOX (attending_box), GTK_BUTTONBOX_SPREAD); - gtk_widget_set_halign (attending_box, GTK_ALIGN_START); - gtk_container_add (GTK_CONTAINER (attending_box), priv->attending_yes); - gtk_container_add (GTK_CONTAINER (attending_box), priv->attending_maybe); - gtk_container_add (GTK_CONTAINER (attending_box), priv->attending_no); - - /* Building the skel grid */ - what = gtk_label_new (_("What")); - gtk_widget_set_halign (what, GTK_ALIGN_END); - gtk_grid_attach (GTK_GRID (object), what, 0, 0, 1, 1); - gtk_grid_attach (GTK_GRID (object), priv->e_what, 1, 0, 1, 1); - - when = gtk_label_new (_("When")); - gtk_widget_set_valign (when, GTK_ALIGN_START); - gtk_widget_set_halign (when, GTK_ALIGN_END); - gtk_grid_attach (GTK_GRID (object), when, 0, 1, 1, 1); - gtk_grid_attach (GTK_GRID (object), priv->d_when, 1, 1, 1, 1); - - where = gtk_label_new (_("Where")); - gtk_widget_set_halign (where, GTK_ALIGN_END); - gtk_grid_attach (GTK_GRID (object), where, 0, 2, 1, 1); - gtk_grid_attach (GTK_GRID (object), priv->e_where, 1, 2, 1, 1); - - calendar = gtk_label_new (_("Calendar")); - gtk_widget_set_halign (calendar, GTK_ALIGN_END); - gtk_grid_attach (GTK_GRID (object), calendar, 0, 3, 1, 1); - gtk_grid_attach (GTK_GRID (object), priv->cb_cal, 1, 3, 1, 1); - - desc = gtk_label_new (_("Description")); - gtk_widget_set_halign (desc, GTK_ALIGN_END); - gtk_widget_set_valign (desc, GTK_ALIGN_START); - gtk_grid_attach (GTK_GRID (object), desc, 0, 4, 1, 1); - gtk_grid_attach (GTK_GRID (object), priv->t_desc, 1, 4, 1, 1); - - rem = gtk_label_new (_("Reminders")); - gtk_widget_set_halign (rem, GTK_ALIGN_END); - gtk_widget_set_valign (rem, GTK_ALIGN_START); - gtk_widget_set_margin_top (rem, 10); - gtk_grid_attach (GTK_GRID (object), rem, 0, 5, 1, 1); - gtk_grid_attach (GTK_GRID (object), priv->reminders, 1, 5, 1, 1); - - attending = gtk_label_new (_("Attending")); - gtk_widget_set_halign (attending, GTK_ALIGN_END); - gtk_grid_attach (GTK_GRID (object), attending, 0, 6, 1, 1); - gtk_grid_attach (GTK_GRID (object), attending_box, 1, 6, 1, 1); - - priv->delete_button = gtk_button_new_with_label (_("Delete Event")); - gtk_widget_set_halign (priv->delete_button, GTK_ALIGN_START); - gtk_widget_set_valign (priv->delete_button, GTK_ALIGN_END); - gtk_widget_set_hexpand (priv->delete_button, FALSE); - gtk_grid_attach (GTK_GRID (object), priv->delete_button, 1, 7, 1, 1); - - g_object_set (object, - "row-spacing", 12, - "column-spacing", 12, - NULL); - gtk_widget_show_all (GTK_WIDGET (object)); - - gtk_widget_hide (priv->delete_button); - - /* Signals */ - g_signal_connect (priv->delete_button, - "clicked", - G_CALLBACK (gcal_event_view_delete_event), - object); -} - -static void -gcal_event_view_finalize (GObject *object) -{ - GcalEventViewPrivate *priv; - - priv = GCAL_EVENT_VIEW (object)->priv; - - if (priv->source_uid != NULL) - g_free (priv->source_uid); - if (priv->event_uid != NULL) - g_free (priv->event_uid); - - if (G_OBJECT_CLASS (gcal_event_view_parent_class)->finalize != NULL) - G_OBJECT_CLASS (gcal_event_view_parent_class)->finalize (object); -} - -static void -gcal_event_view_set_combo_box (GcalEventView *view) -{ - GcalEventViewPrivate *priv; - priv = view->priv; - - gcal_editable_combo_set_model ( - GCAL_EDITABLE_COMBO (priv->cb_cal), - GTK_TREE_MODEL (gcal_manager_get_sources_model (priv->manager))); -} - -/** - * gcal_event_view_update: - * @view: A GcalEventView widget - * - * Update the contents of the widget. - */ -static void -gcal_event_view_update (GcalEventView *view) -{ - GcalEventViewPrivate *priv; - - g_return_if_fail (GCAL_IS_EVENT_VIEW (view)); - priv = view->priv; - - if (priv->event_uid == NULL) - { - /* Setting the widget to blank state */ - g_slist_foreach (priv->e_widgets, (GFunc) gcal_editable_clear, NULL); - } - else - { - gchar *summary; - gchar *when; - const gchar *location; - gchar *description; - GList *reminders; - - g_slist_foreach (priv->e_widgets, (GFunc) gcal_editable_leave_edit_mode, NULL); - - summary = gcal_manager_get_event_summary (priv->manager, - priv->source_uid, - priv->event_uid); - gcal_editable_entry_set_content (GCAL_EDITABLE_ENTRY (priv->e_what), - summary, - FALSE); - - when = gcal_manager_get_event_date (priv->manager, - priv->source_uid, - priv->event_uid); - - gcal_editable_date_set_content (GCAL_EDITABLE_DATE (priv->d_when), - when); - - location = gcal_manager_get_event_location (priv->manager, - priv->source_uid, - priv->event_uid); - gcal_editable_entry_set_content (GCAL_EDITABLE_ENTRY (priv->e_where), - location, - FALSE); - - gcal_editable_combo_set_content ( - GCAL_EDITABLE_COMBO (priv->cb_cal), - gcal_manager_get_source_name (priv->manager, priv->source_uid)); - - description = gcal_manager_get_event_description (priv->manager, - priv->source_uid, - priv->event_uid); - gcal_editable_text_set_content (GCAL_EDITABLE_TEXT (priv->t_desc), - description); - - reminders = gcal_manager_get_event_reminders (priv->manager, - priv->source_uid, - priv->event_uid); - - gcal_editable_reminder_set_content ( - GCAL_EDITABLE_REMINDER (priv->reminders), - reminders); - - /* since this loading is for viewing, we hide delete_button */ - gtk_widget_hide (priv->delete_button); - - g_free (description); - g_free (when); - g_free (summary); - g_list_free_full (reminders, (GDestroyNotify) g_free); - } -} - -static void -gcal_event_view_delete_event (GtkWidget *button, - gpointer user_data) -{ - GcalEventViewPrivate *priv; - gchar *event_uuid; - - g_return_if_fail (GCAL_IS_EVENT_VIEW (user_data)); - priv = GCAL_EVENT_VIEW (user_data)->priv; - - event_uuid = g_strdup_printf ("%s:%s", priv->source_uid, priv->event_uid); - /* Reset the widget, and let the windows it work it's done */ - gcal_event_view_load_new (GCAL_EVENT_VIEW (user_data)); - g_signal_emit (GCAL_EVENT_VIEW (user_data), - signals[WILL_DELETE], - 0, - event_uuid); - g_free (event_uuid); -} - -/* Public API */ - -/** - * gcal_event_view_new_with_manager: - * @manager: A GcalManager instance, the app singleton - * - * Returns: (transfer full): - */ -GtkWidget* -gcal_event_view_new_with_manager (GcalManager *manager) -{ - GtkWidget *view; - GcalEventViewPrivate *priv; - - view = g_object_new (GCAL_TYPE_EVENT_VIEW, NULL); - priv = GCAL_EVENT_VIEW (view)->priv; - priv->manager = manager; - gcal_event_view_set_combo_box (GCAL_EVENT_VIEW (view)); - - return view; -} - -/** - * gcal_event_view_load_new: - * @view: A GcalEventView widget - * - * Sets the widget in a edit mode for creating a new - * event. - */ -void -gcal_event_view_load_new (GcalEventView *view) -{ - GcalEventViewPrivate *priv; - - g_return_if_fail (GCAL_IS_EVENT_VIEW (view)); - priv = view->priv; - - if (priv->source_uid != NULL) - g_free (priv->source_uid); - if (priv->event_uid != NULL) - g_free (priv->event_uid); - - priv->source_uid = NULL; - priv->event_uid = NULL; - - /* Setting the widget to blank state to load a new event */ - g_slist_foreach (priv->e_widgets, (GFunc) gcal_editable_clear, NULL); - - gcal_event_view_update (view); - gcal_event_view_enter_edit_mode (view); -} - -/** - * gcal_event_view_load_event: - * @view: A GcalEventView widget - * @event_uuid: the uuid of the event as referenced in GcalManager - * - * Loads events data in the widget, for viewing - */ -void -gcal_event_view_load_event (GcalEventView *view, - const gchar *event_uuid) -{ - GcalEventViewPrivate *priv; - gchar **tokens; - - g_return_if_fail (GCAL_IS_EVENT_VIEW (view)); - priv = view->priv; - - if (event_uuid != NULL) - { - tokens = g_strsplit (event_uuid, ":", -1); - - if (gcal_manager_exists_event (priv->manager, tokens[0], tokens[1])) - { - if (priv->source_uid != NULL) - g_free (priv->source_uid); - if (priv->event_uid != NULL) - g_free (priv->event_uid); - - priv->source_uid = tokens[0]; - priv->event_uid = tokens[1]; - - /* Setting the widget to blank state to load a new event */ - g_slist_foreach (priv->e_widgets, (GFunc) gcal_editable_clear, NULL); - - gcal_event_view_update (view); - } - } -} - -/** - * gcal_event_view_enter_edit_mode: - * @view: A GcalEventView widget - * - * Sets the widget into edit mode. If it has an event set - * then edit that events, otherwise acts as load_new method. - */ -void -gcal_event_view_enter_edit_mode (GcalEventView *view) -{ - GcalEventViewPrivate *priv; - - g_return_if_fail (GCAL_IS_EVENT_VIEW (view)); - priv = view->priv; - - /* Setting the widget to blank state to load a new event */ - g_slist_foreach (priv->e_widgets, - (GFunc) gcal_editable_enter_edit_mode, - NULL); - - /* showing delete button */ - if (priv->event_uid != NULL) - gtk_widget_show (priv->delete_button); -} - -/** - * gcal_event_view_leave_edit_mode: - * @view: A GcalEventView widget - * - * Sets the widget into view. - * FIXME: Maybe this is the place for update/create the event. - */ -void -gcal_event_view_leave_edit_mode (GcalEventView *view) -{ - GcalEventViewPrivate *priv; - - g_return_if_fail (GCAL_IS_EVENT_VIEW (view)); - priv = view->priv; - - /* Setting the widget to blank state to load a new event */ - g_slist_foreach (priv->e_widgets, - (GFunc) gcal_editable_leave_edit_mode, - NULL); - - gtk_widget_hide (priv->delete_button); -} diff --git a/src/gcal-event-view.h b/src/gcal-event-view.h deleted file mode 100644 index 5f4a63e6..00000000 --- a/src/gcal-event-view.h +++ /dev/null @@ -1,70 +0,0 @@ -/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 2 -*- */ -/* - * gcal-event-view.h - * Copyright (C) 2012 Erick Pérez Castellanos - * - * 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 . - */ - -#ifndef __GCAL_EVENT_VIEW_H__ -#define __GCAL_EVENT_VIEW_H__ - -#include "gcal-manager.h" - -#include - -G_BEGIN_DECLS - -#define GCAL_TYPE_EVENT_VIEW (gcal_event_view_get_type ()) -#define GCAL_EVENT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GCAL_TYPE_EVENT_VIEW, GcalEventView)) -#define GCAL_EVENT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GCAL_TYPE_EVENT_VIEW, GcalEventViewClass)) -#define GCAL_IS_EVENT_VIEW(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GCAL_TYPE_EVENT_VIEW)) -#define GCAL_IS_EVENT_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GCAL_TYPE_EVENT_VIEW)) -#define GCAL_EVENT_VIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GCAL_TYPE_EVENT_VIEW, GcalEventViewClass)) - -typedef struct _GcalEventView GcalEventView; -typedef struct _GcalEventViewClass GcalEventViewClass; -typedef struct _GcalEventViewPrivate GcalEventViewPrivate; - -struct _GcalEventView -{ - GtkGrid parent; - - GcalEventViewPrivate *priv; -}; - -struct _GcalEventViewClass -{ - GtkGridClass parent_class; - - /* Signals */ - void (*will_delete) (GcalEventView *view, const gchar* event_uuid); -}; - -GType gcal_event_view_get_type (void); - -GtkWidget* gcal_event_view_new_with_manager (GcalManager *manager); - -void gcal_event_view_load_new (GcalEventView *view); - -void gcal_event_view_load_event (GcalEventView *view, - const gchar *event_uuid); - -void gcal_event_view_enter_edit_mode (GcalEventView *view); - -void gcal_event_view_leave_edit_mode (GcalEventView *view); - -G_END_DECLS - -#endif /* __GCAL_EVENT_VIEW_H__ */ diff --git a/src/gcal-utils.c b/src/gcal-utils.c index 151d9168..189be6b7 100644 --- a/src/gcal-utils.c +++ b/src/gcal-utils.c @@ -204,6 +204,33 @@ gcal_get_weekday (gint i) return _(weekdays[i]); } +GdkPixbuf* +gcal_get_pixbuf_from_color (GdkColor *color) +{ + cairo_surface_t *surface; + cairo_t *cr; + gint width, height; + GdkPixbuf *pix; + + /* TODO: review size here, maybe not hardcoded */ + width = height = 10; + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height); + cr = cairo_create (surface); + + cairo_set_source_rgb (cr, + color->red / 65535.0, + color->green / 65535.0, + color->blue / 65535.0); + cairo_rectangle (cr, 0, 0, width, height); + cairo_fill (cr); + cairo_destroy (cr); + pix = gdk_pixbuf_get_from_surface (surface, + 0, 0, + width, height); + cairo_surface_destroy (surface); + return pix; +} + /* Function to do a last minute fixup of the AM/PM stuff if the locale * and gettext haven't done it right. Most English speaking countries * except the USA use the 24 hour clock (UK, Australia etc). However diff --git a/src/gcal-utils.h b/src/gcal-utils.h index 12b8df72..05e1fd92 100644 --- a/src/gcal-utils.h +++ b/src/gcal-utils.h @@ -67,6 +67,8 @@ gchar* gcal_get_source_uid (GtkTreeModel const gchar* gcal_get_weekday (gint i); +GdkPixbuf* gcal_get_pixbuf_from_color (GdkColor *color); + /* code brought from evolution */ gsize e_strftime_fix_am_pm (gchar *str, gsize max, diff --git a/src/gcal-window.c b/src/gcal-window.c index edff73dd..5825fccc 100644 --- a/src/gcal-window.c +++ b/src/gcal-window.c @@ -25,7 +25,7 @@ #include "gcal-week-view.h" #include "gcal-view.h" #include "gcal-event-widget.h" -#include "gcal-event-view.h" +#include "gcal-edit-dialog.h" #include "gcal-enum-types.h" #include "gtk-notification.h" #include "gcal-event-overlay.h" @@ -121,10 +121,6 @@ static void gcal_window_events_removed (GcalManager *m static void gcal_window_event_activated (GcalEventWidget *event_widget, gpointer user_data); -static void gcal_window_will_remove_event (GcalEventView *view, - gchar *event_uuid, - gpointer user_data); - static void gcal_window_remove_event (GtkNotification *notification, gpointer user_data); @@ -628,43 +624,13 @@ static void gcal_window_init_edit_dialog (GcalWindow *window) { GcalWindowPrivate *priv; - GcalManager *manager; - - GtkWidget *content_area; - GtkWidget *action_area; g_return_if_fail (GCAL_IS_WINDOW (window)); priv = window->priv; - priv->edit_dialog = gtk_dialog_new (); - gtk_window_set_title (GTK_WINDOW (priv->edit_dialog), _("Edit Event")); - gtk_window_set_modal (GTK_WINDOW (priv->edit_dialog), TRUE); - gtk_window_set_destroy_with_parent (GTK_WINDOW (priv->edit_dialog), TRUE); - gtk_window_set_resizable (GTK_WINDOW (priv->edit_dialog), FALSE); - - content_area = gtk_dialog_get_content_area (GTK_DIALOG (priv->edit_dialog)); - manager = gcal_window_get_manager (window); - - priv->edit_widget = gcal_event_view_new_with_manager (manager); - gtk_container_add (GTK_CONTAINER (content_area), - priv->edit_widget); - - gtk_widget_show_all (content_area); - - gtk_dialog_add_button (GTK_DIALOG (priv->edit_dialog), - GTK_STOCK_CANCEL, - GTK_RESPONSE_REJECT); - gtk_dialog_add_button (GTK_DIALOG (priv->edit_dialog), - _("Done"), - GTK_RESPONSE_ACCEPT); - action_area = gtk_dialog_get_action_area (GTK_DIALOG (priv->edit_dialog)); - gtk_button_box_set_layout (GTK_BUTTON_BOX (action_area), GTK_BUTTONBOX_EDGE); - gtk_widget_show_all (action_area); - /* FIXME: hook delete signal - g_signal_connect (priv->add_view, - "will-delete", - G_CALLBACK (gcal_window_will_remove_event), - window);*/ + priv->edit_dialog = gcal_edit_dialog_new (); + gcal_edit_dialog_set_manager (GCAL_EDIT_DIALOG (priv->edit_dialog), + gcal_window_get_manager (window)); } static void @@ -892,6 +858,12 @@ gcal_window_event_activated (GcalEventWidget *event_widget, gpointer user_data) { GcalWindowPrivate *priv; + gchar **tokens; + gint response; + + GtkWidget *noty; + GtkWidget *grid; + GtkWidget *undo_button; g_return_if_fail (GCAL_IS_WINDOW (user_data)); priv = GCAL_WINDOW (user_data)->priv; @@ -899,73 +871,58 @@ gcal_window_event_activated (GcalEventWidget *event_widget, if (priv->edit_dialog == NULL) gcal_window_init_edit_dialog (GCAL_WINDOW (user_data)); - gcal_event_view_load_event (GCAL_EVENT_VIEW (priv->edit_widget), - gcal_event_widget_peek_uuid (event_widget)); + tokens = g_strsplit (gcal_event_widget_peek_uuid (event_widget), ":", -1); + gcal_edit_dialog_set_event (GCAL_EDIT_DIALOG (priv->edit_dialog), + tokens[0], + tokens[1]); + g_strfreev (tokens); - gtk_dialog_run (GTK_DIALOG (priv->edit_dialog)); + response = gtk_dialog_run (GTK_DIALOG (priv->edit_dialog)); gtk_widget_hide (priv->edit_dialog); -} -static void -gcal_window_will_remove_event (GcalEventView *view, - gchar *event_uuid, - gpointer user_data) -{ - GcalWindowPrivate *priv; - gint activated_page; - - GtkWidget *noty; - GtkWidget *grid; - GtkWidget *undo_button; - - GtkWidget *event_widget; - - priv = GCAL_WINDOW (user_data)->priv; - - gcal_toolbar_set_mode (GCAL_TOOLBAR (priv->main_toolbar), - GCAL_TOOLBAR_OVERVIEW); - - if ((activated_page = gtk_notebook_page_num (GTK_NOTEBOOK (priv->notebook), - priv->views[priv->active_view])) - != -1) + switch (response) { - gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), - activated_page); + case GTK_RESPONSE_CANCEL: + /* do nothing, nor edit, nor nothing */ + break; + case GTK_RESPONSE_ACCEPT: + /* save changes if editable */ + break; + case GCAL_RESPONSE_DELETE_EVENT: + /* delete the event */ + noty = gtk_notification_new (); + grid = gtk_grid_new (); + gtk_grid_set_column_spacing (GTK_GRID (grid), 12); + gtk_container_add (GTK_CONTAINER (grid), + gtk_label_new (_("Event deleted"))); + + undo_button = gtk_button_new_from_stock (GTK_STOCK_UNDO); + gtk_container_add (GTK_CONTAINER (grid), undo_button); + + gtk_container_add (GTK_CONTAINER (noty), grid); + gtk_widget_show_all (noty); + gcal_window_show_notification (GCAL_WINDOW (user_data), noty); + + g_signal_connect (noty, + "dismissed", + G_CALLBACK (gcal_window_remove_event), + user_data); + g_signal_connect (undo_button, + "clicked", + G_CALLBACK (gcal_window_undo_remove_event), + user_data); + + priv->event_to_delete = + g_strdup (gcal_event_widget_peek_uuid (event_widget)); + + /* hide widget of the event */ + gtk_widget_hide (GTK_WIDGET (event_widget)); + break; + + default: + /* do nothing */ + break; } - else - { - /* FIXME: there's something that needs to be done here. */ - g_warning ("Your app has gone crazy"); - } - - noty = gtk_notification_new (); - grid = gtk_grid_new (); - gtk_grid_set_column_spacing (GTK_GRID (grid), 12); - gtk_container_add (GTK_CONTAINER (grid), gtk_label_new (_("Event deleted"))); - - undo_button = gtk_button_new_from_stock (GTK_STOCK_UNDO); - gtk_container_add (GTK_CONTAINER (grid), undo_button); - - gtk_container_add (GTK_CONTAINER (noty), grid); - gtk_widget_show_all (noty); - gcal_window_show_notification (GCAL_WINDOW (user_data), noty); - - g_signal_connect (noty, - "dismissed", - G_CALLBACK (gcal_window_remove_event), - user_data); - g_signal_connect (undo_button, - "clicked", - G_CALLBACK (gcal_window_undo_remove_event), - user_data); - - priv->event_to_delete = g_strdup (event_uuid); - - /* hide widget of the event */ - event_widget = - gcal_view_get_by_uuid (GCAL_VIEW (priv->views[priv->active_view]), - priv->event_to_delete); - gtk_widget_hide (event_widget); } static void @@ -1134,13 +1091,11 @@ gcal_window_create_event (GcalEventOverlay *widget, new_data->start_date, new_data->end_date); - g_debug ("NOW CREATE THE EVENT"); if (open_details) g_debug ("Opening details window NOW"); /* reset and hide */ gcal_window_event_overlay_closed (widget, user_data); - } static void