diff options
Diffstat (limited to 'src/nautilus-properties-window.c')
| -rw-r--r-- | src/nautilus-properties-window.c | 4457 |
1 files changed, 4457 insertions, 0 deletions
diff --git a/src/nautilus-properties-window.c b/src/nautilus-properties-window.c new file mode 100644 index 0000000..32fd42e --- /dev/null +++ b/src/nautilus-properties-window.c @@ -0,0 +1,4457 @@ +/* fm-properties-window.c - window that lets user modify file properties + * + * Copyright (C) 2000 Eazel, Inc. + * + * The Gnome Library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * The Gnome Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with the Gnome Library; see the file COPYING.LIB. If not, + * see <http://www.gnu.org/licenses/>. + * + * Authors: Darin Adler <darin@bentspoon.com> + */ + +#include "nautilus-properties-window.h" + +#include <cairo.h> +#include <eel/eel-stock-dialogs.h> +#include <eel/eel-string.h> +#include <eel/eel-vfs-extensions.h> +#include <gtk/gtk.h> +#include <gdk/gdkkeysyms.h> +#include <glib/gi18n.h> +#include <gio/gunixmounts.h> +#include <nautilus-extension.h> +#include <string.h> +#include <sys/stat.h> + +#define GNOME_DESKTOP_USE_UNSTABLE_API +#include <libgnome-desktop/gnome-desktop-thumbnail.h> + +#include "nautilus-application.h" +#include "nautilus-dbus-launcher.h" +#include "nautilus-enums.h" +#include "nautilus-error-reporting.h" +#include "nautilus-file-operations.h" +#include "nautilus-file-utilities.h" +#include "nautilus-global-preferences.h" +#include "nautilus-icon-info.h" +#include "nautilus-metadata.h" +#include "nautilus-mime-actions.h" +#include "nautilus-module.h" +#include "nautilus-properties-model.h" +#include "nautilus-properties-item.h" +#include "nautilus-signaller.h" +#include "nautilus-tag-manager.h" +#include "nautilus-ui-utilities.h" + +static GHashTable *pending_lists; + +typedef struct +{ + NautilusFile *file; + char *owner; + GtkWindow *window; + unsigned int timeout; + gboolean cancelled; +} OwnerChange; + +typedef struct +{ + NautilusFile *file; + char *group; + GtkWindow *window; + unsigned int timeout; + gboolean cancelled; +} GroupChange; + +struct _NautilusPropertiesWindow +{ + AdwWindow parent_instance; + + GList *original_files; + GList *target_files; + + AdwWindowTitle *window_title; + + GtkStack *page_stack; + + /* Basic page */ + + GtkStack *icon_stack; + GtkWidget *icon_image; + GtkWidget *icon_button; + GtkWidget *icon_button_image; + GtkWidget *icon_chooser; + + GtkWidget *star_button; + + GtkLabel *name_value_label; + GtkWidget *type_value_label; + GtkLabel *type_file_system_label; + GtkWidget *size_value_label; + GtkWidget *contents_box; + GtkWidget *contents_value_label; + GtkWidget *free_space_value_label; + + GtkWidget *disk_list_box; + GtkLevelBar *disk_space_level_bar; + GtkWidget *disk_space_used_value; + GtkWidget *disk_space_free_value; + GtkWidget *disk_space_capacity_value; + + GtkWidget *locations_list_box; + GtkWidget *link_target_row; + GtkWidget *link_target_value_label; + GtkWidget *contents_spinner; + guint update_directory_contents_timeout_id; + guint update_files_timeout_id; + GtkWidget *parent_folder_row; + GtkWidget *parent_folder_value_label; + + GtkWidget *trashed_list_box; + GtkWidget *trashed_on_value_label; + GtkWidget *original_folder_value_label; + + GtkWidget *times_list_box; + GtkWidget *modified_row; + GtkWidget *modified_value_label; + GtkWidget *created_row; + GtkWidget *created_value_label; + GtkWidget *accessed_row; + GtkWidget *accessed_value_label; + + GtkWidget *permissions_navigation_row; + GtkWidget *permissions_value_label; + + GtkWidget *extension_models_list_box; + + /* Permissions page */ + + GtkWidget *permissions_stack; + + GtkWidget *unknown_permissions_page; + + GtkWidget *bottom_prompt_seperator; + GtkWidget *not_the_owner_label; + + AdwComboRow *owner_row; + AdwComboRow *owner_access_row; + AdwComboRow *owner_folder_access_row; + AdwComboRow *owner_file_access_row; + + AdwComboRow *group_row; + AdwComboRow *group_access_row; + AdwComboRow *group_folder_access_row; + AdwComboRow *group_file_access_row; + + AdwComboRow *others_access_row; + AdwComboRow *others_folder_access_row; + AdwComboRow *others_file_access_row; + + AdwComboRow *execution_row; + GtkSwitch *execution_switch; + + GtkWidget *security_context_list_box; + GtkWidget *security_context_value_label; + + GtkWidget *change_permissions_button_box; + GtkWidget *change_permissions_button; + + GroupChange *group_change; + OwnerChange *owner_change; + + GList *permission_rows; + GList *change_permission_combos; + GHashTable *initial_permissions; + gboolean has_recursive_apply; + + GList *value_fields; + + GList *mime_list; + + gboolean deep_count_finished; + GList *deep_count_files; + guint deep_count_spinner_timeout_id; + + guint long_operation_underway; + + GList *changed_files; + + guint64 volume_capacity; + guint64 volume_free; + guint64 volume_used; +}; + +typedef enum +{ + NO_FILES_OR_FOLDERS = (0), + FILES_ONLY = (1 << 0), + FOLDERS_ONLY = (1 << 1), + FILES_AND_FOLDERS = FILES_ONLY | FOLDERS_ONLY, +} FilterType; + +enum +{ + UNIX_PERM_SUID = S_ISUID, + UNIX_PERM_SGID = S_ISGID, + UNIX_PERM_STICKY = 01000, /* S_ISVTX not defined on all systems */ + UNIX_PERM_USER_READ = S_IRUSR, + UNIX_PERM_USER_WRITE = S_IWUSR, + UNIX_PERM_USER_EXEC = S_IXUSR, + UNIX_PERM_USER_ALL = S_IRUSR | S_IWUSR | S_IXUSR, + UNIX_PERM_GROUP_READ = S_IRGRP, + UNIX_PERM_GROUP_WRITE = S_IWGRP, + UNIX_PERM_GROUP_EXEC = S_IXGRP, + UNIX_PERM_GROUP_ALL = S_IRGRP | S_IWGRP | S_IXGRP, + UNIX_PERM_OTHER_READ = S_IROTH, + UNIX_PERM_OTHER_WRITE = S_IWOTH, + UNIX_PERM_OTHER_EXEC = S_IXOTH, + UNIX_PERM_OTHER_ALL = S_IROTH | S_IWOTH | S_IXOTH +}; + +typedef enum +{ + PERMISSION_NONE = (0), + PERMISSION_READ = (1 << 0), + PERMISSION_WRITE = (1 << 1), + PERMISSION_EXEC = (1 << 2), + PERMISSION_INCONSISTENT = (1 << 3) +} PermissionValue; + +typedef enum +{ + PERMISSION_USER, + PERMISSION_GROUP, + PERMISSION_OTHER, + NUM_PERMISSION_TYPE +} PermissionType; + +/** Contains permissions for files and folders for each PermissionType */ +typedef struct +{ + NautilusPropertiesWindow *window; + + PermissionValue folder_permissions[NUM_PERMISSION_TYPE]; + PermissionValue file_permissions[NUM_PERMISSION_TYPE]; + PermissionValue file_exec_permissions; + gboolean has_files; + gboolean has_folders; + gboolean can_set_all_folder_permission; + gboolean can_set_all_file_permission; + gboolean can_set_any_file_permission; + gboolean is_multi_file_window; +} TargetPermissions; + +/* NautilusPermissionEntry - helper struct for permission AdwComboRow */ + +#define NAUTILUS_TYPE_PERMISSION_ENTRY (nautilus_permission_entry_get_type ()) +G_DECLARE_FINAL_TYPE (NautilusPermissionEntry, nautilus_permission_entry, + NAUTILUS, PERMISSION_ENTRY, GObject) + +enum +{ + PROP_NAME = 1, + NUM_PROPERTIES +}; + +struct _NautilusPermissionEntry +{ + GObject parent; + + char *name; + PermissionValue permission_value; +}; + +G_DEFINE_TYPE (NautilusPermissionEntry, + nautilus_permission_entry, + G_TYPE_OBJECT) + +static void +nautilus_permission_entry_init (NautilusPermissionEntry *self) +{ + self->name = NULL; + self->permission_value = PERMISSION_NONE; +} + +static void +nautilus_permission_entry_finalize (GObject *object) +{ + NautilusPermissionEntry *self = NAUTILUS_PERMISSION_ENTRY (object); + + g_free (self->name); + + G_OBJECT_CLASS (nautilus_permission_entry_parent_class)->finalize (object); +} + +static void +nautilus_permission_entry_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + NautilusPermissionEntry *self = NAUTILUS_PERMISSION_ENTRY (object); + + switch (prop_id) + { + case PROP_NAME: + { + g_value_set_string (value, self->name); + } + break; + + default: + { + g_assert_not_reached (); + } + break; + } +} + +static void +nautilus_permission_entry_class_init (NautilusPermissionEntryClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->finalize = nautilus_permission_entry_finalize; + gobject_class->get_property = nautilus_permission_entry_get_property; + + g_object_class_install_property (gobject_class, + PROP_NAME, + g_param_spec_string ("name", "", "", + NULL, + G_PARAM_READABLE)); +} + +static gchar * +permission_value_to_string (PermissionValue permission_value, + gboolean describes_folder) +{ + if (permission_value & PERMISSION_INCONSISTENT) + { + return "---"; + } + else if (permission_value & PERMISSION_READ) + { + if (permission_value & PERMISSION_WRITE) + { + if (!describes_folder) + { + return _("Read and write"); + } + else if (permission_value & PERMISSION_EXEC) + { + return _("Create and delete files"); + } + else + { + return _("Read/write, no access"); + } + } + else + { + if (!describes_folder) + { + return _("Read-only"); + } + else if (permission_value & PERMISSION_EXEC) + { + return _("Access files"); + } + else + { + return _("List files only"); + } + } + } + else + { + if (permission_value & PERMISSION_WRITE) + { + if (!describes_folder || permission_value & PERMISSION_EXEC) + { + return _("Write-only"); + } + else + { + return _("Write-only, no access"); + } + } + else + { + if (describes_folder && permission_value & PERMISSION_EXEC) + { + return _("Access-only"); + } + else + { + /* Translators: this is referred to the permissions the user has in a directory. */ + return _("None"); + } + } + } +} + +/* end NautilusPermissionEntry */ + +enum +{ + COLUMN_NAME, + COLUMN_VALUE, + COLUMN_USE_ORIGINAL, + COLUMN_ID, + NUM_COLUMNS +}; + +typedef struct +{ + GList *original_files; + GList *target_files; + GtkWidget *parent_widget; + GtkWindow *parent_window; + char *startup_id; + char *pending_key; + GHashTable *pending_files; + NautilusPropertiesWindowCallback callback; + gpointer callback_data; + NautilusPropertiesWindow *window; + gboolean cancelled; +} StartupData; + +#define DIRECTORY_CONTENTS_UPDATE_INTERVAL 200 /* milliseconds */ +#define FILES_UPDATE_INTERVAL 200 /* milliseconds */ + +/* + * A timeout before changes through the user/group combo box will be applied. + * When quickly changing owner/groups (i.e. by keyboard or scroll wheel), + * this ensures that the GUI doesn't end up unresponsive. + * + * Both combos react on changes by scheduling a new change and unscheduling + * or cancelling old pending changes. + */ +#define CHOWN_CHGRP_TIMEOUT 300 /* milliseconds */ + +static void schedule_directory_contents_update (NautilusPropertiesWindow *self); +static void directory_contents_value_field_update (NautilusPropertiesWindow *self); +static void file_changed_callback (NautilusFile *file, + gpointer user_data); +static void update_execution_row (GtkWidget *row, + TargetPermissions *target_perm); +static void update_permission_row (AdwComboRow *row, + TargetPermissions *target_perm); +static void value_field_update (GtkLabel *field, + NautilusPropertiesWindow *self); +static void properties_window_update (NautilusPropertiesWindow *self, + GList *files); +static void is_directory_ready_callback (NautilusFile *file, + gpointer data); +static void cancel_group_change_callback (GroupChange *change); +static void cancel_owner_change_callback (OwnerChange *change); +static void update_owner_row (AdwComboRow *row, + TargetPermissions *target_perm); +static void update_group_row (AdwComboRow *row, + TargetPermissions *target_perm); +static void select_image_button_callback (GtkWidget *widget, + NautilusPropertiesWindow *self); +static void set_icon (const char *icon_path, + NautilusPropertiesWindow *self); +static void remove_pending (StartupData *data, + gboolean cancel_call_when_ready, + gboolean cancel_timed_wait); +static void refresh_extension_model_pages (NautilusPropertiesWindow *self); +static gboolean is_root_directory (NautilusFile *file); + +G_DEFINE_TYPE (NautilusPropertiesWindow, nautilus_properties_window, ADW_TYPE_WINDOW); + +static gboolean +is_multi_file_window (NautilusPropertiesWindow *self) +{ + GList *l; + int count; + + count = 0; + + for (l = self->original_files; l != NULL; l = l->next) + { + if (!nautilus_file_is_gone (NAUTILUS_FILE (l->data))) + { + count++; + if (count > 1) + { + return TRUE; + } + } + } + + return FALSE; +} + +static NautilusFile * +get_original_file (NautilusPropertiesWindow *self) +{ + g_return_val_if_fail (!is_multi_file_window (self), NULL); + + if (self->original_files == NULL) + { + return NULL; + } + + return NAUTILUS_FILE (self->original_files->data); +} + +static NautilusFile * +get_target_file_for_original_file (NautilusFile *file) +{ + NautilusFile *target_file; + g_autoptr (GFile) location = NULL; + g_autofree char *uri_to_display = NULL; + + uri_to_display = nautilus_file_get_uri (file); + location = g_file_new_for_uri (uri_to_display); + target_file = nautilus_file_get (location); + + return target_file; +} + +static NautilusFile * +get_target_file (NautilusPropertiesWindow *self) +{ + return NAUTILUS_FILE (self->target_files->data); +} + +static void +navigate_main_page (NautilusPropertiesWindow *self, + GParamSpec *params, + GtkWidget *widget) +{ + gtk_stack_set_visible_child_name (self->page_stack, "main"); +} + +static void +navigate_permissions_page (NautilusPropertiesWindow *self, + GParamSpec *params, + GtkWidget *widget) +{ + gtk_stack_set_visible_child_name (self->page_stack, "permissions"); +} + +static void +navigate_extension_model_page (NautilusPropertiesWindow *self, + GParamSpec *params, + AdwPreferencesRow *row) +{ + gtk_stack_set_visible_child (self->page_stack, + g_object_get_data (G_OBJECT (row), + "nautilus-extension-properties-page")); +} + +static void +get_image_for_properties_window (NautilusPropertiesWindow *self, + char **icon_name, + GdkPaintable **icon_paintable) +{ + g_autoptr (NautilusIconInfo) icon = NULL; + GList *l; + gint icon_scale; + + icon_scale = gtk_widget_get_scale_factor (GTK_WIDGET (self)); + + for (l = self->original_files; l != NULL; l = l->next) + { + NautilusFile *file; + g_autoptr (NautilusIconInfo) new_icon = NULL; + + file = NAUTILUS_FILE (l->data); + + if (!icon) + { + icon = nautilus_file_get_icon (file, NAUTILUS_GRID_ICON_SIZE_MEDIUM, icon_scale, + NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS | + NAUTILUS_FILE_ICON_FLAGS_USE_MOUNT_ICON); + } + else + { + new_icon = nautilus_file_get_icon (file, NAUTILUS_GRID_ICON_SIZE_MEDIUM, icon_scale, + NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS | + NAUTILUS_FILE_ICON_FLAGS_USE_MOUNT_ICON); + if (!new_icon || new_icon != icon) + { + g_object_unref (icon); + icon = NULL; + break; + } + } + } + + if (!icon) + { + g_autoptr (GIcon) gicon = g_themed_icon_new ("text-x-generic"); + + icon = nautilus_icon_info_lookup (gicon, NAUTILUS_GRID_ICON_SIZE_MEDIUM, icon_scale); + } + + if (icon_name != NULL) + { + *icon_name = g_strdup (nautilus_icon_info_get_used_name (icon)); + } + + if (icon_paintable != NULL) + { + *icon_paintable = nautilus_icon_info_get_paintable (icon); + } +} + + +static void +update_properties_window_icon (NautilusPropertiesWindow *self) +{ + g_autoptr (GdkPaintable) paintable = NULL; + g_autofree char *name = NULL; + gint pixel_size; + + get_image_for_properties_window (self, &name, &paintable); + + if (name != NULL) + { + gtk_window_set_icon_name (GTK_WINDOW (self), name); + } + + pixel_size = MAX (gdk_paintable_get_intrinsic_width (paintable), + gdk_paintable_get_intrinsic_width (paintable)); + + gtk_image_set_from_paintable (GTK_IMAGE (self->icon_image), paintable); + gtk_image_set_from_paintable (GTK_IMAGE (self->icon_button_image), paintable); + gtk_image_set_pixel_size (GTK_IMAGE (self->icon_image), pixel_size); + gtk_image_set_pixel_size (GTK_IMAGE (self->icon_button_image), pixel_size); +} + +/* utility to test if a uri refers to a local image */ +static gboolean +uri_is_local_image (const char *uri) +{ + g_autoptr (GdkPixbuf) pixbuf = NULL; + g_autofree char *image_path = NULL; + + image_path = g_filename_from_uri (uri, NULL, NULL); + if (image_path == NULL) + { + return FALSE; + } + + pixbuf = gdk_pixbuf_new_from_file (image_path, NULL); + + if (pixbuf == NULL) + { + return FALSE; + } + + return TRUE; +} + +static void +reset_icon (NautilusPropertiesWindow *self) +{ + GList *l; + + for (l = self->original_files; l != NULL; l = l->next) + { + NautilusFile *file; + + file = NAUTILUS_FILE (l->data); + + nautilus_file_set_metadata (file, + NAUTILUS_METADATA_KEY_CUSTOM_ICON, + NULL, NULL); + } +} + +static void +nautilus_properties_window_drag_drop_cb (GtkDropTarget *target, + const GValue *value, + gdouble x, + gdouble y, + gpointer user_data) +{ + GSList *file_list; + gboolean exactly_one; + GtkImage *image; + GtkWindow *window; + + image = GTK_IMAGE (user_data); + window = GTK_WINDOW (gtk_widget_get_root (GTK_WIDGET (image))); + + if (!G_VALUE_HOLDS (value, GDK_TYPE_FILE_LIST)) + { + return; + } + + file_list = g_value_get_boxed (value); + exactly_one = file_list != NULL && g_slist_next (file_list) == NULL; + + if (!exactly_one) + { + show_dialog (_("You cannot assign more than one custom icon at a time!"), + _("Please drop just one image to set a custom icon."), + window, + GTK_MESSAGE_ERROR); + } + else + { + g_autofree gchar *uri = g_file_get_uri (file_list->data); + + if (uri_is_local_image (uri)) + { + set_icon (uri, NAUTILUS_PROPERTIES_WINDOW (window)); + } + else + { + if (!g_file_is_native (file_list->data)) + { + show_dialog (_("The file that you dropped is not local."), + _("You can only use local images as custom icons."), + window, + GTK_MESSAGE_ERROR); + } + else + { + show_dialog (_("The file that you dropped is not an image."), + _("You can only use local images as custom icons."), + window, + GTK_MESSAGE_ERROR); + } + } + } +} + +static void +star_clicked (NautilusPropertiesWindow *self) +{ + NautilusTagManager *tag_manager = nautilus_tag_manager_get (); + NautilusFile *file = get_original_file (self); + g_autofree gchar *uri = nautilus_file_get_uri (file); + + if (nautilus_tag_manager_file_is_starred (tag_manager, uri)) + { + nautilus_tag_manager_unstar_files (tag_manager, G_OBJECT (self), + &(GList){ file, NULL }, NULL, NULL); + } + else + { + nautilus_tag_manager_star_files (tag_manager, G_OBJECT (self), + &(GList){ file, NULL }, NULL, NULL); + } +} + +static void +update_star (NautilusPropertiesWindow *self, + NautilusTagManager *tag_manager) +{ + gboolean is_starred; + g_autofree gchar *file_uri = NULL; + + file_uri = nautilus_file_get_uri (get_target_file (self)); + is_starred = nautilus_tag_manager_file_is_starred (tag_manager, file_uri); + + gtk_button_set_icon_name (GTK_BUTTON (self->star_button), + is_starred ? "starred-symbolic" : "non-starred-symbolic"); + /* Translators: This is a verb for tagging or untagging a file with a star. */ + gtk_widget_set_tooltip_text (self->star_button, is_starred ? _("Unstar") : _("Star")); +} + +static void +on_starred_changed (NautilusTagManager *tag_manager, + GList *changed_files, + gpointer user_data) +{ + NautilusPropertiesWindow *self = user_data; + NautilusFile *file = get_target_file (self); + + if (g_list_find (changed_files, file)) + { + update_star (self, tag_manager); + } +} + +static void +setup_star_button (NautilusPropertiesWindow *self) +{ + NautilusTagManager *tag_manager = nautilus_tag_manager_get (); + NautilusFile *file = get_target_file (self); + g_autoptr (GFile) parent_location = nautilus_file_get_parent_location (file); + + if (parent_location == NULL) + { + return; + } + + if (nautilus_tag_manager_can_star_contents (tag_manager, parent_location)) + { + gtk_widget_show (self->star_button); + update_star (self, tag_manager); + g_signal_connect_object (tag_manager, "starred-changed", + G_CALLBACK (on_starred_changed), self, 0); + } +} + +static void +setup_image_widget (NautilusPropertiesWindow *self, + gboolean is_customizable) +{ + update_properties_window_icon (self); + + if (is_customizable) + { + GtkDropTarget *target; + + /* prepare the image to receive dropped objects to assign custom images */ + target = gtk_drop_target_new (GDK_TYPE_FILE_LIST, GDK_ACTION_COPY); + gtk_widget_add_controller (self->icon_button, GTK_EVENT_CONTROLLER (target)); + g_signal_connect (target, "drop", + G_CALLBACK (nautilus_properties_window_drag_drop_cb), self->icon_button_image); + + g_signal_connect (self->icon_button, "clicked", + G_CALLBACK (select_image_button_callback), self); + gtk_stack_set_visible_child (self->icon_stack, self->icon_button); + } + else + { + gtk_stack_set_visible_child (self->icon_stack, self->icon_image); + } +} + +static void +update_name_field (NautilusPropertiesWindow *self) +{ + g_autoptr (GString) name_str = g_string_new (""); + g_autofree gchar *os_name = NULL; + gchar *name_value; + guint file_counter = 0; + + for (GList *l = self->target_files; l != NULL; l = l->next) + { + NautilusFile *file = NAUTILUS_FILE (l->data); + + if (!nautilus_file_is_gone (file)) + { + g_autofree gchar *file_name = NULL; + + file_counter += 1; + if (file_counter > 1) + { + g_string_append (name_str, ", "); + } + + file_name = nautilus_file_get_display_name (file); + g_string_append (name_str, file_name); + } + } + + if (!is_multi_file_window (self) && is_root_directory (get_original_file (self))) + { + os_name = g_get_os_info (G_OS_INFO_KEY_NAME); + name_value = (os_name != NULL) ? os_name : _("Operating System"); + } + else + { + name_value = name_str->str; + } + + gtk_label_set_text (self->name_value_label, name_value); +} + +/** + * Returns the attribute value if all files in file_list have identical + * attributes, "unknown" if no files exist and NULL otherwise. + */ +static char * +file_list_get_string_attribute (GList *file_list, + const char *attribute_name) +{ + g_autofree char *first_attr = NULL; + + for (GList *l = file_list; l != NULL; l = l->next) + { + NautilusFile *file = NAUTILUS_FILE (l->data); + + if (nautilus_file_is_gone (file)) + { + continue; + } + + if (first_attr == NULL) + { + first_attr = nautilus_file_get_string_attribute_with_default (file, attribute_name); + } + else + { + g_autofree char *attr = NULL; + attr = nautilus_file_get_string_attribute_with_default (file, attribute_name); + if (!g_str_equal (attr, first_attr)) + { + /* Not all files have the same value for attribute_name. */ + return NULL; + } + } + } + + if (first_attr != NULL) + { + return g_steal_pointer (&first_attr); + } + else + { + return g_strdup (_("unknown")); + } +} + +static GtkWidget * +create_extension_group_row (NautilusPropertiesItem *item, + NautilusPropertiesWindow *self) +{ + GtkWidget *row = adw_action_row_new (); + GtkWidget *box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3); + GtkWidget *name_label = gtk_label_new (NULL); + GtkWidget *value_label = gtk_label_new (NULL); + + gtk_list_box_row_set_selectable (GTK_LIST_BOX_ROW (row), FALSE); + gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE); + adw_action_row_add_prefix (ADW_ACTION_ROW (row), box); + + gtk_widget_set_margin_top (box, 7); + gtk_widget_set_margin_bottom (box, 7); + gtk_box_append (GTK_BOX (box), name_label); + gtk_box_append (GTK_BOX (box), value_label); + + g_object_bind_property (item, "name", name_label, "label", G_BINDING_SYNC_CREATE); + gtk_widget_add_css_class (name_label, "caption"); + gtk_widget_add_css_class (name_label, "dim-label"); + gtk_widget_set_halign (name_label, GTK_ALIGN_START); + gtk_label_set_ellipsize (GTK_LABEL (name_label), PANGO_ELLIPSIZE_END); + + g_object_bind_property (item, "value", value_label, "label", G_BINDING_SYNC_CREATE); + gtk_widget_set_halign (value_label, GTK_ALIGN_START); + gtk_label_set_wrap (GTK_LABEL (value_label), TRUE); + gtk_label_set_wrap_mode (GTK_LABEL (value_label), PANGO_WRAP_WORD_CHAR); + gtk_label_set_selectable (GTK_LABEL (value_label), TRUE); + + return row; +} + +static GtkWidget * +add_extension_model_page (NautilusPropertiesModel *model, + NautilusPropertiesWindow *self) +{ + GListModel *list_model = nautilus_properties_model_get_model (model); + GtkWidget *row; + GtkWidget *title; + GtkWidget *header_bar; + GtkWidget *list_box; + GtkWidget *clamp; + GtkWidget *scrolled_window; + GtkWidget *up_button; + GtkWidget *box; + + row = adw_action_row_new (); + g_object_bind_property (model, "title", row, "title", G_BINDING_SYNC_CREATE); + gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), TRUE); + gtk_list_box_row_set_selectable (GTK_LIST_BOX_ROW (row), FALSE); + adw_action_row_add_suffix (ADW_ACTION_ROW (row), + gtk_image_new_from_icon_name ("go-next-symbolic")); + g_signal_connect_swapped (row, "activated", + G_CALLBACK (navigate_extension_model_page), self); + + title = adw_window_title_new (NULL, NULL); + g_object_bind_property (model, "title", title, "title", G_BINDING_SYNC_CREATE); + + up_button = gtk_button_new_from_icon_name ("go-previous-symbolic"); + g_signal_connect_swapped (up_button, "clicked", G_CALLBACK (navigate_main_page), self); + + header_bar = gtk_header_bar_new (); + gtk_header_bar_set_title_widget (GTK_HEADER_BAR (header_bar), title); + gtk_header_bar_pack_start (GTK_HEADER_BAR (header_bar), up_button); + + list_box = gtk_list_box_new (); + gtk_widget_add_css_class (list_box, "boxed-list"); + gtk_widget_set_valign (list_box, GTK_ALIGN_START); + gtk_list_box_bind_model (GTK_LIST_BOX (list_box), list_model, + (GtkListBoxCreateWidgetFunc) create_extension_group_row, + self, + NULL); + + clamp = adw_clamp_new (); + adw_clamp_set_child (ADW_CLAMP (clamp), list_box); + gtk_widget_set_margin_top (clamp, 18); + gtk_widget_set_margin_bottom (clamp, 18); + gtk_widget_set_margin_start (clamp, 18); + gtk_widget_set_margin_end (clamp, 18); + + scrolled_window = gtk_scrolled_window_new (); + gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (scrolled_window), clamp); + gtk_widget_set_vexpand (scrolled_window, TRUE); + + box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); + gtk_box_append (GTK_BOX (box), header_bar); + gtk_box_append (GTK_BOX (box), scrolled_window); + gtk_widget_add_css_class (scrolled_window, "background"); + + gtk_stack_add_named (self->page_stack, + box, + NULL); + + g_object_set_data (G_OBJECT (row), "nautilus-extension-properties-page", box); + + return row; +} + +static void +remove_from_dialog (NautilusPropertiesWindow *self, + NautilusFile *file) +{ + int index; + GList *original_link; + GList *target_link; + g_autoptr (NautilusFile) original_file = NULL; + g_autoptr (NautilusFile) target_file = NULL; + + index = g_list_index (self->target_files, file); + if (index == -1) + { + index = g_list_index (self->original_files, file); + g_return_if_fail (index != -1); + } + + original_link = g_list_nth (self->original_files, index); + target_link = g_list_nth (self->target_files, index); + + g_return_if_fail (original_link && target_link); + + original_file = NAUTILUS_FILE (original_link->data); + target_file = NAUTILUS_FILE (target_link->data); + + self->original_files = g_list_delete_link (self->original_files, original_link); + self->target_files = g_list_delete_link (self->target_files, target_link); + + g_hash_table_remove (self->initial_permissions, target_file); + + g_signal_handlers_disconnect_by_func (original_file, + G_CALLBACK (file_changed_callback), + self); + g_signal_handlers_disconnect_by_func (target_file, + G_CALLBACK (file_changed_callback), + self); + + nautilus_file_monitor_remove (original_file, &self->original_files); + nautilus_file_monitor_remove (target_file, &self->target_files); +} + +static gboolean +mime_list_equal (GList *a, + GList *b) +{ + while (a && b) + { + if (strcmp (a->data, b->data)) + { + return FALSE; + } + a = a->next; + b = b->next; + } + + return (a == b); +} + +static GList * +get_mime_list (NautilusPropertiesWindow *self) +{ + return g_list_copy_deep (self->target_files, + (GCopyFunc) nautilus_file_get_mime_type, + NULL); +} + +static gboolean +start_spinner_callback (NautilusPropertiesWindow *self) +{ + gtk_widget_show (self->contents_spinner); + gtk_spinner_start (GTK_SPINNER (self->contents_spinner)); + self->deep_count_spinner_timeout_id = 0; + + return FALSE; +} + +static void +schedule_start_spinner (NautilusPropertiesWindow *self) +{ + if (self->deep_count_spinner_timeout_id == 0) + { + self->deep_count_spinner_timeout_id + = g_timeout_add_seconds (1, + (GSourceFunc) start_spinner_callback, + self); + } +} + +static void +stop_spinner (NautilusPropertiesWindow *self) +{ + gtk_spinner_stop (GTK_SPINNER (self->contents_spinner)); + gtk_widget_hide (self->contents_spinner); + g_clear_handle_id (&self->deep_count_spinner_timeout_id, g_source_remove); +} + +static void +stop_deep_count_for_file (NautilusPropertiesWindow *self, + NautilusFile *file) +{ + if (g_list_find (self->deep_count_files, file)) + { + g_signal_handlers_disconnect_by_func (file, + G_CALLBACK (schedule_directory_contents_update), + self); + nautilus_file_unref (file); + self->deep_count_files = g_list_remove (self->deep_count_files, file); + } +} + +static void +start_deep_count_for_file (NautilusFile *file, + NautilusPropertiesWindow *self) +{ + if (!nautilus_file_is_directory (file)) + { + return; + } + + if (!g_list_find (self->deep_count_files, file)) + { + nautilus_file_ref (file); + self->deep_count_files = g_list_prepend (self->deep_count_files, file); + + nautilus_file_recompute_deep_counts (file); + if (!self->deep_count_finished) + { + g_signal_connect_object (file, + "updated-deep-count-in-progress", + G_CALLBACK (schedule_directory_contents_update), + self, G_CONNECT_SWAPPED); + schedule_start_spinner (self); + } + } +} + +static guint32 vfs_perms[3][3] = +{ + {UNIX_PERM_USER_READ, UNIX_PERM_USER_WRITE, UNIX_PERM_USER_EXEC}, + {UNIX_PERM_GROUP_READ, UNIX_PERM_GROUP_WRITE, UNIX_PERM_GROUP_EXEC}, + {UNIX_PERM_OTHER_READ, UNIX_PERM_OTHER_WRITE, UNIX_PERM_OTHER_EXEC}, +}; + +static guint32 +permission_to_vfs (PermissionType type, + PermissionValue perm) +{ + guint32 vfs_perm; + g_assert (type >= 0 && type < 3); + + vfs_perm = 0; + if (perm & PERMISSION_READ) + { + vfs_perm |= vfs_perms[type][0]; + } + if (perm & PERMISSION_WRITE) + { + vfs_perm |= vfs_perms[type][1]; + } + if (perm & PERMISSION_EXEC) + { + vfs_perm |= vfs_perms[type][2]; + } + + return vfs_perm; +} + +static PermissionValue +permission_from_vfs (PermissionType type, + guint32 vfs_perm) +{ + PermissionValue perm = PERMISSION_NONE; + + g_assert (type >= 0 && type < 3); + + if (vfs_perm & vfs_perms[type][0]) + { + perm |= PERMISSION_READ; + } + if (vfs_perm & vfs_perms[type][1]) + { + perm |= PERMISSION_WRITE; + } + if (vfs_perm & vfs_perms[type][2]) + { + perm |= PERMISSION_EXEC; + } + + return perm; +} + +static PermissionValue +exec_permission_from_vfs (guint32 vfs_perm) +{ + guint32 perm_user = vfs_perm & UNIX_PERM_USER_EXEC; + guint32 perm_group = vfs_perm & UNIX_PERM_GROUP_EXEC; + guint32 perm_other = vfs_perm & UNIX_PERM_OTHER_EXEC; + + if (perm_user && perm_group && perm_other) + { + return PERMISSION_EXEC; + } + else if (perm_user || perm_group || perm_other) + { + return PERMISSION_INCONSISTENT; + } + else + { + return PERMISSION_NONE; + } +} + +static TargetPermissions * +get_target_permissions (NautilusPropertiesWindow *self) +{ + TargetPermissions *p = g_new0 (TargetPermissions, 1); + p->window = self; + p->can_set_all_folder_permission = TRUE; + p->can_set_all_file_permission = TRUE; + + for (GList *entry = self->target_files; entry != NULL; entry = entry->next) + { + guint32 vfs_permissions; + gboolean can_set_permissions; + NautilusFile *file = NAUTILUS_FILE (entry->data); + + if (nautilus_file_is_gone (file) || !nautilus_file_can_get_permissions (file)) + { + continue; + } + + vfs_permissions = nautilus_file_get_permissions (file); + can_set_permissions = nautilus_file_can_set_permissions (file); + + if (nautilus_file_is_directory (file)) + { + /* Gather permissions for each type (owner, group, other) */ + for (PermissionType type = PERMISSION_USER; type < NUM_PERMISSION_TYPE; type += 1) + { + PermissionValue permissions = permission_from_vfs (type, vfs_permissions) + & (PERMISSION_READ | PERMISSION_WRITE | PERMISSION_EXEC); + if (!p->has_folders) + { + /* first found folder, initialize with its permissions */ + p->folder_permissions[type] = permissions; + } + else if (permissions != p->folder_permissions[type]) + { + p->folder_permissions[type] = PERMISSION_INCONSISTENT; + } + } + + p->can_set_all_folder_permission &= can_set_permissions; + p->has_folders = TRUE; + } + else + { + PermissionValue exec_permissions = exec_permission_from_vfs (vfs_permissions); + + if (!p->has_files) + { + p->file_exec_permissions = exec_permissions; + } + else if (exec_permissions != p->file_exec_permissions) + { + p->file_exec_permissions = PERMISSION_INCONSISTENT; + } + for (PermissionType type = PERMISSION_USER ; type < NUM_PERMISSION_TYPE; type += 1) + { + PermissionValue permissions = permission_from_vfs (type, vfs_permissions) + & (PERMISSION_READ | PERMISSION_WRITE); + + if (!p->has_files) + { + /* first found file, initialize with its permissions */ + p->file_permissions[type] = permissions; + } + else if (permissions != p->file_permissions[type]) + { + p->file_permissions[type] = PERMISSION_INCONSISTENT; + } + } + + p->can_set_all_file_permission &= can_set_permissions; + p->can_set_any_file_permission |= can_set_permissions; + p->has_files = TRUE; + } + } + + p->is_multi_file_window = is_multi_file_window (self); + + return p; +} + +static void +update_permissions_navigation_row (NautilusPropertiesWindow *self, + TargetPermissions *target_perm) +{ + if (!target_perm->is_multi_file_window) + { + uid_t user_id = geteuid (); + gid_t group_id = getegid (); + PermissionType permission_type = PERMISSION_OTHER; + const gchar *text; + + if (user_id == nautilus_file_get_uid (get_original_file (self))) + { + permission_type = PERMISSION_USER; + } + else if (group_id == nautilus_file_get_gid (get_original_file (self))) + { + permission_type = PERMISSION_GROUP; + } + + if (nautilus_file_is_directory (get_original_file (self))) + { + text = permission_value_to_string (target_perm->folder_permissions[permission_type], TRUE); + } + else + { + text = permission_value_to_string (target_perm->file_permissions[permission_type], FALSE); + } + + gtk_label_set_text (GTK_LABEL (self->permissions_value_label), text); + } +} + +static void +properties_window_update (NautilusPropertiesWindow *self, + GList *files) +{ + GList *mime_list; + NautilusFile *changed_file; + gboolean dirty_original = FALSE; + gboolean dirty_target = FALSE; + + if (files == NULL) + { + dirty_original = TRUE; + dirty_target = TRUE; + } + + for (GList *tmp = files; tmp != NULL; tmp = tmp->next) + { + changed_file = NAUTILUS_FILE (tmp->data); + + if (changed_file && nautilus_file_is_gone (changed_file)) + { + /* Remove the file from the property dialog */ + remove_from_dialog (self, changed_file); + changed_file = NULL; + + if (self->original_files == NULL) + { + return; + } + } + if (changed_file == NULL || + g_list_find (self->original_files, changed_file)) + { + dirty_original = TRUE; + } + if (changed_file == NULL || + g_list_find (self->target_files, changed_file)) + { + dirty_target = TRUE; + } + } + + if (dirty_original) + { + update_properties_window_icon (self); + update_name_field (self); + + /* If any of the value fields start to depend on the original + * value, value_field_updates should be added here */ + } + + if (dirty_target) + { + g_autofree TargetPermissions *target_perm = get_target_permissions (self); + + update_permissions_navigation_row (self, target_perm); + update_owner_row (self->owner_row, target_perm); + update_group_row (self->group_row, target_perm); + update_execution_row (GTK_WIDGET (self->execution_row), target_perm); + g_list_foreach (self->permission_rows, + (GFunc) update_permission_row, + target_perm); + g_list_foreach (self->value_fields, + (GFunc) value_field_update, + self); + } + + mime_list = get_mime_list (self); + + if (self->mime_list == NULL) + { + self->mime_list = mime_list; + } + else + { + if (!mime_list_equal (self->mime_list, mime_list)) + { + refresh_extension_model_pages (self); + } + + g_list_free_full (self->mime_list, g_free); + self->mime_list = mime_list; + } +} + +static gboolean +update_files_callback (gpointer data) +{ + NautilusPropertiesWindow *self; + + self = NAUTILUS_PROPERTIES_WINDOW (data); + + self->update_files_timeout_id = 0; + + properties_window_update (self, self->changed_files); + + if (self->original_files == NULL) + { + /* Close the window if no files are left */ + gtk_window_destroy (GTK_WINDOW (self)); + } + else + { + nautilus_file_list_free (self->changed_files); + self->changed_files = NULL; + } + + return FALSE; +} + +static void +schedule_files_update (NautilusPropertiesWindow *self) +{ + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + if (self->update_files_timeout_id == 0) + { + self->update_files_timeout_id + = g_timeout_add (FILES_UPDATE_INTERVAL, + update_files_callback, + self); + } +} + +static gboolean +location_show_original (NautilusPropertiesWindow *self) +{ + NautilusFile *file; + + /* there is no way a recent item will be mixed with + * other items so just pick the first file to check */ + file = NAUTILUS_FILE (g_list_nth_data (self->original_files, 0)); + return (file != NULL && !nautilus_file_is_in_recent (file)); +} + +static void +value_field_update (GtkLabel *label, + NautilusPropertiesWindow *self) +{ + GList *file_list; + const char *attribute_name; + g_autofree char *attribute_value = NULL; + gboolean is_where; + + g_assert (GTK_IS_LABEL (label)); + + attribute_name = g_object_get_data (G_OBJECT (label), "file_attribute"); + + is_where = (g_strcmp0 (attribute_name, "where") == 0); + if (is_where && location_show_original (self)) + { + file_list = self->original_files; + } + else + { + file_list = self->target_files; + } + + attribute_value = file_list_get_string_attribute (file_list, + attribute_name); + if (g_str_equal (attribute_name, "detailed_type")) + { + g_autofree char *mime_type = NULL; + gchar *cap_label; + + mime_type = file_list_get_string_attribute (file_list, "mime_type"); + gtk_widget_set_tooltip_text (GTK_WIDGET (label), mime_type); + + cap_label = eel_str_capitalize (attribute_value); + if (cap_label != NULL) + { + g_free (attribute_value); + + attribute_value = cap_label; + } + } + else if (g_str_equal (attribute_name, "size")) + { + g_autofree char *size_detail = NULL; + + size_detail = file_list_get_string_attribute (file_list, "size_detail"); + + gtk_widget_set_tooltip_text (GTK_WIDGET (label), size_detail); + } + + gtk_label_set_text (label, attribute_value); +} + +static guint +hash_string_list (GList *list) +{ + guint hash_value = 0; + + for (GList *node = list; node != NULL; node = node->next) + { + hash_value ^= g_str_hash ((gconstpointer) node->data); + } + + return hash_value; +} + +static gsize +get_first_word_length (const gchar *str) +{ + const gchar *space_pos = g_strstr_len (str, -1, " "); + return space_pos ? space_pos - str : strlen (str); +} + +static void +update_combo_row_dropdown (AdwComboRow *row, + GList *entries) +{ + /* check if dropdown already exist and is up to date by comparing with stored hash. */ + guint current_hash = hash_string_list (entries); + guint stored_hash = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (row), "dropdown-hash")); + + if (stored_hash != current_hash) + { + /* Recreate the drop down. */ + g_autoptr (GtkStringList) new_model = gtk_string_list_new (NULL); + + for (GList *node = entries; node != NULL; node = node->next) + { + const char *entry = (const char *) node->data; + gtk_string_list_append (new_model, entry); + } + + adw_combo_row_set_model (row, G_LIST_MODEL (new_model)); + + g_object_set_data (G_OBJECT (row), "dropdown-hash", GUINT_TO_POINTER (current_hash)); + } +} + +typedef gboolean CompareOwnershipRowFunc (GListModel *list, + guint position, + const char *str); + +static void +select_ownership_row_entry (AdwComboRow *row, + const char *entry, + CompareOwnershipRowFunc compare_func) +{ + GListModel *list = adw_combo_row_get_model (row); + guint index_to_select = GTK_INVALID_LIST_POSITION; + guint n_entries; + + /* check if entry is already selected */ + gint selected_pos = adw_combo_row_get_selected (row); + + if (selected_pos >= 0 + && compare_func (list, selected_pos, entry)) + { + /* entry already selected */ + return; + } + + /* check if entry exists in model list */ + n_entries = g_list_model_get_n_items (list); + + for (guint position = 0; position < n_entries; position += 1) + { + if (compare_func (list, position, entry)) + { + /* found entry in list, select it */ + index_to_select = position; + break; + } + } + + if (index_to_select == GTK_INVALID_LIST_POSITION) + { + /* entry not in list, add */ + gtk_string_list_append (GTK_STRING_LIST (list), entry); + index_to_select = n_entries; + } + + adw_combo_row_set_selected (row, index_to_select); +} + +static void +ownership_row_set_single_entry (AdwComboRow *row, + const char *entry, + CompareOwnershipRowFunc compare_func) +{ + GListModel *list = adw_combo_row_get_model (row); + gint selected_pos = adw_combo_row_get_selected (row); + + /* check entry not already displayed */ + if (selected_pos < 0 + || g_list_model_get_n_items (list) > 1 + || !compare_func (list, selected_pos, entry)) + { + g_autoptr (GtkStringList) new_model = gtk_string_list_new (NULL); + + /* set current entry as only entry */ + gtk_string_list_append (new_model, entry); + + adw_combo_row_set_model (row, G_LIST_MODEL (new_model)); + adw_combo_row_set_selected (row, 0); + } +} + +static void +group_change_free (GroupChange *change) +{ + nautilus_file_unref (change->file); + g_free (change->group); + g_object_unref (change->window); + + g_free (change); +} + +static void +group_change_callback (NautilusFile *file, + GFile *res_loc, + GError *error, + GroupChange *change) +{ + NautilusPropertiesWindow *self; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (change->window)); + g_assert (NAUTILUS_IS_FILE (change->file)); + g_assert (change->group != NULL); + + if (!change->cancelled) + { + /* Report the error if it's an error. */ + eel_timed_wait_stop ((EelCancelCallback) cancel_group_change_callback, change); + nautilus_report_error_setting_group (change->file, error, change->window); + } + + self = NAUTILUS_PROPERTIES_WINDOW (change->window); + if (self->group_change == change) + { + self->group_change = NULL; + } + + group_change_free (change); +} + +static void +cancel_group_change_callback (GroupChange *change) +{ + g_assert (NAUTILUS_IS_FILE (change->file)); + g_assert (change->group != NULL); + + change->cancelled = TRUE; + nautilus_file_cancel (change->file, (NautilusFileOperationCallback) group_change_callback, change); +} + +static gboolean +schedule_group_change_timeout (GroupChange *change) +{ + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (change->window)); + g_assert (NAUTILUS_IS_FILE (change->file)); + g_assert (change->group != NULL); + + change->timeout = 0; + + eel_timed_wait_start + ((EelCancelCallback) cancel_group_change_callback, + change, + _("Cancel Group Change?"), + change->window); + + nautilus_file_set_group + (change->file, change->group, + (NautilusFileOperationCallback) group_change_callback, change); + + return FALSE; +} + +static void +schedule_group_change (NautilusPropertiesWindow *self, + NautilusFile *file, + const char *group) +{ + GroupChange *change; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + g_assert (self->group_change == NULL); + g_assert (NAUTILUS_IS_FILE (file)); + + change = g_new0 (GroupChange, 1); + + change->file = nautilus_file_ref (file); + change->group = g_strdup (group); + change->window = GTK_WINDOW (g_object_ref (self)); + change->timeout = + g_timeout_add (CHOWN_CHGRP_TIMEOUT, + (GSourceFunc) schedule_group_change_timeout, + change); + + self->group_change = change; +} + +static void +unschedule_or_cancel_group_change (NautilusPropertiesWindow *self) +{ + GroupChange *change; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + change = self->group_change; + + if (change != NULL) + { + if (change->timeout == 0) + { + /* The operation was started, cancel it and let the operation callback free the change */ + cancel_group_change_callback (change); + eel_timed_wait_stop ((EelCancelCallback) cancel_group_change_callback, change); + } + else + { + g_source_remove (change->timeout); + group_change_free (change); + } + + self->group_change = NULL; + } +} + +/** Apply group owner change on user selection. */ +static void +changed_group_callback (AdwComboRow *row, + GParamSpec *pspec, + NautilusPropertiesWindow *self) +{ + guint selected_pos = adw_combo_row_get_selected (row); + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + if (selected_pos >= 0) + { + NautilusFile *file = get_target_file (self); + GListModel *list = adw_combo_row_get_model (row); + const gchar *new_group_name = gtk_string_list_get_string (GTK_STRING_LIST (list), selected_pos); + g_autofree char *current_group_name = nautilus_file_get_group_name (file); + + g_assert (new_group_name); + g_assert (current_group_name); + + if (strcmp (new_group_name, current_group_name) != 0) + { + /* Try to change file group. If this fails, complain to user. */ + unschedule_or_cancel_group_change (self); + schedule_group_change (self, file, new_group_name); + } + } +} + +static void +owner_change_free (OwnerChange *change) +{ + nautilus_file_unref (change->file); + g_free (change->owner); + g_object_unref (change->window); + + g_free (change); +} + +static void +owner_change_callback (NautilusFile *file, + GFile *result_location, + GError *error, + OwnerChange *change) +{ + NautilusPropertiesWindow *self; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (change->window)); + g_assert (NAUTILUS_IS_FILE (change->file)); + g_assert (change->owner != NULL); + + if (!change->cancelled) + { + /* Report the error if it's an error. */ + eel_timed_wait_stop ((EelCancelCallback) cancel_owner_change_callback, change); + nautilus_report_error_setting_owner (file, error, change->window); + } + + self = NAUTILUS_PROPERTIES_WINDOW (change->window); + if (self->owner_change == change) + { + self->owner_change = NULL; + } + + owner_change_free (change); +} + +static void +cancel_owner_change_callback (OwnerChange *change) +{ + g_assert (NAUTILUS_IS_FILE (change->file)); + g_assert (change->owner != NULL); + + change->cancelled = TRUE; + nautilus_file_cancel (change->file, (NautilusFileOperationCallback) owner_change_callback, change); +} + +static gboolean +schedule_owner_change_timeout (OwnerChange *change) +{ + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (change->window)); + g_assert (NAUTILUS_IS_FILE (change->file)); + g_assert (change->owner != NULL); + + change->timeout = 0; + + eel_timed_wait_start + ((EelCancelCallback) cancel_owner_change_callback, + change, + _("Cancel Owner Change?"), + change->window); + + nautilus_file_set_owner + (change->file, change->owner, + (NautilusFileOperationCallback) owner_change_callback, change); + + return FALSE; +} + +static void +schedule_owner_change (NautilusPropertiesWindow *self, + NautilusFile *file, + const char *owner) +{ + OwnerChange *change; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + g_assert (self->owner_change == NULL); + g_assert (NAUTILUS_IS_FILE (file)); + + change = g_new0 (OwnerChange, 1); + + change->file = nautilus_file_ref (file); + change->owner = g_strdup (owner); + change->window = GTK_WINDOW (g_object_ref (self)); + change->timeout = + g_timeout_add (CHOWN_CHGRP_TIMEOUT, + (GSourceFunc) schedule_owner_change_timeout, + change); + + self->owner_change = change; +} + +static void +unschedule_or_cancel_owner_change (NautilusPropertiesWindow *self) +{ + OwnerChange *change; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + change = self->owner_change; + + if (change != NULL) + { + g_assert (NAUTILUS_IS_FILE (change->file)); + + if (change->timeout == 0) + { + /* The operation was started, cancel it and let the operation callback free the change */ + cancel_owner_change_callback (change); + eel_timed_wait_stop ((EelCancelCallback) cancel_owner_change_callback, change); + } + else + { + g_source_remove (change->timeout); + owner_change_free (change); + } + + self->owner_change = NULL; + } +} + +static void +changed_owner_callback (AdwComboRow *row, + GParamSpec *pspec, + NautilusPropertiesWindow *self) +{ + guint selected_pos = adw_combo_row_get_selected (row); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + if (selected_pos >= 0) + { + NautilusFile *file = get_target_file (self); + + GListModel *list = adw_combo_row_get_model (row); + const gchar *selected_owner_str = gtk_string_list_get_string (GTK_STRING_LIST (list), selected_pos); + gsize owner_name_length = get_first_word_length (selected_owner_str); + g_autofree gchar *new_owner_name = g_strndup (selected_owner_str, owner_name_length); + g_autofree char *current_owner_name = nautilus_file_get_owner_name (file); + + g_assert (NAUTILUS_IS_FILE (file)); + + if (strcmp (new_owner_name, current_owner_name) != 0) + { + /* Try to change file owner. If this fails, complain to user. */ + unschedule_or_cancel_owner_change (self); + schedule_owner_change (self, file, new_owner_name); + } + } +} + +static gboolean +string_list_item_starts_with_word (GListModel *list, + guint position, + const char *word) +{ + const gchar *entry_str = gtk_string_list_get_string (GTK_STRING_LIST (list), position); + + return g_str_has_prefix (entry_str, word) + && strlen (word) == get_first_word_length (entry_str); +} + +static gboolean +string_list_item_equals_string (GListModel *list, + guint position, + const char *string) +{ + const gchar *entry_str = gtk_string_list_get_string (GTK_STRING_LIST (list), position); + + return strcmp (entry_str, string) == 0; +} + +/* Select correct owner if file permissions have changed. */ +static void +update_owner_row (AdwComboRow *row, + TargetPermissions *target_perm) +{ + NautilusPropertiesWindow *self = target_perm->window; + gboolean provide_dropdown = (!target_perm->is_multi_file_window + && nautilus_file_can_set_owner (get_target_file (self))); + gboolean had_dropdown = gtk_widget_is_sensitive (GTK_WIDGET (row)); + + gtk_widget_set_sensitive (GTK_WIDGET (row), provide_dropdown); + + /* check if should provide dropdown */ + if (provide_dropdown) + { + NautilusFile *file = get_target_file (self); + g_autofree char *owner_name = nautilus_file_get_owner_name (file); + GList *users = nautilus_get_user_names (); + + update_combo_row_dropdown (row, users); + + /* display current owner */ + select_ownership_row_entry (row, owner_name, string_list_item_starts_with_word); + + if (!had_dropdown) + { + /* Update file when selection changes. */ + g_signal_connect (row, "notify::selected", + G_CALLBACK (changed_owner_callback), + self); + } + } + else + { + g_autofree char *owner_name = file_list_get_string_attribute (self->target_files, + "owner"); + if (owner_name == NULL) + { + owner_name = g_strdup (_("Multiple")); + } + + g_signal_handlers_disconnect_by_func (row, G_CALLBACK (changed_owner_callback), self); + + ownership_row_set_single_entry (row, owner_name, string_list_item_starts_with_word); + } +} + +/* Select correct group if file permissions have changed. */ +static void +update_group_row (AdwComboRow *row, + TargetPermissions *target_perm) +{ + NautilusPropertiesWindow *self = target_perm->window; + gboolean provide_dropdown = (!target_perm->is_multi_file_window + && nautilus_file_can_set_group (get_target_file (self))); + gboolean had_dropdown = gtk_widget_is_sensitive (GTK_WIDGET (row)); + + gtk_widget_set_sensitive (GTK_WIDGET (row), provide_dropdown); + + if (provide_dropdown) + { + NautilusFile *file = get_target_file (self); + g_autofree char *group_name = nautilus_file_get_group_name (file); + GList *groups = nautilus_file_get_settable_group_names (file); + update_combo_row_dropdown (row, groups); + + /* display current group */ + select_ownership_row_entry (row, group_name, string_list_item_equals_string); + + if (!had_dropdown) + { + /* Update file when selection changes. */ + g_signal_connect (row, "notify::selected", + G_CALLBACK (changed_group_callback), + self); + } + } + else + { + g_autofree char *group_name = file_list_get_string_attribute (self->target_files, + "group"); + if (group_name == NULL) + { + group_name = g_strdup (_("Multiple")); + } + + g_signal_handlers_disconnect_by_func (row, G_CALLBACK (changed_group_callback), self); + + ownership_row_set_single_entry (row, group_name, string_list_item_equals_string); + } +} + +static void +setup_ownership_row (NautilusPropertiesWindow *self, + AdwComboRow *row) +{ + adw_combo_row_set_model (row, G_LIST_MODEL (gtk_string_list_new (NULL))); + + /* Intial setup of list model is handled via update function, called via properties_window_update. */ +} + +static gboolean +file_has_prefix (NautilusFile *file, + GList *prefix_candidates) +{ + GList *p; + g_autoptr (GFile) location = NULL; + + location = nautilus_file_get_location (file); + + for (p = prefix_candidates; p != NULL; p = p->next) + { + g_autoptr (GFile) candidate_location = NULL; + + if (file == p->data) + { + continue; + } + + candidate_location = nautilus_file_get_location (NAUTILUS_FILE (p->data)); + if (g_file_has_prefix (location, candidate_location)) + { + return TRUE; + } + } + + return FALSE; +} + +static void +directory_contents_value_field_update (NautilusPropertiesWindow *self) +{ + NautilusRequestStatus file_status; + g_autofree char *text = NULL; + guint directory_count; + guint file_count; + guint total_count; + guint unreadable_directory_count; + goffset total_size; + NautilusFile *file; + GList *l; + guint file_unreadable; + goffset file_size; + gboolean deep_count_active; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + total_count = 0; + total_size = 0; + unreadable_directory_count = FALSE; + + for (l = self->target_files; l; l = l->next) + { + file = NAUTILUS_FILE (l->data); + + if (file_has_prefix (file, self->target_files)) + { + /* don't count nested files twice */ + continue; + } + + if (nautilus_file_is_directory (file)) + { + file_status = nautilus_file_get_deep_counts (file, + &directory_count, + &file_count, + &file_unreadable, + &file_size, + TRUE); + total_count += (file_count + directory_count); + total_size += file_size; + + if (file_unreadable) + { + unreadable_directory_count = TRUE; + } + + if (file_status == NAUTILUS_REQUEST_DONE) + { + stop_deep_count_for_file (self, file); + } + } + else + { + ++total_count; + total_size += nautilus_file_get_size (file); + } + } + + deep_count_active = (self->deep_count_files != NULL); + /* If we've already displayed the total once, don't do another visible + * count-up if the deep_count happens to get invalidated. + * But still display the new total, since it might have changed. + */ + if (self->deep_count_finished && deep_count_active) + { + return; + } + + text = NULL; + + if (total_count == 0) + { + if (!deep_count_active) + { + if (unreadable_directory_count == 0) + { + text = g_strdup (_("Empty folder")); + } + else + { + text = g_strdup (_("Contents unreadable")); + } + } + else + { + text = g_strdup ("…"); + } + } + else + { + g_autofree char *size_str = NULL; + size_str = g_format_size (total_size); + text = g_strdup_printf (ngettext ("%'d item, with size %s", + "%'d items, totalling %s", + total_count), + total_count, size_str); + + if (unreadable_directory_count != 0) + { + g_autofree char *temp = g_steal_pointer (&text); + + text = g_strconcat (temp, "\n", + _("(some contents unreadable)"), + NULL); + } + } + + gtk_label_set_text (GTK_LABEL (self->contents_value_label), + text); + + if (!deep_count_active) + { + self->deep_count_finished = TRUE; + stop_spinner (self); + } +} + +static gboolean +update_directory_contents_callback (gpointer data) +{ + NautilusPropertiesWindow *self; + + self = NAUTILUS_PROPERTIES_WINDOW (data); + + self->update_directory_contents_timeout_id = 0; + directory_contents_value_field_update (self); + + return FALSE; +} + +static void +schedule_directory_contents_update (NautilusPropertiesWindow *self) +{ + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + if (self->update_directory_contents_timeout_id == 0) + { + self->update_directory_contents_timeout_id + = g_timeout_add (DIRECTORY_CONTENTS_UPDATE_INTERVAL, + update_directory_contents_callback, + self); + } +} + +static void +setup_contents_field (NautilusPropertiesWindow *self) +{ + g_list_foreach (self->target_files, + (GFunc) start_deep_count_for_file, + self); + + /* Fill in the initial value. */ + directory_contents_value_field_update (self); +} + +static gboolean +is_root_directory (NautilusFile *file) +{ + g_autoptr (GFile) location = NULL; + gboolean result; + + location = nautilus_file_get_location (file); + result = nautilus_is_root_directory (location); + + return result; +} + +static gboolean +is_network_directory (NautilusFile *file) +{ + g_autofree char *file_uri = NULL; + + file_uri = nautilus_file_get_uri (file); + + return strcmp (file_uri, "network:///") == 0; +} + +static gboolean +is_burn_directory (NautilusFile *file) +{ + g_autofree char *file_uri = NULL; + + file_uri = nautilus_file_get_uri (file); + + return strcmp (file_uri, "burn:///") == 0; +} + + +static gboolean +is_volume_properties (NautilusPropertiesWindow *self) +{ + NautilusFile *file; + gboolean success = FALSE; + + if (is_multi_file_window (self)) + { + return FALSE; + } + + file = get_original_file (self); + + if (file == NULL) + { + return FALSE; + } + + if (is_root_directory (file) && nautilus_application_is_sandboxed ()) + { + return FALSE; + } + + if (nautilus_file_can_unmount (file)) + { + return TRUE; + } + + success = is_root_directory (file); + +#ifdef TODO_GIO + /* Look at is_mountpoint for activation uri */ +#endif + + return success; +} + +static gboolean +should_show_custom_icon_buttons (NautilusPropertiesWindow *self) +{ + if (is_multi_file_window (self) || is_volume_properties (self) || + is_root_directory (get_original_file (self))) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +is_single_file_type (NautilusPropertiesWindow *self) +{ + if (is_multi_file_window (self)) + { + g_autofree gchar *mime_type = NULL; + GList *l = self->original_files; + + mime_type = nautilus_file_get_mime_type (NAUTILUS_FILE (l->data)); + for (l = l->next; l != NULL; l = l->next) + { + g_autofree gchar *next_mime_type = NULL; + + if (nautilus_file_is_gone (NAUTILUS_FILE (l->data))) + { + continue; + } + + next_mime_type = nautilus_file_get_mime_type (NAUTILUS_FILE (l->data)); + if (g_strcmp0 (next_mime_type, mime_type) != 0) + { + return FALSE; + } + } + } + + return TRUE; +} + +static gboolean +should_show_file_type (NautilusPropertiesWindow *self) +{ + if (!is_single_file_type (self)) + { + return FALSE; + } + + if (!is_multi_file_window (self) + && (nautilus_file_is_in_trash (get_target_file (self)) || + nautilus_file_is_directory (get_original_file (self)) || + is_network_directory (get_target_file (self)) || + is_burn_directory (get_target_file (self)) || + is_volume_properties (self))) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +should_show_location_info (NautilusPropertiesWindow *self) +{ + GList *l; + + for (l = self->original_files; l != NULL; l = l->next) + { + if (nautilus_file_is_in_trash (NAUTILUS_FILE (l->data)) || + is_root_directory (NAUTILUS_FILE (l->data)) || + is_network_directory (NAUTILUS_FILE (l->data)) || + is_burn_directory (NAUTILUS_FILE (l->data))) + { + return FALSE; + } + } + + return TRUE; +} + +static gboolean +should_show_trashed_info (NautilusPropertiesWindow *self) +{ + GList *l; + + for (l = self->original_files; l != NULL; l = l->next) + { + if (!nautilus_file_is_in_trash (NAUTILUS_FILE (l->data))) + { + return FALSE; + } + } + + return TRUE; +} + +static gboolean +should_show_accessed_date (NautilusPropertiesWindow *self) +{ + /* Accessed date for directory seems useless. If we some + * day decide that it is useful, we should separately + * consider whether it's useful for "trash:". + */ + if (nautilus_file_list_are_all_folders (self->target_files) + || is_multi_file_window (self)) + { + return FALSE; + } + + return TRUE; +} + +static gboolean +should_show_modified_date (NautilusPropertiesWindow *self) +{ + return !is_multi_file_window (self); +} + +static gboolean +should_show_created_date (NautilusPropertiesWindow *self) +{ + return !is_multi_file_window (self); +} + +static gboolean +should_show_link_target (NautilusPropertiesWindow *self) +{ + if (!is_multi_file_window (self) + && nautilus_file_is_symbolic_link (get_target_file (self))) + { + return TRUE; + } + + return FALSE; +} + +static gboolean +should_show_free_space (NautilusPropertiesWindow *self) +{ + if (!is_multi_file_window (self) + && (nautilus_file_is_in_trash (get_target_file (self)) || + is_network_directory (get_target_file (self)) || + nautilus_file_is_in_recent (get_target_file (self)) || + is_burn_directory (get_target_file (self)) || + is_volume_properties (self))) + { + return FALSE; + } + + if (nautilus_file_list_are_all_folders (self->target_files)) + { + return TRUE; + } + + return FALSE; +} + +static gboolean +should_show_volume_usage (NautilusPropertiesWindow *self) +{ + return is_volume_properties (self); +} + +static void +setup_volume_information (NautilusPropertiesWindow *self) +{ + NautilusFile *file; + g_autofree gchar *capacity = NULL; + g_autofree gchar *used = NULL; + g_autofree gchar *free = NULL; + const char *fs_type; + g_autofree gchar *uri = NULL; + g_autoptr (GFile) location = NULL; + g_autoptr (GFileInfo) info = NULL; + + capacity = g_format_size (self->volume_capacity); + free = g_format_size (self->volume_free); + used = g_format_size (self->volume_used); + + file = get_original_file (self); + + uri = nautilus_file_get_activation_uri (file); + + gtk_label_set_text (GTK_LABEL (self->disk_space_used_value), used); + gtk_label_set_text (GTK_LABEL (self->disk_space_free_value), free); + gtk_label_set_text (GTK_LABEL (self->disk_space_capacity_value), capacity); + + location = g_file_new_for_uri (uri); + info = g_file_query_filesystem_info (location, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, + NULL, NULL); + if (info) + { + fs_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE); + + /* We shouldn't be using filesystem::type, it's not meant for UI. + * https://gitlab.gnome.org/GNOME/nautilus/-/issues/98 + * + * Until we fix that issue, workaround this common outrageous case. */ + if (g_strcmp0 (fs_type, "msdos") == 0) + { + fs_type = "FAT"; + } + + if (fs_type != NULL) + { + /* Translators: %s will be filled with a filesystem type, such as 'ext4' or 'msdos'. */ + g_autofree gchar *fs_label = g_strdup_printf (_("%s Filesystem"), fs_type); + gchar *cap_label = eel_str_capitalize (fs_label); + if (cap_label != NULL) + { + g_free (fs_label); + fs_label = cap_label; + } + + gtk_label_set_text (self->type_file_system_label, fs_label); + gtk_widget_show (GTK_WIDGET (self->type_file_system_label)); + } + } + + gtk_level_bar_set_value (self->disk_space_level_bar, (double) self->volume_used / (double) self->volume_capacity); + /* display color changing based on filled level */ + gtk_level_bar_add_offset_value (self->disk_space_level_bar, GTK_LEVEL_BAR_OFFSET_FULL, 0.0); +} + +static void +setup_volume_usage_widget (NautilusPropertiesWindow *self) +{ + NautilusFile *file; + g_autofree gchar *uri = NULL; + g_autoptr (GFile) location = NULL; + g_autoptr (GFileInfo) info = NULL; + + file = get_original_file (self); + + uri = nautilus_file_get_activation_uri (file); + + location = g_file_new_for_uri (uri); + info = g_file_query_filesystem_info (location, "filesystem::*", NULL, NULL); + + if (info) + { + self->volume_capacity = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE); + self->volume_free = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE); + if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_FILESYSTEM_USED)) + { + self->volume_used = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_USED); + } + else + { + self->volume_used = self->volume_capacity - self->volume_free; + } + } + else + { + self->volume_capacity = 0; + self->volume_free = 0; + self->volume_used = 0; + } + + if (self->volume_capacity > 0) + { + setup_volume_information (self); + } +} + +static void +open_parent_folder (NautilusPropertiesWindow *self) +{ + g_autoptr (GFile) parent_location = NULL; + + parent_location = nautilus_file_get_parent_location (get_target_file (self)); + g_return_if_fail (parent_location != NULL); + + nautilus_application_open_location_full (NAUTILUS_APPLICATION (g_application_get_default ()), + parent_location, + NAUTILUS_OPEN_FLAG_NEW_WINDOW, + &(GList){get_original_file (self), NULL}, + NULL, NULL); +} + +static void +open_link_target (NautilusPropertiesWindow *self) +{ + g_autofree gchar *link_target_uri = NULL; + g_autoptr (GFile) link_target_location = NULL; + g_autoptr (NautilusFile) link_target_file = NULL; + g_autoptr (GFile) parent_location = NULL; + + link_target_uri = nautilus_file_get_symbolic_link_target_uri (get_target_file (self)); + g_return_if_fail (link_target_uri != NULL); + link_target_location = g_file_new_for_uri (link_target_uri); + link_target_file = nautilus_file_get (link_target_location); + parent_location = nautilus_file_get_parent_location (link_target_file); + g_return_if_fail (parent_location != NULL); + + nautilus_application_open_location_full (NAUTILUS_APPLICATION (g_application_get_default ()), + parent_location, + NAUTILUS_OPEN_FLAG_NEW_WINDOW, + &(GList){link_target_file, NULL}, + NULL, NULL); +} + +static void +open_in_disks (NautilusPropertiesWindow *self) +{ + NautilusDBusLauncher *launcher = nautilus_dbus_launcher_get (); + g_autoptr (GMount) mount = NULL; + g_autoptr (GVolume) volume = NULL; + g_autofree gchar *device_identifier = NULL; + GVariant *parameters; + + mount = nautilus_file_get_mount (get_original_file (self)); + volume = (mount != NULL) ? g_mount_get_volume (mount) : NULL; + + if (volume != NULL) + { + device_identifier = g_volume_get_identifier (volume, + G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); + } + else + { + g_autoptr (GFile) location = NULL; + g_autofree gchar *path = NULL; + g_autoptr (GUnixMountEntry) mount_entry = NULL; + + location = nautilus_file_get_location (get_original_file (self)); + path = g_file_get_path (location); + mount_entry = (path != NULL) ? g_unix_mount_at (path, NULL) : NULL; + if (mount_entry != NULL) + { + device_identifier = g_strdup (g_unix_mount_get_device_path (mount_entry)); + } + } + + if (device_identifier != NULL) + { + parameters = g_variant_new_parsed ("(objectpath '/org/gnome/DiskUtility', " + "@aay [], {'options': <{'block-device': <%s>}> })", + device_identifier); + } + else + { + parameters = g_variant_new_parsed ("(objectpath '/org/gnome/DiskUtility', @aay [], @a{sv} {})"); + } + + nautilus_dbus_launcher_call (launcher, + NAUTILUS_DBUS_LAUNCHER_DISKS, + "CommandLine", parameters, + GTK_WINDOW (self)); +} + +static void +add_updatable_label (NautilusPropertiesWindow *self, + GtkWidget *label, + const char *file_attribute) +{ + g_object_set_data_full (G_OBJECT (label), "file_attribute", + g_strdup (file_attribute), g_free); + + self->value_fields = g_list_prepend (self->value_fields, label); +} + +static void +setup_basic_page (NautilusPropertiesWindow *self) +{ + gboolean should_show_locations_list_box = FALSE; + + /* Icon pixmap */ + + setup_image_widget (self, should_show_custom_icon_buttons (self)); + + self->icon_chooser = NULL; + + if (!is_multi_file_window (self)) + { + setup_star_button (self); + } + + update_name_field (self); + + if (should_show_volume_usage (self)) + { + gtk_widget_show (self->disk_list_box); + setup_volume_usage_widget (self); + } + + if (should_show_file_type (self)) + { + gtk_widget_show (self->type_value_label); + add_updatable_label (self, self->type_value_label, "detailed_type"); + } + + if (should_show_link_target (self)) + { + gtk_widget_show (self->link_target_row); + add_updatable_label (self, self->link_target_value_label, "link_target"); + + should_show_locations_list_box = TRUE; + } + + if (is_multi_file_window (self) || + nautilus_file_is_directory (get_target_file (self))) + { + /* We have a more efficient way to measure used space in volumes. */ + if (!is_volume_properties (self)) + { + gtk_widget_show (self->contents_box); + setup_contents_field (self); + } + } + else + { + gtk_widget_show (self->size_value_label); + add_updatable_label (self, self->size_value_label, "size"); + } + + if (should_show_location_info (self)) + { + gtk_widget_show (self->parent_folder_row); + add_updatable_label (self, self->parent_folder_value_label, "where"); + + should_show_locations_list_box = TRUE; + } + + if (should_show_trashed_info (self)) + { + gtk_widget_show (self->trashed_list_box); + add_updatable_label (self, self->original_folder_value_label, "trash_orig_path"); + add_updatable_label (self, self->trashed_on_value_label, "trashed_on_full"); + } + + if (should_show_modified_date (self)) + { + gtk_widget_show (self->times_list_box); + gtk_widget_show (self->modified_row); + add_updatable_label (self, self->modified_value_label, "date_modified_full"); + } + + if (should_show_created_date (self)) + { + gtk_widget_show (self->created_row); + gtk_widget_show (self->times_list_box); + add_updatable_label (self, self->created_value_label, "date_created_full"); + } + + if (should_show_accessed_date (self)) + { + gtk_widget_show (self->times_list_box); + gtk_widget_show (self->accessed_row); + add_updatable_label (self, self->accessed_value_label, "date_accessed_full"); + } + + if (should_show_free_space (self)) + { + /* We have a more efficient way to measure free space in volumes. */ + if (!is_volume_properties (self)) + { + gtk_widget_show (self->free_space_value_label); + add_updatable_label (self, self->free_space_value_label, "free_space"); + } + } + + if (should_show_locations_list_box) + { + gtk_widget_show (self->locations_list_box); + } +} + +static FilterType +files_get_filter_type (NautilusPropertiesWindow *self) +{ + FilterType filter_type = NO_FILES_OR_FOLDERS; + + for (GList *l = self->target_files; l != NULL && filter_type != FILES_AND_FOLDERS; l = l->next) + { + NautilusFile *file = NAUTILUS_FILE (l->data); + if (nautilus_file_is_directory (file)) + { + filter_type |= FOLDERS_ONLY; + } + else + { + filter_type |= FILES_ONLY; + } + } + + return filter_type; +} + +static gboolean +file_matches_filter_type (NautilusFile *file, + FilterType filter_type) +{ + gboolean is_directory = nautilus_file_is_directory (file); + + switch (filter_type) + { + case FILES_AND_FOLDERS: + { + return TRUE; + } + + case FILES_ONLY: + { + return !is_directory; + } + + case FOLDERS_ONLY: + { + return is_directory; + } + + default: + { + return FALSE; + } + } +} + +static gboolean +files_has_changable_permissions_directory (NautilusPropertiesWindow *self) +{ + GList *l; + gboolean changable = FALSE; + + for (l = self->target_files; l != NULL; l = l->next) + { + NautilusFile *file; + file = NAUTILUS_FILE (l->data); + if (nautilus_file_is_directory (file) && + nautilus_file_can_get_permissions (file) && + nautilus_file_can_set_permissions (file)) + { + changable = TRUE; + } + else + { + changable = FALSE; + break; + } + } + + return changable; +} + +static void +start_long_operation (NautilusPropertiesWindow *self) +{ + if (self->long_operation_underway == 0) + { + /* start long operation */ + gtk_widget_set_cursor_from_name (GTK_WIDGET (self), "wait"); + } + self->long_operation_underway++; +} + +static void +end_long_operation (NautilusPropertiesWindow *self) +{ + if (gtk_native_get_surface (GTK_NATIVE (self)) != NULL && + self->long_operation_underway == 1) + { + /* finished !! */ + gtk_widget_set_cursor (GTK_WIDGET (self), NULL); + } + self->long_operation_underway--; +} + +static void +permission_change_callback (NautilusFile *file, + GFile *res_loc, + GError *error, + gpointer callback_data) +{ + g_autoptr (NautilusPropertiesWindow) self = NAUTILUS_PROPERTIES_WINDOW (callback_data); + g_assert (self != NULL); + + end_long_operation (self); + + /* Report the error if it's an error. */ + nautilus_report_error_setting_permissions (file, error, GTK_WINDOW (self)); +} + +static void +update_permissions (NautilusPropertiesWindow *self, + guint32 vfs_new_perm, + guint32 vfs_mask, + FilterType filter_type, + gboolean use_original) +{ + for (GList *l = self->target_files; l != NULL; l = l->next) + { + NautilusFile *file = NAUTILUS_FILE (l->data); + guint32 permissions; + + if (!nautilus_file_can_get_permissions (file)) + { + continue; + } + + if (!nautilus_file_can_get_permissions (file) || !file_matches_filter_type (file, filter_type)) + { + continue; + } + + permissions = nautilus_file_get_permissions (file); + if (use_original) + { + gpointer ptr; + if (g_hash_table_lookup_extended (self->initial_permissions, + file, NULL, &ptr)) + { + permissions = (permissions & ~vfs_mask) | (GPOINTER_TO_INT (ptr) & vfs_mask); + } + } + else + { + permissions = (permissions & ~vfs_mask) | vfs_new_perm; + } + + start_long_operation (self); + g_object_ref (self); + nautilus_file_set_permissions + (file, permissions, + permission_change_callback, + self); + } +} + +static void +execution_bit_changed (NautilusPropertiesWindow *self, + GParamSpec *params, + GtkWidget *widget) +{ + const guint32 permission_mask = UNIX_PERM_USER_EXEC | UNIX_PERM_GROUP_EXEC | UNIX_PERM_OTHER_EXEC; + const FilterType filter_type = FILES_ONLY; + + /* if activated from switch, switch state is already toggled, thus invert value via XOR. */ + gboolean active = gtk_switch_get_state (self->execution_switch) ^ GTK_IS_SWITCH (widget); + gboolean set_executable = !active; + + update_permissions (self, + set_executable ? permission_mask : 0, + permission_mask, + filter_type, + FALSE); +} + +static gboolean +should_show_exectution_switch (NautilusPropertiesWindow *self) +{ + g_autofree gchar *mime_type = NULL; + + if (is_multi_file_window (self)) + { + return FALSE; + } + + mime_type = nautilus_file_get_mime_type (get_target_file (self)); + return g_content_type_can_be_executable (mime_type); +} + +static void +update_execution_row (GtkWidget *row, + TargetPermissions *target_perm) +{ + NautilusPropertiesWindow *self = target_perm->window; + + if (!should_show_exectution_switch (self)) + { + gtk_widget_hide (GTK_WIDGET (self->execution_row)); + } + else + { + g_signal_handlers_block_by_func (self->execution_switch, + G_CALLBACK (execution_bit_changed), + self); + + gtk_switch_set_state (self->execution_switch, + target_perm->file_exec_permissions == PERMISSION_EXEC); + + g_signal_handlers_unblock_by_func (self->execution_switch, + G_CALLBACK (execution_bit_changed), + self); + + gtk_widget_set_sensitive (row, + target_perm->can_set_any_file_permission); + + gtk_widget_show (GTK_WIDGET (self->execution_row)); + } +} + +static void +on_permission_row_change (AdwComboRow *row, + GParamSpec *pspec, + NautilusPropertiesWindow *self) +{ + GListModel *list = adw_combo_row_get_model (row); + guint position = adw_combo_row_get_selected (row); + g_autoptr (NautilusPermissionEntry) entry = NULL; + FilterType filter_type; + gboolean use_original; + PermissionType type; + PermissionValue mask; + guint32 vfs_new_perm, vfs_mask; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + if (position == GTK_INVALID_LIST_POSITION) + { + return; + } + + filter_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "filter-type")); + type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "permission-type")); + + mask = PERMISSION_READ | PERMISSION_WRITE | ((filter_type == FOLDERS_ONLY) * PERMISSION_EXEC); + vfs_mask = permission_to_vfs (type, mask); + + entry = g_list_model_get_item (list, position); + vfs_new_perm = permission_to_vfs (type, entry->permission_value); + use_original = entry->permission_value & PERMISSION_INCONSISTENT; + + update_permissions (self, vfs_new_perm, vfs_mask, + filter_type, use_original); +} + +static void +list_store_append_nautilus_permission_entry (GListStore *list, + PermissionValue permission_value, + gboolean describes_folder) +{ + g_autoptr (NautilusPermissionEntry) entry = g_object_new (NAUTILUS_TYPE_PERMISSION_ENTRY, NULL); + + entry->name = g_strdup (permission_value_to_string (permission_value, describes_folder)); + entry->permission_value = permission_value; + + g_list_store_append (list, entry); +} + +static gint +get_permission_value_list_position (GListModel *list, + PermissionValue wanted_permissions) +{ + const guint n_entries = g_list_model_get_n_items (list); + + for (guint position = 0; position < n_entries; position += 1) + { + g_autoptr (NautilusPermissionEntry) entry = g_list_model_get_item (list, position); + if (entry->permission_value == wanted_permissions) + { + return position; + } + } + + return -1; +} + +static void +update_permission_row (AdwComboRow *row, + TargetPermissions *target_perm) +{ + NautilusPropertiesWindow *self = target_perm->window; + PermissionType type; + PermissionValue permissions_to_show; + FilterType filter_type; + gboolean is_folder; + GListModel *model; + gint position; + + model = adw_combo_row_get_model (row); + + filter_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "filter-type")); + is_folder = (FOLDERS_ONLY == filter_type); + type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "permission-type")); + + permissions_to_show = is_folder ? target_perm->folder_permissions[type] : + target_perm->file_permissions[type] & ~PERMISSION_EXEC; + + g_signal_handlers_block_by_func (G_OBJECT (row), + G_CALLBACK (on_permission_row_change), + self); + + position = get_permission_value_list_position (model, permissions_to_show); + + if (position == GTK_INVALID_LIST_POSITION) + { + /* configured permissions not listed, create new entry */ + position = g_list_model_get_n_items (model); + list_store_append_nautilus_permission_entry (G_LIST_STORE (model), permissions_to_show, is_folder); + } + + adw_combo_row_set_selected (row, position); + + /* Also enable if no files found (for recursive + * file changes when only selecting folders) */ + gtk_widget_set_sensitive (GTK_WIDGET (row), is_folder ? + target_perm->can_set_all_folder_permission : + target_perm->can_set_all_file_permission); + + g_signal_handlers_unblock_by_func (G_OBJECT (row), + G_CALLBACK (on_permission_row_change), + self); +} + +static void +setup_permissions_combo_box (GtkComboBox *combo, + PermissionType type, + FilterType filter_type) +{ + g_autoptr (GtkListStore) store = NULL; + GtkCellRenderer *cell; + GtkTreeIter iter; + + store = gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING); + gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); + gtk_combo_box_set_id_column (GTK_COMBO_BOX (combo), COLUMN_ID); + + g_object_set_data (G_OBJECT (combo), "filter-type", GINT_TO_POINTER (filter_type)); + g_object_set_data (G_OBJECT (combo), "permission-type", GINT_TO_POINTER (type)); + + if (filter_type == FOLDERS_ONLY) + { + if (type != PERMISSION_USER) + { + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + /* Translators: this is referred to the permissions + * the user has in a directory. + */ + COLUMN_NAME, _("None"), + COLUMN_VALUE, PERMISSION_NONE, + COLUMN_ID, "none", + -1); + } + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_NAME, _("List files only"), + COLUMN_VALUE, PERMISSION_READ, + COLUMN_ID, "r", + -1); + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_NAME, _("Access files"), + COLUMN_VALUE, PERMISSION_READ | PERMISSION_EXEC, + COLUMN_ID, "rx", + -1); + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_NAME, _("Create and delete files"), + COLUMN_VALUE, PERMISSION_READ | PERMISSION_EXEC | PERMISSION_WRITE, + COLUMN_ID, "rwx", + -1); + } + else + { + if (type != PERMISSION_USER) + { + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_NAME, _("None"), + COLUMN_VALUE, PERMISSION_NONE, + COLUMN_ID, "none", + -1); + } + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_NAME, _("Read-only"), + COLUMN_VALUE, PERMISSION_READ, + COLUMN_ID, "r", + -1); + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_NAME, _("Read and write"), + COLUMN_VALUE, PERMISSION_READ | PERMISSION_WRITE, + COLUMN_ID, "rw", + -1); + } + + cell = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE); + gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell, + "text", COLUMN_NAME, + NULL); +} + +static gboolean +all_can_get_permissions (GList *file_list) +{ + GList *l; + for (l = file_list; l != NULL; l = l->next) + { + NautilusFile *file; + + file = NAUTILUS_FILE (l->data); + + if (!nautilus_file_can_get_permissions (file)) + { + return FALSE; + } + } + + return TRUE; +} + +static gboolean +all_can_set_permissions (GList *file_list) +{ + GList *l; + for (l = file_list; l != NULL; l = l->next) + { + NautilusFile *file; + + file = NAUTILUS_FILE (l->data); + + if (!nautilus_file_can_set_permissions (file)) + { + return FALSE; + } + } + + return TRUE; +} + +static GHashTable * +get_initial_permissions (GList *file_list) +{ + GHashTable *ret; + GList *l; + + ret = g_hash_table_new (g_direct_hash, + g_direct_equal); + + for (l = file_list; l != NULL; l = l->next) + { + guint32 permissions; + NautilusFile *file; + + file = NAUTILUS_FILE (l->data); + + permissions = nautilus_file_get_permissions (file); + g_hash_table_insert (ret, file, + GINT_TO_POINTER (permissions)); + } + + return ret; +} + +static GListModel * +create_permission_list_model (PermissionType type, + FilterType filter_type) +{ + GListStore *store = g_list_store_new (NAUTILUS_TYPE_PERMISSION_ENTRY); + + if (type != PERMISSION_USER) + { + list_store_append_nautilus_permission_entry (store, PERMISSION_NONE, /* unused */ FALSE); + } + + if (filter_type == FOLDERS_ONLY) + { + list_store_append_nautilus_permission_entry (store, PERMISSION_READ, TRUE); + list_store_append_nautilus_permission_entry (store, PERMISSION_READ | PERMISSION_EXEC, TRUE); + list_store_append_nautilus_permission_entry (store, PERMISSION_READ | PERMISSION_EXEC | PERMISSION_WRITE, TRUE); + } + else + { + list_store_append_nautilus_permission_entry (store, PERMISSION_READ, FALSE); + list_store_append_nautilus_permission_entry (store, PERMISSION_READ | PERMISSION_WRITE, FALSE); + } + + return G_LIST_MODEL (store); +} + +static void +create_permissions_row (NautilusPropertiesWindow *self, + AdwComboRow *row, + PermissionType permission_type, + FilterType filter_type) +{ + g_autoptr (GtkExpression) expression = NULL; + g_autoptr (GListModel) model = NULL; + + expression = gtk_property_expression_new (NAUTILUS_TYPE_PERMISSION_ENTRY, NULL, "name"); + adw_combo_row_set_expression (row, expression); + + gtk_widget_show (GTK_WIDGET (row)); + + g_object_set_data (G_OBJECT (row), "permission-type", GINT_TO_POINTER (permission_type)); + g_object_set_data (G_OBJECT (row), "filter-type", GINT_TO_POINTER (filter_type)); + model = create_permission_list_model (permission_type, filter_type); + adw_combo_row_set_model (row, model); + + self->permission_rows = g_list_prepend (self->permission_rows, row); + g_signal_connect (row, "notify::selected", G_CALLBACK (on_permission_row_change), self); +} + +static void +create_simple_permissions (NautilusPropertiesWindow *self) +{ + FilterType filter_type = files_get_filter_type (self); + + g_assert (filter_type != NO_FILES_OR_FOLDERS); + + setup_ownership_row (self, self->owner_row); + setup_ownership_row (self, self->group_row); + + if (filter_type == FILES_AND_FOLDERS) + { + /* owner */ + create_permissions_row (self, self->owner_folder_access_row, + PERMISSION_USER, FOLDERS_ONLY); + create_permissions_row (self, self->owner_file_access_row, + PERMISSION_USER, FILES_ONLY); + /* group */ + create_permissions_row (self, self->group_folder_access_row, + PERMISSION_GROUP, FOLDERS_ONLY); + create_permissions_row (self, self->group_file_access_row, + PERMISSION_GROUP, FILES_ONLY); + /* others */ + create_permissions_row (self, self->others_folder_access_row, + PERMISSION_OTHER, FOLDERS_ONLY); + create_permissions_row (self, self->others_file_access_row, + PERMISSION_OTHER, FILES_ONLY); + } + else + { + create_permissions_row (self, self->owner_access_row, + PERMISSION_USER, filter_type); + create_permissions_row (self, self->group_access_row, + PERMISSION_GROUP, filter_type); + create_permissions_row (self, self->others_access_row, + PERMISSION_OTHER, filter_type); + } + + /* Connect execution bit switch, independent of whether it will be visible or not. */ + g_signal_connect_swapped (self->execution_row, "activated", + G_CALLBACK (execution_bit_changed), + self); + g_signal_connect_swapped (self->execution_switch, "notify::active", + G_CALLBACK (execution_bit_changed), + self); +} + +static void +set_recursive_permissions_done (gboolean success, + gpointer callback_data) +{ + g_autoptr (NautilusPropertiesWindow) self = NAUTILUS_PROPERTIES_WINDOW (callback_data); + end_long_operation (self); +} + +static void +on_change_permissions_response (GtkDialog *dialog, + int response, + NautilusPropertiesWindow *self) +{ + guint32 file_permission, file_permission_mask; + guint32 dir_permission, dir_permission_mask; + guint32 vfs_mask, vfs_new_perm; + GtkWidget *combo; + gboolean use_original; + FilterType filter_type; + GList *l; + GtkTreeModel *model; + GtkTreeIter iter; + PermissionType type; + int new_perm, mask; + + if (response != GTK_RESPONSE_OK) + { + g_clear_pointer (&self->change_permission_combos, g_list_free); + gtk_window_destroy (GTK_WINDOW (dialog)); + return; + } + + file_permission = 0; + file_permission_mask = 0; + dir_permission = 0; + dir_permission_mask = 0; + + /* Simple mode, minus exec checkbox */ + for (l = self->change_permission_combos; l != NULL; l = l->next) + { + combo = l->data; + + if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) + { + continue; + } + + type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (combo), "permission-type")); + filter_type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (combo), "filter-type")); + + model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo)); + gtk_tree_model_get (model, &iter, + COLUMN_VALUE, &new_perm, + COLUMN_USE_ORIGINAL, &use_original, -1); + if (use_original) + { + continue; + } + vfs_new_perm = permission_to_vfs (type, new_perm); + + mask = PERMISSION_READ | PERMISSION_WRITE; + if (filter_type == FOLDERS_ONLY) + { + mask |= PERMISSION_EXEC; + } + vfs_mask = permission_to_vfs (type, mask); + + if (filter_type == FOLDERS_ONLY) + { + dir_permission_mask |= vfs_mask; + dir_permission |= vfs_new_perm; + } + else + { + file_permission_mask |= vfs_mask; + file_permission |= vfs_new_perm; + } + } + + for (l = self->target_files; l != NULL; l = l->next) + { + NautilusFile *file; + + file = NAUTILUS_FILE (l->data); + + if (nautilus_file_is_directory (file) && + nautilus_file_can_set_permissions (file)) + { + g_autofree gchar *uri = NULL; + + uri = nautilus_file_get_uri (file); + start_long_operation (self); + g_object_ref (self); + nautilus_file_set_permissions_recursive (uri, + file_permission, + file_permission_mask, + dir_permission, + dir_permission_mask, + set_recursive_permissions_done, + self); + } + } + g_clear_pointer (&self->change_permission_combos, g_list_free); + gtk_window_destroy (GTK_WINDOW (dialog)); +} + +static void +set_active_from_umask (GtkComboBox *combo, + PermissionType type, + FilterType filter_type) +{ + mode_t initial; + mode_t mask; + mode_t p; + const char *id; + + if (filter_type == FOLDERS_ONLY) + { + initial = (S_IRWXU | S_IRWXG | S_IRWXO); + } + else + { + initial = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); + } + + umask (mask = umask (0)); + + p = ~mask & initial; + + if (type == PERMISSION_USER) + { + p &= ~(S_IRWXG | S_IRWXO); + if ((p & S_IRWXU) == S_IRWXU) + { + id = "rwx"; + } + else if ((p & (S_IRUSR | S_IWUSR)) == (S_IRUSR | S_IWUSR)) + { + id = "rw"; + } + else if ((p & (S_IRUSR | S_IXUSR)) == (S_IRUSR | S_IXUSR)) + { + id = "rx"; + } + else if ((p & S_IRUSR) == S_IRUSR) + { + id = "r"; + } + else + { + id = "none"; + } + } + else if (type == PERMISSION_GROUP) + { + p &= ~(S_IRWXU | S_IRWXO); + if ((p & S_IRWXG) == S_IRWXG) + { + id = "rwx"; + } + else if ((p & (S_IRGRP | S_IWGRP)) == (S_IRGRP | S_IWGRP)) + { + id = "rw"; + } + else if ((p & (S_IRGRP | S_IXGRP)) == (S_IRGRP | S_IXGRP)) + { + id = "rx"; + } + else if ((p & S_IRGRP) == S_IRGRP) + { + id = "r"; + } + else + { + id = "none"; + } + } + else + { + p &= ~(S_IRWXU | S_IRWXG); + if ((p & S_IRWXO) == S_IRWXO) + { + id = "rwx"; + } + else if ((p & (S_IROTH | S_IWOTH)) == (S_IROTH | S_IWOTH)) + { + id = "rw"; + } + else if ((p & (S_IROTH | S_IXOTH)) == (S_IROTH | S_IXOTH)) + { + id = "rx"; + } + else if ((p & S_IROTH) == S_IROTH) + { + id = "r"; + } + else + { + id = "none"; + } + } + + gtk_combo_box_set_active_id (combo, id); +} + +static void +on_change_permissions_clicked (GtkWidget *button, + NautilusPropertiesWindow *self) +{ + GtkWidget *dialog; + GtkComboBox *combo; + g_autoptr (GtkBuilder) change_permissions_builder = NULL; + + change_permissions_builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/ui/nautilus-file-properties-change-permissions.ui"); + + dialog = GTK_WIDGET (gtk_builder_get_object (change_permissions_builder, "change_permissions_dialog")); + gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (self)); + + /* Owner Permissions */ + combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "file_owner_combo")); + setup_permissions_combo_box (combo, PERMISSION_USER, FILES_ONLY); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); + set_active_from_umask (combo, PERMISSION_USER, FILES_ONLY); + + combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "folder_owner_combo")); + setup_permissions_combo_box (combo, PERMISSION_USER, FOLDERS_ONLY); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); + set_active_from_umask (combo, PERMISSION_USER, FOLDERS_ONLY); + + /* Group Permissions */ + combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "file_group_combo")); + setup_permissions_combo_box (combo, PERMISSION_GROUP, FILES_ONLY); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); + set_active_from_umask (combo, PERMISSION_GROUP, FILES_ONLY); + + combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "folder_group_combo")); + setup_permissions_combo_box (combo, PERMISSION_GROUP, FOLDERS_ONLY); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); + set_active_from_umask (combo, PERMISSION_GROUP, FOLDERS_ONLY); + + /* Others Permissions */ + combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "file_other_combo")); + setup_permissions_combo_box (combo, PERMISSION_OTHER, FILES_ONLY); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); + set_active_from_umask (combo, PERMISSION_OTHER, FILES_ONLY); + + combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "folder_other_combo")); + setup_permissions_combo_box (combo, PERMISSION_OTHER, FOLDERS_ONLY); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); + set_active_from_umask (combo, PERMISSION_OTHER, FOLDERS_ONLY); + + g_signal_connect (dialog, "response", G_CALLBACK (on_change_permissions_response), self); + gtk_widget_show (dialog); +} + +static void +setup_permissions_page (NautilusPropertiesWindow *self) +{ + GList *file_list; + + file_list = self->original_files; + + self->initial_permissions = NULL; + + if (all_can_get_permissions (file_list) && all_can_get_permissions (self->target_files)) + { + self->initial_permissions = get_initial_permissions (self->target_files); + self->has_recursive_apply = files_has_changable_permissions_directory (self); + + if (!all_can_set_permissions (file_list)) + { + gtk_widget_show (self->not_the_owner_label); + gtk_widget_show (self->bottom_prompt_seperator); + } + + gtk_stack_set_visible_child_name (GTK_STACK (self->permissions_stack), "permissions-box"); + create_simple_permissions (self); + +#ifdef HAVE_SELINUX + gtk_widget_show (self->security_context_list_box); + + /* Stash a copy of the file attribute name in this field for the callback's sake. */ + g_object_set_data_full (G_OBJECT (self->security_context_value_label), "file_attribute", + g_strdup ("selinux_context"), g_free); + + self->value_fields = g_list_prepend (self->value_fields, + self->security_context_value_label); +#endif + + if (self->has_recursive_apply) + { + gtk_widget_show (self->change_permissions_button_box); + g_signal_connect (self->change_permissions_button, "clicked", + G_CALLBACK (on_change_permissions_clicked), + self); + } + } + else + { + /* + * This if block only gets executed if its a single file window, + * in which case the label text needs to be different from the + * default label text. The default label text for a multifile + * window is set in nautilus-properties-window.ui so no else block. + */ + if (!is_multi_file_window (self)) + { + g_autofree gchar *file_name = NULL; + g_autofree gchar *prompt_text = NULL; + + file_name = nautilus_file_get_display_name (get_target_file (self)); + prompt_text = g_strdup_printf (_("The permissions of “%s” could not be determined."), file_name); + adw_status_page_set_description (ADW_STATUS_PAGE (self->unknown_permissions_page), prompt_text); + } + + gtk_stack_set_visible_child_name (GTK_STACK (self->permissions_stack), "permission-indeterminable"); + } +} + +static void +refresh_extension_model_pages (NautilusPropertiesWindow *self) +{ + g_autoptr (GListStore) extensions_list = g_list_store_new (NAUTILUS_TYPE_PROPERTIES_MODEL); + g_autolist (NautilusPropertiesModel) all_models = NULL; + g_autolist (GObject) providers = + nautilus_module_get_extensions_for_type (NAUTILUS_TYPE_PROPERTIES_MODEL_PROVIDER); + + for (GList *l = providers; l != NULL; l = l->next) + { + GList *models = nautilus_properties_model_provider_get_models (l->data, self->original_files); + + all_models = g_list_concat (all_models, models); + } + + for (GList *l = all_models; l != NULL; l = l->next) + { + g_list_store_append (extensions_list, NAUTILUS_PROPERTIES_MODEL (l->data)); + } + + gtk_widget_set_visible (self->extension_models_list_box, + g_list_model_get_n_items (G_LIST_MODEL (extensions_list)) > 0); + + gtk_list_box_bind_model (GTK_LIST_BOX (self->extension_models_list_box), + G_LIST_MODEL (extensions_list), + (GtkListBoxCreateWidgetFunc) add_extension_model_page, + self, + NULL); +} + +static gboolean +should_show_permissions (NautilusPropertiesWindow *self) +{ + GList *l; + + /* Don't show permissions for Trash and Computer since they're not + * really file system objects. + */ + for (l = self->original_files; l != NULL; l = l->next) + { + if (nautilus_file_is_in_trash (NAUTILUS_FILE (l->data)) || + nautilus_file_is_in_recent (NAUTILUS_FILE (l->data))) + { + return FALSE; + } + } + + return TRUE; +} + +static char * +get_pending_key (GList *file_list) +{ + GList *uris = NULL; + GList *l; + GString *key; + char *ret; + + uris = NULL; + for (l = file_list; l != NULL; l = l->next) + { + uris = g_list_prepend (uris, nautilus_file_get_uri (NAUTILUS_FILE (l->data))); + } + uris = g_list_sort (uris, (GCompareFunc) strcmp); + + key = g_string_new (""); + for (l = uris; l != NULL; l = l->next) + { + g_string_append (key, l->data); + g_string_append (key, ";"); + } + + g_list_free_full (uris, g_free); + + ret = key->str; + g_string_free (key, FALSE); + + return ret; +} + +static StartupData * +startup_data_new (GList *original_files, + GList *target_files, + const char *pending_key, + GtkWidget *parent_widget, + GtkWindow *parent_window, + const char *startup_id, + NautilusPropertiesWindowCallback callback, + gpointer callback_data, + NautilusPropertiesWindow *window) +{ + StartupData *data; + GList *l; + + data = g_new0 (StartupData, 1); + data->original_files = nautilus_file_list_copy (original_files); + data->target_files = nautilus_file_list_copy (target_files); + data->parent_widget = parent_widget; + data->parent_window = parent_window; + data->startup_id = g_strdup (startup_id); + data->pending_key = g_strdup (pending_key); + data->pending_files = g_hash_table_new (g_direct_hash, + g_direct_equal); + data->callback = callback; + data->callback_data = callback_data; + data->window = window; + + for (l = data->target_files; l != NULL; l = l->next) + { + g_hash_table_insert (data->pending_files, l->data, l->data); + } + + return data; +} + +static void +startup_data_free (StartupData *data) +{ + nautilus_file_list_free (data->original_files); + nautilus_file_list_free (data->target_files); + g_hash_table_destroy (data->pending_files); + g_free (data->pending_key); + g_free (data->startup_id); + g_free (data); +} + +static void +file_changed_callback (NautilusFile *file, + gpointer user_data) +{ + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); + + if (!g_list_find (self->changed_files, file)) + { + nautilus_file_ref (file); + self->changed_files = g_list_prepend (self->changed_files, file); + schedule_files_update (self); + } +} + +static NautilusPropertiesWindow * +create_properties_window (StartupData *startup_data) +{ + NautilusPropertiesWindow *window; + GList *l; + + window = NAUTILUS_PROPERTIES_WINDOW (g_object_new (NAUTILUS_TYPE_PROPERTIES_WINDOW, + NULL)); + + window->original_files = nautilus_file_list_copy (startup_data->original_files); + + window->target_files = nautilus_file_list_copy (startup_data->target_files); + + if (startup_data->parent_widget) + { + gtk_window_set_display (GTK_WINDOW (window), + gtk_widget_get_display (startup_data->parent_widget)); + } + + if (startup_data->parent_window) + { + gtk_window_set_transient_for (GTK_WINDOW (window), startup_data->parent_window); + } + + if (startup_data->startup_id) + { + gtk_window_set_startup_id (GTK_WINDOW (window), startup_data->startup_id); + } + + /* Start monitoring the file attributes we display. Note that some + * of the attributes are for the original file, and some for the + * target files. + */ + + for (l = window->original_files; l != NULL; l = l->next) + { + NautilusFile *file; + NautilusFileAttributes attributes; + + file = NAUTILUS_FILE (l->data); + + attributes = + NAUTILUS_FILE_ATTRIBUTES_FOR_ICON | + NAUTILUS_FILE_ATTRIBUTE_INFO; + + nautilus_file_monitor_add (file, + &window->original_files, + attributes); + } + + for (l = window->target_files; l != NULL; l = l->next) + { + NautilusFile *file; + NautilusFileAttributes attributes; + + file = NAUTILUS_FILE (l->data); + + attributes = 0; + if (nautilus_file_is_directory (file)) + { + attributes |= NAUTILUS_FILE_ATTRIBUTE_DEEP_COUNTS; + } + + attributes |= NAUTILUS_FILE_ATTRIBUTE_INFO; + nautilus_file_monitor_add (file, &window->target_files, attributes); + } + + for (l = window->target_files; l != NULL; l = l->next) + { + g_signal_connect_object (NAUTILUS_FILE (l->data), + "changed", + G_CALLBACK (file_changed_callback), + G_OBJECT (window), + 0); + } + + for (l = window->original_files; l != NULL; l = l->next) + { + g_signal_connect_object (NAUTILUS_FILE (l->data), + "changed", + G_CALLBACK (file_changed_callback), + G_OBJECT (window), + 0); + } + + /* Create the pages. */ + setup_basic_page (window); + + if (should_show_permissions (window)) + { + setup_permissions_page (window); + gtk_widget_show (window->permissions_navigation_row); + } + + if (should_show_exectution_switch (window)) + { + gtk_widget_show (GTK_WIDGET (window->execution_row)); + } + + /* Add available extension models pages */ + refresh_extension_model_pages (window); + + /* Update from initial state */ + properties_window_update (window, NULL); + + return window; +} + +static GList * +get_target_file_list (GList *original_files) +{ + return g_list_copy_deep (original_files, + (GCopyFunc) get_target_file_for_original_file, + NULL); +} + +static void +properties_window_finish (StartupData *data) +{ + gboolean cancel_timed_wait; + + if (data->parent_widget != NULL) + { + g_signal_handlers_disconnect_by_data (data->parent_widget, + data); + } + if (data->window != NULL) + { + g_signal_handlers_disconnect_by_data (data->window, + data); + } + + cancel_timed_wait = (data->window == NULL && !data->cancelled); + remove_pending (data, TRUE, cancel_timed_wait); + + startup_data_free (data); +} + +static void +cancel_create_properties_window_callback (gpointer callback_data) +{ + StartupData *data; + + data = callback_data; + data->cancelled = TRUE; + + properties_window_finish (data); +} + +static void +parent_widget_destroyed_callback (GtkWidget *widget, + gpointer callback_data) +{ + g_assert (widget == ((StartupData *) callback_data)->parent_widget); + + properties_window_finish ((StartupData *) callback_data); +} + +static void +cancel_call_when_ready_callback (gpointer key, + gpointer value, + gpointer user_data) +{ + nautilus_file_cancel_call_when_ready + (NAUTILUS_FILE (key), + is_directory_ready_callback, + user_data); +} + +static void +remove_pending (StartupData *startup_data, + gboolean cancel_call_when_ready, + gboolean cancel_timed_wait) +{ + if (cancel_call_when_ready) + { + g_hash_table_foreach (startup_data->pending_files, + cancel_call_when_ready_callback, + startup_data); + } + if (cancel_timed_wait) + { + eel_timed_wait_stop + (cancel_create_properties_window_callback, startup_data); + } + if (startup_data->pending_key != NULL) + { + g_hash_table_remove (pending_lists, startup_data->pending_key); + } +} + +static gboolean +widget_on_destroy (GtkWidget *widget, + gpointer user_data) +{ + StartupData *data = (StartupData *) user_data; + + + if (data->callback != NULL) + { + data->callback (data->callback_data); + } + + properties_window_finish (data); + + return GDK_EVENT_PROPAGATE; +} + +static void +is_directory_ready_callback (NautilusFile *file, + gpointer data) +{ + StartupData *startup_data; + + startup_data = data; + + g_hash_table_remove (startup_data->pending_files, file); + + if (g_hash_table_size (startup_data->pending_files) == 0) + { + NautilusPropertiesWindow *new_window; + + new_window = create_properties_window (startup_data); + + startup_data->window = new_window; + + remove_pending (startup_data, FALSE, TRUE); + + gtk_window_present (GTK_WINDOW (new_window)); + g_signal_connect (GTK_WIDGET (new_window), "destroy", + G_CALLBACK (widget_on_destroy), startup_data); + + /* We wish the label to be selectable, but not selected by default. */ + gtk_label_select_region (GTK_LABEL (new_window->name_value_label), -1, -1); + } +} + +void +nautilus_properties_window_present (GList *original_files, + GtkWidget *parent_widget, + const gchar *startup_id, + NautilusPropertiesWindowCallback callback, + gpointer callback_data) +{ + GList *l, *next; + GtkWindow *parent_window; + StartupData *startup_data; + g_autolist (NautilusFile) target_files = NULL; + g_autofree char *pending_key = NULL; + + g_return_if_fail (original_files != NULL); + g_return_if_fail (parent_widget == NULL || GTK_IS_WIDGET (parent_widget)); + + if (pending_lists == NULL) + { + pending_lists = g_hash_table_new (g_str_hash, g_str_equal); + } + + pending_key = get_pending_key (original_files); + + /* Look to see if we're already waiting for a window for this file. */ + if (g_hash_table_lookup (pending_lists, pending_key) != NULL) + { + /* FIXME: No callback is done if this happen. In practice, it's a quite + * corner case + */ + return; + } + + target_files = get_target_file_list (original_files); + + if (parent_widget) + { + parent_window = GTK_WINDOW (gtk_widget_get_ancestor (parent_widget, GTK_TYPE_WINDOW)); + } + else + { + parent_window = NULL; + } + + startup_data = startup_data_new (original_files, + target_files, + pending_key, + parent_widget, + parent_window, + startup_id, + callback, + callback_data, + NULL); + + /* Wait until we can tell whether it's a directory before showing, since + * some one-time layout decisions depend on that info. + */ + + g_hash_table_insert (pending_lists, startup_data->pending_key, startup_data->pending_key); + if (parent_widget) + { + g_signal_connect (parent_widget, "destroy", + G_CALLBACK (parent_widget_destroyed_callback), startup_data); + } + + eel_timed_wait_start + (cancel_create_properties_window_callback, + startup_data, + _("Creating Properties window."), + parent_window == NULL ? NULL : GTK_WINDOW (parent_window)); + + for (l = startup_data->target_files; l != NULL; l = next) + { + next = l->next; + nautilus_file_call_when_ready + (NAUTILUS_FILE (l->data), + NAUTILUS_FILE_ATTRIBUTE_INFO, + is_directory_ready_callback, + startup_data); + } +} + +static void +real_dispose (GObject *object) +{ + NautilusPropertiesWindow *self; + + self = NAUTILUS_PROPERTIES_WINDOW (object); + + unschedule_or_cancel_group_change (self); + unschedule_or_cancel_owner_change (self); + + g_list_foreach (self->original_files, + (GFunc) nautilus_file_monitor_remove, + &self->original_files); + g_clear_list (&self->original_files, (GDestroyNotify) nautilus_file_unref); + + g_list_foreach (self->target_files, + (GFunc) nautilus_file_monitor_remove, + &self->target_files); + g_clear_list (&self->target_files, (GDestroyNotify) nautilus_file_unref); + + g_clear_list (&self->changed_files, (GDestroyNotify) nautilus_file_unref); + + g_clear_handle_id (&self->deep_count_spinner_timeout_id, g_source_remove); + + while (self->deep_count_files) + { + stop_deep_count_for_file (self, self->deep_count_files->data); + } + + g_clear_list (&self->permission_rows, NULL); + + g_clear_list (&self->change_permission_combos, NULL); + + g_clear_pointer (&self->initial_permissions, g_hash_table_destroy); + + g_clear_list (&self->value_fields, NULL); + + g_clear_handle_id (&self->update_directory_contents_timeout_id, g_source_remove); + g_clear_handle_id (&self->update_files_timeout_id, g_source_remove); + + G_OBJECT_CLASS (nautilus_properties_window_parent_class)->dispose (object); +} + +static void +real_finalize (GObject *object) +{ + NautilusPropertiesWindow *self; + + self = NAUTILUS_PROPERTIES_WINDOW (object); + + g_list_free_full (self->mime_list, g_free); + + G_OBJECT_CLASS (nautilus_properties_window_parent_class)->finalize (object); +} + +/* icon selection callback to set the image of the file object to the selected file */ +static void +set_icon (const char *icon_uri, + NautilusPropertiesWindow *self) +{ + NautilusFile *file; + g_autofree gchar *icon_path = NULL; + + g_assert (icon_uri != NULL); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + icon_path = g_filename_from_uri (icon_uri, NULL, NULL); + /* we don't allow remote URIs */ + if (icon_path != NULL) + { + GList *l; + + for (l = self->original_files; l != NULL; l = l->next) + { + g_autofree gchar *file_uri = NULL; + g_autoptr (GFile) file_location = NULL; + g_autoptr (GFile) icon_location = NULL; + g_autofree gchar *real_icon_uri = NULL; + + file = NAUTILUS_FILE (l->data); + file_uri = nautilus_file_get_uri (file); + file_location = nautilus_file_get_location (file); + icon_location = g_file_new_for_uri (icon_uri); + + /* ’Tis a little bit of a misnomer. Actually a path. */ + real_icon_uri = g_file_get_relative_path (icon_location, + file_location); + + if (real_icon_uri == NULL) + { + real_icon_uri = g_strdup (icon_uri); + } + + nautilus_file_set_metadata (file, NAUTILUS_METADATA_KEY_CUSTOM_ICON, NULL, real_icon_uri); + } + } +} + +static void +custom_icon_file_chooser_response_cb (GtkDialog *dialog, + gint response, + NautilusPropertiesWindow *self) +{ + switch (response) + { + case GTK_RESPONSE_NO: + { + reset_icon (self); + } + break; + + case GTK_RESPONSE_OK: + { + g_autoptr (GFile) location = NULL; + g_autofree gchar *uri = NULL; + + location = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog)); + if (location != NULL) + { + uri = g_file_get_uri (location); + set_icon (uri, self); + } + else + { + reset_icon (self); + } + } + break; + + default: + { + } + break; + } + + gtk_widget_hide (GTK_WIDGET (dialog)); +} + +static void +select_image_button_callback (GtkWidget *widget, + NautilusPropertiesWindow *self) +{ + GtkWidget *dialog; + GtkFileFilter *filter; + GList *l; + NautilusFile *file; + gboolean revert_is_sensitive; + + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); + + dialog = self->icon_chooser; + + if (dialog == NULL) + { + g_autoptr (GFile) pictures_location = NULL; + dialog = gtk_file_chooser_dialog_new (_("Select Custom Icon"), GTK_WINDOW (self), + GTK_FILE_CHOOSER_ACTION_OPEN, + _("_Revert"), GTK_RESPONSE_NO, + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Open"), GTK_RESPONSE_OK, + NULL); + pictures_location = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_PICTURES)); + gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), + pictures_location, + NULL); + gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); + gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); + + filter = gtk_file_filter_new (); + gtk_file_filter_add_pixbuf_formats (filter); + gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); + + self->icon_chooser = dialog; + + g_object_add_weak_pointer (G_OBJECT (dialog), + (gpointer *) &self->icon_chooser); + } + + /* it's likely that the user wants to pick an icon that is inside a local directory */ + if (g_list_length (self->original_files) == 1) + { + file = NAUTILUS_FILE (self->original_files->data); + + if (nautilus_file_is_directory (file)) + { + g_autoptr (GFile) image_location = NULL; + + image_location = nautilus_file_get_location (file); + + if (image_location != NULL) + { + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), + image_location, + NULL); + } + } + } + + revert_is_sensitive = FALSE; + for (l = self->original_files; l != NULL; l = l->next) + { + g_autofree gchar *image_path = NULL; + + file = NAUTILUS_FILE (l->data); + image_path = nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_CUSTOM_ICON, NULL); + revert_is_sensitive = (image_path != NULL); + + if (revert_is_sensitive) + { + break; + } + } + gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_NO, revert_is_sensitive); + + g_signal_connect (dialog, "response", + G_CALLBACK (custom_icon_file_chooser_response_cb), self); + gtk_widget_show (dialog); +} + +static void +nautilus_properties_window_class_init (NautilusPropertiesWindowClass *klass) +{ + GtkWidgetClass *widget_class; + GObjectClass *oclass; + + widget_class = GTK_WIDGET_CLASS (klass); + oclass = G_OBJECT_CLASS (klass); + oclass->dispose = real_dispose; + oclass->finalize = real_finalize; + + gtk_widget_class_add_binding (widget_class, + GDK_KEY_Escape, 0, + (GtkShortcutFunc) gtk_window_close, NULL); + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/nautilus/ui/nautilus-properties-window.ui"); + + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, page_stack); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, icon_stack); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, icon_image); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, icon_button); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, icon_button_image); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, star_button); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, name_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, type_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, type_file_system_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, size_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, contents_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, contents_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, contents_spinner); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, bottom_prompt_seperator); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, disk_list_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, disk_space_level_bar); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, disk_space_used_value); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, disk_space_free_value); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, disk_space_capacity_value); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, locations_list_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, link_target_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, link_target_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, parent_folder_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, parent_folder_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, trashed_list_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, trashed_on_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, original_folder_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, times_list_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, modified_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, modified_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, created_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, created_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, accessed_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, accessed_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, permissions_navigation_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, permissions_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, extension_models_list_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, free_space_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, permissions_stack); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, not_the_owner_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, unknown_permissions_page); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, owner_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, owner_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, owner_folder_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, owner_file_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, group_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, group_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, group_folder_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, group_file_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, others_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, others_folder_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, others_file_access_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, execution_row); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, execution_switch); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, security_context_list_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, security_context_value_label); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, change_permissions_button_box); + gtk_widget_class_bind_template_child (widget_class, NautilusPropertiesWindow, change_permissions_button); + + gtk_widget_class_bind_template_callback (widget_class, star_clicked); + gtk_widget_class_bind_template_callback (widget_class, open_in_disks); + gtk_widget_class_bind_template_callback (widget_class, open_parent_folder); + gtk_widget_class_bind_template_callback (widget_class, open_link_target); + gtk_widget_class_bind_template_callback (widget_class, navigate_main_page); + gtk_widget_class_bind_template_callback (widget_class, navigate_permissions_page); +} + +static void +nautilus_properties_window_init (NautilusPropertiesWindow *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); +} |