/* gcal-source-dialog.c * * Copyright (C) 2015 Georges Basile Stavracas Neto * * 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 3 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 . */ #define G_LOG_DOMAIN "GcalSourceDialog" #include "gcal-debug.h" #include "gcal-source-dialog.h" #include "gcal-utils.h" #include #include #include #include /** * SECTION:gcal-source-dialog * @short_description: Dialog to manage calendars * @title:GcalSourceDialog * @stability:unstable * @image:gcal-source-dialog.png * * #GcalSourceDialog is the calendar management widget of GNOME * Calendar. With it, users can create calendars from local files, * local calendars or even import calendars from the Web or their * online accounts. */ struct _GcalSourceDialog { GtkDialog parent; GtkWidget *add_button; GtkWidget *back_button; GtkWidget *calendar_color_button; GtkWidget *calendar_visible_check; GtkWidget *cancel_button; GtkWidget *default_check; GtkWidget *edit_grid; GtkWidget *headerbar; GtkWidget *main_scrolledwindow; GtkWidget *name_entry; GtkWidget *notebook; GtkWidget *remove_button; GtkWidget *stack; GtkWidget *web_source_grid; /* notification */ GtkWidget *notification; GtkWidget *notification_label; /* edit page widgets */ GtkWidget *account_box; GtkWidget *account_label; GtkWidget *account_dim_label; GtkWidget *calendar_url_button; GtkWidget *location_dim_label; GtkWidget *settings_button; /* new source details */ GtkWidget *calendar_address_entry; GtkWidget *web_sources_listbox; GtkWidget *web_sources_revealer; /* credentials dialog */ GtkWidget *credentials_cancel_button; GtkWidget *credentials_connect_button; GtkWidget *credentials_dialog; GtkWidget *credentials_password_entry; GtkWidget *credentials_user_entry; gint calendar_address_id; gint validate_url_resource_id; gint notification_timeout_id; /* overview widgets */ GtkWidget *add_calendar_menu_button; GtkWidget *calendars_listbox; GtkWidget *online_accounts_listbox; /* stub goa rows */ GtkWidget *exchange_stub_row; GtkWidget *google_stub_row; GtkWidget *owncloud_stub_row; /* flags */ GcalSourceDialogMode mode; ESource *source; GList *remote_sources; ESource *removed_source; ESource *old_default_source; GBinding *title_bind; gboolean prompt_password; /* auxiliary */ GSimpleActionGroup *action_group; /* manager */ GcalManager *manager; }; typedef enum { GCAL_ACCOUNT_TYPE_EXCHANGE, GCAL_ACCOUNT_TYPE_GOOGLE, GCAL_ACCOUNT_TYPE_OWNCLOUD, GCAL_ACCOUNT_TYPE_NOT_SUPPORTED } GcalAccountType; #define ENTRY_PROGRESS_TIMEOUT 100 static void add_button_clicked (GtkWidget *button, gpointer user_data); static void add_source (GcalManager *manager, ESource *source, gboolean enabled, gpointer user_data); static void action_widget_activated (GtkWidget *widget, gpointer user_data); static void back_button_clicked (GtkButton *button, gpointer user_data); static void calendar_file_selected (GtkFileChooser *button, gpointer user_data); static void calendar_listbox_row_activated (GtkListBox *box, GtkListBoxRow *row, gpointer user_data); static gint calendar_listbox_sort_func (GtkListBoxRow *row1, GtkListBoxRow *row2, gpointer user_data); static void calendar_visible_check_toggled (GObject *object, GParamSpec *pspec, gpointer user_data); static void cancel_button_clicked (GtkWidget *button, gpointer user_data); static void clear_pages (GcalSourceDialog *dialog); static void color_set (GtkColorButton *button, gpointer user_data); static void default_check_toggled (GObject *object, GParamSpec *pspec, gpointer user_data); static gboolean description_label_link_activated (GtkWidget *widget, gchar *uri, gpointer user_data); static void display_header_func (GtkListBoxRow *row, GtkListBoxRow *before, gpointer user_data); static gboolean is_goa_source (GcalSourceDialog *dialog, ESource *source); static GtkWidget* make_row_from_source (GcalSourceDialog *dialog, ESource *source); static void name_entry_text_changed (GObject *object, GParamSpec *pspec, gpointer user_data); static void online_accounts_listbox_row_activated (GtkListBox *box, GtkListBoxRow *row, gpointer user_data); static gint online_accounts_listbox_sort_func (GtkListBoxRow *row1, GtkListBoxRow *row2, gpointer user_data); static void online_accounts_settings_button_clicked (GtkWidget *button, gpointer user_data); static void on_file_activated (GSimpleAction *action, GVariant *param, gpointer user_data); static void on_local_activated (GSimpleAction *action, GVariant *param, gpointer user_data); static void on_web_activated (GSimpleAction *action, GVariant *param, gpointer user_data); static void remove_source (GcalManager *manager, ESource *source, gpointer user_data); static void response_signal (GtkDialog *dialog, gint response_id, gpointer user_data); static void stack_visible_child_name_changed (GObject *object, GParamSpec *pspec, gpointer user_data); static void settings_button_clicked (GtkWidget *button, gpointer user_data); static void spawn_goa_with_args (const gchar *action, const gchar *arg); static gboolean pulse_web_entry (GcalSourceDialog *dialog); static void url_entry_text_changed (GObject *object, GParamSpec *pspec, gpointer user_data); static gboolean validate_url_cb (GcalSourceDialog *dialog); static gint prompt_credentials (GcalSourceDialog *dialog, gchar **username, gchar **password); static void discover_sources_cb (GObject *source, GAsyncResult *result, gpointer user_data); G_DEFINE_TYPE (GcalSourceDialog, gcal_source_dialog, GTK_TYPE_DIALOG) enum { PROP_0, PROP_MANAGER, N_PROPS }; static GParamSpec *properties[N_PROPS] = { NULL, }; GActionEntry actions[] = { {"file", on_file_activated, NULL, NULL, NULL}, {"local", on_local_activated, NULL, NULL, NULL}, {"web", on_web_activated, NULL, NULL, NULL} }; static void add_button_clicked (GtkWidget *button, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); if (self->source != NULL) { /* Commit the new source */ gcal_manager_save_source (self->manager, self->source); self->source = NULL; gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_NORMAL); } if (self->remote_sources != NULL) { GList *l; /* Commit each new remote source */ for (l = self->remote_sources; l != NULL; l = l->next) gcal_manager_save_source (self->manager, l->data); g_list_free (self->remote_sources); self->remote_sources = NULL; /* Go back to overview */ gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_NORMAL); } } static void add_source (GcalManager *manager, ESource *source, gboolean enabled, gpointer user_data) { GcalSourceDialog *self; GList *children, *l; gboolean contains_source; self = GCAL_SOURCE_DIALOG (user_data); children = gtk_container_get_children (GTK_CONTAINER (self->calendars_listbox)); contains_source = FALSE; for (l = children; l != NULL; l = l->next) { if (g_object_get_data (l->data, "source") == source) { contains_source = TRUE; break; } } if (!contains_source) { GtkWidget *row; ESource *parent; parent = gcal_manager_get_source (self->manager, e_source_get_parent (source)); row = make_row_from_source (GCAL_SOURCE_DIALOG (user_data), source); g_object_set_data (G_OBJECT (row), "source", source); if (e_source_has_extension (parent, E_SOURCE_EXTENSION_GOA)) { ESourceGoa *goa = e_source_get_extension (parent, E_SOURCE_EXTENSION_GOA); g_object_set_data (G_OBJECT (row), "account-id", (gpointer) e_source_goa_get_account_id (goa)); } gtk_container_add (GTK_CONTAINER (self->calendars_listbox), row); g_object_unref (parent); } g_list_free (children); } static void action_widget_activated (GtkWidget *widget, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); gint response = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget), "response")); self->old_default_source = NULL; gtk_dialog_response (GTK_DIALOG (user_data), response); } static void back_button_clicked (GtkButton *button, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); if (gtk_stack_get_visible_child (GTK_STACK (self->stack)) == self->edit_grid) { /* Save the source before leaving */ gcal_manager_save_source (self->manager, self->source); /* Release the source ref we acquired */ g_clear_object (&self->source); } gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_NORMAL); } static gint calendar_listbox_sort_func (GtkListBoxRow *row1, GtkListBoxRow *row2, gpointer user_data) { GcalSourceDialog *self; ESource *source1, *source2; gboolean is_goa1, is_goa2; gint retval; self = GCAL_SOURCE_DIALOG (user_data); /* first source */ source1 = g_object_get_data (G_OBJECT (row1), "source"); is_goa1 = is_goa_source (GCAL_SOURCE_DIALOG (user_data), source1); /* second source */ source2 = g_object_get_data (G_OBJECT (row2), "source"); is_goa2 = is_goa_source (GCAL_SOURCE_DIALOG (user_data), source2); if (is_goa1 == is_goa2) { gchar *parent_name1 = NULL; gchar *parent_name2 = NULL; /* Retrieve parent names */ get_source_parent_name_color (self->manager, source1, &parent_name1, NULL); get_source_parent_name_color (self->manager, source2, &parent_name2, NULL); retval = g_strcmp0 (parent_name1, parent_name2); /* If they have the same parent names, compare by the source display names */ if (retval == 0) retval = g_ascii_strcasecmp (e_source_get_display_name (source1), e_source_get_display_name (source2)); g_free (parent_name1); g_free (parent_name2); } else { /* If one is a GOA account and the other isn't, make the GOA one go first */ retval = is_goa1 ? -1 : 1; } return retval; } static void calendar_visible_check_toggled (GObject *object, GParamSpec *pspec, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (object))) gcal_manager_enable_source (self->manager, self->source); else gcal_manager_disable_source (self->manager, self->source); } static void cancel_button_clicked (GtkWidget *button, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); /* Destroy the ongoing created source */ g_clear_object (&self->source); /* Cleanup detected remote sources that weren't added */ if (self->remote_sources != NULL) { g_list_free_full (self->remote_sources, g_object_unref); self->remote_sources = NULL; } gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_NORMAL); } static void clear_pages (GcalSourceDialog *dialog) { GList *list; gtk_entry_set_text (GTK_ENTRY (dialog->calendar_address_entry), ""); gtk_widget_set_sensitive (dialog->add_button, FALSE); /* Remove discovered web sources (if any) */ list = gtk_container_get_children (GTK_CONTAINER (dialog->web_sources_listbox)); g_list_free_full (list, (GDestroyNotify) gtk_widget_destroy); gtk_revealer_set_reveal_child (GTK_REVEALER (dialog->web_sources_revealer), FALSE); gtk_widget_hide (dialog->web_sources_revealer); } static void color_set (GtkColorButton *button, gpointer user_data) { GcalSourceDialog *self; ESourceSelectable *extension; GdkRGBA color; self = GCAL_SOURCE_DIALOG (user_data); gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &color); extension = E_SOURCE_SELECTABLE (e_source_get_extension (self->source, E_SOURCE_EXTENSION_CALENDAR)); e_source_selectable_set_color (extension, gdk_rgba_to_string (&color)); } static void default_check_toggled (GObject *object, GParamSpec *pspec, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); /* Retrieve the current default source */ if (self->old_default_source == NULL) { self->old_default_source = gcal_manager_get_default_source (self->manager); g_object_unref (self->old_default_source); } /** * Keeps toggling between the * current source and the previous * default source. */ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (object))) gcal_manager_set_default_source (self->manager, self->source); else gcal_manager_set_default_source (self->manager, self->old_default_source); } static gboolean description_label_link_activated (GtkWidget *widget, gchar *uri, gpointer user_data) { spawn_goa_with_args (NULL, NULL); return TRUE; } static void display_header_func (GtkListBoxRow *row, GtkListBoxRow *before, gpointer user_data) { if (before != NULL) { GtkWidget *header = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_show (header); gtk_list_box_row_set_header (row, header); } } static gboolean is_goa_source (GcalSourceDialog *dialog, ESource *source) { ESource *parent; gboolean is_goa; g_assert (source && E_IS_SOURCE (source)); parent = gcal_manager_get_source (dialog->manager, e_source_get_parent (source)); is_goa = e_source_has_extension (parent, E_SOURCE_EXTENSION_GOA); g_object_unref (parent); return is_goa; } static void source_color_changed (GObject *source, GParamSpec *pspec, GtkImage *icon) { ESourceSelectable *extension; cairo_surface_t *surface; GdkRGBA out_color; extension = E_SOURCE_SELECTABLE (source); if (!gdk_rgba_parse (&out_color, e_source_selectable_get_color (extension))) { g_warning ("Error parsing color"); return; } if (gdk_rgba_parse (&out_color, e_source_selectable_get_color (extension))) { surface = get_circle_surface_from_color (&out_color, 24); gtk_image_set_from_surface (GTK_IMAGE (icon), surface); g_clear_pointer (&surface, cairo_surface_destroy); } } static void invalidate_calendar_listbox_sort (GObject *source, GParamSpec *pspec, gpointer user_data) { g_return_if_fail (GTK_IS_LIST_BOX (user_data)); gtk_list_box_invalidate_sort (GTK_LIST_BOX (user_data)); } static GtkWidget* make_row_from_source (GcalSourceDialog *dialog, ESource *source) { cairo_surface_t *surface; GtkBuilder *builder; GtkWidget *bottom_label; GtkWidget *top_label; GtkWidget *icon; GtkWidget *row; GdkRGBA color; gchar *parent_name; ESourceSelectable *extension; get_source_parent_name_color (dialog->manager, source, &parent_name, NULL); builder = gtk_builder_new_from_resource ("/org/gnome/calendar/calendar-row.ui"); /* * Since we're destroying the builder instance before adding * the row to the listbox, it should be referenced here so * it isn't destroyed with the GtkBuilder. */ row = g_object_ref (gtk_builder_get_object (builder, "row")); /* source color icon */ get_color_name_from_source (source, &color); surface = get_circle_surface_from_color (&color, 24); icon = GTK_WIDGET (gtk_builder_get_object (builder, "icon")); gtk_image_set_from_surface (GTK_IMAGE (icon), surface); /* source name label */ top_label = GTK_WIDGET (gtk_builder_get_object (builder, "title")); gtk_label_set_label (GTK_LABEL (top_label), e_source_get_display_name (source)); g_object_bind_property (source, "display-name", top_label, "label", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); g_signal_connect (source, "notify::display-name", G_CALLBACK (invalidate_calendar_listbox_sort), dialog->calendars_listbox); extension = E_SOURCE_SELECTABLE (e_source_get_extension (source, E_SOURCE_EXTENSION_CALENDAR)); g_signal_connect (extension, "notify::color", G_CALLBACK (source_color_changed), icon); /* parent source name label */ bottom_label = GTK_WIDGET (gtk_builder_get_object (builder, "subtitle")); gtk_label_set_label (GTK_LABEL (bottom_label), parent_name); g_clear_pointer (&surface, cairo_surface_destroy); g_object_unref (builder); g_free (parent_name); return row; } static void name_entry_text_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); gboolean valid = gtk_entry_get_text_length (GTK_ENTRY (object)) > 0; /* * Callend when the name entry's text * is edited. It changes the source's * display name, but wait's for the * calendar's ::response signal to * commit these changes. */ gtk_widget_set_sensitive (self->back_button, valid); gtk_widget_set_sensitive (self->add_button, valid); if (valid) e_source_set_display_name (self->source, gtk_entry_get_text (GTK_ENTRY (self->name_entry))); } static GVariant* build_dbus_parameters (const gchar *action, const gchar *arg) { GVariantBuilder builder; GVariant *array[1], *params2[3]; g_variant_builder_init (&builder, G_VARIANT_TYPE ("av")); if (!action && !arg) { g_variant_builder_add (&builder, "v", g_variant_new_string ("")); } else { if (action) g_variant_builder_add (&builder, "v", g_variant_new_string (action)); if (arg) g_variant_builder_add (&builder, "v", g_variant_new_string (arg)); } array[0] = g_variant_new ("v", g_variant_new ("(sav)", "online-accounts", &builder)); params2[0] = g_variant_new_string ("launch-panel"); params2[1] = g_variant_new_array (G_VARIANT_TYPE ("v"), array, 1); params2[2] = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0); return g_variant_new_tuple (params2, 3); } static void spawn_goa_with_args (const gchar *action, const gchar *arg) { GDBusProxy *proxy; proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, NULL, "org.gnome.ControlCenter", "/org/gnome/ControlCenter", "org.gtk.Actions", NULL, NULL); if (!proxy) { g_warning ("Couldn't open Online Accounts panel"); return; } g_dbus_proxy_call_sync (proxy, "Activate", build_dbus_parameters (action, arg), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL); g_clear_object (&proxy); } static void online_accounts_listbox_row_activated (GtkListBox *box, GtkListBoxRow *row, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); if ((GtkWidget*) row == self->exchange_stub_row) { spawn_goa_with_args ("add", "exchange"); } else if ((GtkWidget*) row == self->google_stub_row) { spawn_goa_with_args ("add", "google"); } else if ((GtkWidget*) row == self->owncloud_stub_row) { spawn_goa_with_args ("add", "owncloud"); } else { GoaAccount *account; gchar *id; account = g_object_get_data (G_OBJECT (row), "goa-account"); g_return_if_fail (GOA_IS_ACCOUNT (account)); id = goa_account_dup_id (account); spawn_goa_with_args (id, NULL); g_free (id); } } static void response_signal (GtkDialog *dialog, gint response_id, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (dialog); /* Save the source */ if (self->mode == GCAL_SOURCE_DIALOG_MODE_EDIT && self->source != NULL) { gcal_manager_save_source (self->manager, self->source); g_clear_object (&self->source); } /* Commit the new source; save the current page's source */ if (self->mode == GCAL_SOURCE_DIALOG_MODE_NORMAL && response_id == GTK_RESPONSE_APPLY && self->remote_sources != NULL) { GList *l; /* Commit each new remote source */ for (l = self->remote_sources; l != NULL; l = l->next) gcal_manager_save_source (self->manager, l->data); g_list_free (self->remote_sources); self->remote_sources = NULL; } /* Destroy the source when the operation is cancelled */ if (self->mode == GCAL_SOURCE_DIALOG_MODE_NORMAL && response_id == GTK_RESPONSE_CANCEL && self->remote_sources != NULL) { g_list_free_full (self->remote_sources, g_object_unref); self->remote_sources = NULL; } gtk_widget_hide (GTK_WIDGET (dialog)); } static gboolean is_remote_source (ESource *source) { gboolean has_webdav, has_auth; g_assert (E_IS_SOURCE (source)); has_webdav = e_source_has_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); has_auth = e_source_has_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION); if (!has_webdav || !has_auth) return FALSE; if (has_auth) { ESourceAuthentication *auth; auth = e_source_get_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION); /* No host is set, it's not a remote source */ if (e_source_authentication_get_host (auth) == NULL) return FALSE; } if (has_webdav) { ESourceWebdav *webdav; webdav = e_source_get_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); /* No resource path specified, not a remote source */ if (e_source_webdav_get_resource_path (webdav) == NULL) return FALSE; } return TRUE; } static void settings_button_clicked (GtkWidget *button, gpointer user_data) { GcalSourceDialog *self; const gchar *account_id; self = GCAL_SOURCE_DIALOG (user_data); /* Selects the account to open */ account_id = g_object_get_data (G_OBJECT (self->account_label), "account-id"); spawn_goa_with_args ((gchar*) account_id, NULL); } static void stack_visible_child_name_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { GcalSourceDialog *self; GtkWidget *visible_child; self = GCAL_SOURCE_DIALOG (user_data); visible_child = gtk_stack_get_visible_child (GTK_STACK (object)); if (visible_child == self->main_scrolledwindow) { gtk_header_bar_set_title (GTK_HEADER_BAR (self->headerbar), _("Calendar Settings")); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (self->headerbar), NULL); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (self->headerbar), TRUE); gtk_widget_set_visible (self->add_button, FALSE); gtk_widget_set_visible (self->cancel_button, FALSE); gtk_widget_set_visible (self->back_button, FALSE); } /* * Update fields when it goes to the edit page. * Here, only widgets that depends on the current * source are updated, while indenpendent widgets * are updated at #gcal_source_dialog_set_mode */ if (visible_child == self->edit_grid && self->source != NULL) { ESource *default_source; gchar *parent_name; GdkRGBA color; gboolean creation_mode, is_goa, is_file, is_remote; default_source = gcal_manager_get_default_source (self->manager); creation_mode = (self->mode == GCAL_SOURCE_DIALOG_MODE_CREATE || self->mode == GCAL_SOURCE_DIALOG_MODE_CREATE_WEB); is_goa = is_goa_source (GCAL_SOURCE_DIALOG (user_data), self->source); is_file = e_source_has_extension (self->source, E_SOURCE_EXTENSION_LOCAL_BACKEND); is_remote = is_remote_source (self->source); get_source_parent_name_color (self->manager, self->source, &parent_name, NULL); /* update headerbar buttons */ gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (self->headerbar), !creation_mode); gtk_widget_set_visible (self->calendar_visible_check, !creation_mode); gtk_widget_set_visible (self->back_button, !creation_mode); gtk_widget_set_visible (self->add_button, creation_mode); gtk_widget_set_visible (self->cancel_button, creation_mode); gtk_widget_set_visible (self->account_box, is_goa); gtk_widget_set_visible (self->calendar_url_button, !is_goa && (is_file || is_remote)); /* If it's a file, set the file path */ if (is_file) { ESourceLocal *local; GFile *file; gchar *uri; local = e_source_get_extension (self->source, E_SOURCE_EXTENSION_LOCAL_BACKEND); file = e_source_local_get_custom_file (local); uri = g_file_get_uri (file); gtk_link_button_set_uri (GTK_LINK_BUTTON (self->calendar_url_button), uri); gtk_button_set_label (GTK_BUTTON (self->calendar_url_button), uri); g_free (uri); } /* If it's remote, build the uri */ if (is_remote) { ESourceAuthentication *auth; ESourceWebdav *webdav; gchar *uri; auth = e_source_get_extension (self->source, E_SOURCE_EXTENSION_AUTHENTICATION); webdav = e_source_get_extension (self->source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); uri = g_strdup_printf ("https://%s%s", e_source_authentication_get_host (auth), e_source_webdav_get_resource_path (webdav)); gtk_link_button_set_uri (GTK_LINK_BUTTON (self->calendar_url_button), uri); gtk_button_set_label (GTK_BUTTON (self->calendar_url_button), uri); g_free (uri); } if (is_goa) { gchar *name; get_source_parent_name_color (self->manager, self->source, &name, NULL); gtk_label_set_label (GTK_LABEL (self->account_label), name); } /* block signals */ g_signal_handlers_block_by_func (self->calendar_visible_check, calendar_visible_check_toggled, user_data); g_signal_handlers_block_by_func (self->calendar_color_button, color_set, user_data); g_signal_handlers_block_by_func (self->name_entry, name_entry_text_changed, user_data); /* color button */ get_color_name_from_source (self->source, &color); gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (self->calendar_color_button), &color); /* entry */ gtk_entry_set_text (GTK_ENTRY (self->name_entry), e_source_get_display_name (self->source)); /* enabled check */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->calendar_visible_check), is_source_enabled (self->source)); /* default source check button */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (self->default_check), (self->source == default_source)); gtk_widget_set_visible (self->default_check, gcal_manager_is_client_writable (self->manager, self->source)); /* title */ if (!creation_mode) { gtk_header_bar_set_title (GTK_HEADER_BAR (self->headerbar), e_source_get_display_name (self->source)); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (self->headerbar), parent_name); } /* toggle the remove button */ gtk_widget_set_visible (self->remove_button, e_source_get_removable (self->source)); /* unblock signals */ g_signal_handlers_unblock_by_func (self->calendar_visible_check, calendar_visible_check_toggled, user_data); g_signal_handlers_unblock_by_func (self->calendar_color_button, color_set, user_data); g_signal_handlers_unblock_by_func (self->name_entry, name_entry_text_changed, user_data); g_object_unref (default_source); g_free (parent_name); } } static void calendar_file_selected (GtkFileChooser *button, gpointer user_data) { GcalSourceDialog *self; ESourceExtension *ext; ESource *source; GFile *file; self = GCAL_SOURCE_DIALOG (user_data); file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (button)); if (file == NULL) return; /** * Create the new source and add the needed * extensions. */ source = e_source_new (NULL, NULL, NULL); e_source_set_parent (source, "local-stub"); ext = e_source_get_extension (source, E_SOURCE_EXTENSION_CALENDAR); e_source_backend_set_backend_name (E_SOURCE_BACKEND (ext), "local"); ext = e_source_get_extension (source, E_SOURCE_EXTENSION_LOCAL_BACKEND); e_source_local_set_custom_file (E_SOURCE_LOCAL (ext), file); /* update the source properties */ e_source_set_display_name (source, g_file_get_basename (file)); /* Jump to the edit page */ gcal_source_dialog_set_source (GCAL_SOURCE_DIALOG (user_data), source); gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_CREATE); gtk_widget_set_sensitive (self->add_button, TRUE); } static void calendar_listbox_row_activated (GtkListBox *box, GtkListBoxRow *row, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); g_assert (row != NULL); /* * For non-GOA calendars, show the edit page * directly. */ if (GTK_WIDGET (box) == self->calendars_listbox) { ESource *source = g_object_get_data (G_OBJECT (row), "source"); gcal_source_dialog_set_source (GCAL_SOURCE_DIALOG (user_data), source); gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_EDIT); } } static gboolean pulse_web_entry (GcalSourceDialog *dialog) { gtk_entry_progress_pulse (GTK_ENTRY (dialog->calendar_address_entry)); dialog->calendar_address_id = g_timeout_add (ENTRY_PROGRESS_TIMEOUT, (GSourceFunc) pulse_web_entry, dialog); return FALSE; } static void url_entry_text_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { GcalSourceDialog *self; const gchar* text; self = GCAL_SOURCE_DIALOG (user_data); text = gtk_entry_get_text (GTK_ENTRY (self->calendar_address_entry)); if (self->calendar_address_id != 0) { g_source_remove (self->calendar_address_id); self->calendar_address_id = 0; gtk_entry_set_progress_fraction (GTK_ENTRY (self->calendar_address_entry), 0); } if (self->validate_url_resource_id != 0) { g_source_remove (self->validate_url_resource_id); self->validate_url_resource_id = 0; } if (g_utf8_strlen (text, -1) != 0) { /* Remove any previous unreleased resource */ if (self->validate_url_resource_id != 0) g_source_remove (self->validate_url_resource_id); /* * At first, don't bother the user with * the login prompt. Only prompt it when * it fails. */ self->prompt_password = FALSE; self->validate_url_resource_id = g_timeout_add (500, (GSourceFunc) validate_url_cb, user_data); } else { gtk_entry_set_progress_fraction (GTK_ENTRY (self->calendar_address_entry), 0); } } static void online_accounts_settings_button_clicked (GtkWidget *button, gpointer user_data) { spawn_goa_with_args (NULL, NULL); } static void on_file_activated (GSimpleAction *action, GVariant *param, gpointer user_data) { GtkWidget *dialog; GtkFileFilter *filter; gint response; /* Dialog */ dialog = gtk_file_chooser_dialog_new (_("Select a calendar file"), GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (user_data))), GTK_FILE_CHOOSER_ACTION_SAVE, _("Cancel"), GTK_RESPONSE_CANCEL, _("Open"), GTK_RESPONSE_OK, NULL); g_signal_connect (dialog, "file-activated", G_CALLBACK (calendar_file_selected), user_data); /* File filter */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Calendar files")); gtk_file_filter_add_mime_type (filter, "text/calendar"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter); response = gtk_dialog_run (GTK_DIALOG (dialog)); if (response == GTK_RESPONSE_OK) calendar_file_selected (GTK_FILE_CHOOSER (dialog), user_data); gtk_widget_destroy (dialog); } static void on_local_activated (GSimpleAction *action, GVariant *param, gpointer user_data) { GcalSourceDialog *self; ESourceExtension *ext; ESource *source; self = GCAL_SOURCE_DIALOG (user_data); /** * Create the new source and add the needed * extensions. */ source = e_source_new (NULL, NULL, NULL); e_source_set_parent (source, "local-stub"); ext = e_source_get_extension (source, E_SOURCE_EXTENSION_CALENDAR); e_source_backend_set_backend_name (E_SOURCE_BACKEND (ext), "local"); /* update the source properties */ e_source_set_display_name (source, _("Unnamed Calendar")); /* Jump to the edit page */ gcal_source_dialog_set_source (GCAL_SOURCE_DIALOG (user_data), source); gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_CREATE); gtk_widget_set_sensitive (self->add_button, TRUE); } static void on_web_activated (GSimpleAction *action, GVariant *param, gpointer user_data) { gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_CREATE_WEB); } static void calendar_address_activated (GtkEntry *entry, gpointer user_data) { g_assert (GCAL_IS_SOURCE_DIALOG (user_data)); validate_url_cb (GCAL_SOURCE_DIALOG (user_data)); } static gboolean validate_url_cb (GcalSourceDialog *dialog) { ESourceAuthentication *auth; ENamedParameters *credentials; ESourceExtension *ext; ESourceWebdav *webdav; ESource *source; SoupURI *soup_uri; const gchar *uri; gchar *host, *path; gboolean uri_valid, is_file; dialog->validate_url_resource_id = 0; soup_uri = NULL; host = path = NULL; /** * Remove any reminescent ESources * cached before. */ if (dialog->remote_sources != NULL) { g_list_free_full (dialog->remote_sources, g_object_unref); dialog->remote_sources = NULL; } /* Remove previous results */ g_list_free_full (gtk_container_get_children (GTK_CONTAINER (dialog->web_sources_listbox)), (GDestroyNotify) gtk_widget_destroy); gtk_revealer_set_reveal_child (GTK_REVEALER (dialog->web_sources_revealer), FALSE); /* Clear the entry icon */ gtk_entry_set_icon_from_icon_name (GTK_ENTRY (dialog->calendar_address_entry), GTK_ENTRY_ICON_SECONDARY, NULL); /* Get the hostname and file path from the server */ uri = gtk_entry_get_text (GTK_ENTRY (dialog->calendar_address_entry)); uri_valid = uri_get_fields (uri, NULL, &host, &path, &is_file); if (!host || !uri_valid) goto out; g_debug ("Detected host: '%s', path: '%s'", host, path); /** * Create the new source and add the needed * extensions. */ source = e_source_new (NULL, NULL, NULL); e_source_set_parent (source, "webcal-stub"); ext = e_source_get_extension (source, E_SOURCE_EXTENSION_CALENDAR); e_source_backend_set_backend_name (E_SOURCE_BACKEND (ext), "webcal"); /* Authentication */ auth = e_source_get_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION); e_source_authentication_set_host (auth, host); /* Webdav */ soup_uri = soup_uri_new (uri); webdav = e_source_get_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); e_source_webdav_set_soup_uri (webdav, soup_uri); /* * If we're dealing with an absolute file path, * there is no need to check the server for more * sources. */ if (is_file) { /* Set the private source so it saves at closing */ dialog->remote_sources = g_list_append (dialog->remote_sources, source); /* Update buttons */ gtk_widget_set_sensitive (dialog->add_button, source != NULL); goto out; } /* Pulse the entry while it performs the check */ dialog->calendar_address_id = g_timeout_add (ENTRY_PROGRESS_TIMEOUT, (GSourceFunc) pulse_web_entry, dialog); /* * Try to retrieve the sources without prompting * username and password. If we get any error, * then it prompts and retry. */ credentials = e_named_parameters_new (); if (!dialog->prompt_password) { g_debug ("Trying to connect without credentials..."); /* NULL credentials */ e_named_parameters_set (credentials, E_SOURCE_CREDENTIAL_USERNAME, NULL); e_named_parameters_set (credentials, E_SOURCE_CREDENTIAL_PASSWORD, NULL); e_webdav_discover_sources (source, uri, E_WEBDAV_DISCOVER_SUPPORTS_EVENTS, credentials, NULL, discover_sources_cb, dialog); } else { gint response; gchar *user, *password; g_debug ("No credentials failed, retrying with user credentials..."); user = password = NULL; response = prompt_credentials (dialog, &user, &password); /* * User entered username and password, let's try * with it. */ if (response == GTK_RESPONSE_OK) { /* User inputted credentials */ e_named_parameters_set (credentials, E_SOURCE_CREDENTIAL_USERNAME, user); e_named_parameters_set (credentials, E_SOURCE_CREDENTIAL_PASSWORD, password); e_webdav_discover_sources (source, uri, E_WEBDAV_DISCOVER_SUPPORTS_EVENTS, credentials, NULL, discover_sources_cb, dialog); } g_free (user); g_free (password); } e_named_parameters_free (credentials); out: g_clear_pointer (&soup_uri, soup_uri_free); g_free (host); g_free (path); return FALSE; } static void credential_button_clicked (GtkWidget *button, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG(user_data); if (button == self->credentials_cancel_button) gtk_dialog_response (GTK_DIALOG (self->credentials_dialog), GTK_RESPONSE_CANCEL); else gtk_dialog_response (GTK_DIALOG (self->credentials_dialog), GTK_RESPONSE_OK); } static void credential_entry_activate (GtkEntry *entry, gpointer user_data) { gtk_dialog_response (GTK_DIALOG (user_data), GTK_RESPONSE_OK); } static gint prompt_credentials (GcalSourceDialog *dialog, gchar **username, gchar **password) { gint response; /* Cleanup last credentials */ gtk_entry_set_text (GTK_ENTRY (dialog->credentials_password_entry), ""); gtk_entry_set_text (GTK_ENTRY (dialog->credentials_user_entry), ""); gtk_widget_grab_focus (dialog->credentials_user_entry); /* Show the dialog, then destroy it */ response = gtk_dialog_run (GTK_DIALOG (dialog->credentials_dialog)); if (response == GTK_RESPONSE_OK) { if (username != NULL) *username = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->credentials_user_entry))); if (password != NULL) *password = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->credentials_password_entry))); } gtk_widget_hide (dialog->credentials_dialog); return response; } static ESource* duplicate_source (ESource *source) { ESourceExtension *ext; ESource *new_source; g_assert (source && E_IS_SOURCE (source)); new_source = e_source_new (NULL, NULL, NULL); e_source_set_parent (new_source, "local"); ext = e_source_get_extension (new_source, E_SOURCE_EXTENSION_CALENDAR); e_source_backend_set_backend_name (E_SOURCE_BACKEND (ext), "local"); /* Copy Authentication data */ if (e_source_has_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION)) { ESourceAuthentication *new_auth, *parent_auth; parent_auth = e_source_get_extension (source, E_SOURCE_EXTENSION_AUTHENTICATION); new_auth = e_source_get_extension (new_source, E_SOURCE_EXTENSION_AUTHENTICATION); e_source_authentication_set_host (new_auth, e_source_authentication_get_host (parent_auth)); e_source_authentication_set_method (new_auth, e_source_authentication_get_method (parent_auth)); e_source_authentication_set_port (new_auth, e_source_authentication_get_port (parent_auth)); e_source_authentication_set_user (new_auth, e_source_authentication_get_user (parent_auth)); e_source_authentication_set_proxy_uid (new_auth, e_source_authentication_get_proxy_uid (parent_auth)); } /* Copy Webdav data */ if (e_source_has_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND)) { ESourceWebdav *new_webdav, *parent_webdav; parent_webdav = e_source_get_extension (source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); new_webdav = e_source_get_extension (new_source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); e_source_webdav_set_display_name (new_webdav, e_source_webdav_get_display_name (parent_webdav)); e_source_webdav_set_resource_path (new_webdav, e_source_webdav_get_resource_path (parent_webdav)); e_source_webdav_set_resource_query (new_webdav, e_source_webdav_get_resource_query (parent_webdav)); e_source_webdav_set_email_address (new_webdav, e_source_webdav_get_email_address (parent_webdav)); e_source_webdav_set_ssl_trust (new_webdav, e_source_webdav_get_ssl_trust (parent_webdav)); e_source_set_parent (new_source, "webcal-stub"); e_source_backend_set_backend_name (E_SOURCE_BACKEND (ext), "webcal"); } return new_source; } static void check_activated_cb (GtkWidget *check, GParamSpec *spec, gpointer user_data) { GcalSourceDialog *self; GtkWidget *row; ESource *source; g_assert (user_data && GCAL_IS_SOURCE_DIALOG (user_data)); self = GCAL_SOURCE_DIALOG (user_data); row = gtk_widget_get_parent (check); source = g_object_get_data (G_OBJECT (row), "source"); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check))) self->remote_sources = g_list_prepend (self->remote_sources, source); else self->remote_sources = g_list_remove (self->remote_sources, source); gtk_widget_set_sensitive (self->add_button, g_list_length (self->remote_sources) > 0); } static void discover_sources_cb (GObject *source, GAsyncResult *result, gpointer user_data) { GcalSourceDialog *self; GSList *discovered_sources, *user_addresses, *aux; GError *error; self = GCAL_SOURCE_DIALOG (user_data); error = NULL; /* Stop the pulsing entry */ if (self->calendar_address_id != 0) { gtk_entry_set_progress_fraction (GTK_ENTRY (self->calendar_address_entry), 0); g_source_remove (self->calendar_address_id); self->calendar_address_id = 0; } if (!e_webdav_discover_sources_finish (E_SOURCE (source), result, NULL, NULL, &discovered_sources, &user_addresses, &error)) { /* Don't add an source with errors */ gtk_widget_set_sensitive (self->add_button, FALSE); /* * If it's the first try and things went wrong, * retry with the user credentials. Also, it * checks for the error code, since we don't * really want to retry things on unavailable * servers. */ if (!self->prompt_password && (error->code == 14 || error->code == 403 || error->code == 405)) { self->prompt_password = TRUE; validate_url_cb (GCAL_SOURCE_DIALOG (user_data)); } else { g_debug ("[source-dialog] error: %s", error->message); } g_error_free (error); return; } /* Add a success icon to the entry */ gtk_entry_set_icon_from_icon_name (GTK_ENTRY (self->calendar_address_entry), GTK_ENTRY_ICON_SECONDARY, "emblem-ok-symbolic"); /* Remove previous results */ g_list_free_full (gtk_container_get_children (GTK_CONTAINER (self->web_sources_listbox)), (GDestroyNotify) gtk_widget_destroy); /* Show the list of calendars */ gtk_revealer_set_reveal_child (GTK_REVEALER (self->web_sources_revealer), TRUE); gtk_widget_show (self->web_sources_revealer); /* TODO: show a list of calendars */ for (aux = discovered_sources; aux != NULL; aux = aux->next) { EWebDAVDiscoveredSource *discovered_source; gchar *resource_path = NULL; gboolean uri_valid; discovered_source = aux->data; /* Get the new resource path from the uri */ uri_valid = uri_get_fields (discovered_source->href, NULL, NULL, &resource_path, NULL); if (uri_valid) { ESourceSelectable *selectable; ESourceWebdav *webdav; GtkWidget *row, *check; ESource *new_source; /* build up the new source */ new_source = duplicate_source (E_SOURCE (source)); e_source_set_display_name (E_SOURCE (new_source), discovered_source->display_name); webdav = e_source_get_extension (new_source, E_SOURCE_EXTENSION_WEBDAV_BACKEND); e_source_webdav_set_resource_path (webdav, resource_path); e_source_webdav_set_display_name (webdav, discovered_source->display_name); if (user_addresses) e_source_webdav_set_email_address (webdav, user_addresses->data); /* Setup the color */ selectable = e_source_get_extension (new_source, E_SOURCE_EXTENSION_CALENDAR); e_source_selectable_set_color (selectable, discovered_source->color); /* create the new row */ row = gtk_list_box_row_new (); check = gtk_check_button_new (); gtk_button_set_label (GTK_BUTTON (check), discovered_source->display_name); g_signal_connect (check, "notify::active", G_CALLBACK (check_activated_cb), user_data); gtk_container_add (GTK_CONTAINER (row), check); gtk_container_add (GTK_CONTAINER (self->web_sources_listbox), row); g_object_set_data (G_OBJECT (row), "parent-source", source); g_object_set_data (G_OBJECT (row), "source", new_source); gtk_widget_show_all (row); } g_free (resource_path); } /* Free things up */ e_webdav_discover_free_discovered_sources (discovered_sources); g_slist_free_full (user_addresses, g_free); } /** * remove_source: * * Removes the given source from the source * list. * * Returns: */ static void remove_source (GcalManager *manager, ESource *source, gpointer user_data) { GcalSourceDialog *self; GList *children, *aux; self = GCAL_SOURCE_DIALOG (user_data); children = gtk_container_get_children (GTK_CONTAINER (self->calendars_listbox)); for (aux = children; aux != NULL; aux = aux->next) { ESource *child_source = g_object_get_data (G_OBJECT (aux->data), "source"); if (child_source != NULL && child_source == source) { gtk_widget_destroy (aux->data); break; } } g_list_free (children); } /** * notification_child_revealed_changed: * * Remove the source after the notification * is hidden. * * Returns: */ static void notification_child_revealed_changed (GtkWidget *notification, GParamSpec *spec, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); if (gtk_revealer_get_child_revealed (GTK_REVEALER (notification))) return; /* If we have any removed source, delete it */ if (self->removed_source != NULL) { GError *error = NULL; /* We don't really want to remove non-removable sources */ if (!e_source_get_removable (self->removed_source)) return; /* Enable the source again to remove it's name from disabled list */ gcal_manager_enable_source (self->manager, self->removed_source); e_source_remove_sync (self->removed_source, NULL, &error); /** * If something goes wrong, throw * an alert and add the source back. */ if (error != NULL) { g_warning ("[source-dialog] Error removing source: %s", error->message); add_source (self->manager, self->removed_source, is_source_enabled (self->removed_source), user_data); gcal_manager_enable_source (self->manager, self->removed_source); g_error_free (error); } } } /** * undo_remove_action: * * Readd the removed source. * * Returns: */ static void undo_remove_action (GtkButton *button, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); /* if there's any set source, unremove it */ if (self->removed_source != NULL) { /* Enable the source before adding it again */ gcal_manager_enable_source (self->manager, self->removed_source); add_source (self->manager, self->removed_source, is_source_enabled (self->removed_source), user_data); /* * Don't clear the pointer, since we don't * want to erase the source at all. */ self->removed_source = NULL; /* Hide notification */ gtk_revealer_set_reveal_child (GTK_REVEALER (self->notification), FALSE); } } /** * hide_notification: * * Helper function that hides the * notification, causing the removal * of the source (when valid). * * Returns: */ static void hide_notification (GcalSourceDialog *dialog, GtkWidget *button) { gtk_revealer_set_reveal_child (GTK_REVEALER (dialog->notification), FALSE); dialog->notification_timeout_id = 0; } /** * hide_notification_scheduled: * * Limit the ammount of time that * the notification is shown. * * Returns: %FALSE */ static gboolean hide_notification_scheduled (gpointer dialog) { hide_notification (GCAL_SOURCE_DIALOG (dialog), NULL); return FALSE; } /** * remove_button_clicked: * * Trigger the source removal * logic. * * Returns: */ static void remove_button_clicked (GtkWidget *button, gpointer user_data) { GcalSourceDialog *self = GCAL_SOURCE_DIALOG (user_data); if (self->source != NULL) { GList *children, *l; gchar *str; self->removed_source = self->source; self->source = NULL; children = gtk_container_get_children (GTK_CONTAINER (self->calendars_listbox)); gtk_revealer_set_reveal_child (GTK_REVEALER (self->notification), TRUE); /* Remove the listbox entry (if any) */ for (l = children; l != NULL; l = l->next) { if (g_object_get_data (l->data, "source") == self->removed_source) { gtk_widget_destroy (l->data); break; } } /* Update notification label */ str = g_markup_printf_escaped (_("Calendar %s removed"), e_source_get_display_name (self->removed_source)); gtk_label_set_markup (GTK_LABEL (self->notification_label), str); /* Remove old notifications */ if (self->notification_timeout_id != 0) g_source_remove (self->notification_timeout_id); self->notification_timeout_id = g_timeout_add_seconds (5, hide_notification_scheduled, user_data); /* Disable the source, so it gets hidden */ gcal_manager_disable_source (self->manager, self->removed_source); g_list_free (children); g_free (str); } gcal_source_dialog_set_mode (GCAL_SOURCE_DIALOG (user_data), GCAL_SOURCE_DIALOG_MODE_NORMAL); } /* * Callbacks */ static GcalAccountType get_account_type (GoaAccount *account) { g_return_val_if_fail (GOA_IS_ACCOUNT (account), GCAL_ACCOUNT_TYPE_NOT_SUPPORTED); if (g_strcmp0 (goa_account_get_provider_type (account), "exchange") == 0) return GCAL_ACCOUNT_TYPE_EXCHANGE; if (g_strcmp0 (goa_account_get_provider_type (account), "google") == 0) return GCAL_ACCOUNT_TYPE_GOOGLE; if (g_strcmp0 (goa_account_get_provider_type (account), "owncloud") == 0) return GCAL_ACCOUNT_TYPE_OWNCLOUD; return GCAL_ACCOUNT_TYPE_NOT_SUPPORTED; } static void account_calendar_disable_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { GoaAccount *account = GOA_ACCOUNT (object); g_return_if_fail (GTK_IS_LABEL (user_data)); gtk_label_set_label (GTK_LABEL (user_data), goa_account_get_calendar_disabled (account) ? _("Off") : _("On")); } static void add_goa_account (GcalSourceDialog *dialog, GoaAccount *account) { GcalAccountType type; GtkBuilder *builder; GtkWidget *provider_label; GtkWidget *account_label; GtkWidget *enabled_label; GtkWidget *row; GtkWidget *icon; const gchar *icon_name; type = get_account_type (account); if (type == GCAL_ACCOUNT_TYPE_NOT_SUPPORTED) return; builder = gtk_builder_new_from_resource ("/org/gnome/calendar/online-account-row.ui"); row = GTK_WIDGET (gtk_builder_get_object (builder, "row")); icon = GTK_WIDGET (gtk_builder_get_object (builder, "icon")); provider_label = GTK_WIDGET (gtk_builder_get_object (builder, "account_provider_label")); account_label = GTK_WIDGET (gtk_builder_get_object (builder, "account_name_label")); enabled_label = GTK_WIDGET (gtk_builder_get_object (builder, "on_off_label")); switch (type) { case GCAL_ACCOUNT_TYPE_EXCHANGE: icon_name = "goa"; gtk_widget_hide (dialog->exchange_stub_row); break; case GCAL_ACCOUNT_TYPE_GOOGLE: icon_name = "goa-account-google"; gtk_widget_hide (dialog->google_stub_row); break; case GCAL_ACCOUNT_TYPE_OWNCLOUD: icon_name = "goa-account-owncloud"; gtk_widget_hide (dialog->owncloud_stub_row); break; case GCAL_ACCOUNT_TYPE_NOT_SUPPORTED: default: icon_name = "goa"; g_assert_not_reached (); } /* update fields */ gtk_label_set_label (GTK_LABEL (provider_label), goa_account_get_provider_name (account)); gtk_label_set_label (GTK_LABEL (account_label), goa_account_get_identity (account)); gtk_label_set_label (GTK_LABEL (enabled_label), goa_account_get_attention_needed (account) ? _("Expired") : goa_account_get_calendar_disabled (account) ? _("Off") : _("On")); gtk_image_set_from_icon_name (GTK_IMAGE (icon), icon_name, GTK_ICON_SIZE_DIALOG); gtk_image_set_pixel_size (GTK_IMAGE (icon), 32); g_object_set_data (G_OBJECT (row), "goa-account", account); g_signal_connect (account, "notify::calendar-disabled", G_CALLBACK (account_calendar_disable_changed), enabled_label); gtk_list_box_insert (GTK_LIST_BOX (dialog->online_accounts_listbox), row, 0); g_object_unref (builder); } static void goa_account_added_cb (GoaClient *client, GoaObject *object, gpointer user_data) { add_goa_account (GCAL_SOURCE_DIALOG (user_data), goa_object_get_account (object)); } static void goa_account_removed_cb (GoaClient *client, GoaObject *object, gpointer user_data) { GcalSourceDialog *self; GoaAccount *account; GcalAccountType type; GList *children, *l; gint counter = 1; self = GCAL_SOURCE_DIALOG (user_data); account = goa_object_get_account (object); type = get_account_type (account); if (type == GCAL_ACCOUNT_TYPE_NOT_SUPPORTED) return; children = gtk_container_get_children (GTK_CONTAINER (self->online_accounts_listbox)); for (l = children; l != NULL; l = l->next) { GoaAccount *row_account; GcalAccountType row_type; row_account = g_object_get_data (l->data, "goa-account"); row_type = row_account ? get_account_type (row_account) : GCAL_ACCOUNT_TYPE_NOT_SUPPORTED; if (row_account == account) { gtk_widget_destroy (l->data); counter--; } else if (type == row_type) { counter++; } } /* * If there's any other account with the same type, * it should show back the stub row of the given type. */ if (counter == 0) { switch (type) { case GCAL_ACCOUNT_TYPE_EXCHANGE: gtk_widget_show (self->exchange_stub_row); break; case GCAL_ACCOUNT_TYPE_GOOGLE: gtk_widget_show (self->google_stub_row); break; case GCAL_ACCOUNT_TYPE_OWNCLOUD: gtk_widget_show (self->owncloud_stub_row); break; case GCAL_ACCOUNT_TYPE_NOT_SUPPORTED: default: g_assert_not_reached (); } } g_list_free (children); } static void loading_changed_cb (GcalSourceDialog *dialog) { GoaClient *client; GList *accounts, *l; GCAL_ENTRY; g_return_if_fail (GCAL_IS_SOURCE_DIALOG (dialog)); if (gcal_manager_get_loading (dialog->manager)) { GCAL_TRACE_MSG ("Not loaded yet"); GCAL_EXIT; return; } /* Add already fetched accounts */ client = gcal_manager_get_goa_client (dialog->manager); accounts = goa_client_get_accounts (client); for (l = accounts; l != NULL; l = l->next) add_goa_account (dialog, goa_object_get_account (l->data)); /* Be ready to other accounts */ g_signal_connect (client, "account-added", G_CALLBACK (goa_account_added_cb), dialog); g_signal_connect (client, "account-removed", G_CALLBACK (goa_account_removed_cb), dialog); /* Once we loaded, no need to track it down again */ g_signal_handlers_disconnect_by_func (dialog->manager, loading_changed_cb, dialog); g_list_free (accounts); GCAL_EXIT; } static void gcal_source_dialog_constructed (GObject *object) { GcalSourceDialog *self; GtkBuilder *builder; GMenuModel *menu; self = GCAL_SOURCE_DIALOG (object); G_OBJECT_CLASS (gcal_source_dialog_parent_class)->constructed (object); /* widget responses */ gtk_dialog_set_default_response (GTK_DIALOG (object), GTK_RESPONSE_CANCEL); g_object_set_data (G_OBJECT (self->remove_button), "response", GINT_TO_POINTER (GCAL_RESPONSE_REMOVE_SOURCE)); /* Setup listbox header functions */ gtk_list_box_set_header_func (GTK_LIST_BOX (self->calendars_listbox), display_header_func, NULL, NULL); gtk_list_box_set_sort_func (GTK_LIST_BOX (self->calendars_listbox), (GtkListBoxSortFunc) calendar_listbox_sort_func, object, NULL); gtk_list_box_set_header_func (GTK_LIST_BOX (self->online_accounts_listbox), display_header_func, NULL, NULL); gtk_list_box_set_sort_func (GTK_LIST_BOX (self->online_accounts_listbox), (GtkListBoxSortFunc) online_accounts_listbox_sort_func, object, NULL); /* Action group */ self->action_group = g_simple_action_group_new (); gtk_widget_insert_action_group (GTK_WIDGET (object), "source", G_ACTION_GROUP (self->action_group)); g_action_map_add_action_entries (G_ACTION_MAP (self->action_group), actions, G_N_ELEMENTS (actions), object); /* Load the "Add" button menu */ builder = gtk_builder_new_from_resource ("/org/gnome/calendar/gtk/menus.ui"); menu = G_MENU_MODEL (gtk_builder_get_object (builder, "add-source-menu")); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->add_calendar_menu_button), menu); g_object_unref (builder); /* setup titlebar */ gtk_window_set_titlebar (GTK_WINDOW (object), self->headerbar); } static void gcal_source_dialog_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GcalSourceDialog *self = (GcalSourceDialog *) object; switch (prop_id) { case PROP_MANAGER: g_value_set_object (value, self->manager); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void gcal_source_dialog_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GcalSourceDialog *self = (GcalSourceDialog *) object; switch (prop_id) { case PROP_MANAGER: self->manager = g_value_dup_object (value); if (!gcal_manager_get_loading (self->manager)) { GList *sources, *l; sources = gcal_manager_get_sources_connected (self->manager); for (l = sources; l != NULL; l = l->next) add_source (self->manager, l->data, is_source_enabled (l->data), self); } else { g_signal_connect_swapped (self->manager, "notify::loading", G_CALLBACK (loading_changed_cb), self); } g_signal_connect (self->manager, "source-added", G_CALLBACK (add_source), self); g_signal_connect (self->manager, "source-removed", G_CALLBACK (remove_source), self); g_object_notify_by_pspec (object, properties[PROP_MANAGER]); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } } static void gcal_source_dialog_class_init (GcalSourceDialogClass *klass) { GObjectClass *object_class; GtkWidgetClass *widget_class; /** * Since we cannot guarantee that the * type system registered ESourceLocal, * it must be ensured at least here. */ g_type_ensure (E_TYPE_SOURCE_LOCAL); object_class = G_OBJECT_CLASS (klass); object_class->constructed = gcal_source_dialog_constructed; object_class->get_property = gcal_source_dialog_get_property; object_class->set_property = gcal_source_dialog_set_property; properties[PROP_MANAGER] = g_param_spec_object ("manager", "Manager", "The manager object of the application", GCAL_TYPE_MANAGER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (object_class, N_PROPS, properties); widget_class = GTK_WIDGET_CLASS (klass); /* bind things for/from the template class */ gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/org/gnome/calendar/source-dialog.ui"); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, account_box); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, account_label); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, add_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, add_calendar_menu_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, back_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, calendar_address_entry); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, calendar_color_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, calendar_url_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, calendar_visible_check); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, calendars_listbox); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, cancel_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, credentials_cancel_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, credentials_connect_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, credentials_dialog); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, credentials_password_entry); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, credentials_user_entry); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, default_check); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, edit_grid); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, exchange_stub_row); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, google_stub_row); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, headerbar); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, location_dim_label); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, main_scrolledwindow); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, name_entry); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, notification); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, notification_label); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, online_accounts_listbox); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, owncloud_stub_row); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, remove_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, settings_button); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, stack); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, web_source_grid); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, web_sources_listbox); gtk_widget_class_bind_template_child (widget_class, GcalSourceDialog, web_sources_revealer); gtk_widget_class_bind_template_callback (widget_class, add_button_clicked); gtk_widget_class_bind_template_callback (widget_class, action_widget_activated); gtk_widget_class_bind_template_callback (widget_class, back_button_clicked); gtk_widget_class_bind_template_callback (widget_class, calendar_address_activated); gtk_widget_class_bind_template_callback (widget_class, calendar_file_selected); gtk_widget_class_bind_template_callback (widget_class, calendar_listbox_row_activated); gtk_widget_class_bind_template_callback (widget_class, calendar_visible_check_toggled); gtk_widget_class_bind_template_callback (widget_class, cancel_button_clicked); gtk_widget_class_bind_template_callback (widget_class, credential_button_clicked); gtk_widget_class_bind_template_callback (widget_class, credential_entry_activate); gtk_widget_class_bind_template_callback (widget_class, color_set); gtk_widget_class_bind_template_callback (widget_class, default_check_toggled); gtk_widget_class_bind_template_callback (widget_class, description_label_link_activated); gtk_widget_class_bind_template_callback (widget_class, hide_notification); gtk_widget_class_bind_template_callback (widget_class, name_entry_text_changed); gtk_widget_class_bind_template_callback (widget_class, notification_child_revealed_changed); gtk_widget_class_bind_template_callback (widget_class, online_accounts_listbox_row_activated); gtk_widget_class_bind_template_callback (widget_class, online_accounts_settings_button_clicked); gtk_widget_class_bind_template_callback (widget_class, remove_button_clicked); gtk_widget_class_bind_template_callback (widget_class, response_signal); gtk_widget_class_bind_template_callback (widget_class, settings_button_clicked); gtk_widget_class_bind_template_callback (widget_class, stack_visible_child_name_changed); gtk_widget_class_bind_template_callback (widget_class, undo_remove_action); gtk_widget_class_bind_template_callback (widget_class, url_entry_text_changed); } static void gcal_source_dialog_init (GcalSourceDialog *self) { gtk_widget_init_template (GTK_WIDGET (self)); } static gint online_accounts_listbox_sort_func (GtkListBoxRow *row1, GtkListBoxRow *row2, gpointer user_data) { GcalAccountType t1, t2; GoaAccount *a1 = g_object_get_data (G_OBJECT (row1), "goa-account"); GoaAccount *a2 = g_object_get_data (G_OBJECT (row2), "goa-account"); if (!a1 || !a2) return a1 ? -1 : (a2 ? 1 : 0); t1 = get_account_type (a1); t2 = get_account_type (a2); if (t1 != t2) return t1 - t2; return g_strcmp0 (goa_account_get_identity (a1), goa_account_get_identity (a2)); } /** * gcal_source_dialog_set_mode: * @dialog: a #GcalSourceDialog * @mode: a #GcalSourceDialogMode * * Set the source dialog mode. Creation mode means that a new * calendar will be created, while edit mode means a calendar * will be edited. */ void gcal_source_dialog_set_mode (GcalSourceDialog *dialog, GcalSourceDialogMode mode) { GcalSourceDialogMode previous_mode = dialog->mode; dialog->mode = mode; /* Cleanup old data */ clear_pages (dialog); switch (mode) { case GCAL_SOURCE_DIALOG_MODE_CREATE: gtk_header_bar_set_title (GTK_HEADER_BAR (dialog->headerbar), _("Add Calendar")); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (dialog->headerbar), NULL); gtk_stack_set_visible_child (GTK_STACK (dialog->stack), dialog->edit_grid); break; case GCAL_SOURCE_DIALOG_MODE_CREATE_WEB: gtk_header_bar_set_title (GTK_HEADER_BAR (dialog->headerbar), _("Add Calendar")); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (dialog->headerbar), NULL); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (dialog->headerbar), FALSE); gtk_stack_set_visible_child (GTK_STACK (dialog->stack), dialog->web_source_grid); gtk_widget_set_visible (dialog->add_button, TRUE); gtk_widget_set_visible (dialog->cancel_button, TRUE); break; case GCAL_SOURCE_DIALOG_MODE_EDIT: /* Bind title */ if (dialog->title_bind == NULL) { dialog->title_bind = g_object_bind_property (dialog->name_entry, "text", dialog->headerbar, "title", G_BINDING_DEFAULT); } gtk_stack_set_visible_child (GTK_STACK (dialog->stack), dialog->edit_grid); break; case GCAL_SOURCE_DIALOG_MODE_NORMAL: /* Free any bindings left behind */ g_clear_pointer (&dialog->title_bind, g_binding_unbind); gtk_header_bar_set_title (GTK_HEADER_BAR (dialog->headerbar), _("Calendar Settings")); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (dialog->headerbar), NULL); gtk_stack_set_visible_child (GTK_STACK (dialog->stack), dialog->main_scrolledwindow); break; default: g_assert_not_reached (); } if (previous_mode == mode) stack_visible_child_name_changed (G_OBJECT (dialog->stack), NULL, dialog); } /** * gcal_source_dialog_set_source: * @dialog: a #GcalSourceDialog * @source: an #ESource * * Sets the source to be edited by the user. */ void gcal_source_dialog_set_source (GcalSourceDialog *dialog, ESource *source) { g_return_if_fail (source && E_IS_SOURCE (source)); g_set_object (&dialog->source, source); }