/* * Copyright (C) 2013 Intel, Inc * * 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Author: Thomas Wood * */ #include "cc-sharing-panel.h" #include "cc-hostname-entry.h" #include "cc-list-row.h" #include "cc-sharing-resources.h" #include "cc-remote-login.h" #include "file-share-properties.h" #include "cc-media-sharing.h" #include "cc-sharing-networks.h" #include "cc-gnome-remote-desktop.h" #include "cc-tls-certificate.h" #include "cc-systemd-service.h" #include "org.gnome.SettingsDaemon.Sharing.h" #ifdef GDK_WINDOWING_WAYLAND #include #endif #include #define GCR_API_SUBJECT_TO_CHANGE #include #include #include #include #include static void cc_sharing_panel_setup_label_with_hostname (CcSharingPanel *self, GtkWidget *label); static GtkWidget *cc_sharing_panel_new_media_sharing_row (const char *uri_or_path, CcSharingPanel *self); #define FILE_SHARING_SCHEMA_ID "org.gnome.desktop.file-sharing" #define GNOME_REMOTE_DESKTOP_SCHEMA_ID "org.gnome.desktop.remote-desktop" #define GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID "org.gnome.desktop.remote-desktop.rdp" #define REMOTE_DESKTOP_STORE_CREDENTIALS_TIMEOUT_S 1 #define REMOTE_DESKTOP_SERVICE "gnome-remote-desktop.service" struct _CcSharingPanel { CcPanel parent_instance; GtkWidget *hostname_entry; GtkWidget *main_list_box; GtkWidget *master_switch; GtkWidget *media_sharing_dialog; GtkWidget *media_sharing_headerbar; GtkWidget *media_sharing_row; GtkWidget *media_sharing_switch; GtkWidget *personal_file_sharing_dialog; GtkWidget *personal_file_sharing_grid; GtkWidget *personal_file_sharing_headerbar; GtkWidget *personal_file_sharing_label; GtkWidget *personal_file_sharing_password_entry; GtkWidget *personal_file_sharing_password_label; GtkWidget *personal_file_sharing_require_password_switch; GtkWidget *personal_file_sharing_row; GtkWidget *personal_file_sharing_switch; GtkWidget *remote_login_dialog; GtkWidget *remote_login_label; GtkWidget *remote_login_row; GtkWidget *remote_login_switch; GtkWidget *remote_control_switch; GtkWidget *remote_control_checkbutton; GtkWidget *remote_desktop_toast_overlay; GtkWidget *remote_desktop_password_entry; GtkWidget *remote_desktop_password_copy; GtkWidget *remote_desktop_username_entry; GtkWidget *remote_desktop_username_copy; GtkWidget *remote_desktop_dialog; GtkWidget *remote_desktop_device_name_label; GtkWidget *remote_desktop_device_name_copy; GtkWidget *remote_desktop_address_label; GtkWidget *remote_desktop_address_copy; GtkWidget *remote_desktop_row; GtkWidget *remote_desktop_switch; GtkWidget *remote_desktop_verify_encryption; GtkWidget *remote_desktop_fingerprint_dialog; GtkWidget *remote_desktop_fingerprint_left; GtkWidget *remote_desktop_fingerprint_right; GtkWidget *shared_folders_grid; GtkWidget *shared_folders_listbox; GDBusProxy *sharing_proxy; guint remote_desktop_name_watch; guint remote_desktop_store_credentials_id; GTlsCertificate *remote_desktop_certificate; }; CC_PANEL_REGISTER (CcSharingPanel, cc_sharing_panel) #define OFF_IF_VISIBLE(x, y) { if (gtk_widget_is_visible(x) && (y) != NULL && gtk_widget_is_sensitive(y)) gtk_switch_set_active (GTK_SWITCH(y), FALSE); } static gboolean store_remote_desktop_credentials_timeout (gpointer user_data); static void cc_sharing_panel_master_switch_notify (CcSharingPanel *self) { gboolean active; active = gtk_switch_get_active (GTK_SWITCH (self->master_switch)); if (!active) { /* disable all services if the master switch is not active */ OFF_IF_VISIBLE(self->media_sharing_row, self->media_sharing_switch); OFF_IF_VISIBLE(self->personal_file_sharing_row, self->personal_file_sharing_switch); OFF_IF_VISIBLE(self->remote_desktop_row, self->remote_desktop_switch); gtk_switch_set_active (GTK_SWITCH (self->remote_login_switch), FALSE); } gtk_widget_set_sensitive (self->main_list_box, active); } static void cc_sharing_panel_dispose (GObject *object) { CcSharingPanel *self = CC_SHARING_PANEL (object); if (self->remote_desktop_name_watch) g_bus_unwatch_name (self->remote_desktop_name_watch); self->remote_desktop_name_watch = 0; if (self->media_sharing_dialog) { gtk_window_destroy (GTK_WINDOW (self->media_sharing_dialog)); self->media_sharing_dialog = NULL; } if (self->personal_file_sharing_dialog) { gtk_window_destroy (GTK_WINDOW (self->personal_file_sharing_dialog)); self->personal_file_sharing_dialog = NULL; } if (self->remote_login_dialog) { gtk_window_destroy (GTK_WINDOW (self->remote_login_dialog)); self->remote_login_dialog = NULL; } if (self->remote_desktop_dialog) { gtk_window_destroy (GTK_WINDOW (self->remote_desktop_dialog)); self->remote_desktop_dialog = NULL; } g_clear_object (&self->sharing_proxy); if (self->remote_desktop_store_credentials_id) { g_clear_handle_id (&self->remote_desktop_store_credentials_id, g_source_remove); store_remote_desktop_credentials_timeout (self); } G_OBJECT_CLASS (cc_sharing_panel_parent_class)->dispose (object); } static const char * cc_sharing_panel_get_help_uri (CcPanel *panel) { return "help:gnome-help/prefs-sharing"; } static void remote_desktop_show_encryption_fingerprint (CcSharingPanel *self) { g_autoptr(GByteArray) der = NULL; g_autoptr(GcrCertificate) gcr_cert = NULL; g_autofree char *fingerprint = NULL; g_auto(GStrv) fingerprintv = NULL; g_autofree char *left_string = NULL; g_autofree char *right_string = NULL; g_return_if_fail (self->remote_desktop_certificate); g_object_get (self->remote_desktop_certificate, "certificate", &der, NULL); gcr_cert = gcr_simple_certificate_new (der->data, der->len); if (!gcr_cert) { g_warning ("Failed to load GCR TLS certificate representation"); return; } fingerprint = gcr_certificate_get_fingerprint_hex (gcr_cert, G_CHECKSUM_SHA256); fingerprintv = g_strsplit (fingerprint, " ", -1); g_return_if_fail (g_strv_length (fingerprintv) == 32); left_string = g_strdup_printf ( "%s:%s:%s:%s\n" "%s:%s:%s:%s\n" "%s:%s:%s:%s\n" "%s:%s:%s:%s\n", fingerprintv[0], fingerprintv[1], fingerprintv[2], fingerprintv[3], fingerprintv[8], fingerprintv[9], fingerprintv[10], fingerprintv[11], fingerprintv[16], fingerprintv[17], fingerprintv[18], fingerprintv[19], fingerprintv[24], fingerprintv[25], fingerprintv[26], fingerprintv[27]); right_string = g_strdup_printf ( "%s:%s:%s:%s\n" "%s:%s:%s:%s\n" "%s:%s:%s:%s\n" "%s:%s:%s:%s\n", fingerprintv[4], fingerprintv[5], fingerprintv[6], fingerprintv[7], fingerprintv[12], fingerprintv[13], fingerprintv[14], fingerprintv[15], fingerprintv[20], fingerprintv[21], fingerprintv[22], fingerprintv[23], fingerprintv[28], fingerprintv[29], fingerprintv[30], fingerprintv[31]); gtk_label_set_label (GTK_LABEL (self->remote_desktop_fingerprint_left), left_string); gtk_label_set_label (GTK_LABEL (self->remote_desktop_fingerprint_right), right_string); gtk_window_set_transient_for (GTK_WINDOW (self->remote_desktop_fingerprint_dialog), GTK_WINDOW (self->remote_desktop_dialog)); gtk_window_present (GTK_WINDOW (self->remote_desktop_fingerprint_dialog)); } static void cc_sharing_panel_class_init (CcSharingPanelClass *klass) { GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); GObjectClass *object_class = G_OBJECT_CLASS (klass); CcPanelClass *panel_class = CC_PANEL_CLASS (klass); object_class->dispose = cc_sharing_panel_dispose; panel_class->get_help_uri = cc_sharing_panel_get_help_uri; gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/sharing/cc-sharing-panel.ui"); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, hostname_entry); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, shared_folders_grid); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, master_switch); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, main_list_box); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, media_sharing_dialog); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, media_sharing_headerbar); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, media_sharing_row); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_dialog); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_grid); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_headerbar); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_label); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_password_entry); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_password_label); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_require_password_switch); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, personal_file_sharing_row); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_dialog); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_label); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_row); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_login_switch); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_dialog); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_toast_overlay); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_switch); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_control_switch); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_username_entry); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_username_copy); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_password_entry); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_password_copy); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_device_name_label); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_device_name_copy); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_address_label); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_address_copy); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_verify_encryption); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_fingerprint_dialog); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_row); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_fingerprint_left); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, remote_desktop_fingerprint_right); gtk_widget_class_bind_template_child (widget_class, CcSharingPanel, shared_folders_listbox); gtk_widget_class_bind_template_callback (widget_class, remote_desktop_show_encryption_fingerprint); g_type_ensure (CC_TYPE_LIST_ROW); g_type_ensure (CC_TYPE_HOSTNAME_ENTRY); } static void cc_sharing_panel_run_dialog (CcSharingPanel *self, GtkWidget *dialog) { GtkWidget *parent; /* ensure labels with the hostname are updated if the hostname has changed */ cc_sharing_panel_setup_label_with_hostname (self, self->remote_desktop_address_label); cc_sharing_panel_setup_label_with_hostname (self, self->remote_login_label); cc_sharing_panel_setup_label_with_hostname (self, self->personal_file_sharing_label); parent = cc_shell_get_toplevel (cc_panel_get_shell (CC_PANEL (self))); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent)); gtk_window_present (GTK_WINDOW (dialog)); } static void cc_sharing_panel_main_list_box_row_activated (CcSharingPanel *self, GtkListBoxRow *row) { GtkWidget *dialog; if (row == GTK_LIST_BOX_ROW (self->media_sharing_row)) dialog = self->media_sharing_dialog; else if (row == GTK_LIST_BOX_ROW (self->personal_file_sharing_row)) dialog = self->personal_file_sharing_dialog; else if (row == GTK_LIST_BOX_ROW (self->remote_login_row)) dialog = self->remote_login_dialog; else if (row == GTK_LIST_BOX_ROW (self->remote_desktop_row)) dialog = self->remote_desktop_dialog; else return; gtk_list_box_select_row (GTK_LIST_BOX (self->main_list_box), NULL); cc_sharing_panel_run_dialog (self, dialog); } static gboolean cc_sharing_panel_switch_to_label_transform_func (GBinding *binding, const GValue *source_value, GValue *target_value, CcSharingPanel *self) { gboolean active; if (!G_VALUE_HOLDS_BOOLEAN (source_value)) return FALSE; if (!G_VALUE_HOLDS_STRING (target_value)) return FALSE; active = g_value_get_boolean (source_value); if (active) g_value_set_string (target_value, C_("service is enabled", "On")); else g_value_set_string (target_value, C_("service is disabled", "Off")); /* ensure the master switch is active if one of the services is active */ if (active) gtk_switch_set_active (GTK_SWITCH (self->master_switch), TRUE); return TRUE; } static gboolean cc_sharing_panel_networks_to_label_transform_func (GBinding *binding, const GValue *source_value, GValue *target_value, CcSharingPanel *self) { CcSharingStatus status; if (!G_VALUE_HOLDS_UINT (source_value)) return FALSE; if (!G_VALUE_HOLDS_STRING (target_value)) return FALSE; status = g_value_get_uint (source_value); switch (status) { case CC_SHARING_STATUS_OFF: g_value_set_string (target_value, C_("service is disabled", "Off")); break; case CC_SHARING_STATUS_ENABLED: g_value_set_string (target_value, C_("service is enabled", "Enabled")); break; case CC_SHARING_STATUS_ACTIVE: g_value_set_string (target_value, C_("service is active", "Active")); break; default: return FALSE; } /* ensure the master switch is active if one of the services is active */ if (status != CC_SHARING_STATUS_OFF) gtk_switch_set_active (GTK_SWITCH (self->master_switch), TRUE); return TRUE; } static void cc_sharing_panel_bind_switch_to_label (CcSharingPanel *self, GtkWidget *gtkswitch, GtkWidget *row) { g_object_bind_property_full (gtkswitch, "active", row, "secondary-label", G_BINDING_SYNC_CREATE, (GBindingTransformFunc) cc_sharing_panel_switch_to_label_transform_func, NULL, self, NULL); } static void cc_sharing_panel_bind_networks_to_label (CcSharingPanel *self, GtkWidget *networks, GtkWidget *list_row) { g_object_bind_property_full (networks, "status", list_row, "secondary-label", G_BINDING_SYNC_CREATE, (GBindingTransformFunc) cc_sharing_panel_networks_to_label_transform_func, NULL, self, NULL); } static void cc_sharing_panel_bind_switch_to_widgets (GtkWidget *gtkswitch, GtkWidget *first_widget, ...) { va_list w; GtkWidget *widget; va_start (w, first_widget); g_object_bind_property (gtkswitch, "active", first_widget, "sensitive", G_BINDING_SYNC_CREATE); while ((widget = va_arg (w, GtkWidget*))) { g_object_bind_property (gtkswitch, "active", widget, "sensitive", G_BINDING_SYNC_CREATE); } va_end (w); } static void on_add_folder_dialog_response_cb (GtkDialog *dialog, gint response, CcSharingPanel *self) { g_autofree gchar *folder = NULL; g_autoptr(GFile) file = NULL; GtkWidget *child; gboolean matching = FALSE; gint n_rows = 0; if (response != GTK_RESPONSE_ACCEPT) goto bail; file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog)); folder = g_file_get_uri (file); if (!folder || g_str_equal (folder, "")) goto bail; g_debug ("Trying to add %s", folder); for (child = gtk_widget_get_first_child (self->shared_folders_listbox); child; child = gtk_widget_get_next_sibling (child)) { const char *string; string = g_object_get_data (G_OBJECT (child), "path"); matching = (g_strcmp0 (string, folder) == 0); if (matching) { g_debug ("Found a duplicate for %s", folder); break; } n_rows++; } if (!matching) { GtkWidget *row = cc_sharing_panel_new_media_sharing_row (folder, self); gtk_list_box_insert (GTK_LIST_BOX (self->shared_folders_listbox), row, n_rows - 1); } bail: gtk_window_destroy (GTK_WINDOW (dialog)); } static void cc_sharing_panel_add_folder (CcSharingPanel *self, GtkListBoxRow *row) { GtkWidget *dialog; if (!GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "is-add"))) return; dialog = gtk_file_chooser_dialog_new (_("Choose a Folder"), GTK_WINDOW (self->media_sharing_dialog), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); g_signal_connect_object (dialog, "response", G_CALLBACK (on_add_folder_dialog_response_cb), self, 0); gtk_window_present (GTK_WINDOW (dialog)); } static void cc_sharing_panel_remove_folder (CcSharingPanel *self, GtkButton *button) { GtkWidget *row; row = g_object_get_data (G_OBJECT (button), "row"); gtk_list_box_remove (GTK_LIST_BOX (self->shared_folders_listbox), row); } static void cc_sharing_panel_media_sharing_dialog_response (CcSharingPanel *self, gint reponse_id) { g_autoptr(GPtrArray) folders = NULL; GtkWidget *child; folders = g_ptr_array_new_with_free_func (g_free); for (child = gtk_widget_get_first_child (self->shared_folders_listbox); child; child = gtk_widget_get_next_sibling (child)) { const char *folder; folder = g_object_get_data (G_OBJECT (child), "path"); if (folder == NULL) continue; g_ptr_array_add (folders, g_strdup (folder)); } g_ptr_array_add (folders, NULL); cc_media_sharing_set_preferences ((gchar **) folders->pdata); } #define ICON_NAME_FOLDER "folder-symbolic" #define ICON_NAME_FOLDER_DESKTOP "user-desktop-symbolic" #define ICON_NAME_FOLDER_DOCUMENTS "folder-documents-symbolic" #define ICON_NAME_FOLDER_DOWNLOAD "folder-download-symbolic" #define ICON_NAME_FOLDER_MUSIC "folder-music-symbolic" #define ICON_NAME_FOLDER_PICTURES "folder-pictures-symbolic" #define ICON_NAME_FOLDER_PUBLIC_SHARE "folder-publicshare-symbolic" #define ICON_NAME_FOLDER_TEMPLATES "folder-templates-symbolic" #define ICON_NAME_FOLDER_VIDEOS "folder-videos-symbolic" #define ICON_NAME_FOLDER_SAVED_SEARCH "folder-saved-search-symbolic" static GIcon * special_directory_get_gicon (GUserDirectory directory) { #define ICON_CASE(x) \ case G_USER_DIRECTORY_ ## x: \ return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER_ ## x); switch (directory) { ICON_CASE (DESKTOP); ICON_CASE (DOCUMENTS); ICON_CASE (DOWNLOAD); ICON_CASE (MUSIC); ICON_CASE (PICTURES); ICON_CASE (PUBLIC_SHARE); ICON_CASE (TEMPLATES); ICON_CASE (VIDEOS); default: return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER); } #undef ICON_CASE } static GtkWidget * cc_sharing_panel_new_media_sharing_row (const char *uri_or_path, CcSharingPanel *self) { GtkWidget *row, *w; GUserDirectory dir = G_USER_N_DIRECTORIES; g_autoptr(GIcon) icon = NULL; guint i; g_autofree gchar *basename = NULL; g_autofree gchar *path = NULL; g_autoptr(GFile) file = NULL; file = g_file_new_for_commandline_arg (uri_or_path); path = g_file_get_path (file); row = adw_action_row_new (); /* Find the icon and create it */ for (i = 0; i < G_USER_N_DIRECTORIES; i++) { if (g_strcmp0 (path, g_get_user_special_dir (i)) == 0) { dir = i; break; } } icon = special_directory_get_gicon (dir); adw_action_row_add_prefix (ADW_ACTION_ROW (row), gtk_image_new_from_gicon (icon)); /* Label */ basename = g_filename_display_basename (path); adw_preferences_row_set_title (ADW_PREFERENCES_ROW (row), basename); /* Remove button */ w = gtk_button_new_from_icon_name ("window-close-symbolic"); gtk_widget_add_css_class (w, "flat"); gtk_widget_set_valign (w, GTK_ALIGN_CENTER); gtk_accessible_update_property (GTK_ACCESSIBLE (w), GTK_ACCESSIBLE_PROPERTY_LABEL, _("Remove"), -1); adw_action_row_add_suffix (ADW_ACTION_ROW (row), w); g_signal_connect_object (G_OBJECT (w), "clicked", G_CALLBACK (cc_sharing_panel_remove_folder), self, G_CONNECT_SWAPPED); g_object_set_data (G_OBJECT (w), "row", row); g_object_set_data_full (G_OBJECT (row), "path", g_steal_pointer (&path), g_free); return row; } static GtkWidget * cc_sharing_panel_new_add_media_sharing_row (CcSharingPanel *self) { GtkWidget *row, *box, *w; row = gtk_list_box_row_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_list_box_row_set_child (GTK_LIST_BOX_ROW (row), box); w = gtk_image_new_from_icon_name ("list-add-symbolic"); gtk_widget_set_hexpand (w, TRUE); gtk_widget_set_margin_top (w, 12); gtk_widget_set_margin_bottom (w, 12); gtk_accessible_update_property (GTK_ACCESSIBLE (w), GTK_ACCESSIBLE_PROPERTY_LABEL, _("Add"), -1); gtk_box_append (GTK_BOX (box), w); g_object_set_data (G_OBJECT (w), "row", row); g_object_set_data (G_OBJECT (row), "is-add", GINT_TO_POINTER (1)); return row; } static GtkWidget * create_switch_with_bindings (GtkSwitch *from) { GtkWidget *new_switch = gtk_switch_new (); g_object_bind_property (from, "visible", new_switch, "visible", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); g_object_bind_property (from, "state", new_switch, "state", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); g_object_bind_property (from, "active", new_switch, "active", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); g_object_bind_property (from, "sensitive", new_switch, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); return new_switch; } static void cc_sharing_panel_setup_media_sharing_dialog (CcSharingPanel *self) { g_auto(GStrv) folders = NULL; GStrv list; GtkWidget *row, *networks, *w; g_autofree gchar *path = NULL; path = g_find_program_in_path ("rygel"); if (path == NULL) { gtk_widget_hide (self->media_sharing_row); return; } g_signal_connect_object (self->media_sharing_dialog, "response", G_CALLBACK (cc_sharing_panel_media_sharing_dialog_response), self, G_CONNECT_SWAPPED); cc_media_sharing_get_preferences (&folders); list = folders; while (list && *list) { row = cc_sharing_panel_new_media_sharing_row (*list, self); gtk_list_box_insert (GTK_LIST_BOX (self->shared_folders_listbox), row, -1); list++; } row = cc_sharing_panel_new_add_media_sharing_row (self); gtk_list_box_append (GTK_LIST_BOX (self->shared_folders_listbox), row); g_signal_connect_object (self->shared_folders_listbox, "row-activated", G_CALLBACK (cc_sharing_panel_add_folder), self, G_CONNECT_SWAPPED); networks = cc_sharing_networks_new (self->sharing_proxy, "rygel"); gtk_grid_attach (GTK_GRID (self->shared_folders_grid), networks, 0, 4, 2, 1); w = create_switch_with_bindings (GTK_SWITCH (g_object_get_data (G_OBJECT (networks), "switch"))); gtk_accessible_update_property (GTK_ACCESSIBLE (w), GTK_ACCESSIBLE_PROPERTY_LABEL, _("Enable media sharing"), -1); gtk_header_bar_pack_start (GTK_HEADER_BAR (self->media_sharing_headerbar), w); self->media_sharing_switch = w; cc_sharing_panel_bind_networks_to_label (self, networks, self->media_sharing_row); } static void cc_sharing_panel_setup_label (CcSharingPanel *self, GtkWidget *label, const gchar *hostname) { g_autofree gchar *text = NULL; if (label == self->personal_file_sharing_label) { g_autofree gchar *url = g_strdup_printf ("dav://%s", hostname, hostname); /* TRANSLATORS: %s is replaced with a link to a dav:// URL */ text = g_strdup_printf (_("File Sharing allows you to share your Public folder with others on your current network using: %s"), url); } else if (label == self->remote_login_label) { g_autofree gchar *command = g_strdup_printf ("ssh %s", hostname, hostname); /* TRANSLATORS: %s is replaced with a link to a "ssh " command to run */ text = g_strdup_printf (_("When remote login is enabled, remote users can connect using the Secure Shell command:\n%s"), command); } else if (label == self->remote_desktop_address_label) { text = g_strdup_printf ("ms-rd://%s", hostname); } else g_assert_not_reached (); gtk_label_set_label (GTK_LABEL (label), text); } typedef struct { CcSharingPanel *panel; GtkWidget *label; } GetHostNameData; G_DEFINE_AUTOPTR_CLEANUP_FUNC (GetHostNameData, g_free); static void cc_sharing_panel_get_host_name_fqdn_done (GObject *object, GAsyncResult *res, gpointer user_data) { GDBusConnection *connection = G_DBUS_CONNECTION (object); g_autoptr(GetHostNameData) data = user_data; g_autoptr(GError) error = NULL; g_autoptr(GVariant) variant = NULL; const gchar *fqdn; variant = g_dbus_connection_call_finish (connection, res, &error); if (variant == NULL) { /* Avahi service may not be available */ g_debug ("Error calling GetHostNameFqdn: %s", error->message); if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_autofree gchar *hostname = NULL; hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->hostname_entry)); cc_sharing_panel_setup_label (data->panel, data->label, hostname); } return; } g_variant_get (variant, "(&s)", &fqdn); cc_sharing_panel_setup_label (data->panel, data->label, fqdn); } static void cc_sharing_panel_bus_ready (GObject *object, GAsyncResult *res, gpointer user_data) { g_autoptr(GDBusConnection) connection = NULL; g_autoptr(GetHostNameData) data = user_data; g_autoptr(GError) error = NULL; connection = g_bus_get_finish (res, &error); if (connection == NULL) { g_warning ("Could not connect to system bus: %s", error->message); if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_autofree gchar *hostname = NULL; hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->hostname_entry)); cc_sharing_panel_setup_label (data->panel, data->label, hostname); } return; } g_dbus_connection_call (connection, "org.freedesktop.Avahi", "/", "org.freedesktop.Avahi.Server", "GetHostNameFqdn", NULL, (GVariantType*)"(s)", G_DBUS_CALL_FLAGS_NONE, -1, cc_panel_get_cancellable (CC_PANEL (data->panel)), cc_sharing_panel_get_host_name_fqdn_done, data); g_steal_pointer (&data); } static void cc_sharing_panel_setup_label_with_hostname (CcSharingPanel *self, GtkWidget *label) { GetHostNameData *get_hostname_data; /* set the hostname */ get_hostname_data = g_new (GetHostNameData, 1); get_hostname_data->panel = self; get_hostname_data->label = label; g_bus_get (G_BUS_TYPE_SYSTEM, cc_panel_get_cancellable (CC_PANEL (self)), cc_sharing_panel_bus_ready, get_hostname_data); } static gboolean file_sharing_get_require_password (GValue *value, GVariant *variant, gpointer user_data) { if (g_str_equal (g_variant_get_string (variant, NULL), "always")) g_value_set_boolean (value, TRUE); else g_value_set_boolean (value, FALSE); return TRUE; } static GVariant * file_sharing_set_require_password (const GValue *value, const GVariantType *type, gpointer user_data) { if (g_value_get_boolean (value)) return g_variant_new_string ("always"); else return g_variant_new_string ("never"); } static void file_sharing_password_changed (GtkEntry *entry) { file_share_write_out_password (gtk_editable_get_text (GTK_EDITABLE (entry))); } static void cc_sharing_panel_setup_personal_file_sharing_dialog (CcSharingPanel *self) { GSettings *settings; GtkWidget *networks, *w; cc_sharing_panel_bind_switch_to_widgets (self->personal_file_sharing_require_password_switch, self->personal_file_sharing_password_entry, self->personal_file_sharing_password_label, NULL); cc_sharing_panel_setup_label_with_hostname (self, self->personal_file_sharing_label); /* the password cannot be read, so just make sure the entry is not empty */ gtk_editable_set_text (GTK_EDITABLE (self->personal_file_sharing_password_entry), "password"); settings = g_settings_new (FILE_SHARING_SCHEMA_ID); g_settings_bind_with_mapping (settings, "require-password", self->personal_file_sharing_require_password_switch, "active", G_SETTINGS_BIND_DEFAULT, file_sharing_get_require_password, file_sharing_set_require_password, NULL, NULL); g_signal_connect (self->personal_file_sharing_password_entry, "notify::text", G_CALLBACK (file_sharing_password_changed), NULL); networks = cc_sharing_networks_new (self->sharing_proxy, "gnome-user-share-webdav"); gtk_grid_attach (GTK_GRID (self->personal_file_sharing_grid), networks, 0, 3, 2, 1); w = create_switch_with_bindings (GTK_SWITCH (g_object_get_data (G_OBJECT (networks), "switch"))); gtk_accessible_update_property (GTK_ACCESSIBLE (w), GTK_ACCESSIBLE_PROPERTY_LABEL, _("Enable personal media sharing"), -1); gtk_header_bar_pack_start (GTK_HEADER_BAR (self->personal_file_sharing_headerbar), w); self->personal_file_sharing_switch = w; cc_sharing_panel_bind_networks_to_label (self, networks, self->personal_file_sharing_row); } static void remote_login_switch_activate (CcSharingPanel *self) { cc_remote_login_set_enabled (cc_panel_get_cancellable (CC_PANEL (self)), GTK_SWITCH (self->remote_login_switch)); } static void cc_sharing_panel_setup_remote_login_dialog (CcSharingPanel *self) { cc_sharing_panel_bind_switch_to_label (self, self->remote_login_switch, self->remote_login_row); cc_sharing_panel_setup_label_with_hostname (self, self->remote_login_label); g_signal_connect_object (self->remote_login_switch, "notify::active", G_CALLBACK (remote_login_switch_activate), self, G_CONNECT_SWAPPED); gtk_widget_set_sensitive (self->remote_login_switch, FALSE); cc_remote_login_get_enabled (cc_panel_get_cancellable (CC_PANEL (self)), GTK_SWITCH (self->remote_login_switch), self->remote_login_row); } static gboolean cc_sharing_panel_check_schema_available (CcSharingPanel *self, const gchar *schema_id) { GSettingsSchemaSource *source; g_autoptr(GSettingsSchema) schema = NULL; source = g_settings_schema_source_get_default (); if (!source) return FALSE; schema = g_settings_schema_source_lookup (source, schema_id, TRUE); if (!schema) return FALSE; return TRUE; } static gboolean store_remote_desktop_credentials_timeout (gpointer user_data) { CcSharingPanel *self = CC_SHARING_PANEL (user_data); const char *username, *password; username = gtk_editable_get_text (GTK_EDITABLE (self->remote_desktop_username_entry)); password = gtk_editable_get_text (GTK_EDITABLE (self->remote_desktop_password_entry)); if (username && password) { cc_grd_store_rdp_credentials (username, password, cc_panel_get_cancellable (CC_PANEL (self))); } self->remote_desktop_store_credentials_id = 0; return G_SOURCE_REMOVE; } static void remote_desktop_credentials_changed (CcSharingPanel *self) { g_clear_handle_id (&self->remote_desktop_store_credentials_id, g_source_remove); self->remote_desktop_store_credentials_id = g_timeout_add_seconds (REMOTE_DESKTOP_STORE_CREDENTIALS_TIMEOUT_S, store_remote_desktop_credentials_timeout, self); } static gboolean is_remote_desktop_enabled (CcSharingPanel *self) { g_autoptr(GSettings) rdp_settings = NULL; rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID); if (!g_settings_get_boolean (rdp_settings, "enable")) return FALSE; return cc_is_service_active (REMOTE_DESKTOP_SERVICE, G_BUS_TYPE_SESSION); } static void enable_gnome_remote_desktop_service (CcSharingPanel *self) { g_autoptr(GError) error = NULL; if (is_remote_desktop_enabled (self)) return; if (!cc_enable_service (REMOTE_DESKTOP_SERVICE, G_BUS_TYPE_SESSION, &error)) g_warning ("Failed to enable remote desktop service: %s", error->message); } static void disable_gnome_remote_desktop_service (CcSharingPanel *self) { g_autoptr(GError) error = NULL; g_autoptr(GSettings) rdp_settings = NULL; rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID); g_settings_set_boolean (rdp_settings, "enable", FALSE); if (!cc_disable_service (REMOTE_DESKTOP_SERVICE, G_BUS_TYPE_SESSION, &error)) g_warning ("Failed to enable remote desktop service: %s", error->message); } static void calc_default_tls_paths (char **out_dir_path, char **out_cert_path, char **out_key_path) { g_autofree char *dir_path = NULL; dir_path = g_strdup_printf ("%s/gnome-remote-desktop", g_get_user_data_dir ()); if (out_cert_path) *out_cert_path = g_strdup_printf ("%s/rdp-tls.crt", dir_path); if (out_key_path) *out_key_path = g_strdup_printf ("%s/rdp-tls.key", dir_path); if (out_dir_path) *out_dir_path = g_steal_pointer (&dir_path); } static void set_tls_certificate (CcSharingPanel *self, GTlsCertificate *tls_certificate) { g_set_object (&self->remote_desktop_certificate, tls_certificate); gtk_widget_set_sensitive (self->remote_desktop_verify_encryption, TRUE); } static void on_certificate_generated (GObject *source_object, GAsyncResult *res, gpointer user_data) { CcSharingPanel *self; g_autoptr(GTlsCertificate) tls_certificate = NULL; g_autoptr(GError) error = NULL; g_autofree char *cert_path = NULL; g_autofree char *key_path = NULL; g_autoptr(GSettings) rdp_settings = NULL; tls_certificate = bonsai_tls_certificate_new_generate_finish (res, &error); if (!tls_certificate) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) return; g_warning ("Failed to generate TLS certificate: %s", error->message); return; } self = CC_SHARING_PANEL (user_data); calc_default_tls_paths (NULL, &cert_path, &key_path); rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID); g_settings_set_string (rdp_settings, "tls-cert", cert_path); g_settings_set_string (rdp_settings, "tls-key", key_path); set_tls_certificate (self, tls_certificate); enable_gnome_remote_desktop_service (self); } static void enable_gnome_remote_desktop (CcSharingPanel *self) { g_autofree char *dir_path = NULL; g_autofree char *cert_path = NULL; g_autofree char *key_path = NULL; g_autoptr(GFile) dir = NULL; g_autoptr(GFile) cert_file = NULL; g_autoptr(GFile) key_file = NULL; g_autoptr(GError) error = NULL; g_autoptr(GSettings) rdp_settings = NULL; rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID); g_settings_set_boolean (rdp_settings, "enable", TRUE); cert_path = g_settings_get_string (rdp_settings, "tls-cert"); key_path = g_settings_get_string (rdp_settings, "tls-key"); if (strlen (cert_path) > 0 && strlen (key_path) > 0) { g_autoptr(GTlsCertificate) tls_certificate = NULL; tls_certificate = g_tls_certificate_new_from_file (cert_path, &error); if (tls_certificate) { set_tls_certificate (self, tls_certificate); enable_gnome_remote_desktop_service (self); return; } g_warning ("Configured TLS certificate invalid: %s", error->message); return; } calc_default_tls_paths (&dir_path, &cert_path, &key_path); dir = g_file_new_for_path (dir_path); if (!g_file_query_exists (dir, NULL)) { if (!g_file_make_directory_with_parents (dir, NULL, &error)) { g_warning ("Failed to create remote desktop certificate directory: %s", error->message); return; } } cert_file = g_file_new_for_path (cert_path); key_file = g_file_new_for_path (key_path); if (g_file_query_exists (cert_file, NULL) && g_file_query_exists (key_file, NULL)) { g_autoptr(GTlsCertificate) tls_certificate = NULL; tls_certificate = g_tls_certificate_new_from_file (cert_path, &error); if (tls_certificate) { g_settings_set_string (rdp_settings, "tls-cert", cert_path); g_settings_set_string (rdp_settings, "tls-key", key_path); set_tls_certificate (self, tls_certificate); enable_gnome_remote_desktop_service (self); return; } g_warning ("Existing TLS certificate invalid: %s", error->message); return; } bonsai_tls_certificate_new_generate_async (cert_path, key_path, "US", "GNOME", cc_panel_get_cancellable (CC_PANEL (self)), on_certificate_generated, self); } static void on_remote_desktop_state_changed (GtkWidget *widget, GParamSpec *pspec, CcSharingPanel *self) { if (gtk_switch_get_active (GTK_SWITCH (widget))) enable_gnome_remote_desktop (self); else disable_gnome_remote_desktop_service (self); } static char * get_hostname (void) { g_autoptr(GDBusConnection) bus = NULL; g_autoptr(GVariant) res = NULL; g_autoptr(GVariant) inner = NULL; g_autoptr(GError) error = NULL; const char *hostname; bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); if (bus == NULL) { g_warning ("Failed to get system bus connection: %s", error->message); return NULL; } res = g_dbus_connection_call_sync (bus, "org.freedesktop.hostname1", "/org/freedesktop/hostname1", "org.freedesktop.DBus.Properties", "Get", g_variant_new ("(ss)", "org.freedesktop.hostname1", "PrettyHostname"), (GVariantType*)"(v)", G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (res == NULL) { g_warning ("Getting pretty hostname failed: %s", error->message); return NULL; } g_variant_get (res, "(v)", &inner); hostname = g_variant_get_string (inner, NULL); if (g_strcmp0 (hostname, "") != 0) return g_strdup (hostname); g_clear_pointer (&inner, g_variant_unref); g_clear_pointer (&res, g_variant_unref); res = g_dbus_connection_call_sync (bus, "org.freedesktop.hostname1", "/org/freedesktop/hostname1", "org.freedesktop.DBus.Properties", "Get", g_variant_new ("(ss)", "org.freedesktop.hostname1", "Hostname"), (GVariantType*)"(v)", G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (res == NULL) { g_warning ("Getting hostname failed: %s", error->message); return NULL; } g_variant_get (res, "(v)", &inner); return g_variant_dup_string (inner, NULL); } static void add_toast (CcSharingPanel *self, const char *message) { adw_toast_overlay_add_toast (ADW_TOAST_OVERLAY (self->remote_desktop_toast_overlay), adw_toast_new (message)); } static void on_device_name_copy_clicked (GtkButton *button, CcSharingPanel *self) { GtkLabel *label = GTK_LABEL (self->remote_desktop_device_name_label); gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (button)), gtk_label_get_text (label)); add_toast (self, _("Device name copied")); } static void on_device_address_copy_clicked (GtkButton *button, CcSharingPanel *self) { GtkLabel *label = GTK_LABEL (self->remote_desktop_address_label); gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (button)), gtk_label_get_text (label)); add_toast (self, _("Device address copied")); } static void on_username_copy_clicked (GtkButton *button, CcSharingPanel *self) { GtkEditable *editable = GTK_EDITABLE (self->remote_desktop_username_entry); gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (button)), gtk_editable_get_text (editable)); add_toast (self, _("Username copied")); } static void on_password_copy_clicked (GtkButton *button, CcSharingPanel *self) { GtkEditable *editable = GTK_EDITABLE (self->remote_desktop_password_entry); gdk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (button)), gtk_editable_get_text (editable)); add_toast (self, _("Password copied")); } static pwquality_settings_t * get_pwq (void) { static pwquality_settings_t *settings; if (settings == NULL) { gchar *err = NULL; gint rv = 0; settings = pwquality_default_settings (); pwquality_set_int_value (settings, PWQ_SETTING_MAX_SEQUENCE, 4); rv = pwquality_read_config (settings, NULL, (gpointer)&err); if (rv < 0) { g_warning ("Failed to read pwquality configuration: %s\n", pwquality_strerror (NULL, 0, rv, err)); pwquality_free_settings (settings); /* Load just default settings in case of failure. */ settings = pwquality_default_settings (); pwquality_set_int_value (settings, PWQ_SETTING_MAX_SEQUENCE, 4); } } return settings; } static char * pw_generate (void) { char *res; int rv; rv = pwquality_generate (get_pwq (), 0, &res); if (rv < 0) { g_warning ("Password generation failed: %s\n", pwquality_strerror (NULL, 0, rv, NULL)); return NULL; } return res; } static void cc_sharing_panel_setup_remote_desktop_dialog (CcSharingPanel *self) { const gchar *username = NULL; const gchar *password = NULL; g_autoptr(GSettings) rdp_settings = NULL; g_autofree char *hostname = NULL; cc_sharing_panel_bind_switch_to_label (self, self->remote_desktop_switch, self->remote_desktop_row); cc_sharing_panel_setup_label_with_hostname (self, self->remote_desktop_address_label); rdp_settings = g_settings_new (GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID); g_settings_bind (rdp_settings, "view-only", self->remote_control_switch, "active", G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_INVERT_BOOLEAN); g_object_bind_property (self->remote_desktop_switch, "state", self->remote_control_switch, "sensitive", G_BINDING_SYNC_CREATE); hostname = get_hostname (); gtk_label_set_label (GTK_LABEL (self->remote_desktop_device_name_label), hostname); username = cc_grd_lookup_rdp_username (cc_panel_get_cancellable (CC_PANEL (self))); password = cc_grd_lookup_rdp_password (cc_panel_get_cancellable (CC_PANEL (self))); if (username != NULL) gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_username_entry), username); if (password != NULL) gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_password_entry), password); g_signal_connect_swapped (self->remote_desktop_username_entry, "notify::text", G_CALLBACK (remote_desktop_credentials_changed), self); g_signal_connect_swapped (self->remote_desktop_password_entry, "notify::text", G_CALLBACK (remote_desktop_credentials_changed), self); if (username == NULL) { struct passwd *pw = getpwuid (getuid ()); if (pw != NULL) { gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_username_entry), pw->pw_name); } else { g_warning ("Failed to get username: %s", g_strerror (errno)); } } if (password == NULL) { char * pw = pw_generate (); if (pw) gtk_editable_set_text (GTK_EDITABLE (self->remote_desktop_password_entry), pw ); } g_signal_connect (self->remote_desktop_device_name_copy, "clicked", G_CALLBACK (on_device_name_copy_clicked), self); g_signal_connect (self->remote_desktop_address_copy, "clicked", G_CALLBACK (on_device_address_copy_clicked), self); g_signal_connect (self->remote_desktop_username_copy, "clicked", G_CALLBACK (on_username_copy_clicked), self); g_signal_connect (self->remote_desktop_password_copy, "clicked", G_CALLBACK (on_password_copy_clicked), self); g_signal_connect (self->remote_desktop_switch, "notify::state", G_CALLBACK (on_remote_desktop_state_changed), self); if (is_remote_desktop_enabled (self)) { gtk_switch_set_active (GTK_SWITCH (self->remote_desktop_switch), TRUE); } } static void remote_desktop_name_appeared (GDBusConnection *connection, const gchar *name, const gchar *name_owner, gpointer user_data) { CcSharingPanel *self = CC_SHARING_PANEL (user_data); g_bus_unwatch_name (self->remote_desktop_name_watch); self->remote_desktop_name_watch = 0; cc_sharing_panel_setup_remote_desktop_dialog (self); gtk_widget_show (self->remote_desktop_row); } static void check_remote_desktop_available (CcSharingPanel *self) { if (!cc_sharing_panel_check_schema_available (self, GNOME_REMOTE_DESKTOP_SCHEMA_ID)) return; if (!cc_sharing_panel_check_schema_available (self, GNOME_REMOTE_DESKTOP_RDP_SCHEMA_ID)) return; self->remote_desktop_name_watch = g_bus_watch_name (G_BUS_TYPE_SESSION, "org.gnome.Mutter.RemoteDesktop", G_BUS_NAME_WATCHER_FLAGS_NONE, remote_desktop_name_appeared, NULL, self, NULL); } static void sharing_proxy_ready (GObject *source, GAsyncResult *res, gpointer user_data) { CcSharingPanel *self; GDBusProxy *proxy; g_autoptr(GError) error = NULL; proxy = G_DBUS_PROXY (gsd_sharing_proxy_new_for_bus_finish (res, &error)); if (!proxy) { if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("Failed to get sharing proxy: %s", error->message); return; } self = CC_SHARING_PANEL (user_data); self->sharing_proxy = proxy; /* media sharing */ cc_sharing_panel_setup_media_sharing_dialog (self); /* personal file sharing */ if (cc_sharing_panel_check_schema_available (self, FILE_SHARING_SCHEMA_ID)) cc_sharing_panel_setup_personal_file_sharing_dialog (self); else gtk_widget_hide (self->personal_file_sharing_row); /* remote login */ cc_sharing_panel_setup_remote_login_dialog (self); /* screen sharing */ check_remote_desktop_available (self); gtk_widget_hide (self->remote_desktop_row); } static void cc_sharing_panel_init (CcSharingPanel *self) { g_autoptr(GtkCssProvider) provider = NULL; g_resources_register (cc_sharing_get_resource ()); gtk_widget_init_template (GTK_WIDGET (self)); g_signal_connect_object (self->main_list_box, "row-activated", G_CALLBACK (cc_sharing_panel_main_list_box_row_activated), self, G_CONNECT_SWAPPED); g_signal_connect (self->media_sharing_dialog, "response", G_CALLBACK (gtk_widget_hide), NULL); g_signal_connect (self->personal_file_sharing_dialog, "response", G_CALLBACK (gtk_widget_hide), NULL); g_signal_connect (self->remote_login_dialog, "response", G_CALLBACK (gtk_widget_hide), NULL); g_signal_connect (self->remote_desktop_dialog, "response", G_CALLBACK (gtk_widget_hide), NULL); gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (self->main_list_box), TRUE); /* start the panel in the disabled state */ gtk_switch_set_active (GTK_SWITCH (self->master_switch), FALSE); gtk_widget_set_sensitive (self->main_list_box, FALSE); g_signal_connect_object (self->master_switch, "notify::active", G_CALLBACK (cc_sharing_panel_master_switch_notify), self, G_CONNECT_SWAPPED); gsd_sharing_proxy_new_for_bus (G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, "org.gnome.SettingsDaemon.Sharing", "/org/gnome/SettingsDaemon/Sharing", cc_panel_get_cancellable (CC_PANEL (self)), sharing_proxy_ready, self); /* make sure the hostname entry isn't focused by default */ g_signal_connect_swapped (self, "map", G_CALLBACK (gtk_widget_grab_focus), self->main_list_box); provider = gtk_css_provider_new (); gtk_css_provider_load_from_resource (provider, "/org/gnome/control-center/sharing/sharing.css"); gtk_style_context_add_provider_for_display (gdk_display_get_default (), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); } CcSharingPanel * cc_sharing_panel_new (void) { return g_object_new (CC_TYPE_SHARING_PANEL, NULL); }