From 791ccf838056c03c7ae40ad9deafc15fb3aae126 Mon Sep 17 00:00:00 2001 From: Apoorv Sachan Date: Sun, 2 Aug 2020 22:47:44 +0530 Subject: properties-window: Instance symbol renaming Use "self" as symbol name for the NautilusPropertiesWindow* instance in methods and signal handlers. --- src/nautilus-properties-window.c | 1432 +++++++++++++++++++------------------- 1 file changed, 716 insertions(+), 716 deletions(-) diff --git a/src/nautilus-properties-window.c b/src/nautilus-properties-window.c index 65614252b..05b00d67f 100644 --- a/src/nautilus-properties-window.c +++ b/src/nautilus-properties-window.c @@ -280,49 +280,49 @@ static const GtkTargetEntry target_table[] = */ #define CHOWN_CHGRP_TIMEOUT 300 /* milliseconds */ -static void schedule_directory_contents_update (NautilusPropertiesWindow *window); -static void directory_contents_value_field_update (NautilusPropertiesWindow *window); +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 permission_button_update (NautilusPropertiesWindow *window, +static void permission_button_update (NautilusPropertiesWindow *self, GtkToggleButton *button); -static void permission_combo_update (NautilusPropertiesWindow *window, +static void permission_combo_update (NautilusPropertiesWindow *self, GtkComboBox *combo); -static void value_field_update (NautilusPropertiesWindow *window, +static void value_field_update (NautilusPropertiesWindow *self, GtkLabel *field); -static void properties_window_update (NautilusPropertiesWindow *window, +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 select_image_button_callback (GtkWidget *widget, - NautilusPropertiesWindow *properties_window); + NautilusPropertiesWindow *self); static void set_icon (const char *icon_path, - NautilusPropertiesWindow *properties_window); + NautilusPropertiesWindow *self); static void remove_pending (StartupData *data, gboolean cancel_call_when_ready, gboolean cancel_timed_wait); -static void append_extension_pages (NautilusPropertiesWindow *window); +static void append_extension_pages (NautilusPropertiesWindow *self); static void name_field_focus_changed (GObject *object, GParamSpec *pspec, gpointer user_data); static void name_field_activate (GtkWidget *name_field, gpointer user_data); -static void setup_pie_widget (NautilusPropertiesWindow *window); +static void setup_pie_widget (NautilusPropertiesWindow *self); G_DEFINE_TYPE (NautilusPropertiesWindow, nautilus_properties_window, GTK_TYPE_WINDOW); static gboolean -is_multi_file_window (NautilusPropertiesWindow *window) +is_multi_file_window (NautilusPropertiesWindow *self) { GList *l; int count; count = 0; - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { if (!nautilus_file_is_gone (NAUTILUS_FILE (l->data))) { @@ -338,14 +338,14 @@ is_multi_file_window (NautilusPropertiesWindow *window) } static int -get_not_gone_original_file_count (NautilusPropertiesWindow *window) +get_not_gone_original_file_count (NautilusPropertiesWindow *self) { GList *l; int count; count = 0; - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { if (!nautilus_file_is_gone (NAUTILUS_FILE (l->data))) { @@ -357,16 +357,16 @@ get_not_gone_original_file_count (NautilusPropertiesWindow *window) } static NautilusFile * -get_original_file (NautilusPropertiesWindow *window) +get_original_file (NautilusPropertiesWindow *self) { - g_return_val_if_fail (!is_multi_file_window (window), NULL); + g_return_val_if_fail (!is_multi_file_window (self), NULL); - if (window->original_files == NULL) + if (self->original_files == NULL) { return NULL; } - return NAUTILUS_FILE (window->original_files->data); + return NAUTILUS_FILE (self->original_files->data); } static NautilusFile * @@ -384,13 +384,13 @@ get_target_file_for_original_file (NautilusFile *file) } static NautilusFile * -get_target_file (NautilusPropertiesWindow *window) +get_target_file (NautilusPropertiesWindow *self) { - return NAUTILUS_FILE (window->target_files->data); + return NAUTILUS_FILE (self->target_files->data); } static void -get_image_for_properties_window (NautilusPropertiesWindow *window, +get_image_for_properties_window (NautilusPropertiesWindow *self, char **icon_name, GdkPixbuf **icon_pixbuf) { @@ -399,9 +399,9 @@ get_image_for_properties_window (NautilusPropertiesWindow *window, gint icon_scale; icon = NULL; - icon_scale = gtk_widget_get_scale_factor (GTK_WIDGET (window->notebook)); + icon_scale = gtk_widget_get_scale_factor (GTK_WIDGET (self->notebook)); - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { NautilusFile *file; @@ -451,27 +451,27 @@ get_image_for_properties_window (NautilusPropertiesWindow *window, static void -update_properties_window_icon (NautilusPropertiesWindow *window) +update_properties_window_icon (NautilusPropertiesWindow *self) { GdkPixbuf *pixbuf; cairo_surface_t *surface; char *name; - get_image_for_properties_window (window, &name, &pixbuf); + get_image_for_properties_window (self, &name, &pixbuf); if (name != NULL) { - gtk_window_set_icon_name (GTK_WINDOW (window), name); + gtk_window_set_icon_name (GTK_WINDOW (self), name); } else { - gtk_window_set_icon (GTK_WINDOW (window), pixbuf); + gtk_window_set_icon (GTK_WINDOW (self), pixbuf); } - surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, gtk_widget_get_scale_factor (GTK_WIDGET (window)), - gtk_widget_get_window (GTK_WIDGET (window))); - gtk_image_set_from_surface (GTK_IMAGE (window->icon_image), surface); - gtk_image_set_from_surface (GTK_IMAGE (window->icon_button_image), surface); + surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, gtk_widget_get_scale_factor (GTK_WIDGET (self)), + gtk_widget_get_window (GTK_WIDGET (self))); + gtk_image_set_from_surface (GTK_IMAGE (self->icon_image), surface); + gtk_image_set_from_surface (GTK_IMAGE (self->icon_button_image), surface); g_free (name); g_object_unref (pixbuf); @@ -504,11 +504,11 @@ uri_is_local_image (const char *uri) static void -reset_icon (NautilusPropertiesWindow *properties_window) +reset_icon (NautilusPropertiesWindow *self) { GList *l; - for (l = properties_window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { NautilusFile *file; @@ -581,33 +581,33 @@ nautilus_properties_window_drag_data_received (GtkWidget *widget, } static void -setup_image_widget (NautilusPropertiesWindow *window, +setup_image_widget (NautilusPropertiesWindow *self, gboolean is_customizable) { - update_properties_window_icon (window); + update_properties_window_icon (self); if (is_customizable) { /* prepare the image to receive dropped objects to assign custom images */ - gtk_drag_dest_set (window->icon_button_image, + gtk_drag_dest_set (self->icon_button_image, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target_table, G_N_ELEMENTS (target_table), GDK_ACTION_COPY | GDK_ACTION_MOVE); - g_signal_connect (window->icon_button_image, "drag-data-received", + g_signal_connect (self->icon_button_image, "drag-data-received", G_CALLBACK (nautilus_properties_window_drag_data_received), NULL); - g_signal_connect (window->icon_button, "clicked", - G_CALLBACK (select_image_button_callback), window); - gtk_stack_set_visible_child (window->icon_stack, window->icon_button); + 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 (window->icon_stack, window->icon_image); + gtk_stack_set_visible_child (self->icon_stack, self->icon_image); } } static void -set_name_field (NautilusPropertiesWindow *window, +set_name_field (NautilusPropertiesWindow *self, const gchar *original_name, const gchar *name) { @@ -615,19 +615,19 @@ set_name_field (NautilusPropertiesWindow *window, GtkWidget *stack_child_entry; gboolean use_label; - stack_child_label = gtk_stack_get_child_by_name (window->name_stack, "name_value_label"); - stack_child_entry = gtk_stack_get_child_by_name (window->name_stack, "name_value_entry"); + stack_child_label = gtk_stack_get_child_by_name (self->name_stack, "name_value_label"); + stack_child_entry = gtk_stack_get_child_by_name (self->name_stack, "name_value_entry"); - use_label = is_multi_file_window (window) || !nautilus_file_can_rename (get_original_file (window)); + use_label = is_multi_file_window (self) || !nautilus_file_can_rename (get_original_file (self)); if (use_label) { gtk_label_set_text (GTK_LABEL (stack_child_label), name); - gtk_stack_set_visible_child (window->name_stack, stack_child_label); + gtk_stack_set_visible_child (self->name_stack, stack_child_label); } else { - gtk_stack_set_visible_child (window->name_stack, stack_child_entry); + gtk_stack_set_visible_child (self->name_stack, stack_child_entry); } /* Only replace text if the file's name has changed. */ @@ -639,10 +639,10 @@ set_name_field (NautilusPropertiesWindow *window, * currently showing. This causes minimal ripples (e.g. * selection change). */ - gchar *displayed_name = gtk_editable_get_chars (GTK_EDITABLE (window->name_field), 0, -1); + gchar *displayed_name = gtk_editable_get_chars (GTK_EDITABLE (self->name_field), 0, -1); if (strcmp (displayed_name, name) != 0) { - gtk_entry_set_text (GTK_ENTRY (window->name_field), name); + gtk_entry_set_text (GTK_ENTRY (self->name_field), name); } g_free (displayed_name); } @@ -650,15 +650,15 @@ set_name_field (NautilusPropertiesWindow *window, } static void -update_name_field (NautilusPropertiesWindow *window) +update_name_field (NautilusPropertiesWindow *self) { NautilusFile *file; - gtk_label_set_text_with_mnemonic (window->name_title_label, + gtk_label_set_text_with_mnemonic (self->name_title_label, ngettext ("_Name", "_Names", - get_not_gone_original_file_count (window))); + get_not_gone_original_file_count (self))); - if (is_multi_file_window (window)) + if (is_multi_file_window (self)) { /* Multifile property dialog, show all names */ GString *str; @@ -670,7 +670,7 @@ update_name_field (NautilusPropertiesWindow *window) first = TRUE; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); @@ -687,7 +687,7 @@ update_name_field (NautilusPropertiesWindow *window) g_free (name); } } - set_name_field (window, NULL, str->str); + set_name_field (self, NULL, str->str); g_string_free (str, TRUE); } else @@ -695,7 +695,7 @@ update_name_field (NautilusPropertiesWindow *window) const char *original_name = NULL; char *current_name; - file = get_original_file (window); + file = get_original_file (self); if (file == NULL || nautilus_file_is_gone (file)) { @@ -711,14 +711,14 @@ update_name_field (NautilusPropertiesWindow *window) * an edit in progress. If the name hasn't changed (but some other * aspect of the file might have), then don't clobber changes. */ - original_name = (const char *) g_object_get_data (G_OBJECT (window->name_field), "original_name"); + original_name = (const char *) g_object_get_data (G_OBJECT (self->name_field), "original_name"); - set_name_field (window, original_name, current_name); + set_name_field (self, original_name, current_name); if (original_name == NULL || g_strcmp0 (original_name, current_name) != 0) { - g_object_set_data_full (G_OBJECT (window->name_field), + g_object_set_data_full (G_OBJECT (self->name_field), "original_name", current_name, g_free); @@ -761,34 +761,34 @@ rename_callback (NautilusFile *file, GError *error, gpointer callback_data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (callback_data); + self = NAUTILUS_PROPERTIES_WINDOW (callback_data); /* Complain to user if rename failed. */ if (error != NULL) { nautilus_report_error_renaming_file (file, - window->pending_name, + self->pending_name, error, - GTK_WINDOW (window)); - name_field_restore_original_name (window->name_field); + GTK_WINDOW (self)); + name_field_restore_original_name (self->name_field); } - g_object_unref (window); + g_object_unref (self); } static void -set_pending_name (NautilusPropertiesWindow *window, +set_pending_name (NautilusPropertiesWindow *self, const char *name) { - g_free (window->pending_name); - window->pending_name = g_strdup (name); + g_free (self->pending_name); + self->pending_name = g_strdup (name); } static void name_field_done_editing (GtkWidget *name_field, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { NautilusFile *file; char *new_name; @@ -797,12 +797,12 @@ name_field_done_editing (GtkWidget *name_field, g_return_if_fail (GTK_IS_ENTRY (name_field)); /* Don't apply if the dialog has more than one file */ - if (is_multi_file_window (window)) + if (is_multi_file_window (self)) { return; } - file = get_original_file (window); + file = get_original_file (self); /* This gets called when the window is closed, which might be * caused by the file having been deleted. @@ -821,17 +821,17 @@ name_field_done_editing (GtkWidget *name_field, } else { - original_name = (const char *) g_object_get_data (G_OBJECT (window->name_field), + original_name = (const char *) g_object_get_data (G_OBJECT (self->name_field), "original_name"); /* Don't rename if not changed since we read the display name. * This is needed so that we don't save the display name to the * file when nothing is changed */ if (strcmp (new_name, original_name) != 0) { - set_pending_name (window, new_name); - g_object_ref (window); + set_pending_name (self, new_name); + g_object_ref (self); nautilus_file_rename (file, new_name, - rename_callback, window); + rename_callback, self); } } @@ -858,14 +858,14 @@ name_field_focus_changed (GObject *object, static gboolean select_all_at_idle (gpointer user_data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (user_data); + self = NAUTILUS_PROPERTIES_WINDOW (user_data); - gtk_editable_select_region (GTK_EDITABLE (window->name_field), + gtk_editable_select_region (GTK_EDITABLE (self->name_field), 0, -1); - window->select_idle_id = 0; + self->select_idle_id = 0; return FALSE; } @@ -874,36 +874,36 @@ static void name_field_activate (GtkWidget *name_field, gpointer user_data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; g_assert (GTK_IS_ENTRY (name_field)); g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (user_data)); - window = NAUTILUS_PROPERTIES_WINDOW (user_data); + self = NAUTILUS_PROPERTIES_WINDOW (user_data); /* Accept changes. */ - name_field_done_editing (name_field, window); + name_field_done_editing (name_field, self); - if (window->select_idle_id == 0) + if (self->select_idle_id == 0) { - window->select_idle_id = g_idle_add (select_all_at_idle, - window); + self->select_idle_id = g_idle_add (select_all_at_idle, + self); } } static void -update_properties_window_title (NautilusPropertiesWindow *window) +update_properties_window_title (NautilusPropertiesWindow *self) { char *name, *title; NautilusFile *file; - g_return_if_fail (GTK_IS_WINDOW (window)); + g_return_if_fail (GTK_IS_WINDOW (self)); title = g_strdup_printf (_("Properties")); - if (!is_multi_file_window (window)) + if (!is_multi_file_window (self)) { - file = get_original_file (window); + file = get_original_file (self); if (file != NULL) { @@ -924,30 +924,30 @@ update_properties_window_title (NautilusPropertiesWindow *window) } } - gtk_window_set_title (GTK_WINDOW (window), title); + gtk_window_set_title (GTK_WINDOW (self), title); g_free (title); } static void -clear_extension_pages (NautilusPropertiesWindow *window) +clear_extension_pages (NautilusPropertiesWindow *self) { int i; int num_pages; GtkWidget *page; num_pages = gtk_notebook_get_n_pages - (GTK_NOTEBOOK (window->notebook)); + (GTK_NOTEBOOK (self->notebook)); for (i = 0; i < num_pages; i++) { page = gtk_notebook_get_nth_page - (GTK_NOTEBOOK (window->notebook), i); + (GTK_NOTEBOOK (self->notebook), i); if (g_object_get_data (G_OBJECT (page), "is-extension-page")) { gtk_notebook_remove_page - (GTK_NOTEBOOK (window->notebook), i); + (GTK_NOTEBOOK (self->notebook), i); num_pages--; i--; } @@ -955,14 +955,14 @@ clear_extension_pages (NautilusPropertiesWindow *window) } static void -refresh_extension_pages (NautilusPropertiesWindow *window) +refresh_extension_pages (NautilusPropertiesWindow *self) { - clear_extension_pages (window); - append_extension_pages (window); + clear_extension_pages (self); + append_extension_pages (self); } static void -remove_from_dialog (NautilusPropertiesWindow *window, +remove_from_dialog (NautilusPropertiesWindow *self, NautilusFile *file) { int index; @@ -971,38 +971,38 @@ remove_from_dialog (NautilusPropertiesWindow *window, NautilusFile *original_file; NautilusFile *target_file; - index = g_list_index (window->target_files, file); + index = g_list_index (self->target_files, file); if (index == -1) { - index = g_list_index (window->original_files, file); + index = g_list_index (self->original_files, file); g_return_if_fail (index != -1); } - original_link = g_list_nth (window->original_files, index); - target_link = g_list_nth (window->target_files, index); + 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); - window->original_files = g_list_remove_link (window->original_files, original_link); + self->original_files = g_list_remove_link (self->original_files, original_link); g_list_free (original_link); - window->target_files = g_list_remove_link (window->target_files, target_link); + self->target_files = g_list_remove_link (self->target_files, target_link); g_list_free (target_link); - g_hash_table_remove (window->initial_permissions, target_file); + g_hash_table_remove (self->initial_permissions, target_file); g_signal_handlers_disconnect_by_func (original_file, G_CALLBACK (file_changed_callback), - window); + self); g_signal_handlers_disconnect_by_func (target_file, G_CALLBACK (file_changed_callback), - window); + self); - nautilus_file_monitor_remove (original_file, &window->original_files); - nautilus_file_monitor_remove (target_file, &window->target_files); + nautilus_file_monitor_remove (original_file, &self->original_files); + nautilus_file_monitor_remove (target_file, &self->target_files); nautilus_file_unref (original_file); nautilus_file_unref (target_file); @@ -1026,13 +1026,13 @@ mime_list_equal (GList *a, } static GList * -get_mime_list (NautilusPropertiesWindow *window) +get_mime_list (NautilusPropertiesWindow *self) { GList *ret; GList *l; ret = NULL; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { ret = g_list_append (ret, nautilus_file_get_mime_type (NAUTILUS_FILE (l->data))); } @@ -1041,55 +1041,55 @@ get_mime_list (NautilusPropertiesWindow *window) } static gboolean -start_spinner_callback (NautilusPropertiesWindow *window) +start_spinner_callback (NautilusPropertiesWindow *self) { - gtk_widget_show (window->contents_spinner); - gtk_spinner_start (GTK_SPINNER (window->contents_spinner)); - window->deep_count_spinner_timeout_id = 0; + 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 *window) +schedule_start_spinner (NautilusPropertiesWindow *self) { - if (window->deep_count_spinner_timeout_id == 0) + if (self->deep_count_spinner_timeout_id == 0) { - window->deep_count_spinner_timeout_id + self->deep_count_spinner_timeout_id = g_timeout_add_seconds (1, (GSourceFunc) start_spinner_callback, - window); + self); } } static void -stop_spinner (NautilusPropertiesWindow *window) +stop_spinner (NautilusPropertiesWindow *self) { - gtk_spinner_stop (GTK_SPINNER (window->contents_spinner)); - gtk_widget_hide (window->contents_spinner); - if (window->deep_count_spinner_timeout_id > 0) + gtk_spinner_stop (GTK_SPINNER (self->contents_spinner)); + gtk_widget_hide (self->contents_spinner); + if (self->deep_count_spinner_timeout_id > 0) { - g_source_remove (window->deep_count_spinner_timeout_id); - window->deep_count_spinner_timeout_id = 0; + g_source_remove (self->deep_count_spinner_timeout_id); + self->deep_count_spinner_timeout_id = 0; } } static void -stop_deep_count_for_file (NautilusPropertiesWindow *window, +stop_deep_count_for_file (NautilusPropertiesWindow *self, NautilusFile *file) { - if (g_list_find (window->deep_count_files, file)) + if (g_list_find (self->deep_count_files, file)) { g_signal_handlers_disconnect_by_func (file, G_CALLBACK (schedule_directory_contents_update), - window); + self); nautilus_file_unref (file); - window->deep_count_files = g_list_remove (window->deep_count_files, file); + self->deep_count_files = g_list_remove (self->deep_count_files, file); } } static void -start_deep_count_for_file (NautilusPropertiesWindow *window, +start_deep_count_for_file (NautilusPropertiesWindow *self, NautilusFile *file) { if (!nautilus_file_is_directory (file)) @@ -1097,25 +1097,25 @@ start_deep_count_for_file (NautilusPropertiesWindow *window, return; } - if (!g_list_find (window->deep_count_files, file)) + if (!g_list_find (self->deep_count_files, file)) { nautilus_file_ref (file); - window->deep_count_files = g_list_prepend (window->deep_count_files, file); + self->deep_count_files = g_list_prepend (self->deep_count_files, file); nautilus_file_recompute_deep_counts (file); - if (!window->deep_count_finished) + if (!self->deep_count_finished) { g_signal_connect_object (file, "updated-deep-count-in-progress", G_CALLBACK (schedule_directory_contents_update), - window, G_CONNECT_SWAPPED); - schedule_start_spinner (window); + self, G_CONNECT_SWAPPED); + schedule_start_spinner (self); } } } static void -properties_window_update (NautilusPropertiesWindow *window, +properties_window_update (NautilusPropertiesWindow *self, GList *files) { GList *l; @@ -1138,21 +1138,21 @@ properties_window_update (NautilusPropertiesWindow *window, if (changed_file && nautilus_file_is_gone (changed_file)) { /* Remove the file from the property dialog */ - remove_from_dialog (window, changed_file); + remove_from_dialog (self, changed_file); changed_file = NULL; - if (window->original_files == NULL) + if (self->original_files == NULL) { return; } } if (changed_file == NULL || - g_list_find (window->original_files, changed_file)) + g_list_find (self->original_files, changed_file)) { dirty_original = TRUE; } if (changed_file == NULL || - g_list_find (window->target_files, changed_file)) + g_list_find (self->target_files, changed_file)) { dirty_target = TRUE; } @@ -1160,9 +1160,9 @@ properties_window_update (NautilusPropertiesWindow *window, if (dirty_original) { - update_properties_window_title (window); - update_properties_window_icon (window); - update_name_field (window); + update_properties_window_title (self); + 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 */ @@ -1170,76 +1170,76 @@ properties_window_update (NautilusPropertiesWindow *window, if (dirty_target) { - for (l = window->permission_buttons; l != NULL; l = l->next) + for (l = self->permission_buttons; l != NULL; l = l->next) { - permission_button_update (window, GTK_TOGGLE_BUTTON (l->data)); + permission_button_update (self, GTK_TOGGLE_BUTTON (l->data)); } - for (l = window->permission_combos; l != NULL; l = l->next) + for (l = self->permission_combos; l != NULL; l = l->next) { - permission_combo_update (window, GTK_COMBO_BOX (l->data)); + permission_combo_update (self, GTK_COMBO_BOX (l->data)); } - for (l = window->value_fields; l != NULL; l = l->next) + for (l = self->value_fields; l != NULL; l = l->next) { - value_field_update (window, GTK_LABEL (l->data)); + value_field_update (self, GTK_LABEL (l->data)); } } - mime_list = get_mime_list (window); + mime_list = get_mime_list (self); - if (!window->mime_list) + if (!self->mime_list) { - window->mime_list = mime_list; + self->mime_list = mime_list; } else { - if (!mime_list_equal (window->mime_list, mime_list)) + if (!mime_list_equal (self->mime_list, mime_list)) { - refresh_extension_pages (window); + refresh_extension_pages (self); } - g_list_free_full (window->mime_list, g_free); - window->mime_list = mime_list; + g_list_free_full (self->mime_list, g_free); + self->mime_list = mime_list; } } static gboolean update_files_callback (gpointer data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (data); + self = NAUTILUS_PROPERTIES_WINDOW (data); - window->update_files_timeout_id = 0; + self->update_files_timeout_id = 0; - properties_window_update (window, window->changed_files); + properties_window_update (self, self->changed_files); - if (window->original_files == NULL) + if (self->original_files == NULL) { /* Close the window if no files are left */ - gtk_widget_destroy (GTK_WIDGET (window)); + gtk_widget_destroy (GTK_WIDGET (self)); } else { - nautilus_file_list_free (window->changed_files); - window->changed_files = NULL; + nautilus_file_list_free (self->changed_files); + self->changed_files = NULL; } return FALSE; } static void -schedule_files_update (NautilusPropertiesWindow *window) +schedule_files_update (NautilusPropertiesWindow *self) { - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); - if (window->update_files_timeout_id == 0) + if (self->update_files_timeout_id == 0) { - window->update_files_timeout_id + self->update_files_timeout_id = g_timeout_add (FILES_UPDATE_INTERVAL, update_files_callback, - window); + self); } } @@ -1335,18 +1335,18 @@ file_list_all_directories (GList *file_list) "\xE2\x80\x92" static gboolean -location_show_original (NautilusPropertiesWindow *window) +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 (window->original_files, 0)); + 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 (NautilusPropertiesWindow *window, +value_field_update (NautilusPropertiesWindow *self, GtkLabel *label) { GList *file_list; @@ -1361,13 +1361,13 @@ value_field_update (NautilusPropertiesWindow *window, 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 (window)) + if (is_where && location_show_original (self)) { - file_list = window->original_files; + file_list = self->original_files; } else { - file_list = window->target_files; + file_list = self->target_files; } inconsistent_string = INCONSISTENT_STATE_STRING; @@ -1408,7 +1408,7 @@ group_change_callback (NautilusFile *file, GError *error, GroupChange *change) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (change->window)); g_assert (NAUTILUS_IS_FILE (change->file)); @@ -1421,10 +1421,10 @@ group_change_callback (NautilusFile *file, nautilus_report_error_setting_group (change->file, error, change->window); } - window = NAUTILUS_PROPERTIES_WINDOW (change->window); - if (window->group_change == change) + self = NAUTILUS_PROPERTIES_WINDOW (change->window); + if (self->group_change == change) { - window->group_change = NULL; + self->group_change = NULL; } group_change_free (change); @@ -1463,37 +1463,37 @@ schedule_group_change_timeout (GroupChange *change) } static void -schedule_group_change (NautilusPropertiesWindow *window, +schedule_group_change (NautilusPropertiesWindow *self, NautilusFile *file, const char *group) { GroupChange *change; - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); - g_assert (window->group_change == NULL); + 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 (window)); + change->window = GTK_WINDOW (g_object_ref (self)); change->timeout = g_timeout_add (CHOWN_CHGRP_TIMEOUT, (GSourceFunc) schedule_group_change_timeout, change); - window->group_change = change; + self->group_change = change; } static void -unschedule_or_cancel_group_change (NautilusPropertiesWindow *window) +unschedule_or_cancel_group_change (NautilusPropertiesWindow *self) { GroupChange *change; - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); - change = window->group_change; + change = self->group_change; if (change != NULL) { @@ -1509,7 +1509,7 @@ unschedule_or_cancel_group_change (NautilusPropertiesWindow *window) group_change_free (change); } - window->group_change = NULL; + self->group_change = NULL; } } @@ -1517,7 +1517,7 @@ static void changed_group_callback (GtkComboBox *combo_box, NautilusFile *file) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; char *group; char *cur_group; @@ -1530,10 +1530,10 @@ changed_group_callback (GtkComboBox *combo_box, if (group != NULL && strcmp (group, cur_group) != 0) { /* Try to change file group. If this fails, complain to user. */ - window = NAUTILUS_PROPERTIES_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (combo_box), GTK_TYPE_WINDOW)); + self = NAUTILUS_PROPERTIES_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (combo_box), GTK_TYPE_WINDOW)); - unschedule_or_cancel_group_change (window); - schedule_group_change (window, file, group); + unschedule_or_cancel_group_change (self); + schedule_group_change (self, file, group); } g_free (group); g_free (cur_group); @@ -1788,7 +1788,7 @@ owner_change_callback (NautilusFile *file, GError *error, OwnerChange *change) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (change->window)); g_assert (NAUTILUS_IS_FILE (change->file)); @@ -1801,10 +1801,10 @@ owner_change_callback (NautilusFile *file, nautilus_report_error_setting_owner (file, error, change->window); } - window = NAUTILUS_PROPERTIES_WINDOW (change->window); - if (window->owner_change == change) + self = NAUTILUS_PROPERTIES_WINDOW (change->window); + if (self->owner_change == change) { - window->owner_change = NULL; + self->owner_change = NULL; } owner_change_free (change); @@ -1843,37 +1843,37 @@ schedule_owner_change_timeout (OwnerChange *change) } static void -schedule_owner_change (NautilusPropertiesWindow *window, +schedule_owner_change (NautilusPropertiesWindow *self, NautilusFile *file, const char *owner) { OwnerChange *change; - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); - g_assert (window->owner_change == NULL); + 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 (window)); + change->window = GTK_WINDOW (g_object_ref (self)); change->timeout = g_timeout_add (CHOWN_CHGRP_TIMEOUT, (GSourceFunc) schedule_owner_change_timeout, change); - window->owner_change = change; + self->owner_change = change; } static void -unschedule_or_cancel_owner_change (NautilusPropertiesWindow *window) +unschedule_or_cancel_owner_change (NautilusPropertiesWindow *self) { OwnerChange *change; - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); - change = window->owner_change; + change = self->owner_change; if (change != NULL) { @@ -1891,7 +1891,7 @@ unschedule_or_cancel_owner_change (NautilusPropertiesWindow *window) owner_change_free (change); } - window->owner_change = NULL; + self->owner_change = NULL; } } @@ -1899,7 +1899,7 @@ static void changed_owner_callback (GtkComboBox *combo_box, NautilusFile *file) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; char *new_owner; char *cur_owner; @@ -1916,10 +1916,10 @@ changed_owner_callback (GtkComboBox *combo_box, if (strcmp (new_owner, cur_owner) != 0) { /* Try to change file owner. If this fails, complain to user. */ - window = NAUTILUS_PROPERTIES_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (combo_box), GTK_TYPE_WINDOW)); + self = NAUTILUS_PROPERTIES_WINDOW (gtk_widget_get_ancestor (GTK_WIDGET (combo_box), GTK_TYPE_WINDOW)); - unschedule_or_cancel_owner_change (window); - schedule_owner_change (window, file, new_owner); + unschedule_or_cancel_owner_change (self); + schedule_owner_change (self, file, new_owner); } g_free (new_owner); g_free (cur_owner); @@ -2093,7 +2093,7 @@ file_has_prefix (NautilusFile *file, } static void -directory_contents_value_field_update (NautilusPropertiesWindow *window) +directory_contents_value_field_update (NautilusPropertiesWindow *self) { NautilusRequestStatus file_status; char *text, *temp; @@ -2108,17 +2108,17 @@ directory_contents_value_field_update (NautilusPropertiesWindow *window) goffset file_size; gboolean deep_count_active; - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); total_count = 0; total_size = 0; unreadable_directory_count = FALSE; - for (l = window->target_files; l; l = l->next) + for (l = self->target_files; l; l = l->next) { file = NAUTILUS_FILE (l->data); - if (file_has_prefix (file, window->target_files)) + if (file_has_prefix (file, self->target_files)) { /* don't count nested files twice */ continue; @@ -2142,7 +2142,7 @@ directory_contents_value_field_update (NautilusPropertiesWindow *window) if (file_status == NAUTILUS_REQUEST_DONE) { - stop_deep_count_for_file (window, file); + stop_deep_count_for_file (self, file); } } else @@ -2152,12 +2152,12 @@ directory_contents_value_field_update (NautilusPropertiesWindow *window) } } - deep_count_active = (window->deep_count_files != NULL); + 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 (window->deep_count_finished && deep_count_active) + if (self->deep_count_finished && deep_count_active) { return; } @@ -2202,60 +2202,60 @@ directory_contents_value_field_update (NautilusPropertiesWindow *window) } } - gtk_label_set_text (GTK_LABEL (window->contents_value_label), + gtk_label_set_text (GTK_LABEL (self->contents_value_label), text); g_free (text); if (!deep_count_active) { - window->deep_count_finished = TRUE; - stop_spinner (window); + self->deep_count_finished = TRUE; + stop_spinner (self); } } static gboolean update_directory_contents_callback (gpointer data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (data); + self = NAUTILUS_PROPERTIES_WINDOW (data); - window->update_directory_contents_timeout_id = 0; - directory_contents_value_field_update (window); + self->update_directory_contents_timeout_id = 0; + directory_contents_value_field_update (self); return FALSE; } static void -schedule_directory_contents_update (NautilusPropertiesWindow *window) +schedule_directory_contents_update (NautilusPropertiesWindow *self) { - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); - if (window->update_directory_contents_timeout_id == 0) + if (self->update_directory_contents_timeout_id == 0) { - window->update_directory_contents_timeout_id + self->update_directory_contents_timeout_id = g_timeout_add (DIRECTORY_CONTENTS_UPDATE_INTERVAL, update_directory_contents_callback, - window); + self); } } static void -setup_contents_field (NautilusPropertiesWindow *window, +setup_contents_field (NautilusPropertiesWindow *self, GtkGrid *grid) { GList *l; - for (l = window->target_files; l; l = l->next) + for (l = self->target_files; l; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (l->data); - start_deep_count_for_file (window, file); + start_deep_count_for_file (self, file); } /* Fill in the initial value. */ - directory_contents_value_field_update (window); + directory_contents_value_field_update (self); } static gboolean @@ -2298,9 +2298,9 @@ is_burn_directory (NautilusFile *file) } static gboolean -should_show_custom_icon_buttons (NautilusPropertiesWindow *window) +should_show_custom_icon_buttons (NautilusPropertiesWindow *self) { - if (is_multi_file_window (window)) + if (is_multi_file_window (self)) { return FALSE; } @@ -2309,12 +2309,12 @@ should_show_custom_icon_buttons (NautilusPropertiesWindow *window) } static gboolean -should_show_file_type (NautilusPropertiesWindow *window) +should_show_file_type (NautilusPropertiesWindow *self) { - if (!is_multi_file_window (window) - && (nautilus_file_is_in_trash (get_target_file (window)) || - is_network_directory (get_target_file (window)) || - is_burn_directory (get_target_file (window)))) + if (!is_multi_file_window (self) + && (nautilus_file_is_in_trash (get_target_file (self)) || + is_network_directory (get_target_file (self)) || + is_burn_directory (get_target_file (self)))) { return FALSE; } @@ -2324,11 +2324,11 @@ should_show_file_type (NautilusPropertiesWindow *window) } static gboolean -should_show_location_info (NautilusPropertiesWindow *window) +should_show_location_info (NautilusPropertiesWindow *self) { GList *l; - for (l = window->original_files; l != NULL; l = l->next) + 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)) || @@ -2343,11 +2343,11 @@ should_show_location_info (NautilusPropertiesWindow *window) } static gboolean -should_show_trash_orig_path (NautilusPropertiesWindow *window) +should_show_trash_orig_path (NautilusPropertiesWindow *self) { GList *l; - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { if (!nautilus_file_is_in_trash (NAUTILUS_FILE (l->data))) { @@ -2359,14 +2359,14 @@ should_show_trash_orig_path (NautilusPropertiesWindow *window) } static gboolean -should_show_accessed_date (NautilusPropertiesWindow *window) +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 (file_list_all_directories (window->target_files) - || is_multi_file_window (window)) + if (file_list_all_directories (self->target_files) + || is_multi_file_window (self)) { return FALSE; } @@ -2375,17 +2375,17 @@ should_show_accessed_date (NautilusPropertiesWindow *window) } static gboolean -should_show_modified_date (NautilusPropertiesWindow *window) +should_show_modified_date (NautilusPropertiesWindow *self) { - return !is_multi_file_window (window); + return !is_multi_file_window (self); } static gboolean -should_show_trashed_on (NautilusPropertiesWindow *window) +should_show_trashed_on (NautilusPropertiesWindow *self) { GList *l; - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { if (!nautilus_file_is_in_trash (NAUTILUS_FILE (l->data))) { @@ -2397,10 +2397,10 @@ should_show_trashed_on (NautilusPropertiesWindow *window) } static gboolean -should_show_link_target (NautilusPropertiesWindow *window) +should_show_link_target (NautilusPropertiesWindow *self) { - if (!is_multi_file_window (window) - && nautilus_file_is_symbolic_link (get_target_file (window))) + if (!is_multi_file_window (self) + && nautilus_file_is_symbolic_link (get_target_file (self))) { return TRUE; } @@ -2409,18 +2409,18 @@ should_show_link_target (NautilusPropertiesWindow *window) } static gboolean -should_show_free_space (NautilusPropertiesWindow *window) +should_show_free_space (NautilusPropertiesWindow *self) { - if (!is_multi_file_window (window) - && (nautilus_file_is_in_trash (get_target_file (window)) || - is_network_directory (get_target_file (window)) || - nautilus_file_is_in_recent (get_target_file (window)) || - is_burn_directory (get_target_file (window)))) + 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)))) { return FALSE; } - if (file_list_all_directories (window->target_files)) + if (file_list_all_directories (self->target_files)) { return TRUE; } @@ -2429,16 +2429,16 @@ should_show_free_space (NautilusPropertiesWindow *window) } static gboolean -should_show_volume_info (NautilusPropertiesWindow *window) +should_show_volume_info (NautilusPropertiesWindow *self) { NautilusFile *file; - if (is_multi_file_window (window)) + if (is_multi_file_window (self)) { return FALSE; } - file = get_original_file (window); + file = get_original_file (self); if (file == NULL) { @@ -2454,17 +2454,17 @@ should_show_volume_info (NautilusPropertiesWindow *window) } static gboolean -should_show_volume_usage (NautilusPropertiesWindow *window) +should_show_volume_usage (NautilusPropertiesWindow *self) { NautilusFile *file; gboolean success = FALSE; - if (is_multi_file_window (window)) + if (is_multi_file_window (self)) { return FALSE; } - file = get_original_file (window); + file = get_original_file (self); if (file == NULL) { @@ -2578,13 +2578,13 @@ paint_pie_chart (GtkWidget *widget, cairo_t *cr, gpointer data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; double free, used, reserved; - window = NAUTILUS_PROPERTIES_WINDOW (data); + self = NAUTILUS_PROPERTIES_WINDOW (data); - free = (double) window->volume_free / (double) window->volume_capacity; - used = (double) window->volume_used / (double) window->volume_capacity; + free = (double) self->volume_free / (double) self->volume_capacity; + used = (double) self->volume_used / (double) self->volume_capacity; reserved = 1.0 - (used + free); paint_slice (widget, cr, @@ -2597,7 +2597,7 @@ paint_pie_chart (GtkWidget *widget, } static void -setup_pie_widget (NautilusPropertiesWindow *window) +setup_pie_widget (NautilusPropertiesWindow *self) { NautilusFile *file; gchar *capacity; @@ -2608,23 +2608,23 @@ setup_pie_widget (NautilusPropertiesWindow *window) GFile *location; GFileInfo *info; - capacity = g_format_size (window->volume_capacity); - free = g_format_size (window->volume_free); - used = g_format_size (window->volume_used); + 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 (window); + file = get_original_file (self); uri = nautilus_file_get_activation_uri (file); /* Translators: "used" refers to the capacity of the filesystem */ - gtk_label_set_text (GTK_LABEL (window->used_value), used); + gtk_label_set_text (GTK_LABEL (self->used_value), used); /* Translators: "free" refers to the capacity of the filesystem */ - gtk_label_set_text (GTK_LABEL (window->free_value), free); + gtk_label_set_text (GTK_LABEL (self->free_value), free); - gtk_label_set_text (GTK_LABEL (window->total_capacity_value), capacity); + gtk_label_set_text (GTK_LABEL (self->total_capacity_value), capacity); - gtk_label_set_text (GTK_LABEL (window->file_system_value), NULL); + gtk_label_set_text (GTK_LABEL (self->file_system_value), NULL); location = g_file_new_for_uri (uri); info = g_file_query_filesystem_info (location, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, @@ -2634,7 +2634,7 @@ setup_pie_widget (NautilusPropertiesWindow *window) fs_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE); if (fs_type != NULL) { - gtk_label_set_text (GTK_LABEL (window->file_system_value), fs_type); + gtk_label_set_text (GTK_LABEL (self->file_system_value), fs_type); } g_object_unref (info); @@ -2646,23 +2646,23 @@ setup_pie_widget (NautilusPropertiesWindow *window) g_free (used); g_free (free); - g_signal_connect (window->pie_chart, "draw", - G_CALLBACK (paint_pie_chart), window); - g_signal_connect (window->used_color, "draw", - G_CALLBACK (paint_legend), window); - g_signal_connect (window->free_color, "draw", - G_CALLBACK (paint_legend), window); + g_signal_connect (self->pie_chart, "draw", + G_CALLBACK (paint_pie_chart), self); + g_signal_connect (self->used_color, "draw", + G_CALLBACK (paint_legend), self); + g_signal_connect (self->free_color, "draw", + G_CALLBACK (paint_legend), self); } static void -setup_volume_usage_widget (NautilusPropertiesWindow *window) +setup_volume_usage_widget (NautilusPropertiesWindow *self) { gchar *uri; NautilusFile *file; GFile *location; GFileInfo *info; - file = get_original_file (window); + file = get_original_file (self); uri = nautilus_file_get_activation_uri (file); @@ -2671,31 +2671,31 @@ setup_volume_usage_widget (NautilusPropertiesWindow *window) if (info) { - window->volume_capacity = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE); - window->volume_free = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE); + 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)) { - window->volume_used = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_USED); + self->volume_used = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_USED); } else { - window->volume_used = window->volume_capacity - window->volume_free; + self->volume_used = self->volume_capacity - self->volume_free; } g_object_unref (info); } else { - window->volume_capacity = 0; - window->volume_free = 0; - window->volume_used = 0; + self->volume_capacity = 0; + self->volume_free = 0; + self->volume_used = 0; } g_object_unref (location); - if (window->volume_capacity > 0) + if (self->volume_capacity > 0) { - setup_pie_widget (window); + setup_pie_widget (self); } } @@ -2725,181 +2725,181 @@ open_in_disks (GtkButton *button, } static void -setup_basic_page (NautilusPropertiesWindow *window) +setup_basic_page (NautilusPropertiesWindow *self) { GtkGrid *grid; /* Icon pixmap */ - setup_image_widget (window, should_show_custom_icon_buttons (window)); + setup_image_widget (self, should_show_custom_icon_buttons (self)); - window->icon_chooser = NULL; + self->icon_chooser = NULL; /* Grid */ - grid = window->basic_grid; + grid = self->basic_grid; - update_name_field (window); + update_name_field (self); - g_signal_connect_object (window->name_field, "notify::has-focus", - G_CALLBACK (name_field_focus_changed), window, 0); - g_signal_connect_object (window->name_field, "activate", - G_CALLBACK (name_field_activate), window, 0); + g_signal_connect_object (self->name_field, "notify::has-focus", + G_CALLBACK (name_field_focus_changed), self, 0); + g_signal_connect_object (self->name_field, "activate", + G_CALLBACK (name_field_activate), self, 0); /* Start with name field selected, if it's an entry. */ - if (GTK_IS_ENTRY (gtk_stack_get_visible_child (window->name_stack))) + if (GTK_IS_ENTRY (gtk_stack_get_visible_child (self->name_stack))) { - gtk_widget_grab_focus (GTK_WIDGET (window->name_field)); + gtk_widget_grab_focus (GTK_WIDGET (self->name_field)); } - if (should_show_file_type (window)) + if (should_show_file_type (self)) { - gtk_widget_show (window->type_title_label); - gtk_widget_show (window->type_value_label); - g_object_set_data_full (G_OBJECT (window->type_value_label), "file_attribute", + gtk_widget_show (self->type_title_label); + gtk_widget_show (self->type_value_label); + g_object_set_data_full (G_OBJECT (self->type_value_label), "file_attribute", g_strdup ("detailed_type"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->type_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->type_value_label); } - if (should_show_link_target (window)) + if (should_show_link_target (self)) { - gtk_widget_show (window->link_target_title_label); - gtk_widget_show (window->link_target_value_label); - g_object_set_data_full (G_OBJECT (window->link_target_value_label), "file_attribute", + gtk_widget_show (self->link_target_title_label); + gtk_widget_show (self->link_target_value_label); + g_object_set_data_full (G_OBJECT (self->link_target_value_label), "file_attribute", g_strdup ("link_target"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->link_target_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->link_target_value_label); } - if (is_multi_file_window (window) || - nautilus_file_is_directory (get_target_file (window))) + if (is_multi_file_window (self) || + nautilus_file_is_directory (get_target_file (self))) { - gtk_widget_show (window->contents_title_label); - gtk_widget_show (window->contents_value_label); - setup_contents_field (window, grid); + gtk_widget_show (self->contents_title_label); + gtk_widget_show (self->contents_value_label); + setup_contents_field (self, grid); } else { - gtk_widget_show (window->size_title_label); - gtk_widget_show (window->size_value_label); + gtk_widget_show (self->size_title_label); + gtk_widget_show (self->size_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ - g_object_set_data_full (G_OBJECT (window->size_value_label), "file_attribute", + g_object_set_data_full (G_OBJECT (self->size_value_label), "file_attribute", g_strdup ("size_detail"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->size_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->size_value_label); } - if (should_show_location_info (window)) + if (should_show_location_info (self)) { - gtk_widget_show (window->parent_folder_title_label); - gtk_widget_show (window->parent_folder_value_label); + gtk_widget_show (self->parent_folder_title_label); + gtk_widget_show (self->parent_folder_value_label); - g_object_set_data_full (G_OBJECT (window->parent_folder_value_label), "file_attribute", + g_object_set_data_full (G_OBJECT (self->parent_folder_value_label), "file_attribute", g_strdup ("where"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->parent_folder_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->parent_folder_value_label); } - if (should_show_trash_orig_path (window)) + if (should_show_trash_orig_path (self)) { - gtk_widget_show (window->original_folder_title_label); - gtk_widget_show (window->original_folder_value_label); - g_object_set_data_full (G_OBJECT (window->original_folder_value_label), "file_attribute", + gtk_widget_show (self->original_folder_title_label); + gtk_widget_show (self->original_folder_value_label); + g_object_set_data_full (G_OBJECT (self->original_folder_value_label), "file_attribute", g_strdup ("trash_orig_path"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->original_folder_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->original_folder_value_label); } - if (should_show_volume_info (window)) + if (should_show_volume_info (self)) { - gtk_widget_show (window->volume_title_label); - gtk_widget_show (window->volume_value_label); - g_object_set_data_full (G_OBJECT (window->volume_value_label), "file_attribute", + gtk_widget_show (self->volume_title_label); + gtk_widget_show (self->volume_value_label); + g_object_set_data_full (G_OBJECT (self->volume_value_label), "file_attribute", g_strdup ("volume"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->volume_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->volume_value_label); } - if (should_show_trashed_on (window)) + if (should_show_trashed_on (self)) { - gtk_widget_show (window->trashed_on_title_label); - gtk_widget_show (window->trashed_on_value_label); - g_object_set_data_full (G_OBJECT (window->trashed_on_value_label), "file_attribute", + gtk_widget_show (self->trashed_on_title_label); + gtk_widget_show (self->trashed_on_value_label); + g_object_set_data_full (G_OBJECT (self->trashed_on_value_label), "file_attribute", g_strdup ("trashed_on_full"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->trashed_on_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->trashed_on_value_label); } - if (should_show_accessed_date (window) - || should_show_modified_date (window)) + if (should_show_accessed_date (self) + || should_show_modified_date (self)) { - gtk_widget_show (window->spacer_2); + gtk_widget_show (self->spacer_2); } - if (should_show_accessed_date (window)) + if (should_show_accessed_date (self)) { - gtk_widget_show (window->accessed_title_label); - gtk_widget_show (window->accessed_value_label); + gtk_widget_show (self->accessed_title_label); + gtk_widget_show (self->accessed_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ - g_object_set_data_full (G_OBJECT (window->accessed_value_label), "file_attribute", + g_object_set_data_full (G_OBJECT (self->accessed_value_label), "file_attribute", g_strdup ("date_accessed_full"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->accessed_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->accessed_value_label); } - if (should_show_modified_date (window)) + if (should_show_modified_date (self)) { - gtk_widget_show (window->modified_title_label); - gtk_widget_show (window->modified_value_label); + gtk_widget_show (self->modified_title_label); + gtk_widget_show (self->modified_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ - g_object_set_data_full (G_OBJECT (window->modified_value_label), "file_attribute", + g_object_set_data_full (G_OBJECT (self->modified_value_label), "file_attribute", g_strdup ("date_modified_full"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->modified_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->modified_value_label); } - if (should_show_free_space (window) - && !should_show_volume_usage (window)) + if (should_show_free_space (self) + && !should_show_volume_usage (self)) { - gtk_widget_show (window->spacer_3); - gtk_widget_show (window->free_space_title_label); - gtk_widget_show (window->free_space_value_label); + gtk_widget_show (self->spacer_3); + gtk_widget_show (self->free_space_title_label); + gtk_widget_show (self->free_space_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ - g_object_set_data_full (G_OBJECT (window->free_space_value_label), "file_attribute", + g_object_set_data_full (G_OBJECT (self->free_space_value_label), "file_attribute", g_strdup ("free_space"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->free_space_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->free_space_value_label); } - if (should_show_volume_usage (window)) + if (should_show_volume_usage (self)) { - gtk_widget_show (window->volume_widget_box); - gtk_widget_show (window->open_in_disks_button); - setup_volume_usage_widget (window); + gtk_widget_show (self->volume_widget_box); + gtk_widget_show (self->open_in_disks_button); + setup_volume_usage_widget (self); /*Translators: Here Disks mean the name of application GNOME Disks.*/ - g_signal_connect (window->open_in_disks_button, "clicked", G_CALLBACK (open_in_disks), NULL); + g_signal_connect (self->open_in_disks_button, "clicked", G_CALLBACK (open_in_disks), NULL); } } static gboolean -files_has_directory (NautilusPropertiesWindow *window) +files_has_directory (NautilusPropertiesWindow *self) { GList *l; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (l->data); @@ -2913,12 +2913,12 @@ files_has_directory (NautilusPropertiesWindow *window) } static gboolean -files_has_changable_permissions_directory (NautilusPropertiesWindow *window) +files_has_changable_permissions_directory (NautilusPropertiesWindow *self) { GList *l; gboolean changable = FALSE; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (l->data); @@ -2939,11 +2939,11 @@ files_has_changable_permissions_directory (NautilusPropertiesWindow *window) } static gboolean -files_has_file (NautilusPropertiesWindow *window) +files_has_file (NautilusPropertiesWindow *self) { GList *l; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (l->data); @@ -2957,32 +2957,32 @@ files_has_file (NautilusPropertiesWindow *window) } static void -start_long_operation (NautilusPropertiesWindow *window) +start_long_operation (NautilusPropertiesWindow *self) { - if (window->long_operation_underway == 0) + if (self->long_operation_underway == 0) { /* start long operation */ GdkDisplay *display; GdkCursor *cursor; - display = gtk_widget_get_display (GTK_WIDGET (window)); + display = gtk_widget_get_display (GTK_WIDGET (self)); cursor = gdk_cursor_new_for_display (display, GDK_WATCH); - gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), cursor); + gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (self)), cursor); g_object_unref (cursor); } - window->long_operation_underway++; + self->long_operation_underway++; } static void -end_long_operation (NautilusPropertiesWindow *window) +end_long_operation (NautilusPropertiesWindow *self) { - if (gtk_widget_get_window (GTK_WIDGET (window)) != NULL && - window->long_operation_underway == 1) + if (gtk_widget_get_window (GTK_WIDGET (self)) != NULL && + self->long_operation_underway == 1) { /* finished !! */ - gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), NULL); + gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (self)), NULL); } - window->long_operation_underway--; + self->long_operation_underway--; } static void @@ -2991,20 +2991,20 @@ permission_change_callback (NautilusFile *file, GError *error, gpointer callback_data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; g_assert (callback_data != NULL); - window = NAUTILUS_PROPERTIES_WINDOW (callback_data); - end_long_operation (window); + self = NAUTILUS_PROPERTIES_WINDOW (callback_data); + end_long_operation (self); /* Report the error if it's an error. */ - nautilus_report_error_setting_permissions (file, error, GTK_WINDOW (window)); + nautilus_report_error_setting_permissions (file, error, GTK_WINDOW (self)); - g_object_unref (window); + g_object_unref (self); } static void -update_permissions (NautilusPropertiesWindow *window, +update_permissions (NautilusPropertiesWindow *self, guint32 vfs_new_perm, guint32 vfs_mask, gboolean is_folder, @@ -3013,7 +3013,7 @@ update_permissions (NautilusPropertiesWindow *window, { GList *l; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; guint32 permissions; @@ -3036,7 +3036,7 @@ update_permissions (NautilusPropertiesWindow *window, if (use_original) { gpointer ptr; - if (g_hash_table_lookup_extended (window->initial_permissions, + if (g_hash_table_lookup_extended (self->initial_permissions, file, NULL, &ptr)) { permissions = (permissions & ~vfs_mask) | (GPOINTER_TO_INT (ptr) & vfs_mask); @@ -3047,17 +3047,17 @@ update_permissions (NautilusPropertiesWindow *window, permissions = (permissions & ~vfs_mask) | vfs_new_perm; } - start_long_operation (window); - g_object_ref (window); + start_long_operation (self); + g_object_ref (self); nautilus_file_set_permissions (file, permissions, permission_change_callback, - window); + self); } } static gboolean -initial_permission_state_consistent (NautilusPropertiesWindow *window, +initial_permission_state_consistent (NautilusPropertiesWindow *self, guint32 mask, gboolean is_folder, gboolean both_folder_and_dir) @@ -3068,7 +3068,7 @@ initial_permission_state_consistent (NautilusPropertiesWindow *window, first = TRUE; first_permissions = 0; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; guint32 permissions; @@ -3082,7 +3082,7 @@ initial_permission_state_consistent (NautilusPropertiesWindow *window, continue; } - permissions = GPOINTER_TO_INT (g_hash_table_lookup (window->initial_permissions, + permissions = GPOINTER_TO_INT (g_hash_table_lookup (self->initial_permissions, file)); if (first) @@ -3108,7 +3108,7 @@ initial_permission_state_consistent (NautilusPropertiesWindow *window, static void permission_button_toggled (GtkToggleButton *button, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { gboolean is_folder, is_special; guint32 permission_mask; @@ -3130,7 +3130,7 @@ permission_button_toggled (GtkToggleButton *button, inconsistent = TRUE; on = TRUE; - if (initial_permission_state_consistent (window, permission_mask, is_folder, is_special)) + if (initial_permission_state_consistent (self, permission_mask, is_folder, is_special)) { inconsistent = FALSE; on = TRUE; @@ -3150,16 +3150,16 @@ permission_button_toggled (GtkToggleButton *button, g_signal_handlers_block_by_func (G_OBJECT (button), G_CALLBACK (permission_button_toggled), - window); + self); gtk_toggle_button_set_active (button, on); gtk_toggle_button_set_inconsistent (button, inconsistent); g_signal_handlers_unblock_by_func (G_OBJECT (button), G_CALLBACK (permission_button_toggled), - window); + self); - update_permissions (window, + update_permissions (self, on ? permission_mask : 0, permission_mask, is_folder, @@ -3168,7 +3168,7 @@ permission_button_toggled (GtkToggleButton *button, } static void -permission_button_update (NautilusPropertiesWindow *window, +permission_button_update (NautilusPropertiesWindow *self, GtkToggleButton *button) { GList *l; @@ -3191,7 +3191,7 @@ permission_button_update (NautilusPropertiesWindow *window, all_unset = TRUE; all_cannot_set = TRUE; no_match = TRUE; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; guint32 file_permissions; @@ -3238,7 +3238,7 @@ permission_button_update (NautilusPropertiesWindow *window, g_signal_handlers_block_by_func (G_OBJECT (button), G_CALLBACK (permission_button_toggled), - window); + self); gtk_toggle_button_set_active (button, !all_unset); /* if actually inconsistent, or default value for file buttons @@ -3250,45 +3250,45 @@ permission_button_update (NautilusPropertiesWindow *window, g_signal_handlers_unblock_by_func (G_OBJECT (button), G_CALLBACK (permission_button_toggled), - window); + self); } static void -setup_execute_checkbox_with_label (NautilusPropertiesWindow *window, +setup_execute_checkbox_with_label (NautilusPropertiesWindow *self, guint32 permission_to_check) { gboolean a11y_enabled; GtkLabel *label_for; - label_for = GTK_LABEL (window->execute_label); - gtk_widget_show (window->execute_label); - gtk_widget_show (window->execute_checkbox); + label_for = GTK_LABEL (self->execute_label); + gtk_widget_show (self->execute_label); + gtk_widget_show (self->execute_checkbox); /* Load up the check_button with data we'll need when updating its state. */ - g_object_set_data (G_OBJECT (window->execute_checkbox), "permission", + g_object_set_data (G_OBJECT (self->execute_checkbox), "permission", GINT_TO_POINTER (permission_to_check)); - g_object_set_data (G_OBJECT (window->execute_checkbox), "properties_window", - window); - g_object_set_data (G_OBJECT (window->execute_checkbox), "is-folder", + g_object_set_data (G_OBJECT (self->execute_checkbox), "properties_window", + self); + g_object_set_data (G_OBJECT (self->execute_checkbox), "is-folder", GINT_TO_POINTER (FALSE)); - window->permission_buttons = - g_list_prepend (window->permission_buttons, - window->execute_checkbox); + self->permission_buttons = + g_list_prepend (self->permission_buttons, + self->execute_checkbox); - g_signal_connect_object (window->execute_checkbox, "toggled", + g_signal_connect_object (self->execute_checkbox, "toggled", G_CALLBACK (permission_button_toggled), - window, + self, 0); - a11y_enabled = GTK_IS_ACCESSIBLE (gtk_widget_get_accessible (window->execute_checkbox)); + a11y_enabled = GTK_IS_ACCESSIBLE (gtk_widget_get_accessible (self->execute_checkbox)); if (a11y_enabled && label_for != NULL) { AtkObject *atk_widget; AtkObject *atk_label; atk_label = gtk_widget_get_accessible (GTK_WIDGET (label_for)); - atk_widget = gtk_widget_get_accessible (window->execute_checkbox); + atk_widget = gtk_widget_get_accessible (self->execute_checkbox); /* Create the label -> widget relation */ atk_object_add_relationship (atk_label, ATK_RELATION_LABEL_FOR, atk_widget); @@ -3389,7 +3389,7 @@ permission_from_vfs (PermissionType type, static void permission_combo_changed (GtkWidget *combo, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { GtkTreeIter iter; GtkTreeModel *model; @@ -3422,7 +3422,7 @@ permission_combo_changed (GtkWidget *combo, COLUMN_USE_ORIGINAL, &use_original, -1); vfs_new_perm = permission_to_vfs (type, new_perm); - update_permissions (window, vfs_new_perm, vfs_mask, + update_permissions (self, vfs_new_perm, vfs_mask, is_folder, FALSE, use_original); } @@ -3463,7 +3463,7 @@ permission_combo_add_multiple_choice (GtkComboBox *combo, } static void -permission_combo_update (NautilusPropertiesWindow *window, +permission_combo_update (NautilusPropertiesWindow *self, GtkComboBox *combo) { PermissionType type; @@ -3497,7 +3497,7 @@ permission_combo_update (NautilusPropertiesWindow *window, all_dir_cannot_set = TRUE; all_file_cannot_set = TRUE; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; guint32 file_permissions; @@ -3651,7 +3651,7 @@ permission_combo_update (NautilusPropertiesWindow *window, g_signal_handlers_block_by_func (G_OBJECT (combo), G_CALLBACK (permission_combo_changed), - window); + self); gtk_combo_box_set_active_iter (combo, &iter); @@ -3669,7 +3669,7 @@ permission_combo_update (NautilusPropertiesWindow *window, g_signal_handlers_unblock_by_func (G_OBJECT (combo), G_CALLBACK (permission_combo_changed), - window); + self); } static void @@ -3817,7 +3817,7 @@ get_initial_permissions (GList *file_list) } static void -create_simple_permissions (NautilusPropertiesWindow *window, +create_simple_permissions (NautilusPropertiesWindow *self, GtkGrid *page_grid) { gboolean has_directory; @@ -3827,140 +3827,140 @@ create_simple_permissions (NautilusPropertiesWindow *window, GtkWidget *group_combo_box; GtkWidget *group_value_label; - has_directory = files_has_directory (window); - has_file = files_has_file (window); + has_directory = files_has_directory (self); + has_file = files_has_file (self); - if (!is_multi_file_window (window) && nautilus_file_can_set_owner (get_target_file (window))) + if (!is_multi_file_window (self) && nautilus_file_can_set_owner (get_target_file (self))) { /* Combo box in this case. */ - owner_combo_box = gtk_stack_get_child_by_name (GTK_STACK (window->owner_value_stack), "combo_box"); - gtk_stack_set_visible_child (GTK_STACK (window->owner_value_stack), owner_combo_box); - setup_owner_combo_box (owner_combo_box, get_target_file (window)); + owner_combo_box = gtk_stack_get_child_by_name (GTK_STACK (self->owner_value_stack), "combo_box"); + gtk_stack_set_visible_child (GTK_STACK (self->owner_value_stack), owner_combo_box); + setup_owner_combo_box (owner_combo_box, get_target_file (self)); } else { /* Static text in this case. */ - owner_value_label = gtk_stack_get_child_by_name (GTK_STACK (window->owner_value_stack), "label"); - gtk_stack_set_visible_child (GTK_STACK (window->owner_value_stack), owner_value_label); + owner_value_label = gtk_stack_get_child_by_name (GTK_STACK (self->owner_value_stack), "label"); + gtk_stack_set_visible_child (GTK_STACK (self->owner_value_stack), owner_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ g_object_set_data_full (G_OBJECT (owner_value_label), "file_attribute", g_strdup ("owner"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - owner_value_label); + self->value_fields = g_list_prepend (self->value_fields, + owner_value_label); } if (has_directory && has_file) { - gtk_widget_show (window->owner_folder_access_label); - gtk_widget_show (window->owner_folder_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->owner_folder_access_combo), + gtk_widget_show (self->owner_folder_access_label); + gtk_widget_show (self->owner_folder_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->owner_folder_access_combo), PERMISSION_USER, TRUE); - window->permission_combos = g_list_prepend (window->permission_combos, - window->owner_folder_access_combo); - g_signal_connect (window->owner_folder_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->owner_folder_access_combo); + g_signal_connect (self->owner_folder_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); - gtk_widget_show (window->owner_file_access_label); - gtk_widget_show (window->owner_file_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->owner_file_access_combo), + gtk_widget_show (self->owner_file_access_label); + gtk_widget_show (self->owner_file_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->owner_file_access_combo), PERMISSION_USER, FALSE); - window->permission_combos = g_list_prepend (window->permission_combos, - window->owner_file_access_combo); - g_signal_connect (window->owner_file_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->owner_file_access_combo); + g_signal_connect (self->owner_file_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); } else { - gtk_widget_show (window->owner_access_label); - gtk_widget_show (window->owner_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->owner_access_combo), + gtk_widget_show (self->owner_access_label); + gtk_widget_show (self->owner_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->owner_access_combo), PERMISSION_USER, has_directory); - window->permission_combos = g_list_prepend (window->permission_combos, - window->owner_access_combo); - g_signal_connect (window->owner_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->owner_access_combo); + g_signal_connect (self->owner_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); } - if (!is_multi_file_window (window) && nautilus_file_can_set_group (get_target_file (window))) + if (!is_multi_file_window (self) && nautilus_file_can_set_group (get_target_file (self))) { /* Combo box in this case. */ - group_combo_box = gtk_stack_get_child_by_name (GTK_STACK (window->group_value_stack), "combo_box"); - gtk_stack_set_visible_child (GTK_STACK (window->group_value_stack), group_combo_box); - setup_group_combo_box (group_combo_box, get_target_file (window)); + group_combo_box = gtk_stack_get_child_by_name (GTK_STACK (self->group_value_stack), "combo_box"); + gtk_stack_set_visible_child (GTK_STACK (self->group_value_stack), group_combo_box); + setup_group_combo_box (group_combo_box, get_target_file (self)); } else { - group_value_label = gtk_stack_get_child_by_name (GTK_STACK (window->group_value_stack), "label"); - gtk_stack_set_visible_child (GTK_STACK (window->group_value_stack), group_value_label); + group_value_label = gtk_stack_get_child_by_name (GTK_STACK (self->group_value_stack), "label"); + gtk_stack_set_visible_child (GTK_STACK (self->group_value_stack), group_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ g_object_set_data_full (G_OBJECT (group_value_label), "file_attribute", g_strdup ("group"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - group_value_label); + self->value_fields = g_list_prepend (self->value_fields, + group_value_label); } if (has_directory && has_file) { - gtk_widget_show (window->group_folder_access_label); - gtk_widget_show (window->group_folder_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->group_folder_access_combo), + gtk_widget_show (self->group_folder_access_label); + gtk_widget_show (self->group_folder_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->group_folder_access_combo), PERMISSION_GROUP, TRUE); - window->permission_combos = g_list_prepend (window->permission_combos, - window->group_folder_access_combo); - g_signal_connect (window->group_folder_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->group_folder_access_combo); + g_signal_connect (self->group_folder_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); - gtk_widget_show (window->group_file_access_label); - gtk_widget_show (window->group_file_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->group_file_access_combo), + gtk_widget_show (self->group_file_access_label); + gtk_widget_show (self->group_file_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->group_file_access_combo), PERMISSION_GROUP, FALSE); - window->permission_combos = g_list_prepend (window->permission_combos, - window->group_file_access_combo); - g_signal_connect (window->group_file_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->group_file_access_combo); + g_signal_connect (self->group_file_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); } else { - gtk_widget_show (window->group_access_label); - gtk_widget_show (window->group_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->group_access_combo), + gtk_widget_show (self->group_access_label); + gtk_widget_show (self->group_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->group_access_combo), PERMISSION_GROUP, has_directory); - window->permission_combos = g_list_prepend (window->permission_combos, - window->group_access_combo); - g_signal_connect (window->group_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->group_access_combo); + g_signal_connect (self->group_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); } /* Others Row */ if (has_directory && has_file) { - gtk_widget_show (window->others_folder_access_label); - gtk_widget_show (window->others_folder_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->others_folder_access_combo), + gtk_widget_show (self->others_folder_access_label); + gtk_widget_show (self->others_folder_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->others_folder_access_combo), PERMISSION_OTHER, TRUE); - window->permission_combos = g_list_prepend (window->permission_combos, - window->others_folder_access_combo); - g_signal_connect (window->others_folder_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->others_folder_access_combo); + g_signal_connect (self->others_folder_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); - gtk_widget_show (window->others_file_access_label); - gtk_widget_show (window->others_file_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->others_file_access_combo), + gtk_widget_show (self->others_file_access_label); + gtk_widget_show (self->others_file_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->others_file_access_combo), PERMISSION_OTHER, FALSE); - window->permission_combos = g_list_prepend (window->permission_combos, - window->others_file_access_combo); - g_signal_connect (window->others_file_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->others_file_access_combo); + g_signal_connect (self->others_file_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); } else { - gtk_widget_show (window->others_access_label); - gtk_widget_show (window->others_access_combo); - setup_permissions_combo_box (GTK_COMBO_BOX (window->others_access_combo), + gtk_widget_show (self->others_access_label); + gtk_widget_show (self->others_access_combo); + setup_permissions_combo_box (GTK_COMBO_BOX (self->others_access_combo), PERMISSION_OTHER, has_directory); - window->permission_combos = g_list_prepend (window->permission_combos, - window->others_access_combo); - g_signal_connect (window->others_access_combo, "changed", G_CALLBACK (permission_combo_changed), window); + self->permission_combos = g_list_prepend (self->permission_combos, + self->others_access_combo); + g_signal_connect (self->others_access_combo, "changed", G_CALLBACK (permission_combo_changed), self); } if (!has_directory) { - setup_execute_checkbox_with_label (window, + setup_execute_checkbox_with_label (self, UNIX_PERM_USER_EXEC | UNIX_PERM_GROUP_EXEC | UNIX_PERM_OTHER_EXEC); } } @@ -3969,18 +3969,18 @@ static void set_recursive_permissions_done (gboolean success, gpointer callback_data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (callback_data); - end_long_operation (window); + self = NAUTILUS_PROPERTIES_WINDOW (callback_data); + end_long_operation (self); - g_object_unref (window); + g_object_unref (self); } static void on_change_permissions_response (GtkDialog *dialog, int response, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { guint32 file_permission, file_permission_mask; guint32 dir_permission, dir_permission_mask; @@ -3995,7 +3995,7 @@ on_change_permissions_response (GtkDialog *dialog, if (response != GTK_RESPONSE_OK) { - g_clear_pointer (&window->change_permission_combos, g_list_free); + g_clear_pointer (&self->change_permission_combos, g_list_free); gtk_widget_destroy (GTK_WIDGET (dialog)); return; } @@ -4006,7 +4006,7 @@ on_change_permissions_response (GtkDialog *dialog, dir_permission_mask = 0; /* Simple mode, minus exec checkbox */ - for (l = window->change_permission_combos; l != NULL; l = l->next) + for (l = self->change_permission_combos; l != NULL; l = l->next) { combo = l->data; @@ -4050,7 +4050,7 @@ on_change_permissions_response (GtkDialog *dialog, } } - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { NautilusFile *file; char *uri; @@ -4061,19 +4061,19 @@ on_change_permissions_response (GtkDialog *dialog, nautilus_file_can_set_permissions (file)) { uri = nautilus_file_get_uri (file); - start_long_operation (window); - g_object_ref (window); + 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, - window); + self); g_free (uri); } } - g_clear_pointer (&window->change_permission_combos, g_list_free); + g_clear_pointer (&self->change_permission_combos, g_list_free); gtk_widget_destroy (GTK_WIDGET (dialog)); } @@ -4178,7 +4178,7 @@ set_active_from_umask (GtkComboBox *combo, static void on_change_permissions_clicked (GtkWidget *button, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { GtkWidget *dialog; GtkComboBox *combo; @@ -4187,94 +4187,94 @@ on_change_permissions_clicked (GtkWidget *button, 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 (window)); + 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, FALSE); - window->change_permission_combos = g_list_prepend (window->change_permission_combos, - combo); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); set_active_from_umask (combo, PERMISSION_USER, FALSE); combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "folder_owner_combo")); setup_permissions_combo_box (combo, PERMISSION_USER, TRUE); - window->change_permission_combos = g_list_prepend (window->change_permission_combos, - combo); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); set_active_from_umask (combo, PERMISSION_USER, TRUE); /* Group Permissions */ combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "file_group_combo")); setup_permissions_combo_box (combo, PERMISSION_GROUP, FALSE); - window->change_permission_combos = g_list_prepend (window->change_permission_combos, - combo); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); set_active_from_umask (combo, PERMISSION_GROUP, FALSE); combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "folder_group_combo")); setup_permissions_combo_box (combo, PERMISSION_GROUP, TRUE); - window->change_permission_combos = g_list_prepend (window->change_permission_combos, - combo); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); set_active_from_umask (combo, PERMISSION_GROUP, TRUE); /* Others Permissions */ combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "file_other_combo")); setup_permissions_combo_box (combo, PERMISSION_OTHER, FALSE); - window->change_permission_combos = g_list_prepend (window->change_permission_combos, - combo); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); set_active_from_umask (combo, PERMISSION_OTHER, FALSE); combo = GTK_COMBO_BOX (gtk_builder_get_object (change_permissions_builder, "folder_other_combo")); setup_permissions_combo_box (combo, PERMISSION_OTHER, TRUE); - window->change_permission_combos = g_list_prepend (window->change_permission_combos, - combo); + self->change_permission_combos = g_list_prepend (self->change_permission_combos, + combo); set_active_from_umask (combo, PERMISSION_OTHER, TRUE); - g_signal_connect (dialog, "response", G_CALLBACK (on_change_permissions_response), window); + g_signal_connect (dialog, "response", G_CALLBACK (on_change_permissions_response), self); gtk_widget_show_all (dialog); g_object_unref (change_permissions_builder); } static void -setup_permissions_page (NautilusPropertiesWindow *window) +setup_permissions_page (NautilusPropertiesWindow *self) { char *file_name, *prompt_text; GList *file_list; - file_list = window->original_files; + file_list = self->original_files; - window->initial_permissions = NULL; + self->initial_permissions = NULL; - if (all_can_get_permissions (file_list) && all_can_get_permissions (window->target_files)) + if (all_can_get_permissions (file_list) && all_can_get_permissions (self->target_files)) { - window->initial_permissions = get_initial_permissions (window->target_files); - window->has_recursive_apply = files_has_changable_permissions_directory (window); + 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 (window->not_the_owner_label); - gtk_widget_show (window->bottom_prompt_seperator); + gtk_widget_show (self->not_the_owner_label); + gtk_widget_show (self->bottom_prompt_seperator); } - gtk_widget_show (window->permissions_grid); - create_simple_permissions (window, GTK_GRID (window->permissions_grid)); + gtk_widget_show (self->permissions_grid); + create_simple_permissions (self, GTK_GRID (self->permissions_grid)); #ifdef HAVE_SELINUX - gtk_widget_show (window->security_context_title_label); - gtk_widget_show (window->security_context_value_label); + gtk_widget_show (self->security_context_title_label); + gtk_widget_show (self->security_context_value_label); /* Stash a copy of the file attribute name in this field for the callback's sake. */ - g_object_set_data_full (G_OBJECT (window->security_context_value_label), "file_attribute", + g_object_set_data_full (G_OBJECT (self->security_context_value_label), "file_attribute", g_strdup ("selinux_context"), g_free); - window->value_fields = g_list_prepend (window->value_fields, - window->security_context_value_label); + self->value_fields = g_list_prepend (self->value_fields, + self->security_context_value_label); #endif - if (window->has_recursive_apply) + if (self->has_recursive_apply) { - gtk_widget_show_all (window->change_permissions_button_box); - g_signal_connect (window->change_permissions_button, "clicked", + gtk_widget_show_all (self->change_permissions_button_box); + g_signal_connect (self->change_permissions_button, "clicked", G_CALLBACK (on_change_permissions_clicked), - window); + self); } } else @@ -4285,21 +4285,21 @@ setup_permissions_page (NautilusPropertiesWindow *window) * 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 (window)) + if (!is_multi_file_window (self)) { - file_name = nautilus_file_get_display_name (get_target_file (window)); + 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); - gtk_label_set_text (GTK_LABEL (window->permission_indeterminable_label), prompt_text); + gtk_label_set_text (GTK_LABEL (self->permission_indeterminable_label), prompt_text); g_free (file_name); g_free (prompt_text); } - gtk_widget_show (window->permission_indeterminable_label); + gtk_widget_show (self->permission_indeterminable_label); } } static void -append_extension_pages (NautilusPropertiesWindow *window) +append_extension_pages (NautilusPropertiesWindow *self) { GList *providers; GList *p; @@ -4315,7 +4315,7 @@ append_extension_pages (NautilusPropertiesWindow *window) provider = NAUTILUS_PROPERTY_PAGE_PROVIDER (p->data); pages = nautilus_property_page_provider_get_pages - (provider, window->original_files); + (provider, self->original_files); for (l = pages; l != NULL; l = l->next) { @@ -4329,9 +4329,9 @@ append_extension_pages (NautilusPropertiesWindow *window) "page", &page_widget, "label", &label, NULL); - gtk_notebook_append_page (window->notebook, + gtk_notebook_append_page (self->notebook, page_widget, label); - gtk_container_child_set (GTK_CONTAINER (window->notebook), + gtk_container_child_set (GTK_CONTAINER (self->notebook), page_widget, "tab-expand", TRUE, NULL); @@ -4353,14 +4353,14 @@ append_extension_pages (NautilusPropertiesWindow *window) } static gboolean -should_show_permissions (NautilusPropertiesWindow *window) +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 = window->original_files; l != NULL; l = l->next) + 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))) @@ -4452,18 +4452,18 @@ static void file_changed_callback (NautilusFile *file, gpointer user_data) { - NautilusPropertiesWindow *window = NAUTILUS_PROPERTIES_WINDOW (user_data); + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); - if (!g_list_find (window->changed_files, file)) + if (!g_list_find (self->changed_files, file)) { nautilus_file_ref (file); - window->changed_files = g_list_prepend (window->changed_files, file); - schedule_files_update (window); + self->changed_files = g_list_prepend (self->changed_files, file); + schedule_files_update (self); } } static gboolean -should_show_open_with (NautilusPropertiesWindow *window) +should_show_open_with (NautilusPropertiesWindow *self) { NautilusFile *file; char *mime_type; @@ -4478,17 +4478,17 @@ should_show_open_with (NautilusPropertiesWindow *window) * leads to all sort of hard to understand errors. */ - if (is_multi_file_window (window)) + if (is_multi_file_window (self)) { GList *l; - if (!file_list_attributes_identical (window->target_files, + if (!file_list_attributes_identical (self->target_files, "mime_type")) { return FALSE; } - for (l = window->target_files; l; l = l->next) + for (l = self->target_files; l; l = l->next) { file = NAUTILUS_FILE (l->data); app_info = nautilus_mime_get_default_application_for_file (file); @@ -4500,11 +4500,11 @@ should_show_open_with (NautilusPropertiesWindow *window) /* since we just confirmed all the mime types are the * same we only need to test one file */ - file = window->target_files->data; + file = self->target_files->data; } else { - file = get_target_file (window); + file = get_target_file (self); app_info = nautilus_mime_get_default_application_for_file (file); if (nautilus_file_is_directory (file) || !app_info || file == NULL) @@ -4526,19 +4526,19 @@ static void add_clicked_cb (GtkButton *button, gpointer user_data) { - NautilusPropertiesWindow *window = NAUTILUS_PROPERTIES_WINDOW (user_data); + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); GAppInfo *info; gchar *message; GError *error = NULL; - info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (window->app_chooser_widget)); + info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->app_chooser_widget)); if (info == NULL) { return; } - g_app_info_set_as_last_used_for_type (info, window->content_type, &error); + g_app_info_set_as_last_used_for_type (info, self->content_type, &error); if (error != NULL) { @@ -4546,14 +4546,14 @@ add_clicked_cb (GtkButton *button, g_app_info_get_display_name (info), error->message); show_dialog (_("Could not add application"), message, - GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (window))), + GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))), GTK_MESSAGE_ERROR); g_error_free (error); g_free (message); } else { - gtk_app_chooser_refresh (GTK_APP_CHOOSER (window->app_chooser_widget)); + gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->app_chooser_widget)); g_signal_emit_by_name (nautilus_signaller_get_current (), "mime-data-changed"); } @@ -4564,27 +4564,27 @@ static void remove_clicked_cb (GtkMenuItem *item, gpointer user_data) { - NautilusPropertiesWindow *window = NAUTILUS_PROPERTIES_WINDOW (user_data); + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); GError *error; GAppInfo *info; - info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (window->app_chooser_widget)); + info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->app_chooser_widget)); if (info) { error = NULL; if (!g_app_info_remove_supports_type (info, - window->content_type, + self->content_type, &error)) { show_dialog (_("Could not forget association"), error->message, - GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (window))), + GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))), GTK_MESSAGE_ERROR); g_error_free (error); } - gtk_app_chooser_refresh (GTK_APP_CHOOSER (window->app_chooser_widget)); + gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->app_chooser_widget)); g_object_unref (info); } @@ -4598,7 +4598,7 @@ populate_popup_cb (GtkAppChooserWidget *widget, gpointer user_data) { GtkWidget *item; - NautilusPropertiesWindow *window = NAUTILUS_PROPERTIES_WINDOW (user_data); + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); if (g_app_info_can_remove_supports_type (app)) { @@ -4607,7 +4607,7 @@ populate_popup_cb (GtkAppChooserWidget *widget, gtk_widget_show (item); g_signal_connect (item, "activate", - G_CALLBACK (remove_clicked_cb), window); + G_CALLBACK (remove_clicked_cb), self); } } @@ -4615,12 +4615,12 @@ static void reset_clicked_cb (GtkButton *button, gpointer user_data) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (user_data); + self = NAUTILUS_PROPERTIES_WINDOW (user_data); - g_app_info_reset_type_associations (window->content_type); - gtk_app_chooser_refresh (GTK_APP_CHOOSER (window->app_chooser_widget)); + g_app_info_reset_type_associations (self->content_type); + gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->app_chooser_widget)); g_signal_emit_by_name (nautilus_signaller_get_current (), "mime-data-changed"); } @@ -4629,14 +4629,14 @@ static void set_as_default_clicked_cb (GtkButton *button, gpointer user_data) { - NautilusPropertiesWindow *window = NAUTILUS_PROPERTIES_WINDOW (user_data); + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); GAppInfo *info; GError *error = NULL; gchar *message = NULL; - info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (window->app_chooser_widget)); + info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->app_chooser_widget)); - g_app_info_set_as_default_for_type (info, window->content_type, + g_app_info_set_as_default_for_type (info, self->content_type, &error); if (error != NULL) @@ -4645,13 +4645,13 @@ set_as_default_clicked_cb (GtkButton *button, g_app_info_get_display_name (info), error->message); show_dialog (_("Could not set as default"), message, - GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (window))), + GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))), GTK_MESSAGE_ERROR); } g_object_unref (info); - gtk_app_chooser_refresh (GTK_APP_CHOOSER (window->app_chooser_widget)); + gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->app_chooser_widget)); g_signal_emit_by_name (nautilus_signaller_get_current (), "mime-data-changed"); } @@ -4696,32 +4696,32 @@ application_selected_cb (GtkAppChooserWidget *widget, GAppInfo *info, gpointer user_data) { - NautilusPropertiesWindow *window = NAUTILUS_PROPERTIES_WINDOW (user_data); + NautilusPropertiesWindow *self = NAUTILUS_PROPERTIES_WINDOW (user_data); GAppInfo *default_app; - default_app = g_app_info_get_default_for_type (window->content_type, FALSE); + default_app = g_app_info_get_default_for_type (self->content_type, FALSE); if (default_app != NULL) { - gtk_widget_set_sensitive (window->set_as_default_button, + gtk_widget_set_sensitive (self->set_as_default_button, !g_app_info_equal (info, default_app)); g_object_unref (default_app); } - gtk_widget_set_sensitive (window->add_button, - app_info_can_add (info, window->content_type)); + gtk_widget_set_sensitive (self->add_button, + app_info_can_add (info, self->content_type)); } static void -application_chooser_apply_labels (NautilusPropertiesWindow *window) +application_chooser_apply_labels (NautilusPropertiesWindow *self) { gchar *label, *extension = NULL, *description = NULL; gint num_files; NautilusFile *file; - num_files = g_list_length (window->open_with_files); - file = window->open_with_files->data; + num_files = g_list_length (self->open_with_files); + file = self->open_with_files->data; /* here we assume all files are of the same content type */ - if (g_content_type_is_unknown (window->content_type)) + if (g_content_type_is_unknown (self->content_type)) { extension = nautilus_file_get_extension (file); @@ -4730,7 +4730,7 @@ application_chooser_apply_labels (NautilusPropertiesWindow *window) } else { - description = g_content_type_get_description (window->content_type); + description = g_content_type_get_description (self->content_type); } if (num_files > 1) @@ -4751,7 +4751,7 @@ application_chooser_apply_labels (NautilusPropertiesWindow *window) g_free (display_name); } - gtk_label_set_markup (GTK_LABEL (window->open_with_label), label); + gtk_label_set_markup (GTK_LABEL (self->open_with_label), label); g_free (label); g_free (extension); @@ -4759,72 +4759,72 @@ application_chooser_apply_labels (NautilusPropertiesWindow *window) } static void -setup_app_chooser_area (NautilusPropertiesWindow *window) +setup_app_chooser_area (NautilusPropertiesWindow *self) { GAppInfo *info; - window->app_chooser_widget = gtk_app_chooser_widget_new (window->content_type); - gtk_box_pack_start (GTK_BOX (window->app_chooser_widget_box), window->app_chooser_widget, TRUE, TRUE, 0); + self->app_chooser_widget = gtk_app_chooser_widget_new (self->content_type); + gtk_box_pack_start (GTK_BOX (self->app_chooser_widget_box), self->app_chooser_widget, TRUE, TRUE, 0); - gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (window->app_chooser_widget), TRUE); - gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (window->app_chooser_widget), TRUE); - gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (window->app_chooser_widget), TRUE); - gtk_widget_show (window->app_chooser_widget); - g_signal_connect (window->reset_button, "clicked", + gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (self->app_chooser_widget), TRUE); + gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (self->app_chooser_widget), TRUE); + gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (self->app_chooser_widget), TRUE); + gtk_widget_show (self->app_chooser_widget); + g_signal_connect (self->reset_button, "clicked", G_CALLBACK (reset_clicked_cb), - window); - g_signal_connect (window->add_button, "clicked", + self); + g_signal_connect (self->add_button, "clicked", G_CALLBACK (add_clicked_cb), - window); - g_signal_connect (window->set_as_default_button, "clicked", + self); + g_signal_connect (self->set_as_default_button, "clicked", G_CALLBACK (set_as_default_clicked_cb), - window); + self); /* initialize sensitivity */ - info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (window->app_chooser_widget)); + info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->app_chooser_widget)); if (info != NULL) { - application_selected_cb (GTK_APP_CHOOSER_WIDGET (window->app_chooser_widget), - info, window); + application_selected_cb (GTK_APP_CHOOSER_WIDGET (self->app_chooser_widget), + info, self); g_object_unref (info); } - g_signal_connect (window->app_chooser_widget, + g_signal_connect (self->app_chooser_widget, "application-selected", G_CALLBACK (application_selected_cb), - window); - g_signal_connect (window->app_chooser_widget, + self); + g_signal_connect (self->app_chooser_widget, "populate-popup", G_CALLBACK (populate_popup_cb), - window); + self); - application_chooser_apply_labels (window); + application_chooser_apply_labels (self); } static void -setup_open_with_page (NautilusPropertiesWindow *window) +setup_open_with_page (NautilusPropertiesWindow *self) { GList *files = NULL; NautilusFile *target_file; - target_file = get_target_file (window); - window->content_type = nautilus_file_get_mime_type (target_file); + target_file = get_target_file (self); + self->content_type = nautilus_file_get_mime_type (target_file); - if (!is_multi_file_window (window)) + if (!is_multi_file_window (self)) { files = g_list_prepend (NULL, target_file); } else { - files = g_list_copy (window->original_files); + files = g_list_copy (self->original_files); if (files == NULL) { return; } } - window->open_with_files = files; - setup_app_chooser_area (window); + self->open_with_files = files; + setup_app_chooser_area (self); } @@ -4963,24 +4963,24 @@ get_target_file_list (GList *original_files) } static void -add_window (NautilusPropertiesWindow *window) +add_window (NautilusPropertiesWindow *self) { - if (!is_multi_file_window (window)) + if (!is_multi_file_window (self)) { g_hash_table_insert (windows, - get_original_file (window), - window); - g_object_set_data (G_OBJECT (window), "window_key", - get_original_file (window)); + get_original_file (self), + self); + g_object_set_data (G_OBJECT (self), "window_key", + get_original_file (self)); } } static void -remove_window (NautilusPropertiesWindow *window) +remove_window (NautilusPropertiesWindow *self) { gpointer key; - key = g_object_get_data (G_OBJECT (window), "window_key"); + key = g_object_get_data (G_OBJECT (self), "window_key"); if (key) { g_hash_table_remove (windows, key); @@ -5235,71 +5235,71 @@ nautilus_properties_window_present (GList *original_f static void real_destroy (GtkWidget *object) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; GList *l; - window = NAUTILUS_PROPERTIES_WINDOW (object); + self = NAUTILUS_PROPERTIES_WINDOW (object); - remove_window (window); + remove_window (self); - unschedule_or_cancel_group_change (window); - unschedule_or_cancel_owner_change (window); + unschedule_or_cancel_group_change (self); + unschedule_or_cancel_owner_change (self); - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { - nautilus_file_monitor_remove (NAUTILUS_FILE (l->data), &window->original_files); + nautilus_file_monitor_remove (NAUTILUS_FILE (l->data), &self->original_files); } - nautilus_file_list_free (window->original_files); - window->original_files = NULL; + nautilus_file_list_free (self->original_files); + self->original_files = NULL; - for (l = window->target_files; l != NULL; l = l->next) + for (l = self->target_files; l != NULL; l = l->next) { - nautilus_file_monitor_remove (NAUTILUS_FILE (l->data), &window->target_files); + nautilus_file_monitor_remove (NAUTILUS_FILE (l->data), &self->target_files); } - nautilus_file_list_free (window->target_files); - window->target_files = NULL; + nautilus_file_list_free (self->target_files); + self->target_files = NULL; - nautilus_file_list_free (window->changed_files); - window->changed_files = NULL; + nautilus_file_list_free (self->changed_files); + self->changed_files = NULL; - if (window->deep_count_spinner_timeout_id > 0) + if (self->deep_count_spinner_timeout_id > 0) { - g_source_remove (window->deep_count_spinner_timeout_id); + g_source_remove (self->deep_count_spinner_timeout_id); } - while (window->deep_count_files) + while (self->deep_count_files) { - stop_deep_count_for_file (window, window->deep_count_files->data); + stop_deep_count_for_file (self, self->deep_count_files->data); } - g_list_free (window->permission_buttons); - window->permission_buttons = NULL; + g_list_free (self->permission_buttons); + self->permission_buttons = NULL; - g_list_free (window->permission_combos); - window->permission_combos = NULL; + g_list_free (self->permission_combos); + self->permission_combos = NULL; - g_list_free (window->change_permission_combos); - window->change_permission_combos = NULL; + g_list_free (self->change_permission_combos); + self->change_permission_combos = NULL; - if (window->initial_permissions) + if (self->initial_permissions) { - g_hash_table_destroy (window->initial_permissions); - window->initial_permissions = NULL; + g_hash_table_destroy (self->initial_permissions); + self->initial_permissions = NULL; } - g_list_free (window->value_fields); - window->value_fields = NULL; + g_list_free (self->value_fields); + self->value_fields = NULL; - if (window->update_directory_contents_timeout_id != 0) + if (self->update_directory_contents_timeout_id != 0) { - g_source_remove (window->update_directory_contents_timeout_id); - window->update_directory_contents_timeout_id = 0; + g_source_remove (self->update_directory_contents_timeout_id); + self->update_directory_contents_timeout_id = 0; } - if (window->update_files_timeout_id != 0) + if (self->update_files_timeout_id != 0) { - g_source_remove (window->update_files_timeout_id); - window->update_files_timeout_id = 0; + g_source_remove (self->update_files_timeout_id); + self->update_files_timeout_id = 0; } GTK_WIDGET_CLASS (nautilus_properties_window_parent_class)->destroy (object); @@ -5308,19 +5308,19 @@ real_destroy (GtkWidget *object) static void real_finalize (GObject *object) { - NautilusPropertiesWindow *window; + NautilusPropertiesWindow *self; - window = NAUTILUS_PROPERTIES_WINDOW (object); + self = NAUTILUS_PROPERTIES_WINDOW (object); - g_list_free_full (window->mime_list, g_free); + g_list_free_full (self->mime_list, g_free); - g_free (window->pending_name); - g_free (window->content_type); - g_list_free (window->open_with_files); + g_free (self->pending_name); + g_free (self->content_type); + g_list_free (self->open_with_files); - if (window->select_idle_id != 0) + if (self->select_idle_id != 0) { - g_source_remove (window->select_idle_id); + g_source_remove (self->select_idle_id); } G_OBJECT_CLASS (nautilus_properties_window_parent_class)->finalize (object); @@ -5329,14 +5329,14 @@ real_finalize (GObject *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 *properties_window) + NautilusPropertiesWindow *self) { NautilusFile *file; char *file_uri; char *icon_path; g_assert (icon_uri != NULL); - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (properties_window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); icon_path = g_filename_from_uri (icon_uri, NULL, NULL); /* we don't allow remote URIs */ @@ -5344,7 +5344,7 @@ set_icon (const char *icon_uri, { GList *l; - for (l = properties_window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { g_autoptr (GFile) file_location = NULL; g_autoptr (GFile) icon_location = NULL; @@ -5375,7 +5375,7 @@ set_icon (const char *icon_uri, static void update_preview_callback (GtkFileChooser *icon_chooser, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { GtkWidget *preview_widget; GdkPixbuf *pixbuf, *scaled_pixbuf; @@ -5426,7 +5426,7 @@ update_preview_callback (GtkFileChooser *icon_chooser, static void custom_icon_file_chooser_response_cb (GtkDialog *dialog, gint response, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { char *uri; @@ -5434,7 +5434,7 @@ custom_icon_file_chooser_response_cb (GtkDialog *dialog, { case GTK_RESPONSE_NO: { - reset_icon (window); + reset_icon (self); } break; @@ -5443,11 +5443,11 @@ custom_icon_file_chooser_response_cb (GtkDialog *dialog, uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); if (uri != NULL) { - set_icon (uri, window); + set_icon (uri, self); } else { - reset_icon (window); + reset_icon (self); } g_free (uri); } @@ -5464,7 +5464,7 @@ custom_icon_file_chooser_response_cb (GtkDialog *dialog, static void select_image_button_callback (GtkWidget *widget, - NautilusPropertiesWindow *window) + NautilusPropertiesWindow *self) { GtkWidget *dialog, *preview; GtkFileFilter *filter; @@ -5474,13 +5474,13 @@ select_image_button_callback (GtkWidget *widget, char *image_path; gboolean revert_is_sensitive; - g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (window)); + g_assert (NAUTILUS_IS_PROPERTIES_WINDOW (self)); - dialog = window->icon_chooser; + dialog = self->icon_chooser; if (dialog == NULL) { - dialog = gtk_file_chooser_dialog_new (_("Select Custom Icon"), GTK_WINDOW (window), + 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, @@ -5503,18 +5503,18 @@ select_image_button_callback (GtkWidget *widget, gtk_file_chooser_set_preview_widget_active (GTK_FILE_CHOOSER (dialog), FALSE); g_signal_connect (dialog, "update-preview", - G_CALLBACK (update_preview_callback), window); + G_CALLBACK (update_preview_callback), self); - window->icon_chooser = dialog; + self->icon_chooser = dialog; g_object_add_weak_pointer (G_OBJECT (dialog), - (gpointer *) &window->icon_chooser); + (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 (window->original_files) == 1) + if (g_list_length (self->original_files) == 1) { - file = NAUTILUS_FILE (window->original_files->data); + file = NAUTILUS_FILE (self->original_files->data); if (nautilus_file_is_directory (file)) { @@ -5532,7 +5532,7 @@ select_image_button_callback (GtkWidget *widget, } revert_is_sensitive = FALSE; - for (l = window->original_files; l != NULL; l = l->next) + for (l = self->original_files; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); image_path = nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_CUSTOM_ICON, NULL); @@ -5547,7 +5547,7 @@ select_image_button_callback (GtkWidget *widget, 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), window); + G_CALLBACK (custom_icon_file_chooser_response_cb), self); gtk_widget_show (dialog); } @@ -5658,8 +5658,8 @@ nautilus_properties_window_class_init (NautilusPropertiesWindowClass *klass) } static void -nautilus_properties_window_init (NautilusPropertiesWindow *window) +nautilus_properties_window_init (NautilusPropertiesWindow *self) { - gtk_widget_init_template (GTK_WIDGET (window)); - g_signal_connect (window, "close", G_CALLBACK (gtk_window_close), NULL); + gtk_widget_init_template (GTK_WIDGET (self)); + g_signal_connect (self, "close", G_CALLBACK (gtk_window_close), NULL); } -- cgit v1.2.1