/* nautilus-files-view.c * * Copyright (C) 1999, 2000 Free Software Foundation * Copyright (C) 2000, 2001 Eazel, Inc. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program; if not, see . * * Authors: Ettore Perazzoli, * John Sullivan , * Darin Adler , * Pavel Cisler , * David Emory Watson */ #include "nautilus-files-view.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DEBUG_FLAG NAUTILUS_DEBUG_DIRECTORY_VIEW #include "nautilus-debug.h" #include "nautilus-application.h" #include "nautilus-app-chooser.h" #include "nautilus-batch-rename-dialog.h" #include "nautilus-batch-rename-utilities.h" #include "nautilus-clipboard.h" #include "nautilus-compress-dialog-controller.h" #include "nautilus-dbus-launcher.h" #include "nautilus-directory.h" #include "nautilus-dnd.h" #include "nautilus-enums.h" #include "nautilus-error-reporting.h" #include "nautilus-file-changes-queue.h" #include "nautilus-file-name-widget-controller.h" #include "nautilus-file-operations.h" #include "nautilus-file-private.h" #include "nautilus-file-undo-manager.h" #include "nautilus-file-utilities.h" #include "nautilus-file.h" #include "nautilus-floating-bar.h" #include "nautilus-global-preferences.h" #include "nautilus-icon-info.h" #include "nautilus-icon-names.h" #include "nautilus-list-view.h" #include "nautilus-metadata.h" #include "nautilus-mime-actions.h" #include "nautilus-module.h" #include "nautilus-new-folder-dialog-controller.h" #include "nautilus-previewer.h" #include "nautilus-profile.h" #include "nautilus-program-choosing.h" #include "nautilus-properties-window.h" #include "nautilus-rename-file-popover-controller.h" #include "nautilus-search-directory.h" #include "nautilus-signaller.h" #include "nautilus-tag-manager.h" #include "nautilus-toolbar.h" #include "nautilus-trash-monitor.h" #include "nautilus-ui-utilities.h" #include "nautilus-view.h" #include "nautilus-grid-view.h" #include "nautilus-window.h" #include "nautilus-tracker-utilities.h" /* Minimum starting update inverval */ #define UPDATE_INTERVAL_MIN 100 /* Maximum update interval */ #define UPDATE_INTERVAL_MAX 2000 /* Amount of miliseconds the update interval is increased */ #define UPDATE_INTERVAL_INC 250 /* Interval at which the update interval is increased */ #define UPDATE_INTERVAL_TIMEOUT_INTERVAL 250 /* Milliseconds that have to pass without a change to reset the update interval */ #define UPDATE_INTERVAL_RESET 1000 #define SILENT_WINDOW_OPEN_LIMIT 5 #define DUPLICATE_HORIZONTAL_ICON_OFFSET 70 #define DUPLICATE_VERTICAL_ICON_OFFSET 30 #define MAX_QUEUED_UPDATES 500 #define MAX_MENU_LEVELS 5 #define TEMPLATE_LIMIT 30 #define SHORTCUTS_PATH "/nautilus/scripts-accels" /* Delay to show the Loading... floating bar */ #define FLOATING_BAR_LOADING_DELAY 200 /* ms */ #define MIN_COMMON_FILENAME_PREFIX_LENGTH 4 enum { ADD_FILES, BEGIN_FILE_CHANGES, BEGIN_LOADING, CLEAR, END_FILE_CHANGES, END_LOADING, FILE_CHANGED, MOVE_COPY_ITEMS, REMOVE_FILE, SELECTION_CHANGED, TRASH, DELETE, LAST_SIGNAL }; enum { PROP_WINDOW_SLOT = 1, PROP_SUPPORTS_ZOOMING, PROP_ICON, PROP_SEARCHING, PROP_LOADING, PROP_SELECTION, PROP_LOCATION, PROP_SEARCH_QUERY, PROP_EXTENSIONS_BACKGROUND_MENU, PROP_TEMPLATES_MENU, NUM_PROPERTIES }; static guint signals[LAST_SIGNAL]; static char *scripts_directory_uri = NULL; static int scripts_directory_uri_length; static GHashTable *script_accels = NULL; typedef struct { /* Main components */ GtkWidget *overlay; NautilusWindowSlot *slot; NautilusDirectory *model; NautilusFile *directory_as_file; GFile *location; guint dir_merge_id; NautilusQuery *search_query; NautilusRenameFilePopoverController *rename_file_controller; NautilusNewFolderDialogController *new_folder_controller; NautilusCompressDialogController *compress_controller; gboolean supports_zooming; GList *scripts_directory_list; GList *templates_directory_list; gboolean scripts_menu_updated; gboolean templates_menu_updated; guint display_selection_idle_id; guint update_context_menus_timeout_id; guint update_status_idle_id; guint reveal_selection_idle_id; guint display_pending_source_id; guint changes_timeout_id; guint update_interval; guint64 last_queued; gulong files_added_handler_id; gulong files_changed_handler_id; gulong load_error_handler_id; gulong done_loading_handler_id; gulong file_changed_handler_id; /* Containers with FileAndDirectory* elements */ GList *new_added_files; GList *new_changed_files; GHashTable *non_ready_files; GList *old_added_files; GList *old_changed_files; GList *pending_selection; GHashTable *pending_reveal; /* whether we are in the active slot */ gboolean active; /* loading indicates whether this view has begun loading a directory. * This flag should need not be set inside subclasses. NautilusFilesView automatically * sets 'loading' to TRUE before it begins loading a directory's contents and to FALSE * after it finishes loading the directory and its view. */ gboolean loading; gboolean in_destruction; gboolean sort_directories_first; gboolean show_hidden_files; gboolean ignore_hidden_file_preferences; gboolean selection_was_removed; gboolean metadata_for_directory_as_file_pending; gboolean metadata_for_files_in_directory_pending; GList *subdirectory_list; GMenu *selection_menu_model; GMenu *background_menu_model; GtkWidget *selection_menu; GtkWidget *background_menu; GActionGroup *view_action_group; GtkWidget *stack; GtkWidget *scrolled_window; /* Empty states */ GtkWidget *empty_view_page; /* Floating bar */ guint floating_bar_set_status_timeout_id; guint floating_bar_loading_timeout_id; guint floating_bar_set_passthrough_timeout_id; GtkWidget *floating_bar; /* Toolbar menu */ NautilusToolbarMenuSections *toolbar_menu_sections; /* Exposed menus, for the path bar etc. */ GMenuModel *extensions_background_menu; GMenuModel *templates_menu; /* Non exported menu, only for caching */ GMenuModel *scripts_menu; GCancellable *clipboard_cancellable; GCancellable *starred_cancellable; gulong name_accepted_handler_id; gulong cancelled_handler_id; } NautilusFilesViewPrivate; /** * FileAndDirectory: * @file: A #NautilusFile * @directory: A #NautilusDirectory where @file is present. * * The #FileAndDirectory struct is used to relate files to the directories they * are displayed in. This is necessary because the same file can appear multiple * times in the same view, by expanding folders as a tree in a list of search * results. (Adapted from commit 671e4bdaa4d07b039015bedfcb5d42026e5d099e) */ typedef struct { NautilusFile *file; NautilusDirectory *directory; } FileAndDirectory; typedef struct { NautilusFilesView *view; GList *selection; } CompressCallbackData; /* forward declarations */ static gboolean display_selection_info_idle_callback (gpointer data); static void trash_or_delete_files (GtkWindow *parent_window, const GList *files, NautilusFilesView *view); static void load_directory (NautilusFilesView *view, NautilusDirectory *directory); static void on_clipboard_owner_changed (GdkClipboard *clipboard, gpointer user_data); static void schedule_update_context_menus (NautilusFilesView *view); static void remove_update_context_menus_timeout_callback (NautilusFilesView *view); static void schedule_update_status (NautilusFilesView *view); static void remove_update_status_idle_callback (NautilusFilesView *view); static void reset_update_interval (NautilusFilesView *view); static void schedule_idle_display_of_pending_files (NautilusFilesView *view); static void unschedule_display_of_pending_files (NautilusFilesView *view); static void disconnect_model_handlers (NautilusFilesView *view); static void metadata_for_directory_as_file_ready_callback (NautilusFile *file, gpointer callback_data); static void metadata_for_files_in_directory_ready_callback (NautilusDirectory *directory, GList *files, gpointer callback_data); static void nautilus_files_view_trash_state_changed_callback (NautilusTrashMonitor *trash, gboolean state, gpointer callback_data); static void nautilus_files_view_select_file (NautilusFilesView *view, NautilusFile *file); static void update_templates_directory (NautilusFilesView *view); static void extract_files (NautilusFilesView *view, GList *files, GFile *destination_directory); static void extract_files_to_chosen_location (NautilusFilesView *view, GList *files); static void nautilus_files_view_check_empty_states (NautilusFilesView *view); static gboolean nautilus_files_view_is_searching (NautilusView *view); static void nautilus_files_view_iface_init (NautilusViewInterface *view); static void set_search_query_internal (NautilusFilesView *files_view, NautilusQuery *query, NautilusDirectory *base_model); static gboolean nautilus_files_view_is_read_only (NautilusFilesView *view); G_DEFINE_TYPE_WITH_CODE (NautilusFilesView, nautilus_files_view, ADW_TYPE_BIN, G_IMPLEMENT_INTERFACE (NAUTILUS_TYPE_VIEW, nautilus_files_view_iface_init) G_ADD_PRIVATE (NautilusFilesView)); /* Clipboard async helpers. */ static void clipboard_read_value_callback (GObject *source_object, GAsyncResult *result, gpointer user_data) { GdkClipboard *clipboard = GDK_CLIPBOARD (source_object); g_autoptr (GTask) task = user_data; g_autoptr (GError) error = NULL; const GValue *value; value = gdk_clipboard_read_value_finish (clipboard, result, &error); if (error != NULL) { g_task_return_error (task, g_steal_pointer (&error)); } else { g_warn_if_fail (G_VALUE_HOLDS (value, NAUTILUS_TYPE_CLIPBOARD)); g_task_return_pointer (task, g_value_get_boxed (value), NULL); } } void nautilus_files_view_get_clipboard_async (NautilusFilesView *self, GAsyncReadyCallback callback, gpointer callback_data) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (self); GTask *task; if (priv->clipboard_cancellable == NULL) { priv->clipboard_cancellable = g_cancellable_new (); } task = g_task_new (self, priv->clipboard_cancellable, callback, callback_data); gdk_clipboard_read_value_async (gtk_widget_get_clipboard (GTK_WIDGET (self)), NAUTILUS_TYPE_CLIPBOARD, G_PRIORITY_DEFAULT, priv->clipboard_cancellable, clipboard_read_value_callback, task); } NautilusClipboard * nautilus_files_view_get_clipboard_finish (NautilusFilesView *self, GAsyncResult *result, GError **error) { return g_task_propagate_pointer (G_TASK (result), error); } /* * Floating Bar code */ static void remove_loading_floating_bar (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->floating_bar_loading_timeout_id != 0) { g_source_remove (priv->floating_bar_loading_timeout_id); priv->floating_bar_loading_timeout_id = 0; } gtk_widget_hide (priv->floating_bar); nautilus_floating_bar_set_show_stop (NAUTILUS_FLOATING_BAR (priv->floating_bar), FALSE); } static void real_setup_loading_floating_bar (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); nautilus_floating_bar_set_primary_label (NAUTILUS_FLOATING_BAR (priv->floating_bar), nautilus_view_is_searching (NAUTILUS_VIEW (view)) ? _("Searching…") : _("Loading…")); nautilus_floating_bar_set_details_label (NAUTILUS_FLOATING_BAR (priv->floating_bar), NULL); nautilus_floating_bar_set_show_spinner (NAUTILUS_FLOATING_BAR (priv->floating_bar), priv->loading); nautilus_floating_bar_set_show_stop (NAUTILUS_FLOATING_BAR (priv->floating_bar), priv->loading); gtk_widget_set_halign (priv->floating_bar, GTK_ALIGN_END); gtk_widget_show (priv->floating_bar); } static gboolean setup_loading_floating_bar_timeout_cb (gpointer user_data) { NautilusFilesView *view = user_data; NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); priv->floating_bar_loading_timeout_id = 0; real_setup_loading_floating_bar (view); return FALSE; } static void setup_loading_floating_bar (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* setup loading overlay */ if (priv->floating_bar_set_status_timeout_id != 0) { g_source_remove (priv->floating_bar_set_status_timeout_id); priv->floating_bar_set_status_timeout_id = 0; } if (priv->floating_bar_loading_timeout_id != 0) { g_source_remove (priv->floating_bar_loading_timeout_id); priv->floating_bar_loading_timeout_id = 0; } priv->floating_bar_loading_timeout_id = g_timeout_add (FLOATING_BAR_LOADING_DELAY, setup_loading_floating_bar_timeout_cb, view); } static void floating_bar_stop_cb (NautilusFloatingBar *floating_bar, NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); remove_loading_floating_bar (view); nautilus_window_slot_stop_loading (priv->slot); } static void real_floating_bar_set_short_status (NautilusFilesView *view, const gchar *primary_status, const gchar *detail_status) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->loading) { return; } nautilus_floating_bar_set_show_spinner (NAUTILUS_FLOATING_BAR (priv->floating_bar), FALSE); nautilus_floating_bar_set_show_stop (NAUTILUS_FLOATING_BAR (priv->floating_bar), FALSE); if (primary_status == NULL && detail_status == NULL) { gtk_widget_hide (priv->floating_bar); nautilus_floating_bar_remove_hover_timeout (NAUTILUS_FLOATING_BAR (priv->floating_bar)); return; } nautilus_floating_bar_set_labels (NAUTILUS_FLOATING_BAR (priv->floating_bar), primary_status, detail_status); gtk_widget_show (priv->floating_bar); } typedef struct { gchar *primary_status; gchar *detail_status; NautilusFilesView *view; } FloatingBarSetStatusData; static void floating_bar_set_status_data_free (gpointer data) { FloatingBarSetStatusData *status_data = data; g_free (status_data->primary_status); g_free (status_data->detail_status); g_slice_free (FloatingBarSetStatusData, data); } static gboolean floating_bar_set_status_timeout_cb (gpointer data) { NautilusFilesViewPrivate *priv; FloatingBarSetStatusData *status_data = data; priv = nautilus_files_view_get_instance_private (status_data->view); priv->floating_bar_set_status_timeout_id = 0; real_floating_bar_set_short_status (status_data->view, status_data->primary_status, status_data->detail_status); return FALSE; } static gboolean remove_floating_bar_passthrough (gpointer data) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (data)); gtk_widget_set_can_target (priv->floating_bar, TRUE); priv->floating_bar_set_passthrough_timeout_id = 0; return G_SOURCE_REMOVE; } static void set_floating_bar_status (NautilusFilesView *view, const gchar *primary_status, const gchar *detail_status) { GtkSettings *settings; gint double_click_time; FloatingBarSetStatusData *status_data; NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->floating_bar_set_status_timeout_id != 0) { g_source_remove (priv->floating_bar_set_status_timeout_id); priv->floating_bar_set_status_timeout_id = 0; } settings = gtk_settings_get_for_display (gtk_widget_get_display (GTK_WIDGET (view))); g_object_get (settings, "gtk-double-click-time", &double_click_time, NULL); status_data = g_slice_new0 (FloatingBarSetStatusData); status_data->primary_status = g_strdup (primary_status); status_data->detail_status = g_strdup (detail_status); status_data->view = view; if (priv->floating_bar_set_passthrough_timeout_id != 0) { g_source_remove (priv->floating_bar_set_passthrough_timeout_id); priv->floating_bar_set_passthrough_timeout_id = 0; } /* Activate passthrough on the floating bar just long enough for a * potential double click to happen, so to not interfere with it */ gtk_widget_set_can_target (priv->floating_bar, FALSE); priv->floating_bar_set_passthrough_timeout_id = g_timeout_add ((guint) double_click_time, remove_floating_bar_passthrough, view); /* waiting for half of the double-click-time before setting * the status seems to be a good approximation of not setting it * too often and not delaying the statusbar too much. */ priv->floating_bar_set_status_timeout_id = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) (double_click_time / 2), floating_bar_set_status_timeout_cb, status_data, floating_bar_set_status_data_free); } static char * real_get_backing_uri (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (view); if (priv->model == NULL) { return NULL; } return nautilus_directory_get_uri (priv->model); } /** * * nautilus_files_view_get_backing_uri: * * Returns the URI for the target location of new directory, new file, new * link and paste operations. */ char * nautilus_files_view_get_backing_uri (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->get_backing_uri (view); } /** * nautilus_files_view_select_all: * * select all the items in the view * **/ static void nautilus_files_view_select_all (NautilusFilesView *view) { g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->select_all (view); } static void nautilus_files_view_select_first (NautilusFilesView *view) { g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->select_first (view); } static void nautilus_files_view_call_set_selection (NautilusFilesView *view, GList *selection) { g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->set_selection (view, selection); } static GList * nautilus_files_view_get_selection_for_file_transfer (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->get_selection_for_file_transfer (view); } static void nautilus_files_view_invert_selection (NautilusFilesView *view) { g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->invert_selection (view); } /** * nautilus_files_view_reveal_selection: * * Scroll as necessary to reveal the selected items. **/ static void nautilus_files_view_reveal_selection (NautilusFilesView *view) { g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->reveal_selection (view); } /** * nautilus_files_view_get_toolbar_menu_sections: * @view: a #NautilusFilesView * * Retrieves the menu sections that should be added to the toolbar menu when * this view is active * * Returns: (transfer none): a #NautilusToolbarMenuSections with the details of * which menu sections should be added to the menu */ static NautilusToolbarMenuSections * nautilus_files_view_get_toolbar_menu_sections (NautilusView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (view)); return priv->toolbar_menu_sections; } static GMenuModel * nautilus_files_view_get_templates_menu (NautilusView *self) { GMenuModel *menu; g_object_get (self, "templates-menu", &menu, NULL); return menu; } static GMenuModel * nautilus_files_view_get_extensions_background_menu (NautilusView *self) { GMenuModel *menu; g_object_get (self, "extensions-background-menu", &menu, NULL); return menu; } static GMenuModel * real_get_extensions_background_menu (NautilusView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (view)); return priv->extensions_background_menu; } static GMenuModel * real_get_templates_menu (NautilusView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (view)); return priv->templates_menu; } static void nautilus_files_view_set_templates_menu (NautilusView *self, GMenuModel *menu) { g_object_set (self, "templates-menu", menu, NULL); } static void nautilus_files_view_set_extensions_background_menu (NautilusView *self, GMenuModel *menu) { g_object_set (self, "extensions-background-menu", menu, NULL); } static void real_set_extensions_background_menu (NautilusView *view, GMenuModel *menu) { NautilusFilesViewPrivate *priv; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (view)); g_set_object (&priv->extensions_background_menu, menu); } static void real_set_templates_menu (NautilusView *view, GMenuModel *menu) { NautilusFilesViewPrivate *priv; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (view)); g_set_object (&priv->templates_menu, menu); } static gboolean showing_trash_directory (NautilusFilesView *view) { NautilusFile *file; file = nautilus_files_view_get_directory_as_file (view); if (file != NULL) { return nautilus_file_is_in_trash (file); } return FALSE; } static gboolean showing_recent_directory (NautilusFilesView *view) { NautilusFile *file; file = nautilus_files_view_get_directory_as_file (view); if (file != NULL) { return nautilus_file_is_in_recent (file); } return FALSE; } static gboolean showing_starred_directory (NautilusFilesView *view) { NautilusFile *file; file = nautilus_files_view_get_directory_as_file (view); if (file != NULL) { return nautilus_file_is_in_starred (file); } return FALSE; } static gboolean nautilus_files_view_supports_creating_files (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); return !nautilus_files_view_is_read_only (view) && !showing_trash_directory (view) && !showing_recent_directory (view) && !showing_starred_directory (view); } static gboolean nautilus_files_view_supports_extract_here (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); return nautilus_files_view_supports_creating_files (view) && !nautilus_view_is_searching (NAUTILUS_VIEW (view)); } static gboolean nautilus_files_view_is_empty (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->is_empty (view); } /** * nautilus_files_view_bump_zoom_level: * * bump the current zoom level by invoking the relevant subclass through the slot * **/ void nautilus_files_view_bump_zoom_level (NautilusFilesView *view, int zoom_increment) { g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); if (!nautilus_files_view_supports_zooming (view)) { return; } NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->bump_zoom_level (view, zoom_increment); } /** * nautilus_files_view_can_zoom_in: * * Determine whether the view can be zoomed any closer. * @view: The zoomable NautilusFilesView. * * Return value: TRUE if @view can be zoomed any closer, FALSE otherwise. * **/ gboolean nautilus_files_view_can_zoom_in (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); if (!nautilus_files_view_supports_zooming (view)) { return FALSE; } return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->can_zoom_in (view); } /** * nautilus_files_view_can_zoom_out: * * Determine whether the view can be zoomed any further away. * @view: The zoomable NautilusFilesView. * * Return value: TRUE if @view can be zoomed any further away, FALSE otherwise. * **/ gboolean nautilus_files_view_can_zoom_out (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); if (!nautilus_files_view_supports_zooming (view)) { return FALSE; } return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->can_zoom_out (view); } gboolean nautilus_files_view_supports_zooming (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); return priv->supports_zooming; } /** * nautilus_files_view_restore_standard_zoom_level: * * Restore the zoom level to 100% */ static void nautilus_files_view_restore_standard_zoom_level (NautilusFilesView *view) { if (!nautilus_files_view_supports_zooming (view)) { return; } NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->restore_standard_zoom_level (view); } static gboolean nautilus_files_view_is_zoom_level_default (NautilusFilesView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->is_zoom_level_default (view); } gboolean nautilus_files_view_is_searching (NautilusView *view) { NautilusFilesView *files_view; NautilusFilesViewPrivate *priv; files_view = NAUTILUS_FILES_VIEW (view); priv = nautilus_files_view_get_instance_private (files_view); if (!priv->model) { return FALSE; } return NAUTILUS_IS_SEARCH_DIRECTORY (priv->model); } static guint nautilus_files_view_get_view_id (NautilusView *view) { return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->get_view_id (NAUTILUS_FILES_VIEW (view)); } char * nautilus_files_view_get_first_visible_file (NautilusFilesView *view) { return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->get_first_visible_file (view); } void nautilus_files_view_scroll_to_file (NautilusFilesView *view, const char *uri) { NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->scroll_to_file (view, uri); } /** * nautilus_files_view_get_selection: * * Get a list of NautilusFile pointers that represents the * currently-selected items in this view. Subclasses must override * the signal handler for the 'get_selection' signal. Callers are * responsible for g_free-ing the list (and unrefing its data). * @view: NautilusFilesView whose selected items are of interest. * * Return value: GList of NautilusFile pointers representing the selection. * **/ static GList * nautilus_files_view_get_selection (NautilusView *view) { g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->get_selection (NAUTILUS_FILES_VIEW (view)); } typedef struct { NautilusFile *file; NautilusFilesView *directory_view; } ScriptLaunchParameters; typedef struct { NautilusFile *file; NautilusFilesView *directory_view; } CreateTemplateParameters; static FileAndDirectory * file_and_directory_new (NautilusFile *file, NautilusDirectory *directory) { FileAndDirectory *fad; fad = g_new0 (FileAndDirectory, 1); fad->directory = nautilus_directory_ref (directory); fad->file = nautilus_file_ref (file); return fad; } static NautilusFile * file_and_directory_get_file (FileAndDirectory *fad) { g_return_val_if_fail (fad != NULL, NULL); return nautilus_file_ref (fad->file); } static void file_and_directory_free (gpointer data) { FileAndDirectory *fad = data; nautilus_directory_unref (fad->directory); nautilus_file_unref (fad->file); g_free (fad); } G_DEFINE_AUTOPTR_CLEANUP_FUNC (FileAndDirectory, file_and_directory_free) static gboolean file_and_directory_equal (gconstpointer v1, gconstpointer v2) { const FileAndDirectory *fad1, *fad2; fad1 = v1; fad2 = v2; return (fad1->file == fad2->file && fad1->directory == fad2->directory); } static guint file_and_directory_hash (gconstpointer v) { const FileAndDirectory *fad; fad = v; return GPOINTER_TO_UINT (fad->file) ^ GPOINTER_TO_UINT (fad->directory); } static ScriptLaunchParameters * script_launch_parameters_new (NautilusFile *file, NautilusFilesView *directory_view) { ScriptLaunchParameters *result; result = g_new0 (ScriptLaunchParameters, 1); result->directory_view = directory_view; nautilus_file_ref (file); result->file = file; return result; } static void script_launch_parameters_free (ScriptLaunchParameters *parameters) { nautilus_file_unref (parameters->file); g_free (parameters); } static CreateTemplateParameters * create_template_parameters_new (NautilusFile *file, NautilusFilesView *directory_view) { CreateTemplateParameters *result; result = g_new0 (CreateTemplateParameters, 1); result->directory_view = directory_view; nautilus_file_ref (file); result->file = file; return result; } static void create_templates_parameters_free (CreateTemplateParameters *parameters) { nautilus_file_unref (parameters->file); g_free (parameters); } NautilusWindow * nautilus_files_view_get_window (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); return nautilus_window_slot_get_window (priv->slot); } NautilusWindowSlot * nautilus_files_view_get_nautilus_window_slot (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); g_assert (priv->slot != NULL); return priv->slot; } /* Returns the GtkWindow that this directory view occupies, or NULL * if at the moment this directory view is not in a GtkWindow or the * GtkWindow cannot be determined. Primarily used for parenting dialogs. */ static GtkWindow * nautilus_files_view_get_containing_window (NautilusFilesView *view) { GtkWidget *window; g_assert (NAUTILUS_IS_FILES_VIEW (view)); window = gtk_widget_get_ancestor (GTK_WIDGET (view), GTK_TYPE_WINDOW); if (window == NULL) { return NULL; } return GTK_WINDOW (window); } static char * get_view_directory (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; char *uri, *path; GFile *f; priv = nautilus_files_view_get_instance_private (view); uri = nautilus_directory_get_uri (priv->model); f = g_file_new_for_uri (uri); path = g_file_get_path (f); g_object_unref (f); g_free (uri); return path; } typedef struct { gchar *uri; gboolean is_update; } PreviewExportData; static void preview_export_data_free (gpointer _data) { PreviewExportData *data = _data; g_free (data->uri); g_free (data); } G_DEFINE_AUTOPTR_CLEANUP_FUNC (PreviewExportData, preview_export_data_free) static void on_window_handle_export (NautilusWindow *window, const char *handle, guint xid, gpointer user_data) { g_autoptr (PreviewExportData) data = user_data; nautilus_previewer_call_show_file (data->uri, handle, xid, !data->is_update); } static void nautilus_files_view_preview (NautilusFilesView *view, PreviewExportData *data) { if (!nautilus_window_export_handle (nautilus_files_view_get_window (view), on_window_handle_export, data)) { /* Let's use a fallback, so at least a preview will be displayed */ nautilus_previewer_call_show_file (data->uri, "x11:0", 0, !data->is_update); } } static void nautilus_files_view_preview_update (NautilusFilesView *view) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); GtkApplication *app; GtkWindow *window; g_autolist (NautilusFile) selection = NULL; PreviewExportData *data; if (!priv->active || !nautilus_previewer_is_visible ()) { return; } app = GTK_APPLICATION (g_application_get_default ()); window = GTK_WINDOW (nautilus_files_view_get_window (view)); if (window == NULL || window != gtk_application_get_active_window (app)) { return; } selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (selection == NULL) { return; } data = g_new0 (PreviewExportData, 1); data->uri = nautilus_file_get_uri (selection->data); data->is_update = TRUE; nautilus_files_view_preview (view, data); } void nautilus_files_view_preview_selection_event (NautilusFilesView *view, GtkDirectionType direction) { NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->preview_selection_event (view, direction); } void nautilus_files_view_activate_selection (NautilusFilesView *view) { g_autolist (NautilusFile) selection = NULL; selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); nautilus_files_view_activate_files (view, selection, 0, TRUE); } void nautilus_files_view_activate_files (NautilusFilesView *view, GList *files, NautilusOpenFlags flags, gboolean confirm_multiple) { NautilusFilesViewPrivate *priv; GList *files_to_extract; GList *files_to_activate; char *path; if (files == NULL) { return; } priv = nautilus_files_view_get_instance_private (view); files_to_extract = nautilus_file_list_filter (files, &files_to_activate, (NautilusFileFilterFunc) nautilus_mime_file_extracts, NULL); if (nautilus_files_view_supports_extract_here (view)) { g_autoptr (GFile) location = NULL; g_autoptr (GFile) parent = NULL; location = nautilus_file_get_location (NAUTILUS_FILE (g_list_first (files)->data)); /* Get a parent from a random file. We assume all files has a common parent. * But don't assume the parent is the view location, since that's not the * case in list view when expand-folder setting is set */ parent = g_file_get_parent (location); extract_files (view, files_to_extract, parent); } else { extract_files_to_chosen_location (view, files_to_extract); } path = get_view_directory (view); nautilus_mime_activate_files (nautilus_files_view_get_containing_window (view), priv->slot, files_to_activate, path, flags, confirm_multiple); g_free (path); g_list_free (files_to_extract); g_list_free (files_to_activate); } void nautilus_files_view_activate_file (NautilusFilesView *view, NautilusFile *file, NautilusOpenFlags flags) { g_autoptr (GList) files = NULL; files = g_list_append (files, file); nautilus_files_view_activate_files (view, files, flags, FALSE); } static void action_open_with_default_application (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); nautilus_files_view_activate_selection (view); } static void action_open_item_location (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; NautilusFile *item; GFile *activation_location; NautilusFile *activation_file; NautilusFile *parent; g_autoptr (GFile) parent_location = NULL; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (!selection) { return; } item = NAUTILUS_FILE (selection->data); activation_location = nautilus_file_get_activation_location (item); activation_file = nautilus_file_get (activation_location); parent = nautilus_file_get_parent (activation_file); parent_location = nautilus_file_get_location (parent); if (nautilus_file_is_in_recent (item)) { /* Selection logic will check against a NautilusFile of the * activation uri, not the recent:// one. Fixes bug 784516 */ nautilus_file_unref (item); item = nautilus_file_ref (activation_file); selection->data = item; } nautilus_application_open_location_full (NAUTILUS_APPLICATION (g_application_get_default ()), parent_location, 0, selection, NULL, nautilus_files_view_get_nautilus_window_slot (view)); nautilus_file_unref (parent); nautilus_file_unref (activation_file); g_object_unref (activation_location); } static void action_open_item_new_tab (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); nautilus_files_view_activate_files (view, selection, NAUTILUS_OPEN_FLAG_NEW_TAB | NAUTILUS_OPEN_FLAG_DONT_MAKE_ACTIVE, TRUE); } static void app_chooser_dialog_response_cb (GtkDialog *dialog, gint response_id, gpointer user_data) { GtkWindow *parent_window; GList *files; GAppInfo *info; parent_window = user_data; files = g_object_get_data (G_OBJECT (dialog), "directory-view:files"); if (response_id != GTK_RESPONSE_OK) { goto out; } info = nautilus_app_chooser_get_app_info (NAUTILUS_APP_CHOOSER (dialog)); nautilus_launch_application (info, files, parent_window); g_object_unref (info); out: gtk_window_destroy (GTK_WINDOW (dialog)); } static void choose_program (NautilusFilesView *view, GList *files) { GtkWidget *dialog; GtkWindow *parent_window; g_assert (NAUTILUS_IS_FILES_VIEW (view)); parent_window = nautilus_files_view_get_containing_window (view); dialog = GTK_WIDGET (nautilus_app_chooser_new (files, parent_window)); g_object_set_data_full (G_OBJECT (dialog), "directory-view:files", files, (GDestroyNotify) nautilus_file_list_free); gtk_widget_show (dialog); g_signal_connect_object (dialog, "response", G_CALLBACK (app_chooser_dialog_response_cb), parent_window, 0); } static void open_with_other_program (NautilusFilesView *view) { g_autolist (NautilusFile) selection = NULL; g_assert (NAUTILUS_IS_FILES_VIEW (view)); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); choose_program (view, g_steal_pointer (&selection)); } static void action_open_with_other_application (GSimpleAction *action, GVariant *state, gpointer user_data) { g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); open_with_other_program (NAUTILUS_FILES_VIEW (user_data)); } static void action_open_current_directory_with_other_application (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; GList *files; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); if (priv->directory_as_file != NULL) { files = g_list_append (NULL, nautilus_file_ref (priv->directory_as_file)); choose_program (view, files); } } static void trash_or_delete_selected_files (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* This might be rapidly called multiple times for the same selection * when using keybindings. So we remember if the current selection * was already removed (but the view doesn't know about it yet). */ if (!priv->selection_was_removed) { g_autolist (NautilusFile) selection = NULL; selection = nautilus_files_view_get_selection_for_file_transfer (view); trash_or_delete_files (nautilus_files_view_get_containing_window (view), selection, view); priv->selection_was_removed = TRUE; } } static void action_move_to_trash (GSimpleAction *action, GVariant *state, gpointer user_data) { trash_or_delete_selected_files (NAUTILUS_FILES_VIEW (user_data)); } static void action_remove_from_recent (GSimpleAction *action, GVariant *state, gpointer user_data) { /* TODO:implement a set of functions for this, is very confusing to * call trash_or_delete_file to remove from recent, even if it does like * that not deleting/moving the files to trash */ trash_or_delete_selected_files (NAUTILUS_FILES_VIEW (user_data)); } static void delete_selected_files (NautilusFilesView *view) { GList *selection; GList *node; GList *locations; selection = nautilus_files_view_get_selection_for_file_transfer (view); if (selection == NULL) { return; } locations = NULL; for (node = selection; node != NULL; node = node->next) { locations = g_list_prepend (locations, nautilus_file_get_location ((NautilusFile *) node->data)); } locations = g_list_reverse (locations); nautilus_file_operations_delete_async (locations, nautilus_files_view_get_containing_window (view), NULL, NULL, NULL); g_list_free_full (locations, g_object_unref); nautilus_file_list_free (selection); } static void action_delete (GSimpleAction *action, GVariant *state, gpointer user_data) { delete_selected_files (NAUTILUS_FILES_VIEW (user_data)); } static void action_star (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); nautilus_tag_manager_star_files (nautilus_tag_manager_get (), G_OBJECT (view), selection, NULL, priv->starred_cancellable); } static void action_unstar (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); nautilus_tag_manager_unstar_files (nautilus_tag_manager_get (), G_OBJECT (view), selection, NULL, priv->starred_cancellable); } static void action_restore_from_trash (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GList *selection; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_files_view_get_selection_for_file_transfer (view); nautilus_restore_files_from_trash (selection, nautilus_files_view_get_containing_window (view)); nautilus_file_list_free (selection); } static void action_select_all (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); nautilus_files_view_select_all (view); } static void action_invert_selection (GSimpleAction *action, GVariant *state, gpointer user_data) { g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); nautilus_files_view_invert_selection (user_data); } static void action_preview_selection (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (user_data); g_autolist (NautilusFile) selection = NULL; PreviewExportData *data = g_new0 (PreviewExportData, 1); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); data->uri = nautilus_file_get_uri (selection->data); data->is_update = FALSE; nautilus_files_view_preview (view, data); } static void action_popup_menu (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (user_data); g_autolist (NautilusFile) selection = nautilus_files_view_get_selection (NAUTILUS_VIEW (view)); if (selection == NULL) { nautilus_files_view_pop_up_background_context_menu (view, 0, 0); return; } nautilus_files_view_pop_up_selection_context_menu (view, -1, -1); } static void pattern_select_response_cb (GtkWidget *dialog, int response, gpointer user_data) { NautilusFilesView *view; NautilusDirectory *directory; GtkWidget *entry; GList *selection; view = NAUTILUS_FILES_VIEW (user_data); switch (response) { case GTK_RESPONSE_OK: { entry = g_object_get_data (G_OBJECT (dialog), "entry"); directory = nautilus_files_view_get_model (view); selection = nautilus_directory_match_pattern (directory, gtk_editable_get_text (GTK_EDITABLE (entry))); nautilus_files_view_call_set_selection (view, selection); nautilus_files_view_reveal_selection (view); if (selection) { nautilus_file_list_free (selection); } /* fall through */ } case GTK_RESPONSE_NONE: case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_CANCEL: { gtk_window_destroy (GTK_WINDOW (dialog)); } break; default: { g_assert_not_reached (); } } } static void select_pattern (NautilusFilesView *view) { g_autoptr (GtkBuilder) builder = NULL; GtkWidget *dialog; NautilusWindow *window; GtkWidget *example; GtkWidget *entry; char *example_pattern; window = nautilus_files_view_get_window (view); builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/ui/nautilus-files-view-select-items.ui"); dialog = GTK_WIDGET (gtk_builder_get_object (builder, "select_items_dialog")); example = GTK_WIDGET (gtk_builder_get_object (builder, "example")); example_pattern = g_strdup_printf ("%s%s ", _("Examples: "), "*.png, file\?\?.txt, pict*.\?\?\?"); gtk_label_set_markup (GTK_LABEL (example), example_pattern); g_free (example_pattern); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (window)); entry = GTK_WIDGET (gtk_builder_get_object (builder, "pattern_entry")); g_object_set_data (G_OBJECT (dialog), "entry", entry); g_signal_connect (dialog, "response", G_CALLBACK (pattern_select_response_cb), view); gtk_widget_show (dialog); } static void action_select_pattern (GSimpleAction *action, GVariant *state, gpointer user_data) { g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); select_pattern (user_data); } typedef struct { NautilusFilesView *directory_view; GHashTable *added_locations; GList *selection; } NewFolderData; typedef struct { NautilusFilesView *directory_view; GHashTable *to_remove_locations; NautilusFile *new_folder; } NewFolderSelectionData; static void track_newly_added_locations (NautilusFilesView *view, GList *new_files, gpointer user_data) { GHashTable *added_locations; added_locations = user_data; while (new_files) { NautilusFile *new_file; new_file = NAUTILUS_FILE (new_files->data); g_hash_table_add (added_locations, nautilus_file_get_location (new_file)); new_files = new_files->next; } } static void new_folder_done (GFile *new_folder, gboolean success, gpointer user_data) { NautilusFilesView *directory_view; NautilusFilesViewPrivate *priv; NautilusFile *file; NewFolderData *data; data = (NewFolderData *) user_data; directory_view = data->directory_view; priv = nautilus_files_view_get_instance_private (directory_view); if (directory_view == NULL) { goto fail; } g_signal_handlers_disconnect_by_func (directory_view, G_CALLBACK (track_newly_added_locations), data->added_locations); if (new_folder == NULL) { goto fail; } file = nautilus_file_get (new_folder); if (data->selection != NULL) { GList *uris, *l; char *target_uri; uris = NULL; for (l = data->selection; l != NULL; l = l->next) { uris = g_list_prepend (uris, nautilus_file_get_uri ((NautilusFile *) l->data)); } uris = g_list_reverse (uris); target_uri = nautilus_file_get_uri (file); nautilus_files_view_move_copy_items (directory_view, uris, target_uri, GDK_ACTION_MOVE); g_list_free_full (uris, g_free); g_free (target_uri); } if (g_hash_table_contains (data->added_locations, new_folder)) { /* The file was already added */ nautilus_files_view_select_file (directory_view, file); nautilus_files_view_reveal_selection (directory_view); } else { g_hash_table_insert (priv->pending_reveal, file, GUINT_TO_POINTER (TRUE)); } nautilus_file_unref (file); fail: g_hash_table_destroy (data->added_locations); if (data->directory_view != NULL) { g_object_remove_weak_pointer (G_OBJECT (data->directory_view), (gpointer *) &data->directory_view); } nautilus_file_list_free (data->selection); g_free (data); } static NewFolderData * new_folder_data_new (NautilusFilesView *directory_view, gboolean with_selection) { NewFolderData *data; data = g_new (NewFolderData, 1); data->directory_view = directory_view; data->added_locations = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal, g_object_unref, NULL); if (with_selection) { data->selection = nautilus_files_view_get_selection_for_file_transfer (directory_view); } else { data->selection = NULL; } g_object_add_weak_pointer (G_OBJECT (data->directory_view), (gpointer *) &data->directory_view); return data; } static GdkRectangle * nautilus_files_view_compute_rename_popover_pointing_to (NautilusFilesView *view) { return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->compute_rename_popover_pointing_to (view); } static void disconnect_rename_controller_signals (NautilusFilesView *self) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (self)); priv = nautilus_files_view_get_instance_private (self); g_clear_signal_handler (&priv->name_accepted_handler_id, priv->rename_file_controller); g_clear_signal_handler (&priv->cancelled_handler_id, priv->rename_file_controller); } static void rename_file_popover_controller_on_name_accepted (NautilusFileNameWidgetController *controller, gpointer user_data) { NautilusFilesView *view; NautilusFile *target_file; g_autofree gchar *name = NULL; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); name = nautilus_file_name_widget_controller_get_new_name (controller); target_file = nautilus_rename_file_popover_controller_get_target_file (priv->rename_file_controller); /* Put it on the queue for reveal after the view acknowledges the change */ g_hash_table_insert (priv->pending_reveal, target_file, GUINT_TO_POINTER (FALSE)); nautilus_rename_file (target_file, name, NULL, NULL); disconnect_rename_controller_signals (view); } static void rename_file_popover_controller_on_cancelled (NautilusFileNameWidgetController *controller, gpointer user_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); disconnect_rename_controller_signals (view); } static void nautilus_files_view_rename_file_popover_new (NautilusFilesView *view, NautilusFile *target_file) { GdkRectangle *pointing_to; NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* Make sure the whole item is visible. The selection is a single item, the * one to rename with the popover, so we can use reveal_selection() for this. */ nautilus_files_view_reveal_selection (view); pointing_to = nautilus_files_view_compute_rename_popover_pointing_to (view); nautilus_rename_file_popover_controller_show_for_file (priv->rename_file_controller, target_file, pointing_to); priv->name_accepted_handler_id = g_signal_connect (priv->rename_file_controller, "name-accepted", G_CALLBACK (rename_file_popover_controller_on_name_accepted), view); priv->cancelled_handler_id = g_signal_connect (priv->rename_file_controller, "cancelled", G_CALLBACK (rename_file_popover_controller_on_cancelled), view); } static void new_folder_dialog_controller_on_name_accepted (NautilusFileNameWidgetController *controller, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; NewFolderData *data; g_autofree gchar *parent_uri = NULL; g_autofree gchar *name = NULL; NautilusFile *parent; gboolean with_selection; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); with_selection = nautilus_new_folder_dialog_controller_get_with_selection (priv->new_folder_controller); data = new_folder_data_new (view, with_selection); name = nautilus_file_name_widget_controller_get_new_name (controller); g_signal_connect_data (view, "add-files", G_CALLBACK (track_newly_added_locations), data->added_locations, (GClosureNotify) NULL, G_CONNECT_AFTER); parent_uri = nautilus_files_view_get_backing_uri (view); parent = nautilus_file_get_by_uri (parent_uri); nautilus_file_operations_new_folder (GTK_WIDGET (view), NULL, parent_uri, name, new_folder_done, data); g_clear_object (&priv->new_folder_controller); /* After the dialog is destroyed the focus, is probably in the menu item * that created the dialog, but we want the focus to be in the newly created * folder. */ gtk_widget_grab_focus (GTK_WIDGET (view)); g_object_unref (parent); } static void new_folder_dialog_controller_on_cancelled (NautilusNewFolderDialogController *controller, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); g_clear_object (&priv->new_folder_controller); } static void nautilus_files_view_new_folder_dialog_new (NautilusFilesView *view, gboolean with_selection) { g_autoptr (NautilusDirectory) containing_directory = NULL; NautilusFilesViewPrivate *priv; g_autofree char *uri = NULL; g_autofree char *common_prefix = NULL; priv = nautilus_files_view_get_instance_private (view); if (priv->new_folder_controller != NULL) { return; } uri = nautilus_files_view_get_backing_uri (view); containing_directory = nautilus_directory_get_by_uri (uri); if (with_selection) { g_autolist (NautilusFile) selection = NULL; selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); common_prefix = nautilus_get_common_filename_prefix (selection, MIN_COMMON_FILENAME_PREFIX_LENGTH); } priv->new_folder_controller = nautilus_new_folder_dialog_controller_new (nautilus_files_view_get_containing_window (view), containing_directory, with_selection, common_prefix); g_signal_connect (priv->new_folder_controller, "name-accepted", (GCallback) new_folder_dialog_controller_on_name_accepted, view); g_signal_connect (priv->new_folder_controller, "cancelled", (GCallback) new_folder_dialog_controller_on_cancelled, view); } typedef struct { NautilusFilesView *view; GHashTable *added_locations; } CompressData; static void compress_done (GFile *new_file, gboolean success, gpointer user_data) { CompressData *data; NautilusFilesView *view; NautilusFilesViewPrivate *priv; NautilusFile *file; char *uri = NULL; data = user_data; view = data->view; if (view == NULL) { goto out; } priv = nautilus_files_view_get_instance_private (view); g_signal_handlers_disconnect_by_func (view, G_CALLBACK (track_newly_added_locations), data->added_locations); if (!success) { goto out; } file = nautilus_file_get (new_file); if (g_hash_table_contains (data->added_locations, new_file)) { /* The file was already added */ nautilus_files_view_select_file (view, file); nautilus_files_view_reveal_selection (view); } else { g_hash_table_insert (priv->pending_reveal, file, GUINT_TO_POINTER (TRUE)); } uri = nautilus_file_get_uri (file); gtk_recent_manager_add_item (gtk_recent_manager_get_default (), uri); nautilus_file_unref (file); out: g_hash_table_destroy (data->added_locations); if (data->view != NULL) { g_object_remove_weak_pointer (G_OBJECT (data->view), (gpointer *) &data->view); } g_free (uri); g_free (data); } static void compress_dialog_controller_on_name_accepted (NautilusFileNameWidgetController *controller, gpointer user_data) { CompressCallbackData *callback_data = user_data; NautilusFilesView *view; g_autofree gchar *name = NULL; GList *source_files = NULL; GList *l; CompressData *data; g_autoptr (GFile) output = NULL; g_autoptr (GFile) parent = NULL; NautilusCompressionFormat compression_format; NautilusFilesViewPrivate *priv; AutoarFormat format; AutoarFilter filter; const gchar *passphrase = NULL; view = NAUTILUS_FILES_VIEW (callback_data->view); priv = nautilus_files_view_get_instance_private (view); for (l = callback_data->selection; l != NULL; l = l->next) { source_files = g_list_prepend (source_files, nautilus_file_get_location (l->data)); } source_files = g_list_reverse (source_files); name = nautilus_file_name_widget_controller_get_new_name (controller); /* Get a parent from a random file. We assume all files has a common parent. * But don't assume the parent is the view location, since that's not the * case in list view when expand-folder setting is set */ parent = g_file_get_parent (G_FILE (g_list_first (source_files)->data)); output = g_file_get_child (parent, name); data = g_new (CompressData, 1); data->view = view; data->added_locations = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal, g_object_unref, NULL); g_object_add_weak_pointer (G_OBJECT (data->view), (gpointer *) &data->view); g_signal_connect_data (view, "add-files", G_CALLBACK (track_newly_added_locations), data->added_locations, NULL, G_CONNECT_AFTER); compression_format = g_settings_get_enum (nautilus_compression_preferences, NAUTILUS_PREFERENCES_DEFAULT_COMPRESSION_FORMAT); switch (compression_format) { case NAUTILUS_COMPRESSION_ZIP: { format = AUTOAR_FORMAT_ZIP; filter = AUTOAR_FILTER_NONE; } break; case NAUTILUS_COMPRESSION_ENCRYPTED_ZIP: { format = AUTOAR_FORMAT_ZIP; filter = AUTOAR_FILTER_NONE; passphrase = nautilus_compress_dialog_controller_get_passphrase (priv->compress_controller); } break; case NAUTILUS_COMPRESSION_TAR_XZ: { format = AUTOAR_FORMAT_TAR; filter = AUTOAR_FILTER_XZ; } break; case NAUTILUS_COMPRESSION_7ZIP: { format = AUTOAR_FORMAT_7ZIP; filter = AUTOAR_FILTER_NONE; } break; default: { g_assert_not_reached (); } } nautilus_file_operations_compress (source_files, output, format, filter, passphrase, nautilus_files_view_get_containing_window (view), NULL, compress_done, data); g_list_free_full (source_files, g_object_unref); g_clear_object (&priv->compress_controller); } static void compress_dialog_controller_on_cancelled (NautilusNewFolderDialogController *controller, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); g_clear_object (&priv->compress_controller); } static void compress_callback_data_free (CompressCallbackData *data) { nautilus_file_list_free (data->selection); g_free (data); } static void nautilus_files_view_compress_dialog_new (NautilusFilesView *view) { NautilusDirectory *containing_directory; NautilusFilesViewPrivate *priv; g_autolist (NautilusFile) selection = NULL; g_autofree char *common_prefix = NULL; CompressCallbackData *data; priv = nautilus_files_view_get_instance_private (view); if (priv->compress_controller != NULL) { return; } containing_directory = nautilus_directory_get_by_uri (nautilus_files_view_get_backing_uri (view)); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (g_list_length (selection) == 1) { g_autofree char *display_name = NULL; display_name = nautilus_file_get_display_name (selection->data); if (nautilus_file_is_directory (selection->data)) { common_prefix = g_steal_pointer (&display_name); } else { common_prefix = eel_filename_strip_extension (display_name); } } else { common_prefix = nautilus_get_common_filename_prefix (selection, MIN_COMMON_FILENAME_PREFIX_LENGTH); } priv->compress_controller = nautilus_compress_dialog_controller_new (nautilus_files_view_get_containing_window (view), containing_directory, common_prefix); data = g_new0 (CompressCallbackData, 1); data->view = view; data->selection = nautilus_files_view_get_selection_for_file_transfer (view); g_signal_connect_data (priv->compress_controller, "name-accepted", (GCallback) compress_dialog_controller_on_name_accepted, data, (GClosureNotify) compress_callback_data_free, G_CONNECT_AFTER); g_signal_connect (priv->compress_controller, "cancelled", (GCallback) compress_dialog_controller_on_cancelled, view); } static void nautilus_files_view_new_folder (NautilusFilesView *directory_view, gboolean with_selection) { nautilus_files_view_new_folder_dialog_new (directory_view, with_selection); } static NewFolderData * setup_new_folder_data (NautilusFilesView *directory_view) { NewFolderData *data; data = new_folder_data_new (directory_view, FALSE); g_signal_connect_data (directory_view, "add-files", G_CALLBACK (track_newly_added_locations), data->added_locations, (GClosureNotify) NULL, G_CONNECT_AFTER); return data; } void nautilus_files_view_new_file_with_initial_contents (NautilusFilesView *view, const char *parent_uri, const char *filename, const char *initial_contents, int length) { NewFolderData *data; g_assert (parent_uri != NULL); data = setup_new_folder_data (view); nautilus_file_operations_new_file (GTK_WIDGET (view), parent_uri, filename, initial_contents, length, new_folder_done, data); } static void nautilus_files_view_new_file (NautilusFilesView *directory_view, const char *parent_uri, NautilusFile *source) { NewFolderData *data; char *source_uri; char *container_uri; container_uri = NULL; if (parent_uri == NULL) { container_uri = nautilus_files_view_get_backing_uri (directory_view); g_assert (container_uri != NULL); } if (source == NULL) { nautilus_files_view_new_file_with_initial_contents (directory_view, parent_uri != NULL ? parent_uri : container_uri, NULL, NULL, 0); g_free (container_uri); return; } data = setup_new_folder_data (directory_view); source_uri = nautilus_file_get_uri (source); nautilus_file_operations_new_file_from_template (GTK_WIDGET (directory_view), parent_uri != NULL ? parent_uri : container_uri, NULL, source_uri, new_folder_done, data); g_free (source_uri); g_free (container_uri); } static void action_empty_trash (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GtkRoot *window; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); window = gtk_widget_get_root (GTK_WIDGET (view)); nautilus_file_operations_empty_trash (GTK_WIDGET (window), TRUE, NULL); } static void action_new_folder (GSimpleAction *action, GVariant *state, gpointer user_data) { g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); nautilus_files_view_new_folder (NAUTILUS_FILES_VIEW (user_data), FALSE); } static void action_new_folder_with_selection (GSimpleAction *action, GVariant *state, gpointer user_data) { g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); nautilus_files_view_new_folder (NAUTILUS_FILES_VIEW (user_data), TRUE); } static void real_open_console (NautilusFile *file, NautilusFilesView *view) { GtkRoot *window = gtk_widget_get_root (GTK_WIDGET (view)); GVariant *parameters; g_autofree gchar *uri = NULL; uri = nautilus_file_get_uri (file); parameters = g_variant_new_parsed ("([%s], @a{sv} {})", uri); nautilus_dbus_launcher_call (nautilus_dbus_launcher_get (), NAUTILUS_DBUS_LAUNCHER_CONSOLE, "Open", parameters, GTK_WINDOW (window)); } static void action_open_console (GSimpleAction *action, GVariant *state, gpointer user_data) { g_autolist (NautilusFile) selection = NULL; selection = nautilus_view_get_selection (NAUTILUS_VIEW (user_data)); g_return_if_fail (selection != NULL && g_list_length (selection) == 1); real_open_console (NAUTILUS_FILE (selection->data), NAUTILUS_FILES_VIEW (user_data)); } static void action_current_dir_open_console (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); real_open_console (priv->directory_as_file, view); } static void action_properties (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; g_autolist (NautilusFile) selection = NULL; GList *files; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (g_list_length (selection) == 0) { if (priv->directory_as_file != NULL) { files = g_list_append (NULL, nautilus_file_ref (priv->directory_as_file)); nautilus_properties_window_present (files, GTK_WIDGET (view), NULL, NULL, NULL); nautilus_file_list_free (files); } } else { nautilus_properties_window_present (selection, GTK_WIDGET (view), NULL, NULL, NULL); } } static void action_current_dir_properties (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; GList *files; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); if (priv->directory_as_file != NULL) { files = g_list_append (NULL, nautilus_file_ref (priv->directory_as_file)); nautilus_properties_window_present (files, GTK_WIDGET (view), NULL, NULL, NULL); nautilus_file_list_free (files); } } static void nautilus_files_view_set_show_hidden_files (NautilusFilesView *view, gboolean show_hidden) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->ignore_hidden_file_preferences) { return; } if (show_hidden != priv->show_hidden_files) { priv->show_hidden_files = show_hidden; g_settings_set_boolean (gtk_filechooser_preferences, NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES, show_hidden); if (priv->model != NULL) { load_directory (view, priv->model); } } } static void action_show_hidden_files (GSimpleAction *action, GVariant *state, gpointer user_data) { gboolean show_hidden; NautilusFilesView *view; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); show_hidden = g_variant_get_boolean (state); nautilus_files_view_set_show_hidden_files (view, show_hidden); g_simple_action_set_state (action, state); } static void action_zoom_in (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); nautilus_files_view_bump_zoom_level (view, 1); } static void action_zoom_out (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); nautilus_files_view_bump_zoom_level (view, -1); } static void action_zoom_standard (GSimpleAction *action, GVariant *state, gpointer user_data) { nautilus_files_view_restore_standard_zoom_level (user_data); } static void action_open_item_new_window (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GList *selection; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); nautilus_files_view_activate_files (view, selection, NAUTILUS_OPEN_FLAG_NEW_WINDOW, TRUE); nautilus_file_list_free (selection); } static void handle_clipboard_data (NautilusFilesView *view, NautilusClipboard *clip, char *destination_uri, GdkDragAction action) { GList *item_uris = nautilus_clipboard_get_uri_list (clip); if (item_uris != NULL && destination_uri != NULL) { nautilus_files_view_move_copy_items (view, item_uris, destination_uri, action); /* If items are cut then remove from clipboard */ if (action == GDK_ACTION_MOVE) { gdk_clipboard_set_content (gtk_widget_get_clipboard (GTK_WIDGET (view)), NULL); } g_list_free_full (item_uris, g_free); } } static void paste_clipboard_data (NautilusFilesView *view, NautilusClipboard *clip, char *destination_uri) { GdkDragAction action; if (nautilus_clipboard_is_cut (clip)) { action = GDK_ACTION_MOVE; } else { action = GDK_ACTION_COPY; } handle_clipboard_data (view, clip, destination_uri, action); } static void paste_clipboard_received_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (source_object); NautilusClipboard *clip; g_autofree char *view_uri = NULL; clip = nautilus_files_view_get_clipboard_finish (view, res, NULL); if (clip != NULL) { view_uri = nautilus_files_view_get_backing_uri (view); paste_clipboard_data (view, clip, view_uri); } } static void paste_files (NautilusFilesView *view) { nautilus_files_view_get_clipboard_async (view, paste_clipboard_received_callback, NULL); } static void action_paste_files (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); paste_files (view); } static void action_paste_files_accel (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); if (nautilus_files_view_is_read_only (view)) { show_dialog (_("Could not paste files"), _("Permissions do not allow pasting files in this directory"), nautilus_files_view_get_containing_window (view), GTK_MESSAGE_ERROR); } else { paste_files (view); } } static void create_links_clipboard_received_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (source_object); NautilusClipboard *clip; g_autofree char *view_uri = NULL; clip = nautilus_files_view_get_clipboard_finish (view, res, NULL); if (clip != NULL) { view_uri = nautilus_files_view_get_backing_uri (view); handle_clipboard_data (view, clip, view_uri, GDK_ACTION_LINK); } } static void action_create_links (GSimpleAction *action, GVariant *state, gpointer user_data) { g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); nautilus_files_view_get_clipboard_async (NAUTILUS_FILES_VIEW (user_data), create_links_clipboard_received_callback, NULL); } static void click_policy_changed_callback (gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->click_policy_changed (view); } gboolean nautilus_files_view_should_sort_directories_first (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; gboolean is_search; priv = nautilus_files_view_get_instance_private (view); is_search = nautilus_view_is_searching (NAUTILUS_VIEW (view)); return priv->sort_directories_first && !is_search; } static void sort_directories_first_changed_callback (gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; gboolean preference_value; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); preference_value = g_settings_get_boolean (gtk_filechooser_preferences, NAUTILUS_PREFERENCES_SORT_DIRECTORIES_FIRST); if (preference_value != priv->sort_directories_first) { priv->sort_directories_first = preference_value; NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->sort_directories_first_changed (view); } } static void show_hidden_files_changed_callback (gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; gboolean preference_value; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); preference_value = g_settings_get_boolean (gtk_filechooser_preferences, NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES); nautilus_files_view_set_show_hidden_files (view, preference_value); if (priv->active) { schedule_update_context_menus (view); } } static gboolean set_up_scripts_directory_global (void) { g_autofree gchar *old_scripts_directory_path = NULL; g_autoptr (GFile) old_scripts_directory = NULL; g_autofree gchar *scripts_directory_path = NULL; g_autoptr (GFile) scripts_directory = NULL; const char *override; GFileType file_type; g_autoptr (GError) error = NULL; if (scripts_directory_uri != NULL) { return TRUE; } scripts_directory_path = nautilus_get_scripts_directory_path (); override = g_getenv ("GNOME22_USER_DIR"); if (override) { old_scripts_directory_path = g_build_filename (override, "nautilus-scripts", NULL); } else { old_scripts_directory_path = g_build_filename (g_get_home_dir (), ".gnome2", "nautilus-scripts", NULL); } old_scripts_directory = g_file_new_for_path (old_scripts_directory_path); scripts_directory = g_file_new_for_path (scripts_directory_path); file_type = g_file_query_file_type (old_scripts_directory, G_FILE_QUERY_INFO_NONE, NULL); if (file_type == G_FILE_TYPE_DIRECTORY && !g_file_query_exists (scripts_directory, NULL)) { g_autoptr (GFile) updated = NULL; const char *message; /* test if we already attempted to migrate first */ updated = g_file_get_child (old_scripts_directory, "DEPRECATED-DIRECTORY"); message = _("Nautilus 3.6 deprecated this directory and tried migrating " "this configuration to ~/.local/share/nautilus"); if (!g_file_query_exists (updated, NULL)) { g_autoptr (GFile) parent = NULL; parent = g_file_get_parent (scripts_directory); g_file_make_directory_with_parents (parent, NULL, &error); if (error == NULL || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) { g_clear_error (&error); g_file_set_attribute_uint32 (parent, G_FILE_ATTRIBUTE_UNIX_MODE, S_IRWXU, G_FILE_QUERY_INFO_NONE, NULL, NULL); g_file_move (old_scripts_directory, scripts_directory, G_FILE_COPY_NONE, NULL, NULL, NULL, &error); if (error == NULL) { g_file_replace_contents (updated, message, strlen (message), NULL, FALSE, G_FILE_CREATE_PRIVATE, NULL, NULL, NULL); } } g_clear_error (&error); } } g_file_make_directory_with_parents (scripts_directory, NULL, &error); if (error == NULL || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) { g_file_set_attribute_uint32 (scripts_directory, G_FILE_ATTRIBUTE_UNIX_MODE, S_IRWXU, G_FILE_QUERY_INFO_NONE, NULL, NULL); scripts_directory_uri = g_file_get_uri (scripts_directory); scripts_directory_uri_length = strlen (scripts_directory_uri); } return scripts_directory_uri != NULL; } static void scripts_added_or_changed_callback (NautilusDirectory *directory, GList *files, gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); priv->scripts_menu_updated = FALSE; if (priv->active) { schedule_update_context_menus (view); } } static void templates_added_or_changed_callback (NautilusDirectory *directory, GList *files, gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); priv->templates_menu_updated = FALSE; if (priv->active) { schedule_update_context_menus (view); } } static void add_directory_to_directory_list (NautilusFilesView *view, NautilusDirectory *directory, GList **directory_list, GCallback changed_callback) { NautilusFileAttributes attributes; if (g_list_find (*directory_list, directory) == NULL) { nautilus_directory_ref (directory); attributes = NAUTILUS_FILE_ATTRIBUTES_FOR_ICON | NAUTILUS_FILE_ATTRIBUTE_INFO | NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT; nautilus_directory_file_monitor_add (directory, directory_list, FALSE, attributes, (NautilusDirectoryCallback) changed_callback, view); g_signal_connect_object (directory, "files-added", G_CALLBACK (changed_callback), view, 0); g_signal_connect_object (directory, "files-changed", G_CALLBACK (changed_callback), view, 0); *directory_list = g_list_append (*directory_list, directory); } } static void remove_directory_from_directory_list (NautilusFilesView *view, NautilusDirectory *directory, GList **directory_list, GCallback changed_callback) { *directory_list = g_list_remove (*directory_list, directory); g_signal_handlers_disconnect_by_func (directory, G_CALLBACK (changed_callback), view); nautilus_directory_file_monitor_remove (directory, directory_list); nautilus_directory_unref (directory); } static void add_directory_to_scripts_directory_list (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); add_directory_to_directory_list (view, directory, &priv->scripts_directory_list, G_CALLBACK (scripts_added_or_changed_callback)); } static void remove_directory_from_scripts_directory_list (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); remove_directory_from_directory_list (view, directory, &priv->scripts_directory_list, G_CALLBACK (scripts_added_or_changed_callback)); } static void add_directory_to_templates_directory_list (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); add_directory_to_directory_list (view, directory, &priv->templates_directory_list, G_CALLBACK (templates_added_or_changed_callback)); } static void remove_directory_from_templates_directory_list (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); remove_directory_from_directory_list (view, directory, &priv->templates_directory_list, G_CALLBACK (templates_added_or_changed_callback)); } static void slot_active_changed (NautilusWindowSlot *slot, GParamSpec *pspec, NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->active == nautilus_window_slot_get_active (slot)) { return; } priv->active = nautilus_window_slot_get_active (slot); if (priv->active) { /* Avoid updating the toolbar withouth making sure the toolbar * zoom slider has the correct adjustment that changes when the * view mode changes */ nautilus_files_view_update_context_menus (view); nautilus_files_view_update_toolbar_menus (view); schedule_update_context_menus (view); gtk_widget_insert_action_group (GTK_WIDGET (nautilus_files_view_get_window (view)), "view", G_ACTION_GROUP (priv->view_action_group)); } else { remove_update_context_menus_timeout_callback (view); gtk_widget_insert_action_group (GTK_WIDGET (nautilus_files_view_get_window (view)), "view", NULL); } } static gboolean nautilus_files_view_focus (GtkWidget *widget, GtkDirectionType direction) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; GtkWidget *focus; GtkWidget *main_child; view = NAUTILUS_FILES_VIEW (widget); priv = nautilus_files_view_get_instance_private (view); focus = gtk_window_get_focus (GTK_WINDOW (gtk_widget_get_root (widget))); /* In general, we want to forward focus movement to the main child. However, * we must chain up for default focus handling in case the focus in in any * other child, e.g. a popover. */ if (gtk_widget_is_ancestor (focus, widget) && !gtk_widget_is_ancestor (focus, priv->scrolled_window)) { if (GTK_WIDGET_CLASS (nautilus_files_view_parent_class)->focus (widget, direction)) { return TRUE; } else { /* The default handler returns FALSE if a popover has just been * closed, because it moves the focus forward. But we want to move * focus back into the view's main child. So, fall through. */ } } main_child = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (priv->scrolled_window)); if (main_child != NULL) { return gtk_widget_child_focus (main_child, direction); } return FALSE; } static gboolean nautilus_files_view_grab_focus (GtkWidget *widget) { /* focus the child of the scrolled window if it exists */ NautilusFilesView *view; NautilusFilesViewPrivate *priv; GtkWidget *child; view = NAUTILUS_FILES_VIEW (widget); priv = nautilus_files_view_get_instance_private (view); child = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (priv->scrolled_window)); if (child != NULL) { return gtk_widget_grab_focus (GTK_WIDGET (child)); } return GTK_WIDGET_CLASS (nautilus_files_view_parent_class)->grab_focus (widget); } static void nautilus_files_view_set_selection (NautilusView *nautilus_files_view, GList *selection) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; GList *pending_selection; view = NAUTILUS_FILES_VIEW (nautilus_files_view); priv = nautilus_files_view_get_instance_private (view); if (!priv->loading) { /* If we aren't still loading, set the selection right now, * and reveal the new selection. */ nautilus_files_view_call_set_selection (view, selection); nautilus_files_view_reveal_selection (view); } else { /* If we are still loading, set the list of pending URIs instead. * done_loading() will eventually select the pending URIs and reveal them. */ pending_selection = g_list_copy_deep (selection, (GCopyFunc) g_object_ref, NULL); g_list_free_full (priv->pending_selection, g_object_unref); priv->pending_selection = pending_selection; } } static void nautilus_files_view_dispose (GObject *object) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; GdkClipboard *clipboard; GList *node, *next; view = NAUTILUS_FILES_VIEW (object); priv = nautilus_files_view_get_instance_private (view); priv->in_destruction = TRUE; nautilus_files_view_stop_loading (view); g_clear_pointer (&priv->selection_menu, gtk_widget_unparent); g_clear_pointer (&priv->background_menu, gtk_widget_unparent); if (priv->model) { nautilus_directory_unref (priv->model); priv->model = NULL; } for (node = priv->scripts_directory_list; node != NULL; node = next) { next = node->next; remove_directory_from_scripts_directory_list (view, node->data); } for (node = priv->templates_directory_list; node != NULL; node = next) { next = node->next; remove_directory_from_templates_directory_list (view, node->data); } while (priv->subdirectory_list != NULL) { nautilus_files_view_remove_subdirectory (view, priv->subdirectory_list->data); } remove_update_context_menus_timeout_callback (view); remove_update_status_idle_callback (view); if (priv->display_selection_idle_id != 0) { g_source_remove (priv->display_selection_idle_id); priv->display_selection_idle_id = 0; } if (priv->reveal_selection_idle_id != 0) { g_source_remove (priv->reveal_selection_idle_id); priv->reveal_selection_idle_id = 0; } if (priv->floating_bar_set_status_timeout_id != 0) { g_source_remove (priv->floating_bar_set_status_timeout_id); priv->floating_bar_set_status_timeout_id = 0; } if (priv->floating_bar_loading_timeout_id != 0) { g_source_remove (priv->floating_bar_loading_timeout_id); priv->floating_bar_loading_timeout_id = 0; } if (priv->floating_bar_set_passthrough_timeout_id != 0) { g_source_remove (priv->floating_bar_set_passthrough_timeout_id); priv->floating_bar_set_passthrough_timeout_id = 0; } g_signal_handlers_disconnect_by_func (nautilus_preferences, schedule_update_context_menus, view); g_signal_handlers_disconnect_by_func (nautilus_preferences, click_policy_changed_callback, view); g_signal_handlers_disconnect_by_func (gtk_filechooser_preferences, sort_directories_first_changed_callback, view); g_signal_handlers_disconnect_by_func (gtk_filechooser_preferences, show_hidden_files_changed_callback, view); g_signal_handlers_disconnect_by_func (nautilus_window_state, nautilus_files_view_display_selection_info, view); g_signal_handlers_disconnect_by_func (gnome_lockdown_preferences, schedule_update_context_menus, view); g_signal_handlers_disconnect_by_func (nautilus_trash_monitor_get (), nautilus_files_view_trash_state_changed_callback, view); clipboard = gdk_display_get_clipboard (gdk_display_get_default ()); g_signal_handlers_disconnect_by_func (clipboard, on_clipboard_owner_changed, view); g_cancellable_cancel (priv->clipboard_cancellable); nautilus_file_unref (priv->directory_as_file); priv->directory_as_file = NULL; g_clear_object (&priv->search_query); g_clear_object (&priv->location); G_OBJECT_CLASS (nautilus_files_view_parent_class)->dispose (object); } static void nautilus_files_view_finalize (GObject *object) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (object); priv = nautilus_files_view_get_instance_private (view); g_clear_object (&priv->view_action_group); g_clear_object (&priv->background_menu_model); g_clear_object (&priv->selection_menu_model); g_clear_object (&priv->toolbar_menu_sections->sort_section); g_clear_object (&priv->extensions_background_menu); g_clear_object (&priv->templates_menu); g_clear_object (&priv->rename_file_controller); g_clear_object (&priv->new_folder_controller); g_clear_object (&priv->compress_controller); /* We don't own the slot, so no unref */ priv->slot = NULL; g_free (priv->toolbar_menu_sections); g_hash_table_destroy (priv->non_ready_files); g_hash_table_destroy (priv->pending_reveal); g_clear_object (&priv->clipboard_cancellable); g_cancellable_cancel (priv->starred_cancellable); g_clear_object (&priv->starred_cancellable); G_OBJECT_CLASS (nautilus_files_view_parent_class)->finalize (object); } /** * nautilus_files_view_display_selection_info: * * Display information about the current selection, and notify the view frame of the changed selection. * @view: NautilusFilesView for which to display selection info. * **/ void nautilus_files_view_display_selection_info (NautilusFilesView *view) { g_autolist (NautilusFile) selection = NULL; goffset non_folder_size; gboolean non_folder_size_known; guint non_folder_count, folder_count, folder_item_count; gboolean folder_item_count_known; guint file_item_count; GList *p; char *first_item_name; char *non_folder_count_str; char *non_folder_item_count_str; char *non_folder_counts_str; char *folder_count_str; char *folder_item_count_str; char *folder_counts_str; char *primary_status; char *detail_status; NautilusFile *file; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); folder_item_count_known = TRUE; folder_count = 0; folder_item_count = 0; non_folder_count = 0; non_folder_size_known = FALSE; non_folder_size = 0; first_item_name = NULL; folder_count_str = NULL; folder_item_count_str = NULL; folder_counts_str = NULL; non_folder_count_str = NULL; non_folder_item_count_str = NULL; non_folder_counts_str = NULL; for (p = selection; p != NULL; p = p->next) { file = p->data; if (nautilus_file_is_directory (file)) { folder_count++; if (nautilus_file_get_directory_item_count (file, &file_item_count, NULL)) { folder_item_count += file_item_count; } else { folder_item_count_known = FALSE; } } else { non_folder_count++; if (!nautilus_file_can_get_size (file)) { non_folder_size_known = TRUE; non_folder_size += nautilus_file_get_size (file); } } if (first_item_name == NULL) { first_item_name = nautilus_file_get_display_name (file); } } /* Break out cases for localization's sake. But note that there are still pieces * being assembled in a particular order, which may be a problem for some localizers. */ if (folder_count != 0) { if (folder_count == 1 && non_folder_count == 0) { folder_count_str = g_strdup_printf (_("“%s” selected"), first_item_name); } else { folder_count_str = g_strdup_printf (ngettext ("%'d folder selected", "%'d folders selected", folder_count), folder_count); } if (folder_count == 1) { if (!folder_item_count_known) { folder_item_count_str = g_strdup (""); } else { folder_item_count_str = g_strdup_printf (ngettext ("(containing %'d item)", "(containing %'d items)", folder_item_count), folder_item_count); } } else { if (!folder_item_count_known) { folder_item_count_str = g_strdup (""); } else { /* translators: this is preceded with a string of form 'N folders' (N more than 1) */ folder_item_count_str = g_strdup_printf (ngettext ("(containing a total of %'d item)", "(containing a total of %'d items)", folder_item_count), folder_item_count); } } } if (non_folder_count != 0) { if (folder_count == 0) { if (non_folder_count == 1) { non_folder_count_str = g_strdup_printf (_("“%s” selected"), first_item_name); } else { non_folder_count_str = g_strdup_printf (ngettext ("%'d item selected", "%'d items selected", non_folder_count), non_folder_count); } } else { /* Folders selected also, use "other" terminology */ non_folder_count_str = g_strdup_printf (ngettext ("%'d other item selected", "%'d other items selected", non_folder_count), non_folder_count); } if (non_folder_size_known) { char *size_string; size_string = g_format_size (non_folder_size); /* This is marked for translation in case a localiser * needs to use something other than parentheses. The * the message in parentheses is the size of the selected items. */ non_folder_item_count_str = g_strdup_printf (_("(%s)"), size_string); g_free (size_string); } else { non_folder_item_count_str = g_strdup (""); } } if (folder_count == 0 && non_folder_count == 0) { primary_status = NULL; detail_status = NULL; } else if (folder_count == 0) { primary_status = g_strdup (non_folder_count_str); detail_status = g_strdup (non_folder_item_count_str); } else if (non_folder_count == 0) { primary_status = g_strdup (folder_count_str); detail_status = g_strdup (folder_item_count_str); } else { if (folder_item_count_known) { folder_counts_str = g_strconcat (folder_count_str, " ", folder_item_count_str, NULL); } else { folder_counts_str = g_strdup (folder_count_str); } if (non_folder_size_known) { non_folder_counts_str = g_strconcat (non_folder_count_str, " ", non_folder_item_count_str, NULL); } else { non_folder_counts_str = g_strdup (non_folder_count_str); } /* This is marked for translation in case a localizer * needs to change ", " to something else. The comma * is between the message about the number of folders * and the number of items in those folders and the * message about the number of other items and the * total size of those items. */ primary_status = g_strdup_printf (_("%s, %s"), folder_counts_str, non_folder_counts_str); detail_status = NULL; } g_free (first_item_name); g_free (folder_count_str); g_free (folder_item_count_str); g_free (folder_counts_str); g_free (non_folder_count_str); g_free (non_folder_item_count_str); g_free (non_folder_counts_str); set_floating_bar_status (view, primary_status, detail_status); g_free (primary_status); g_free (detail_status); } static void nautilus_files_view_send_selection_change (NautilusFilesView *view) { g_signal_emit (view, signals[SELECTION_CHANGED], 0); g_object_notify (G_OBJECT (view), "selection"); } static void nautilus_files_view_set_location (NautilusView *view, GFile *location) { NautilusDirectory *directory; NautilusFilesView *files_view; nautilus_profile_start (NULL); files_view = NAUTILUS_FILES_VIEW (view); directory = nautilus_directory_get (location); nautilus_files_view_stop_loading (files_view); /* In case we want to load a previous search we need to extract the real * location and the search location, and load the directory when everything * is ready. That's why we cannot use the nautilus_view_set_query, because * to set a query we need a previous location loaded, but to load a search * location we need to know the real location behind it. */ if (NAUTILUS_IS_SEARCH_DIRECTORY (directory)) { NautilusQuery *previous_query; NautilusDirectory *base_model; base_model = nautilus_search_directory_get_base_model (NAUTILUS_SEARCH_DIRECTORY (directory)); previous_query = nautilus_search_directory_get_query (NAUTILUS_SEARCH_DIRECTORY (directory)); set_search_query_internal (files_view, previous_query, base_model); g_object_unref (previous_query); } else { load_directory (NAUTILUS_FILES_VIEW (view), directory); } nautilus_directory_unref (directory); nautilus_profile_end (NULL); } static gboolean reveal_selection_idle_callback (gpointer data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (data); priv = nautilus_files_view_get_instance_private (view); priv->reveal_selection_idle_id = 0; nautilus_files_view_reveal_selection (view); return FALSE; } static void nautilus_files_view_check_empty_states (NautilusFilesView *view) { NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->check_empty_states (view); } static void real_check_empty_states (NautilusFilesView *view) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); g_autofree gchar *uri = NULL; AdwStatusPage *status_page = ADW_STATUS_PAGE (priv->empty_view_page); if (!priv->loading && nautilus_files_view_is_empty (view)) { uri = g_file_get_uri (priv->location); if (nautilus_view_is_searching (NAUTILUS_VIEW (view))) { adw_status_page_set_icon_name (status_page, "edit-find-symbolic"); adw_status_page_set_title (status_page, _("No Results Found")); adw_status_page_set_description (status_page, _("Try a different search.")); } else if (eel_uri_is_trash_root (uri)) { adw_status_page_set_icon_name (status_page, "user-trash-symbolic"); adw_status_page_set_title (status_page, _("Trash is Empty")); adw_status_page_set_description (status_page, NULL); } else if (eel_uri_is_starred (uri)) { adw_status_page_set_icon_name (status_page, "starred-symbolic"); adw_status_page_set_title (status_page, _("No Starred Files")); adw_status_page_set_description (status_page, NULL); } else if (eel_uri_is_recent (uri)) { adw_status_page_set_icon_name (status_page, "document-open-recent-symbolic"); adw_status_page_set_title (status_page, _("No Recent Files")); adw_status_page_set_description (status_page, NULL); } else { adw_status_page_set_icon_name (status_page, "folder-symbolic"); adw_status_page_set_title (status_page, _("Folder is Empty")); adw_status_page_set_description (status_page, NULL); } gtk_stack_set_visible_child (GTK_STACK (priv->stack), priv->empty_view_page); } else { gtk_stack_set_visible_child (GTK_STACK (priv->stack), priv->scrolled_window); } } static void done_loading (NautilusFilesView *view, gboolean all_files_seen) { NautilusFilesViewPrivate *priv; g_autolist (NautilusFile) selection = NULL; gboolean do_reveal = FALSE; priv = nautilus_files_view_get_instance_private (view); if (!priv->loading) { return; } nautilus_profile_start (NULL); if (!priv->in_destruction) { remove_loading_floating_bar (view); schedule_update_context_menus (view); schedule_update_status (view); nautilus_files_view_update_toolbar_menus (view); reset_update_interval (view); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (nautilus_view_is_searching (NAUTILUS_VIEW (view)) && all_files_seen && selection == NULL && priv->pending_selection == NULL) { nautilus_files_view_select_first (view); do_reveal = TRUE; } else if (priv->pending_selection != NULL && all_files_seen) { g_autolist (NautilusFile) pending_selection = NULL; pending_selection = g_steal_pointer (&priv->pending_selection); nautilus_files_view_call_set_selection (view, pending_selection); do_reveal = TRUE; } g_clear_pointer (&priv->pending_selection, nautilus_file_list_free); if (do_reveal) { if (NAUTILUS_IS_LIST_VIEW (view) || NAUTILUS_IS_GRID_VIEW (view)) { /* HACK: We should be able to directly call reveal_selection here, * but at this point the GtkTreeView hasn't allocated the new nodes * yet, and it has a bug in the scroll calculation dealing with this * special case. It would always make the selection the top row, even * if no scrolling would be neccessary to reveal it. So we let it * allocate before revealing. */ if (priv->reveal_selection_idle_id != 0) { g_source_remove (priv->reveal_selection_idle_id); } priv->reveal_selection_idle_id = g_idle_add (reveal_selection_idle_callback, view); } else { nautilus_files_view_reveal_selection (view); } } nautilus_files_view_display_selection_info (view); } priv->loading = FALSE; g_signal_emit (view, signals[END_LOADING], 0, all_files_seen); g_object_notify (G_OBJECT (view), "loading"); if (!priv->in_destruction) { nautilus_files_view_check_empty_states (view); } nautilus_profile_end (NULL); } typedef struct { GHashTable *debuting_files; GList *added_files; } DebutingFilesData; static void debuting_files_data_free (DebutingFilesData *data) { g_hash_table_unref (data->debuting_files); nautilus_file_list_free (data->added_files); g_free (data); } /* This signal handler watch for the arrival of the icons created * as the result of a file operation. Once the last one is detected * it selects and reveals them all. */ static void debuting_files_add_files_callback (NautilusFilesView *view, GList *new_files, DebutingFilesData *data) { GFile *location; GList *l; nautilus_profile_start (NULL); for (l = new_files; l != NULL; l = l->next) { location = nautilus_file_get_location (NAUTILUS_FILE (l->data)); if (g_hash_table_remove (data->debuting_files, location)) { nautilus_file_ref (NAUTILUS_FILE (l->data)); data->added_files = g_list_prepend (data->added_files, NAUTILUS_FILE (l->data)); } g_object_unref (location); } if (g_hash_table_size (data->debuting_files) == 0) { nautilus_files_view_call_set_selection (view, data->added_files); nautilus_files_view_reveal_selection (view); g_signal_handlers_disconnect_by_func (view, G_CALLBACK (debuting_files_add_files_callback), data); } nautilus_profile_end (NULL); } typedef struct { GList *added_files; NautilusFilesView *directory_view; } CopyMoveDoneData; static void copy_move_done_data_free (CopyMoveDoneData *data) { g_assert (data != NULL); if (data->directory_view != NULL) { g_object_remove_weak_pointer (G_OBJECT (data->directory_view), (gpointer *) &data->directory_view); } nautilus_file_list_free (data->added_files); g_free (data); } static void pre_copy_move_add_files_callback (NautilusFilesView *view, GList *new_files, CopyMoveDoneData *data) { GList *l; for (l = new_files; l != NULL; l = l->next) { nautilus_file_ref (NAUTILUS_FILE (l->data)); data->added_files = g_list_prepend (data->added_files, l->data); } } /* This needs to be called prior to nautilus_file_operations_copy_move. * It hooks up a signal handler to catch any icons that get added before * the copy_done_callback is invoked. The return value should be passed * as the data for uri_copy_move_done_callback. */ static CopyMoveDoneData * pre_copy_move (NautilusFilesView *directory_view) { CopyMoveDoneData *copy_move_done_data; copy_move_done_data = g_new0 (CopyMoveDoneData, 1); copy_move_done_data->directory_view = directory_view; g_object_add_weak_pointer (G_OBJECT (copy_move_done_data->directory_view), (gpointer *) ©_move_done_data->directory_view); /* We need to run after the default handler adds the folder we want to * operate on. The ADD_FILES signal is registered as G_SIGNAL_RUN_LAST, so we * must use connect_after. */ g_signal_connect_after (directory_view, "add-files", G_CALLBACK (pre_copy_move_add_files_callback), copy_move_done_data); return copy_move_done_data; } /* This function is used to pull out any debuting uris that were added * and (as a side effect) remove them from the debuting uri hash table. */ static gboolean copy_move_done_partition_func (NautilusFile *file, gpointer callback_data) { GFile *location; gboolean result; location = nautilus_file_get_location (file); result = g_hash_table_remove ((GHashTable *) callback_data, location); g_object_unref (location); return result; } static gboolean remove_not_really_moved_files (gpointer key, gpointer value, gpointer callback_data) { GList **added_files; GFile *loc; loc = key; if (GPOINTER_TO_INT (value)) { return FALSE; } added_files = callback_data; *added_files = g_list_prepend (*added_files, nautilus_file_get (loc)); return TRUE; } /* When this function is invoked, the file operation is over, but all * the icons may not have been added to the directory view yet, so * we can't select them yet. * * We're passed a hash table of the uri's to look out for, we hook * up a signal handler to await their arrival. */ static void copy_move_done_callback (GHashTable *debuting_files, gboolean success, gpointer data) { NautilusFilesView *directory_view; CopyMoveDoneData *copy_move_done_data; DebutingFilesData *debuting_files_data; GList *failed_files; copy_move_done_data = (CopyMoveDoneData *) data; directory_view = copy_move_done_data->directory_view; if (directory_view != NULL) { g_assert (NAUTILUS_IS_FILES_VIEW (directory_view)); debuting_files_data = g_new (DebutingFilesData, 1); debuting_files_data->debuting_files = g_hash_table_ref (debuting_files); debuting_files_data->added_files = nautilus_file_list_filter (copy_move_done_data->added_files, &failed_files, copy_move_done_partition_func, debuting_files); nautilus_file_list_free (copy_move_done_data->added_files); copy_move_done_data->added_files = failed_files; /* We're passed the same data used by pre_copy_move_add_files_callback, so disconnecting * it will free data. We've already siphoned off the added_files we need, and stashed the * directory_view pointer. */ g_signal_handlers_disconnect_by_func (directory_view, G_CALLBACK (pre_copy_move_add_files_callback), data); /* Any items in the debuting_files hash table that have * "FALSE" as their value aren't really being copied * or moved, so we can't wait for an add_files signal * to come in for those. */ g_hash_table_foreach_remove (debuting_files, remove_not_really_moved_files, &debuting_files_data->added_files); if (g_hash_table_size (debuting_files) == 0) { /* on the off-chance that all the icons have already been added */ if (debuting_files_data->added_files != NULL) { nautilus_files_view_call_set_selection (directory_view, debuting_files_data->added_files); nautilus_files_view_reveal_selection (directory_view); } debuting_files_data_free (debuting_files_data); } else { /* We need to run after the default handler adds the folder we want to * operate on. The ADD_FILES signal is registered as G_SIGNAL_RUN_LAST, so we * must use connect_after. */ g_signal_connect_data (directory_view, "add-files", G_CALLBACK (debuting_files_add_files_callback), debuting_files_data, (GClosureNotify) debuting_files_data_free, G_CONNECT_AFTER); } /* Schedule menu update for undo items */ schedule_update_context_menus (directory_view); } copy_move_done_data_free (copy_move_done_data); } static gboolean view_file_still_belongs (NautilusFilesView *view, FileAndDirectory *fad) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->model != fad->directory && g_list_find (priv->subdirectory_list, fad->directory) == NULL) { return FALSE; } return nautilus_directory_contains_file (fad->directory, fad->file); } static gboolean still_should_show_file (NautilusFilesView *view, FileAndDirectory *fad) { return nautilus_files_view_should_show_file (view, fad->file) && view_file_still_belongs (view, fad); } static gboolean ready_to_load (NautilusFile *file) { return nautilus_file_check_if_ready (file, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); } /* Go through all the new added and changed files. * Put any that are not ready to load in the non_ready_files hash table. * Add all the rest to the old_added_files and old_changed_files lists. * Sort the old_*_files lists if anything was added to them. */ static void process_new_files (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_autolist (FileAndDirectory) new_added_files = NULL; g_autolist (FileAndDirectory) new_changed_files = NULL; GList *old_added_files; GList *old_changed_files; GHashTable *non_ready_files; GList *node, *next; FileAndDirectory *pending; gboolean in_non_ready; priv = nautilus_files_view_get_instance_private (view); new_added_files = g_steal_pointer (&priv->new_added_files); new_changed_files = g_steal_pointer (&priv->new_changed_files); non_ready_files = priv->non_ready_files; old_added_files = priv->old_added_files; old_changed_files = priv->old_changed_files; /* Newly added files go into the old_added_files list if they're * ready, and into the hash table if they're not. */ for (node = new_added_files; node != NULL; node = next) { next = node->next; pending = (FileAndDirectory *) node->data; in_non_ready = g_hash_table_contains (non_ready_files, pending); if (nautilus_files_view_should_show_file (view, pending->file)) { if (ready_to_load (pending->file)) { if (in_non_ready) { g_hash_table_remove (non_ready_files, pending); } new_added_files = g_list_delete_link (new_added_files, node); old_added_files = g_list_prepend (old_added_files, pending); } else { if (!in_non_ready) { new_added_files = g_list_delete_link (new_added_files, node); g_hash_table_add (non_ready_files, pending); } } } } /* Newly changed files go into the old_added_files list if they're ready * and were seen non-ready in the past, into the old_changed_files list * if they are read and were not seen non-ready in the past, and into * the hash table if they're not ready. */ for (node = new_changed_files; node != NULL; node = next) { next = node->next; pending = (FileAndDirectory *) node->data; if (!still_should_show_file (view, pending) || ready_to_load (pending->file)) { if (g_hash_table_contains (non_ready_files, pending)) { g_hash_table_remove (non_ready_files, pending); if (still_should_show_file (view, pending)) { new_changed_files = g_list_delete_link (new_changed_files, node); old_added_files = g_list_prepend (old_added_files, pending); } } else { new_changed_files = g_list_delete_link (new_changed_files, node); old_changed_files = g_list_prepend (old_changed_files, pending); } } } if (old_added_files != priv->old_added_files) { priv->old_added_files = old_added_files; } if (old_changed_files != priv->old_changed_files) { priv->old_changed_files = old_changed_files; } } static void on_end_file_changes (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* Addition and removal of files modify the empty state */ nautilus_files_view_check_empty_states (view); /* If the view is empty, zoom slider and sort menu are insensitive */ nautilus_files_view_update_toolbar_menus (view); /* Reveal files that were pending to be revealed, only if all of them * were acknowledged by the view */ if (g_hash_table_size (priv->pending_reveal) > 0) { GList *keys; GList *l; gboolean all_files_acknowledged = TRUE; keys = g_hash_table_get_keys (priv->pending_reveal); for (l = keys; l && all_files_acknowledged; l = l->next) { all_files_acknowledged = GPOINTER_TO_UINT (g_hash_table_lookup (priv->pending_reveal, l->data)); } if (all_files_acknowledged) { nautilus_files_view_set_selection (NAUTILUS_VIEW (view), keys); nautilus_files_view_reveal_selection (view); g_hash_table_remove_all (priv->pending_reveal); } g_list_free (keys); } } static int compare_pointers (gconstpointer pointer_1, gconstpointer pointer_2) { if (pointer_1 < pointer_2) { return -1; } else if (pointer_1 > pointer_2) { return +1; } return 0; } static gboolean _g_lists_sort_and_check_for_intersection (GList **list_1, GList **list_2) { GList *node_1; GList *node_2; int compare_result; *list_1 = g_list_sort (*list_1, compare_pointers); *list_2 = g_list_sort (*list_2, compare_pointers); node_1 = *list_1; node_2 = *list_2; while (node_1 != NULL && node_2 != NULL) { compare_result = compare_pointers (node_1->data, node_2->data); if (compare_result == 0) { return TRUE; } if (compare_result <= 0) { node_1 = node_1->next; } if (compare_result >= 0) { node_2 = node_2->next; } } return FALSE; } static void process_old_files (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_autolist (FileAndDirectory) files_added = NULL; g_autolist (FileAndDirectory) files_changed = NULL; FileAndDirectory *pending; GList *files; g_autoptr (GList) pending_additions = NULL; priv = nautilus_files_view_get_instance_private (view); files_added = g_steal_pointer (&priv->old_added_files); files_changed = g_steal_pointer (&priv->old_changed_files); if (files_added != NULL || files_changed != NULL) { gboolean send_selection_change = FALSE; g_signal_emit (view, signals[BEGIN_FILE_CHANGES], 0); for (GList *node = files_added; node != NULL; node = node->next) { pending = node->data; pending_additions = g_list_prepend (pending_additions, pending->file); /* Acknowledge the files that were pending to be revealed */ if (g_hash_table_contains (priv->pending_reveal, pending->file)) { g_hash_table_insert (priv->pending_reveal, pending->file, GUINT_TO_POINTER (TRUE)); } } pending_additions = g_list_reverse (pending_additions); if (files_added != NULL) { g_signal_emit (view, signals[ADD_FILES], 0, pending_additions); } for (GList *node = files_changed; node != NULL; node = node->next) { gboolean should_show_file; pending = node->data; should_show_file = still_should_show_file (view, pending); g_signal_emit (view, signals[should_show_file ? FILE_CHANGED : REMOVE_FILE], 0, pending->file, pending->directory); /* Acknowledge the files that were pending to be revealed */ if (g_hash_table_contains (priv->pending_reveal, pending->file)) { if (should_show_file) { g_hash_table_insert (priv->pending_reveal, pending->file, GUINT_TO_POINTER (TRUE)); } else { g_hash_table_remove (priv->pending_reveal, pending->file); } } } if (files_changed != NULL) { g_autolist (NautilusFile) selection = NULL; selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); files = g_list_copy_deep (files_changed, (GCopyFunc) file_and_directory_get_file, NULL); send_selection_change = _g_lists_sort_and_check_for_intersection (&files, &selection); nautilus_file_list_free (files); } if (send_selection_change) { /* Send a selection change since some file names could * have changed. */ nautilus_files_view_send_selection_change (view); } g_signal_emit (view, signals[END_FILE_CHANGES], 0); } } static void display_pending_files (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_autolist (NautilusFile) selection = NULL; process_new_files (view); process_old_files (view); priv = nautilus_files_view_get_instance_private (view); selection = nautilus_files_view_get_selection (NAUTILUS_VIEW (view)); if (selection == NULL && !priv->pending_selection && nautilus_view_is_searching (NAUTILUS_VIEW (view))) { nautilus_files_view_select_first (view); } if (priv->model != NULL && nautilus_directory_are_all_files_seen (priv->model) && g_hash_table_size (priv->non_ready_files) == 0) { done_loading (view, TRUE); } } static gboolean display_selection_info_idle_callback (gpointer data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (data); priv = nautilus_files_view_get_instance_private (view); g_object_ref (G_OBJECT (view)); priv->display_selection_idle_id = 0; nautilus_files_view_display_selection_info (view); nautilus_files_view_send_selection_change (view); g_object_unref (G_OBJECT (view)); return FALSE; } static void remove_update_context_menus_timeout_callback (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->update_context_menus_timeout_id != 0) { g_source_remove (priv->update_context_menus_timeout_id); priv->update_context_menus_timeout_id = 0; } } static void update_context_menus_if_pending (NautilusFilesView *view) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); if (priv->update_context_menus_timeout_id != 0) { remove_update_context_menus_timeout_callback (view); nautilus_files_view_update_context_menus (view); } } static gboolean update_context_menus_timeout_callback (gpointer data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (data); priv = nautilus_files_view_get_instance_private (view); g_object_ref (G_OBJECT (view)); priv->update_context_menus_timeout_id = 0; nautilus_files_view_update_context_menus (view); g_object_unref (G_OBJECT (view)); return FALSE; } static gboolean display_pending_callback (gpointer data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (data); priv = nautilus_files_view_get_instance_private (view); g_object_ref (G_OBJECT (view)); priv->display_pending_source_id = 0; display_pending_files (view); g_object_unref (G_OBJECT (view)); return FALSE; } static void schedule_idle_display_of_pending_files (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* Get rid of a pending source as it might be a timeout */ unschedule_display_of_pending_files (view); /* We want higher priority than the idle that handles the relayout * to avoid a resort on each add. But we still want to allow repaints * and other hight prio events while we have pending files to show. */ priv->display_pending_source_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE - 20, display_pending_callback, view, NULL); } static void schedule_timeout_display_of_pending_files (NautilusFilesView *view, guint interval) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* No need to schedule an update if there's already one pending. */ if (priv->display_pending_source_id != 0) { return; } priv->display_pending_source_id = g_timeout_add (interval, display_pending_callback, view); } static void unschedule_display_of_pending_files (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* Get rid of source if it's active. */ if (priv->display_pending_source_id != 0) { g_source_remove (priv->display_pending_source_id); priv->display_pending_source_id = 0; } } static void queue_pending_files (NautilusFilesView *view, NautilusDirectory *directory, GList *files, GList **pending_list) { NautilusFilesViewPrivate *priv; GList *fad_list; priv = nautilus_files_view_get_instance_private (view); if (files == NULL) { return; } fad_list = g_list_copy_deep (files, (GCopyFunc) file_and_directory_new, directory); *pending_list = g_list_concat (fad_list, *pending_list); /* Generally we don't want to show the files while the directory is loading * the files themselves, so we avoid jumping and oddities. However, for * search it can be a long wait, and we actually want to show files as * they are getting found. So for search is fine if not all files are * seen */ if (!priv->loading || (nautilus_directory_are_all_files_seen (directory) || nautilus_view_is_searching (NAUTILUS_VIEW (view)))) { schedule_timeout_display_of_pending_files (view, priv->update_interval); } } static void remove_changes_timeout_callback (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->changes_timeout_id != 0) { g_source_remove (priv->changes_timeout_id); priv->changes_timeout_id = 0; } } static void reset_update_interval (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); priv->update_interval = UPDATE_INTERVAL_MIN; remove_changes_timeout_callback (view); /* Reschedule a pending timeout to idle */ if (priv->display_pending_source_id != 0) { schedule_idle_display_of_pending_files (view); } } static gboolean changes_timeout_callback (gpointer data) { gint64 now; gint64 time_delta; gboolean ret; NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (data); priv = nautilus_files_view_get_instance_private (view); g_object_ref (G_OBJECT (view)); now = g_get_monotonic_time (); time_delta = now - priv->last_queued; if (time_delta < UPDATE_INTERVAL_RESET * 1000) { if (priv->update_interval < UPDATE_INTERVAL_MAX && priv->loading) { /* Increase */ priv->update_interval += UPDATE_INTERVAL_INC; } ret = TRUE; } else { /* Reset */ reset_update_interval (view); ret = FALSE; } g_object_unref (G_OBJECT (view)); return ret; } static void schedule_changes (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); /* Remember when the change was queued */ priv->last_queued = g_get_monotonic_time (); /* No need to schedule if there are already changes pending or during loading */ if (priv->changes_timeout_id != 0 || priv->loading) { return; } priv->changes_timeout_id = g_timeout_add (UPDATE_INTERVAL_TIMEOUT_INTERVAL, changes_timeout_callback, view); } static void files_added_callback (NautilusDirectory *directory, GList *files, gpointer callback_data) { NautilusFilesViewPrivate *priv; NautilusFilesView *view; GtkWindow *window; char *uri; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); nautilus_profile_start (NULL); window = nautilus_files_view_get_containing_window (view); uri = nautilus_files_view_get_uri (view); DEBUG_FILES (files, "Files added in window %p: %s", window, uri ? uri : "(no directory)"); g_free (uri); schedule_changes (view); queue_pending_files (view, directory, files, &priv->new_added_files); /* The number of items could have changed */ schedule_update_status (view); nautilus_profile_end (NULL); } static void files_changed_callback (NautilusDirectory *directory, GList *files, gpointer callback_data) { NautilusFilesViewPrivate *priv; NautilusFilesView *view; GtkWindow *window; char *uri; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); window = nautilus_files_view_get_containing_window (view); uri = nautilus_files_view_get_uri (view); DEBUG_FILES (files, "Files changed in window %p: %s", window, uri ? uri : "(no directory)"); g_free (uri); schedule_changes (view); queue_pending_files (view, directory, files, &priv->new_changed_files); /* The free space or the number of items could have changed */ schedule_update_status (view); /* A change in MIME type could affect the Open with menu, for * one thing, so we need to update menus when files change. */ schedule_update_context_menus (view); } static void done_loading_callback (NautilusDirectory *directory, gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (callback_data); priv = nautilus_files_view_get_instance_private (view); nautilus_profile_start (NULL); process_new_files (view); if (g_hash_table_size (priv->non_ready_files) == 0) { /* Unschedule a pending update and schedule a new one with the minimal * update interval. This gives the view a short chance at gathering the * (cached) deep counts. */ unschedule_display_of_pending_files (view); schedule_timeout_display_of_pending_files (view, UPDATE_INTERVAL_MIN); remove_loading_floating_bar (view); } nautilus_profile_end (NULL); } static void load_error_callback (NautilusDirectory *directory, GError *error, gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); /* FIXME: By doing a stop, we discard some pending files. Is * that OK? */ nautilus_files_view_stop_loading (view); nautilus_report_error_loading_directory (nautilus_files_view_get_directory_as_file (view), error, nautilus_files_view_get_containing_window (view)); } void nautilus_files_view_add_subdirectory (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFileAttributes attributes; NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); g_return_if_fail (!g_list_find (priv->subdirectory_list, directory)); nautilus_directory_ref (directory); attributes = NAUTILUS_FILE_ATTRIBUTES_FOR_ICON | NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT | NAUTILUS_FILE_ATTRIBUTE_INFO | NAUTILUS_FILE_ATTRIBUTE_MOUNT | NAUTILUS_FILE_ATTRIBUTE_EXTENSION_INFO; nautilus_directory_file_monitor_add (directory, &priv->model, priv->show_hidden_files, attributes, files_added_callback, view); g_signal_connect (directory, "files-added", G_CALLBACK (files_added_callback), view); g_signal_connect (directory, "files-changed", G_CALLBACK (files_changed_callback), view); priv->subdirectory_list = g_list_prepend ( priv->subdirectory_list, directory); } void nautilus_files_view_remove_subdirectory (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); g_return_if_fail (g_list_find (priv->subdirectory_list, directory)); priv->subdirectory_list = g_list_remove ( priv->subdirectory_list, directory); g_signal_handlers_disconnect_by_func (directory, G_CALLBACK (files_added_callback), view); g_signal_handlers_disconnect_by_func (directory, G_CALLBACK (files_changed_callback), view); nautilus_directory_file_monitor_remove (directory, &priv->model); nautilus_directory_unref (directory); } /** * nautilus_files_view_get_loading: * @view: an #NautilusFilesView. * * Return value: #gboolean inicating whether @view is currently loaded. * **/ gboolean nautilus_files_view_get_loading (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), FALSE); priv = nautilus_files_view_get_instance_private (view); return priv->loading; } /** * nautilus_files_view_get_model: * * Get the model for this NautilusFilesView. * @view: NautilusFilesView of interest. * * Return value: NautilusDirectory for this view. * **/ NautilusDirectory * nautilus_files_view_get_model (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (view); return priv->model; } GtkWidget * nautilus_files_view_get_content_widget (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (view); return priv->scrolled_window; } /* home_dir_in_selection() * * Return TRUE if the home directory is in the selection. */ static gboolean home_dir_in_selection (GList *selection) { for (GList *node = selection; node != NULL; node = node->next) { if (nautilus_file_is_home (NAUTILUS_FILE (node->data))) { return TRUE; } } return FALSE; } static void trash_or_delete_done_cb (GHashTable *debuting_uris, gboolean user_cancel, NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (user_cancel) { priv->selection_was_removed = FALSE; } } static void trash_or_delete_files (GtkWindow *parent_window, const GList *files, NautilusFilesView *view) { GList *locations; const GList *node; locations = NULL; for (node = files; node != NULL; node = node->next) { locations = g_list_prepend (locations, nautilus_file_get_location ((NautilusFile *) node->data)); } locations = g_list_reverse (locations); nautilus_file_operations_trash_or_delete_async (locations, parent_window, NULL, (NautilusDeleteCallback) trash_or_delete_done_cb, view); g_list_free_full (locations, g_object_unref); } NautilusFile * nautilus_files_view_get_directory_as_file (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); return priv->directory_as_file; } static GdkTexture * get_menu_icon_for_file (NautilusFile *file, GtkWidget *widget) { int scale = gtk_widget_get_scale_factor (widget); return nautilus_file_get_icon_texture (file, 16, scale, 0); } static GList * get_extension_selection_menu_items (NautilusFilesView *view) { GList *items; GList *providers; GList *l; g_autolist (NautilusFile) selection = NULL; selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); providers = nautilus_module_get_extensions_for_type (NAUTILUS_TYPE_MENU_PROVIDER); items = NULL; for (l = providers; l != NULL; l = l->next) { NautilusMenuProvider *provider; GList *file_items; provider = NAUTILUS_MENU_PROVIDER (l->data); file_items = nautilus_menu_provider_get_file_items (provider, selection); items = g_list_concat (items, file_items); } nautilus_module_extension_list_free (providers); return items; } static GList * get_extension_background_menu_items (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; GList *items; GList *providers; GList *l; priv = nautilus_files_view_get_instance_private (view); providers = nautilus_module_get_extensions_for_type (NAUTILUS_TYPE_MENU_PROVIDER); items = NULL; for (l = providers; l != NULL; l = l->next) { NautilusMenuProvider *provider; NautilusFileInfo *file_info; GList *file_items; provider = NAUTILUS_MENU_PROVIDER (l->data); file_info = NAUTILUS_FILE_INFO (priv->directory_as_file); file_items = nautilus_menu_provider_get_background_items (provider, file_info); items = g_list_concat (items, file_items); } nautilus_module_extension_list_free (providers); return items; } static void extension_action_callback (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusMenuItem *item = user_data; nautilus_menu_item_activate (item); } static void add_extension_action (NautilusFilesView *view, NautilusMenuItem *item, const char *action_name) { NautilusFilesViewPrivate *priv; gboolean sensitive; GSimpleAction *action; priv = nautilus_files_view_get_instance_private (view); g_object_get (item, "sensitive", &sensitive, NULL); action = g_simple_action_new (action_name, NULL); g_signal_connect_data (action, "activate", G_CALLBACK (extension_action_callback), g_object_ref (item), (GClosureNotify) g_object_unref, 0); g_action_map_add_action (G_ACTION_MAP (priv->view_action_group), G_ACTION (action)); g_simple_action_set_enabled (action, sensitive); g_object_unref (action); } static GMenuModel * build_menu_for_extension_menu_items (NautilusFilesView *view, const gchar *extension_prefix, GList *menu_items) { GList *l; GMenu *gmenu; gint idx = 0; gmenu = g_menu_new (); for (l = menu_items; l; l = l->next) { NautilusMenuItem *item; NautilusMenu *menu; GMenuItem *menu_item; char *name, *label; g_autofree gchar *escaped_name = NULL; char *extension_id, *detailed_action_name; item = NAUTILUS_MENU_ITEM (l->data); g_object_get (item, "label", &label, "menu", &menu, "name", &name, NULL); escaped_name = g_uri_escape_string (name, NULL, TRUE); extension_id = g_strdup_printf ("extension_%s_%d_%s", extension_prefix, idx, escaped_name); add_extension_action (view, item, extension_id); detailed_action_name = g_strconcat ("view.", extension_id, NULL); menu_item = g_menu_item_new (label, detailed_action_name); if (menu != NULL) { GList *children; g_autoptr (GMenuModel) children_menu = NULL; children = nautilus_menu_get_items (menu); children_menu = build_menu_for_extension_menu_items (view, extension_id, children); g_menu_item_set_submenu (menu_item, children_menu); nautilus_menu_item_list_free (children); } g_menu_append_item (gmenu, menu_item); idx++; g_free (extension_id); g_free (detailed_action_name); g_free (name); g_free (label); g_object_unref (menu_item); } return G_MENU_MODEL (gmenu); } static void update_extensions_menus (NautilusFilesView *view, GtkBuilder *builder) { GList *selection_items, *background_items; GObject *object; g_autoptr (GMenuModel) background_menu = NULL; g_autoptr (GMenuModel) selection_menu = NULL; selection_items = get_extension_selection_menu_items (view); if (selection_items != NULL) { selection_menu = build_menu_for_extension_menu_items (view, "extensions", selection_items); object = gtk_builder_get_object (builder, "selection-extensions-section"); nautilus_gmenu_set_from_model (G_MENU (object), selection_menu); nautilus_menu_item_list_free (selection_items); } background_items = get_extension_background_menu_items (view); if (background_items != NULL) { background_menu = build_menu_for_extension_menu_items (view, "extensions", background_items); object = gtk_builder_get_object (builder, "background-extensions-section"); nautilus_gmenu_set_from_model (G_MENU (object), background_menu); nautilus_menu_item_list_free (background_items); } nautilus_view_set_extensions_background_menu (NAUTILUS_VIEW (view), background_menu); } static char * change_to_view_directory (NautilusFilesView *view) { char *path; char *old_path; old_path = g_get_current_dir (); path = get_view_directory (view); /* FIXME: What to do about non-local directories? */ if (path != NULL) { g_chdir (path); } g_free (path); return old_path; } static char ** get_file_names_as_parameter_array (GList *selection, NautilusDirectory *model) { char **parameters; g_autoptr (GFile) model_location = NULL; int i; if (model == NULL) { return NULL; } parameters = g_new (char *, g_list_length (selection) + 1); model_location = nautilus_directory_get_location (model); i = 0; for (GList *node = selection; node != NULL; node = node->next, i++) { g_autoptr (GFile) file_location = NULL; NautilusFile *file = NAUTILUS_FILE (node->data); if (!nautilus_file_has_local_path (file)) { parameters[i] = NULL; g_strfreev (parameters); return NULL; } file_location = nautilus_file_get_location (file); parameters[i] = g_file_get_relative_path (model_location, file_location); if (parameters[i] == NULL) { parameters[i] = g_file_get_path (file_location); } } parameters[i] = NULL; return parameters; } static char * get_file_paths_or_uris_as_newline_delimited_string (GList *selection, gboolean get_paths) { GString *expanding_string; expanding_string = g_string_new (""); for (GList *node = selection; node != NULL; node = node->next) { NautilusFile *file = NAUTILUS_FILE (node->data); g_autofree gchar *uri = NULL; uri = nautilus_file_get_uri (file); if (uri == NULL) { continue; } if (get_paths) { g_autofree gchar *path = NULL; if (!nautilus_file_has_local_path (file)) { g_string_free (expanding_string, TRUE); return g_strdup (""); } path = g_filename_from_uri (uri, NULL, NULL); if (path != NULL) { g_string_append (expanding_string, path); g_string_append (expanding_string, "\n"); } } else { g_string_append (expanding_string, uri); g_string_append (expanding_string, "\n"); } } return g_string_free (expanding_string, FALSE); } static char * get_file_paths_as_newline_delimited_string (GList *selection) { return get_file_paths_or_uris_as_newline_delimited_string (selection, TRUE); } static char * get_file_uris_as_newline_delimited_string (GList *selection) { return get_file_paths_or_uris_as_newline_delimited_string (selection, FALSE); } /* * Set up some environment variables that scripts can use * to take advantage of the current Nautilus state. */ static void set_script_environment_variables (NautilusFilesView *view, GList *selected_files) { g_autofree gchar *file_paths = NULL; g_autofree gchar *uris = NULL; g_autofree gchar *uri = NULL; NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); file_paths = get_file_paths_as_newline_delimited_string (selected_files); g_setenv ("NAUTILUS_SCRIPT_SELECTED_FILE_PATHS", file_paths, TRUE); uris = get_file_uris_as_newline_delimited_string (selected_files); g_setenv ("NAUTILUS_SCRIPT_SELECTED_URIS", uris, TRUE); uri = nautilus_directory_get_uri (priv->model); g_setenv ("NAUTILUS_SCRIPT_CURRENT_URI", uri, TRUE); } /* Unset all the special script environment variables. */ static void unset_script_environment_variables (void) { g_unsetenv ("NAUTILUS_SCRIPT_SELECTED_FILE_PATHS"); g_unsetenv ("NAUTILUS_SCRIPT_SELECTED_URIS"); g_unsetenv ("NAUTILUS_SCRIPT_CURRENT_URI"); } static void run_script (GSimpleAction *action, GVariant *state, gpointer user_data) { ScriptLaunchParameters *launch_parameters; NautilusFilesViewPrivate *priv; g_autofree gchar *file_uri = NULL; g_autofree gchar *local_file_path = NULL; g_autofree gchar *quoted_path = NULL; g_autofree gchar *old_working_dir = NULL; g_autolist (NautilusFile) selection = NULL; g_auto (GStrv) parameters = NULL; GdkDisplay *display; launch_parameters = (ScriptLaunchParameters *) user_data; priv = nautilus_files_view_get_instance_private (launch_parameters->directory_view); file_uri = nautilus_file_get_uri (launch_parameters->file); local_file_path = g_filename_from_uri (file_uri, NULL, NULL); g_assert (local_file_path != NULL); quoted_path = g_shell_quote (local_file_path); old_working_dir = change_to_view_directory (launch_parameters->directory_view); selection = nautilus_view_get_selection (NAUTILUS_VIEW (launch_parameters->directory_view)); set_script_environment_variables (launch_parameters->directory_view, selection); parameters = get_file_names_as_parameter_array (selection, priv->model); display = gtk_widget_get_display (GTK_WIDGET (launch_parameters->directory_view)); DEBUG ("run_script, script_path=“%s” (omitting script parameters)", local_file_path); nautilus_launch_application_from_command_array (display, quoted_path, FALSE, (const char * const *) parameters); unset_script_environment_variables (); g_chdir (old_working_dir); } static void add_script_to_scripts_menus (NautilusFilesView *view, NautilusFile *file, GMenu *menu) { NautilusFilesViewPrivate *priv; gchar *name; g_autofree gchar *uri = NULL; g_autofree gchar *escaped_uri = NULL; GdkTexture *mimetype_icon; gchar *action_name, *detailed_action_name; ScriptLaunchParameters *launch_parameters; GAction *action; GMenuItem *menu_item; const gchar *shortcut; priv = nautilus_files_view_get_instance_private (view); launch_parameters = script_launch_parameters_new (file, view); name = nautilus_file_get_display_name (file); uri = nautilus_file_get_uri (file); escaped_uri = g_uri_escape_string (uri, NULL, TRUE); action_name = g_strconcat ("script_", escaped_uri, NULL); action = G_ACTION (g_simple_action_new (action_name, NULL)); g_signal_connect_data (action, "activate", G_CALLBACK (run_script), launch_parameters, (GClosureNotify) script_launch_parameters_free, 0); g_action_map_add_action (G_ACTION_MAP (priv->view_action_group), action); g_object_unref (action); detailed_action_name = g_strconcat ("view.", action_name, NULL); menu_item = g_menu_item_new (name, detailed_action_name); mimetype_icon = get_menu_icon_for_file (file, GTK_WIDGET (view)); if (mimetype_icon != NULL) { g_menu_item_set_icon (menu_item, G_ICON (mimetype_icon)); g_object_unref (mimetype_icon); } g_menu_append_item (menu, menu_item); if ((shortcut = g_hash_table_lookup (script_accels, name))) { nautilus_application_set_accelerator (g_application_get_default (), detailed_action_name, shortcut); } g_free (name); g_free (action_name); g_free (detailed_action_name); g_object_unref (menu_item); } static gboolean directory_belongs_in_scripts_menu (const char *uri) { int num_levels; int i; if (!g_str_has_prefix (uri, scripts_directory_uri)) { return FALSE; } num_levels = 0; for (i = scripts_directory_uri_length; uri[i] != '\0'; i++) { if (uri[i] == '/') { num_levels++; } } if (num_levels > MAX_MENU_LEVELS) { return FALSE; } return TRUE; } /* Expected format: accel script_name */ static void nautilus_load_custom_accel_for_scripts (void) { gchar *path, *contents; gchar **lines, **result; GError *error = NULL; const int max_len = 100; int i; path = g_build_filename (g_get_user_config_dir (), SHORTCUTS_PATH, NULL); if (g_file_get_contents (path, &contents, NULL, &error)) { lines = g_strsplit (contents, "\n", -1); for (i = 0; lines[i] && (strstr (lines[i], " ") > 0); i++) { result = g_strsplit (lines[i], " ", 2); g_hash_table_insert (script_accels, g_strndup (result[1], max_len), g_strndup (result[0], max_len)); g_strfreev (result); } g_free (contents); g_strfreev (lines); } else { DEBUG ("Unable to open '%s', error message: %s", path, error->message); g_clear_error (&error); } g_free (path); } static GMenu * update_directory_in_scripts_menu (NautilusFilesView *view, NautilusDirectory *directory) { GList *file_list, *filtered, *node; GMenu *menu, *children_menu; GMenuItem *menu_item; gboolean any_scripts; NautilusFile *file; NautilusDirectory *dir; char *uri; gchar *file_name; int num; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), NULL); if (script_accels == NULL) { script_accels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); nautilus_load_custom_accel_for_scripts (); } file_list = nautilus_directory_get_file_list (directory); filtered = nautilus_file_list_filter_hidden (file_list, FALSE); nautilus_file_list_free (file_list); menu = g_menu_new (); filtered = nautilus_file_list_sort_by_display_name (filtered); num = 0; any_scripts = FALSE; for (node = filtered; num < TEMPLATE_LIMIT && node != NULL; node = node->next, num++) { file = node->data; if (nautilus_file_is_directory (file)) { uri = nautilus_file_get_uri (file); if (directory_belongs_in_scripts_menu (uri)) { dir = nautilus_directory_get_by_uri (uri); add_directory_to_scripts_directory_list (view, dir); children_menu = update_directory_in_scripts_menu (view, dir); if (children_menu != NULL) { file_name = nautilus_file_get_display_name (file); menu_item = g_menu_item_new_submenu (file_name, G_MENU_MODEL (children_menu)); g_menu_append_item (menu, menu_item); any_scripts = TRUE; g_object_unref (menu_item); g_object_unref (children_menu); g_free (file_name); } nautilus_directory_unref (dir); } g_free (uri); } else if (nautilus_file_is_launchable (file)) { add_script_to_scripts_menus (view, file, menu); any_scripts = TRUE; } } nautilus_file_list_free (filtered); if (!any_scripts) { g_object_unref (menu); menu = NULL; } return menu; } static void update_scripts_menu (NautilusFilesView *view, GtkBuilder *builder) { NautilusFilesViewPrivate *priv; g_autolist (NautilusDirectory) sorted_copy = NULL; g_autoptr (NautilusDirectory) directory = NULL; g_autoptr (GMenu) submenu = NULL; priv = nautilus_files_view_get_instance_private (view); sorted_copy = nautilus_directory_list_sort_by_uri (nautilus_directory_list_copy (priv->scripts_directory_list)); for (GList *dir_l = sorted_copy; dir_l != NULL; dir_l = dir_l->next) { g_autofree char *uri = nautilus_directory_get_uri (dir_l->data); if (!directory_belongs_in_scripts_menu (uri)) { remove_directory_from_scripts_directory_list (view, dir_l->data); } } directory = nautilus_directory_get_by_uri (scripts_directory_uri); submenu = update_directory_in_scripts_menu (view, directory); g_set_object (&priv->scripts_menu, G_MENU_MODEL (submenu)); } static void create_template (GSimpleAction *action, GVariant *state, gpointer user_data) { CreateTemplateParameters *parameters; parameters = user_data; nautilus_files_view_new_file (parameters->directory_view, NULL, parameters->file); } static void add_template_to_templates_menus (NautilusFilesView *view, NautilusFile *file, GMenu *menu) { NautilusFilesViewPrivate *priv; char *uri, *name; g_autofree gchar *escaped_uri = NULL; GdkTexture *mimetype_icon; char *action_name, *detailed_action_name; CreateTemplateParameters *parameters; GAction *action; g_autofree char *label = NULL; GMenuItem *menu_item; priv = nautilus_files_view_get_instance_private (view); name = nautilus_file_get_display_name (file); uri = nautilus_file_get_uri (file); escaped_uri = g_uri_escape_string (uri, NULL, TRUE); action_name = g_strconcat ("template_", escaped_uri, NULL); action = G_ACTION (g_simple_action_new (action_name, NULL)); parameters = create_template_parameters_new (file, view); g_signal_connect_data (action, "activate", G_CALLBACK (create_template), parameters, (GClosureNotify) create_templates_parameters_free, 0); g_action_map_add_action (G_ACTION_MAP (priv->view_action_group), action); detailed_action_name = g_strconcat ("view.", action_name, NULL); label = eel_str_double_underscores (name); menu_item = g_menu_item_new (label, detailed_action_name); mimetype_icon = get_menu_icon_for_file (file, GTK_WIDGET (view)); if (mimetype_icon != NULL) { g_menu_item_set_icon (menu_item, G_ICON (mimetype_icon)); g_object_unref (mimetype_icon); } g_menu_append_item (menu, menu_item); g_free (name); g_free (uri); g_free (action_name); g_free (detailed_action_name); g_object_unref (action); g_object_unref (menu_item); } static void update_templates_directory (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; NautilusDirectory *templates_directory; GList *node, *next; char *templates_uri; priv = nautilus_files_view_get_instance_private (view); for (node = priv->templates_directory_list; node != NULL; node = next) { next = node->next; remove_directory_from_templates_directory_list (view, node->data); } if (nautilus_should_use_templates_directory ()) { templates_uri = nautilus_get_templates_directory_uri (); templates_directory = nautilus_directory_get_by_uri (templates_uri); g_free (templates_uri); add_directory_to_templates_directory_list (view, templates_directory); nautilus_directory_unref (templates_directory); } } static gboolean directory_belongs_in_templates_menu (const char *templates_directory_uri, const char *uri) { int num_levels; int i; if (templates_directory_uri == NULL) { return FALSE; } if (!g_str_has_prefix (uri, templates_directory_uri)) { return FALSE; } num_levels = 0; for (i = strlen (templates_directory_uri); uri[i] != '\0'; i++) { if (uri[i] == '/') { num_levels++; } } if (num_levels > MAX_MENU_LEVELS) { return FALSE; } return TRUE; } static gboolean filter_templates_callback (NautilusFile *file, gpointer callback_data) { gboolean show_hidden = GPOINTER_TO_INT (callback_data); if (nautilus_file_is_hidden_file (file)) { if (!show_hidden) { return FALSE; } if (nautilus_file_is_directory (file)) { return FALSE; } } return TRUE; } static GList * filter_templates (GList *files, gboolean show_hidden) { GList *filtered_files; GList *removed_files; filtered_files = nautilus_file_list_filter (files, &removed_files, filter_templates_callback, GINT_TO_POINTER (show_hidden)); nautilus_file_list_free (removed_files); return filtered_files; } static GMenuModel * update_directory_in_templates_menu (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFilesViewPrivate *priv; GList *file_list, *filtered, *node; GMenu *menu; GMenuItem *menu_item; gboolean any_templates; NautilusFile *file; NautilusDirectory *dir; char *uri; char *templates_directory_uri; int num; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), NULL); priv = nautilus_files_view_get_instance_private (view); file_list = nautilus_directory_get_file_list (directory); /* * The nautilus_file_list_filter_hidden() function isn't used here, because * we want to show hidden files, but not directories. This is a compromise * to allow creating hidden files but to prevent content from .git directory * for example. See https://gitlab.gnome.org/GNOME/nautilus/issues/1413. */ filtered = filter_templates (file_list, priv->show_hidden_files); nautilus_file_list_free (file_list); templates_directory_uri = nautilus_get_templates_directory_uri (); menu = g_menu_new (); filtered = nautilus_file_list_sort_by_display_name (filtered); num = 0; any_templates = FALSE; for (node = filtered; num < TEMPLATE_LIMIT && node != NULL; node = node->next, num++) { file = node->data; if (nautilus_file_is_directory (file)) { uri = nautilus_file_get_uri (file); if (directory_belongs_in_templates_menu (templates_directory_uri, uri)) { g_autoptr (GMenuModel) children_menu = NULL; dir = nautilus_directory_get_by_uri (uri); add_directory_to_templates_directory_list (view, dir); children_menu = update_directory_in_templates_menu (view, dir); if (children_menu != NULL) { g_autofree char *display_name = NULL; g_autofree char *label = NULL; display_name = nautilus_file_get_display_name (file); label = eel_str_double_underscores (display_name); menu_item = g_menu_item_new_submenu (label, children_menu); g_menu_append_item (menu, menu_item); any_templates = TRUE; g_object_unref (menu_item); } nautilus_directory_unref (dir); } g_free (uri); } else if (nautilus_file_can_read (file)) { add_template_to_templates_menus (view, file, menu); any_templates = TRUE; } } nautilus_file_list_free (filtered); g_free (templates_directory_uri); if (!any_templates) { g_object_unref (menu); menu = NULL; } return G_MENU_MODEL (menu); } static void update_templates_menu (NautilusFilesView *view, GtkBuilder *builder) { NautilusFilesViewPrivate *priv; g_autolist (NautilusDirectory) sorted_copy = NULL; g_autoptr (NautilusDirectory) directory = NULL; g_autoptr (GMenuModel) submenu = NULL; g_autofree char *templates_directory_uri = NULL; priv = nautilus_files_view_get_instance_private (view); if (!nautilus_should_use_templates_directory ()) { nautilus_view_set_templates_menu (NAUTILUS_VIEW (view), NULL); return; } templates_directory_uri = nautilus_get_templates_directory_uri (); sorted_copy = nautilus_directory_list_sort_by_uri (nautilus_directory_list_copy (priv->templates_directory_list)); for (GList *dir_l = sorted_copy; dir_l != NULL; dir_l = dir_l->next) { g_autofree char *uri = nautilus_directory_get_uri (dir_l->data); if (!directory_belongs_in_templates_menu (templates_directory_uri, uri)) { remove_directory_from_templates_directory_list (view, dir_l->data); } } directory = nautilus_directory_get_by_uri (templates_directory_uri); submenu = update_directory_in_templates_menu (view, directory); nautilus_view_set_templates_menu (NAUTILUS_VIEW (view), submenu); } static void action_open_scripts_folder (GSimpleAction *action, GVariant *state, gpointer user_data) { static GFile *location = NULL; if (location == NULL) { location = g_file_new_for_uri (scripts_directory_uri); } nautilus_application_open_location_full (NAUTILUS_APPLICATION (g_application_get_default ()), location, 0, NULL, NULL, NULL); } typedef struct _CopyCallbackData { NautilusFilesView *view; GList *selection; gboolean is_move; } CopyCallbackData; static void copy_data_free (CopyCallbackData *data) { nautilus_file_list_free (data->selection); g_free (data); } static void on_destination_dialog_response (GtkDialog *dialog, gint response_id, gpointer user_data) { CopyCallbackData *copy_data = user_data; if (response_id == GTK_RESPONSE_OK) { g_autoptr (GFile) target_location = NULL; char *target_uri; GList *uris, *l; target_location = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog)); target_uri = g_file_get_uri (target_location); uris = NULL; for (l = copy_data->selection; l != NULL; l = l->next) { uris = g_list_prepend (uris, nautilus_file_get_uri ((NautilusFile *) l->data)); } uris = g_list_reverse (uris); nautilus_files_view_move_copy_items (copy_data->view, uris, target_uri, copy_data->is_move ? GDK_ACTION_MOVE : GDK_ACTION_COPY); g_list_free_full (uris, g_free); g_free (target_uri); } copy_data_free (copy_data); gtk_window_destroy (GTK_WINDOW (dialog)); } static void copy_or_move_selection (NautilusFilesView *view, gboolean is_move) { NautilusFilesViewPrivate *priv; GtkWidget *dialog; g_autoptr (GFile) location = NULL; CopyCallbackData *copy_data; GList *selection; const gchar *title; NautilusDirectory *directory; priv = nautilus_files_view_get_instance_private (view); if (is_move) { title = _("Select Move Destination"); } else { title = _("Select Copy Destination"); } selection = nautilus_files_view_get_selection_for_file_transfer (view); dialog = gtk_file_chooser_dialog_new (title, GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Select"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); copy_data = g_new0 (CopyCallbackData, 1); copy_data->view = view; copy_data->selection = selection; copy_data->is_move = is_move; if (nautilus_view_is_searching (NAUTILUS_VIEW (view))) { directory = nautilus_search_directory_get_base_model (NAUTILUS_SEARCH_DIRECTORY (priv->model)); location = nautilus_directory_get_location (directory); } else if (showing_starred_directory (view)) { location = nautilus_file_get_parent_location (NAUTILUS_FILE (selection->data)); } else { location = nautilus_directory_get_location (priv->model); } gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), location, NULL); g_signal_connect (dialog, "response", G_CALLBACK (on_destination_dialog_response), copy_data); gtk_widget_show (dialog); } static void action_copy (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GdkClipboard *clipboard; GList *selection; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_files_view_get_selection_for_file_transfer (view); clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view)); nautilus_clipboard_prepare_for_files (clipboard, selection, FALSE); nautilus_file_list_free (selection); } static void action_cut (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GList *selection; GdkClipboard *clipboard; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_files_view_get_selection_for_file_transfer (view); clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view)); nautilus_clipboard_prepare_for_files (clipboard, selection, TRUE); nautilus_file_list_free (selection); } static void action_copy_current_location (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GdkClipboard *clipboard; GList *files; NautilusFilesViewPrivate *priv; view = NAUTILUS_FILES_VIEW (user_data); priv = nautilus_files_view_get_instance_private (view); if (priv->directory_as_file != NULL) { files = g_list_append (NULL, nautilus_file_ref (priv->directory_as_file)); clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view)); nautilus_clipboard_prepare_for_files (clipboard, files, FALSE); nautilus_file_list_free (files); } } static void action_create_links_in_place (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; GList *selection; GList *item_uris; GList *l; char *destination_uri; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_files_view_get_selection_for_file_transfer (view); item_uris = NULL; for (l = selection; l != NULL; l = l->next) { item_uris = g_list_prepend (item_uris, nautilus_file_get_uri (l->data)); } item_uris = g_list_reverse (item_uris); destination_uri = nautilus_files_view_get_backing_uri (view); nautilus_files_view_move_copy_items (view, item_uris, destination_uri, GDK_ACTION_LINK); g_list_free_full (item_uris, g_free); nautilus_file_list_free (selection); } static void action_copy_to (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); copy_or_move_selection (view, FALSE); } static void action_move_to (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); copy_or_move_selection (view, TRUE); } static void paste_into_clipboard_received_callback (GObject *source_object, GAsyncResult *res, gpointer user_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (source_object); NautilusClipboard *clip; g_autofree char *directory_uri = user_data; clip = nautilus_files_view_get_clipboard_finish (view, res, NULL); if (clip != NULL) { paste_clipboard_data (view, clip, directory_uri); } } static void paste_into (NautilusFilesView *view, NautilusFile *target) { g_assert (NAUTILUS_IS_FILES_VIEW (view)); g_assert (NAUTILUS_IS_FILE (target)); nautilus_files_view_get_clipboard_async (view, paste_into_clipboard_received_callback, nautilus_file_get_activation_uri (target)); } static void action_paste_files_into (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (selection != NULL) { paste_into (view, NAUTILUS_FILE (selection->data)); } } static void real_action_rename (NautilusFilesView *view) { NautilusFile *file; g_autolist (NautilusFile) selection = NULL; GtkWidget *dialog; g_assert (NAUTILUS_IS_FILES_VIEW (view)); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (selection != NULL) { /* If there is more than one file selected, invoke a batch renamer */ if (selection->next != NULL) { NautilusWindow *window; window = nautilus_files_view_get_window (view); gtk_widget_set_cursor_from_name (GTK_WIDGET (window), "progress"); dialog = nautilus_batch_rename_dialog_new (selection, nautilus_files_view_get_model (view), window); gtk_widget_show (GTK_WIDGET (dialog)); } else { file = NAUTILUS_FILE (selection->data); nautilus_files_view_rename_file_popover_new (view, file); } } } static void action_rename (GSimpleAction *action, GVariant *state, gpointer user_data) { real_action_rename (NAUTILUS_FILES_VIEW (user_data)); } typedef struct { NautilusFilesView *view; GHashTable *added_locations; } ExtractData; static void extract_done (GList *outputs, gpointer user_data) { NautilusFilesViewPrivate *priv; ExtractData *data; GList *l; gboolean all_files_acknowledged; data = user_data; if (data->view == NULL) { goto out; } priv = nautilus_files_view_get_instance_private (data->view); g_signal_handlers_disconnect_by_func (data->view, G_CALLBACK (track_newly_added_locations), data->added_locations); if (outputs == NULL) { goto out; } all_files_acknowledged = TRUE; for (l = outputs; l && all_files_acknowledged; l = l->next) { all_files_acknowledged = g_hash_table_contains (data->added_locations, l->data); } if (all_files_acknowledged) { GList *selection = NULL; for (l = outputs; l != NULL; l = l->next) { selection = g_list_prepend (selection, nautilus_file_get (l->data)); } nautilus_files_view_set_selection (NAUTILUS_VIEW (data->view), selection); nautilus_files_view_reveal_selection (data->view); nautilus_file_list_free (selection); } else { for (l = outputs; l != NULL; l = l->next) { gboolean acknowledged; acknowledged = g_hash_table_contains (data->added_locations, l->data); g_hash_table_insert (priv->pending_reveal, nautilus_file_get (l->data), GUINT_TO_POINTER (acknowledged)); } } out: g_hash_table_destroy (data->added_locations); if (data->view != NULL) { g_object_remove_weak_pointer (G_OBJECT (data->view), (gpointer *) &data->view); } g_free (data); } static void extract_files (NautilusFilesView *view, GList *files, GFile *destination_directory) { GList *locations = NULL; GList *l; gboolean extracting_to_current_directory; if (files == NULL) { return; } for (l = files; l != NULL; l = l->next) { locations = g_list_prepend (locations, nautilus_file_get_location (l->data)); } locations = g_list_reverse (locations); extracting_to_current_directory = g_file_equal (destination_directory, nautilus_view_get_location (NAUTILUS_VIEW (view))); if (extracting_to_current_directory) { ExtractData *data; data = g_new (ExtractData, 1); data->view = view; data->added_locations = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal, g_object_unref, NULL); g_object_add_weak_pointer (G_OBJECT (data->view), (gpointer *) &data->view); g_signal_connect_data (view, "add-files", G_CALLBACK (track_newly_added_locations), data->added_locations, NULL, G_CONNECT_AFTER); nautilus_file_operations_extract_files (locations, destination_directory, nautilus_files_view_get_containing_window (view), NULL, extract_done, data); } else { nautilus_file_operations_extract_files (locations, destination_directory, nautilus_files_view_get_containing_window (view), NULL, NULL, NULL); } g_list_free_full (locations, g_object_unref); } typedef struct { NautilusFilesView *view; GList *files; } ExtractToData; static void on_extract_destination_dialog_response (GtkDialog *dialog, gint response_id, gpointer user_data) { ExtractToData *data; data = user_data; if (response_id == GTK_RESPONSE_OK) { g_autoptr (GFile) destination_directory = NULL; destination_directory = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog)); extract_files (data->view, data->files, destination_directory); } gtk_window_destroy (GTK_WINDOW (dialog)); nautilus_file_list_free (data->files); g_free (data); } static void extract_files_to_chosen_location (NautilusFilesView *view, GList *files) { NautilusFilesViewPrivate *priv; ExtractToData *data; GtkWidget *dialog; g_autoptr (GFile) location = NULL; priv = nautilus_files_view_get_instance_private (view); if (files == NULL) { return; } data = g_new (ExtractToData, 1); dialog = gtk_file_chooser_dialog_new (_("Select Extract Destination"), GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Select"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); /* The file chooser will not be able to display the search directory, * so we need to get the base directory of the search if we are, in fact, * in search. */ if (nautilus_view_is_searching (NAUTILUS_VIEW (view))) { NautilusSearchDirectory *search_directory; NautilusDirectory *directory; search_directory = NAUTILUS_SEARCH_DIRECTORY (priv->model); directory = nautilus_search_directory_get_base_model (search_directory); location = nautilus_directory_get_location (directory); } else { location = nautilus_directory_get_location (priv->model); } gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), location, NULL); data->view = view; data->files = nautilus_file_list_copy (files); g_signal_connect (dialog, "response", G_CALLBACK (on_extract_destination_dialog_response), data); gtk_widget_show (dialog); } static void action_extract_here (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; g_autoptr (GFile) location = NULL; g_autoptr (GFile) parent = NULL; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); location = nautilus_file_get_location (NAUTILUS_FILE (g_list_first (selection)->data)); /* Get a parent from a random file. We assume all files has a common parent. * But don't assume the parent is the view location, since that's not the * case in list view when expand-folder setting is set */ parent = g_file_get_parent (location); extract_files (view, selection, parent); } static void action_extract_to (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); extract_files_to_chosen_location (view, selection); } static void action_compress (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view = user_data; nautilus_files_view_compress_dialog_new (view); } static void send_email_done (GObject *source_object, GAsyncResult *res, gpointer user_data) { GtkWindow *window = user_data; g_autoptr (GError) error = NULL; xdp_portal_compose_email_finish (XDP_PORTAL (source_object), res, &error); if (error != NULL) { show_dialog (_("Error sending email."), error->message, window, GTK_MESSAGE_ERROR); } } static void real_send_email (GStrv attachments, NautilusFilesView *view) { /* Although the documentation says that addresses can be NULL, it takes * no action when addresses is NULL. Since we don't know the address, * provide an empty list */ const char * const addresses[] = {NULL}; g_autoptr (XdpPortal) portal = NULL; XdpParent *parent; GtkWidget *toplevel; portal = xdp_portal_new (); toplevel = gtk_widget_get_ancestor (GTK_WIDGET (view), GTK_TYPE_WINDOW); parent = xdp_parent_new_gtk (GTK_WINDOW (toplevel)); xdp_portal_compose_email (portal, parent, addresses, NULL, NULL, NULL, NULL, (const char * const *) attachments, XDP_EMAIL_FLAG_NONE, NULL, send_email_done, toplevel); } static void email_archive_ready (GFile *new_file, gboolean success, gpointer user_data) { g_autoptr (GStrvBuilder) strv_builder = NULL; g_auto (GStrv) attachments = NULL; NautilusFilesView *view = user_data; if (success) { strv_builder = g_strv_builder_new (); g_strv_builder_add (strv_builder, g_file_get_path (new_file)); attachments = g_strv_builder_end (strv_builder); real_send_email (attachments, view); } } static void action_send_email (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view = user_data; g_autolist (NautilusFile) selection = NULL; g_auto (GStrv) attachments = NULL; g_autoptr (GStrvBuilder) strv_builder = NULL; gboolean has_directory = FALSE; strv_builder = g_strv_builder_new (); selection = nautilus_files_view_get_selection (NAUTILUS_VIEW (view)); for (GList *l = selection; l != NULL; l = l->next) { if (nautilus_file_has_local_path (l->data)) { g_autoptr (GFile) location = nautilus_file_get_location (l->data); g_strv_builder_add (strv_builder, g_file_get_path (location)); } /* If there's a directory in the list, we can't attach a folder, * so to keep things simple let's archive the whole selection */ if (nautilus_file_is_directory (l->data)) { has_directory = TRUE; break; } } if (has_directory) { g_autolist (GFile) source_locations = NULL; g_autofree gchar *archive_directory_name = NULL; g_autoptr (GFile) archive_directory = NULL; g_autoptr (GFile) archive_location = NULL; for (GList *l = selection; l != NULL; l = l->next) { source_locations = g_list_prepend (source_locations, nautilus_file_get_location (l->data)); } source_locations = g_list_reverse (source_locations); archive_directory_name = g_dir_make_tmp ("nautilus-sendto-XXXXXX", NULL); archive_directory = g_file_new_for_path (archive_directory_name); archive_location = g_file_get_child (archive_directory, "archive.zip"); nautilus_file_operations_compress (source_locations, archive_location, AUTOAR_FORMAT_ZIP, AUTOAR_FILTER_NONE, NULL, nautilus_files_view_get_containing_window (view), NULL, email_archive_ready, view); } else { attachments = g_strv_builder_end (strv_builder); real_send_email (attachments, view); } } static gboolean can_run_in_terminal (GList *selection) { NautilusFile *file; if (g_list_length (selection) != 1) { return FALSE; } file = NAUTILUS_FILE (selection->data); if (nautilus_file_is_launchable (file) && nautilus_file_contains_text (file)) { g_autofree gchar *activation_uri = NULL; g_autofree gchar *executable_path = NULL; activation_uri = nautilus_file_get_activation_uri (file); executable_path = g_filename_from_uri (activation_uri, NULL, NULL); if (executable_path != NULL) { return TRUE; } } return FALSE; } static void action_run_in_terminal (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFilesView *view; g_autolist (NautilusFile) selection = NULL; g_autofree char *old_working_dir = NULL; g_autofree char *uri = NULL; g_autofree char *executable_path = NULL; g_autofree char *quoted_path = NULL; GtkWindow *parent_window; GdkDisplay *display; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); if (!can_run_in_terminal (selection)) { return; } old_working_dir = change_to_view_directory (view); uri = nautilus_file_get_activation_uri (NAUTILUS_FILE (selection->data)); executable_path = g_filename_from_uri (uri, NULL, NULL); quoted_path = g_shell_quote (executable_path); parent_window = nautilus_files_view_get_containing_window (view); display = gtk_widget_get_display (GTK_WIDGET (parent_window)); DEBUG ("Launching in terminal %s", quoted_path); nautilus_launch_application_from_command (display, quoted_path, TRUE, NULL); g_chdir (old_working_dir); } static gboolean can_set_wallpaper (GList *selection) { NautilusFile *file; if (g_list_length (selection) != 1) { return FALSE; } file = NAUTILUS_FILE (selection->data); if (!nautilus_file_is_mime_type (file, "image/*")) { return FALSE; } /* FIXME: check file size? */ return TRUE; } static void set_wallpaper_with_portal_cb (GObject *source, GAsyncResult *result, gpointer user_data) { XdpPortal *portal = XDP_PORTAL (source); g_autoptr (GError) error = NULL; if (!xdp_portal_set_wallpaper_finish (portal, result, &error) && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { g_warning ("Failed to set wallpaper via portal: %s", error->message); } } static void set_wallpaper_with_portal (NautilusFile *file, gpointer user_data) { g_autoptr (XdpPortal) portal = NULL; g_autofree gchar *uri = NULL; XdpParent *parent = NULL; GtkWidget *toplevel; portal = xdp_portal_new (); toplevel = gtk_widget_get_ancestor (GTK_WIDGET (user_data), GTK_TYPE_WINDOW); parent = xdp_parent_new_gtk (GTK_WINDOW (toplevel)); uri = nautilus_file_get_uri (file); xdp_portal_set_wallpaper (portal, parent, uri, XDP_WALLPAPER_FLAG_BACKGROUND | XDP_WALLPAPER_FLAG_PREVIEW, NULL, set_wallpaper_with_portal_cb, NULL); xdp_parent_free (parent); } static void action_set_as_wallpaper (GSimpleAction *action, GVariant *state, gpointer user_data) { g_autolist (NautilusFile) selection = NULL; g_assert (NAUTILUS_IS_FILES_VIEW (user_data)); selection = nautilus_view_get_selection (user_data); if (can_set_wallpaper (selection)) { NautilusFile *file; file = NAUTILUS_FILE (selection->data); set_wallpaper_with_portal (file, user_data); } } static void file_mount_callback (NautilusFile *file, GFile *result_location, GError *error, gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); if (error != NULL && (error->domain != G_IO_ERROR || (error->code != G_IO_ERROR_CANCELLED && error->code != G_IO_ERROR_FAILED_HANDLED && error->code != G_IO_ERROR_ALREADY_MOUNTED))) { char *text; char *name; name = nautilus_file_get_display_name (file); /* Translators: %s is a file name formatted for display */ text = g_strdup_printf (_("Unable to access “%s”"), name); show_dialog (text, error->message, GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_MESSAGE_ERROR); g_free (text); g_free (name); } } static void file_unmount_callback (NautilusFile *file, GFile *result_location, GError *error, gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); g_object_unref (view); if (error != NULL && (error->domain != G_IO_ERROR || (error->code != G_IO_ERROR_CANCELLED && error->code != G_IO_ERROR_FAILED_HANDLED))) { char *text; char *name; name = nautilus_file_get_display_name (file); /* Translators: %s is a file name formatted for display */ text = g_strdup_printf (_("Unable to remove “%s”"), name); show_dialog (text, error->message, GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_MESSAGE_ERROR); g_free (text); g_free (name); } } static void file_eject_callback (NautilusFile *file, GFile *result_location, GError *error, gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); g_object_unref (view); if (error != NULL && (error->domain != G_IO_ERROR || (error->code != G_IO_ERROR_CANCELLED && error->code != G_IO_ERROR_FAILED_HANDLED))) { char *text; char *name; name = nautilus_file_get_display_name (file); /* Translators: %s is a file name formatted for display */ text = g_strdup_printf (_("Unable to eject “%s”"), name); show_dialog (text, error->message, GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_MESSAGE_ERROR); g_free (text); g_free (name); } } static void file_stop_callback (NautilusFile *file, GFile *result_location, GError *error, gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); if (error != NULL && (error->domain != G_IO_ERROR || (error->code != G_IO_ERROR_CANCELLED && error->code != G_IO_ERROR_FAILED_HANDLED))) { show_dialog (_("Unable to stop drive"), error->message, GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_MESSAGE_ERROR); } } static void action_mount_volume (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; GList *selection, *l; NautilusFilesView *view; GMountOperation *mount_op; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); for (l = selection; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); if (nautilus_file_can_mount (file)) { mount_op = gtk_mount_operation_new (nautilus_files_view_get_containing_window (view)); g_mount_operation_set_password_save (mount_op, G_PASSWORD_SAVE_FOR_SESSION); nautilus_file_mount (file, mount_op, NULL, file_mount_callback, view); g_object_unref (mount_op); } } nautilus_file_list_free (selection); } static void action_unmount_volume (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; g_autolist (NautilusFile) selection = NULL; GList *l; NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); for (l = selection; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); if (nautilus_file_can_unmount (file)) { GMountOperation *mount_op; mount_op = gtk_mount_operation_new (nautilus_files_view_get_containing_window (view)); nautilus_file_unmount (file, mount_op, NULL, file_unmount_callback, g_object_ref (view)); g_object_unref (mount_op); } } } static void action_eject_volume (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; g_autolist (NautilusFile) selection = NULL; GList *l; NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); for (l = selection; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); if (nautilus_file_can_eject (file)) { GMountOperation *mount_op; mount_op = gtk_mount_operation_new (nautilus_files_view_get_containing_window (view)); nautilus_file_eject (file, mount_op, NULL, file_eject_callback, g_object_ref (view)); g_object_unref (mount_op); } } } static void file_start_callback (NautilusFile *file, GFile *result_location, GError *error, gpointer callback_data) { NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (callback_data); if (error != NULL && (error->domain != G_IO_ERROR || (error->code != G_IO_ERROR_CANCELLED && error->code != G_IO_ERROR_FAILED_HANDLED && error->code != G_IO_ERROR_ALREADY_MOUNTED))) { char *text; char *name; name = nautilus_file_get_display_name (file); /* Translators: %s is a file name formatted for display */ text = g_strdup_printf (_("Unable to start “%s”"), name); show_dialog (text, error->message, GTK_WINDOW (nautilus_files_view_get_window (view)), GTK_MESSAGE_ERROR); g_free (text); g_free (name); } } static void action_start_volume (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; g_autolist (NautilusFile) selection = NULL; GList *l; NautilusFilesView *view; GMountOperation *mount_op; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); for (l = selection; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); if (nautilus_file_can_start (file) || nautilus_file_can_start_degraded (file)) { mount_op = gtk_mount_operation_new (nautilus_files_view_get_containing_window (view)); nautilus_file_start (file, mount_op, NULL, file_start_callback, view); g_object_unref (mount_op); } } } static void action_stop_volume (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; g_autolist (NautilusFile) selection = NULL; GList *l; NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (user_data); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); for (l = selection; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); if (nautilus_file_can_stop (file)) { GMountOperation *mount_op; mount_op = gtk_mount_operation_new (nautilus_files_view_get_containing_window (view)); nautilus_file_stop (file, mount_op, NULL, file_stop_callback, view); g_object_unref (mount_op); } } } static void action_detect_media (GSimpleAction *action, GVariant *state, gpointer user_data) { NautilusFile *file; g_autolist (NautilusFile) selection = NULL; GList *l; NautilusView *view; view = NAUTILUS_VIEW (user_data); selection = nautilus_view_get_selection (view); for (l = selection; l != NULL; l = l->next) { file = NAUTILUS_FILE (l->data); if (nautilus_file_can_poll_for_media (file) && !nautilus_file_is_media_check_automatic (file)) { nautilus_file_poll_for_media (file); } } } const GActionEntry view_entries[] = { /* Toolbar menu */ { "zoom-in", action_zoom_in }, { "zoom-out", action_zoom_out }, { "zoom-standard", action_zoom_standard }, { "show-hidden-files", NULL, NULL, "true", action_show_hidden_files }, /* Background menu */ { "empty-trash", action_empty_trash }, { "new-folder", action_new_folder }, { "select-all", action_select_all }, { "paste", action_paste_files }, { "copy-current-location", action_copy_current_location }, { "paste_accel", action_paste_files_accel }, { "create-link", action_create_links }, { "create-link-shortcut", action_create_links }, /* Selection menu */ { "new-folder-with-selection", action_new_folder_with_selection }, { "open-scripts-folder", action_open_scripts_folder }, { "open-item-location", action_open_item_location }, { "open-with-default-application", action_open_with_default_application }, { "open-with-other-application", action_open_with_other_application }, { "open-current-directory-with-other-application", action_open_current_directory_with_other_application }, { "open-item-new-window", action_open_item_new_window }, { "open-item-new-tab", action_open_item_new_tab }, { "cut", action_cut}, { "copy", action_copy}, { "create-link-in-place", action_create_links_in_place }, { "create-link-in-place-shortcut", action_create_links_in_place }, { "move-to", action_move_to}, { "copy-to", action_copy_to}, { "move-to-trash", action_move_to_trash}, { "delete-from-trash", action_delete }, { "star", action_star}, { "unstar", action_unstar}, /* We separate the shortcut and the menu item since we want the shortcut * to always be available, but we don't want the menu item shown if not * completely necesary. Since the visibility of the menu item is based on * the action enability, we need to split the actions for the menu and the * shortcut. */ { "delete-permanently-shortcut", action_delete }, { "delete-permanently-menu-item", action_delete }, /* This is only shown when the setting to show always delete permanently * is set and when the common use cases for delete permanently which uses * Delete as a shortcut are not needed. For instance this will be only * present when the setting is true and when it can trash files */ { "permanent-delete-permanently-menu-item", action_delete }, { "remove-from-recent", action_remove_from_recent }, { "restore-from-trash", action_restore_from_trash}, { "paste-into", action_paste_files_into }, { "rename", action_rename}, { "extract-here", action_extract_here }, { "extract-to", action_extract_to }, { "compress", action_compress }, { "send-email", action_send_email }, { "console", action_open_console }, { "current-directory-console", action_current_dir_open_console }, { "properties", action_properties}, { "current-directory-properties", action_current_dir_properties}, { "run-in-terminal", action_run_in_terminal }, { "set-as-wallpaper", action_set_as_wallpaper }, { "mount-volume", action_mount_volume }, { "unmount-volume", action_unmount_volume }, { "eject-volume", action_eject_volume }, { "start-volume", action_start_volume }, { "stop-volume", action_stop_volume }, { "detect-media", action_detect_media }, /* Only accesible by shorcuts */ { "select-pattern", action_select_pattern }, { "invert-selection", action_invert_selection }, { "preview-selection", action_preview_selection }, { "popup-menu", action_popup_menu }, }; static gboolean can_paste_into_file (NautilusFile *file) { if (nautilus_file_is_directory (file) && nautilus_file_can_write (file)) { return TRUE; } if (nautilus_file_has_activation_uri (file)) { GFile *location; NautilusFile *activation_file; gboolean res; location = nautilus_file_get_activation_location (file); activation_file = nautilus_file_get (location); g_object_unref (location); /* The target location might not have data for it read yet, * and we can't want to do sync I/O, so treat the unknown * case as can-write */ res = (nautilus_file_get_file_type (activation_file) == G_FILE_TYPE_UNKNOWN) || (nautilus_file_get_file_type (activation_file) == G_FILE_TYPE_DIRECTORY && nautilus_file_can_write (activation_file)); nautilus_file_unref (activation_file); return res; } return FALSE; } static void update_actions_clipboard_contents_received (GObject *source_object, GAsyncResult *res, gpointer user_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (source_object); NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); NautilusClipboard *clip; gboolean can_link_from_copied_files; gboolean settings_show_create_link; gboolean is_read_only; gboolean selection_contains_recent; gboolean selection_contains_starred; GAction *action; clip = nautilus_files_view_get_clipboard_finish (view, res, NULL); if (priv->in_destruction || !priv->active) { /* We've been destroyed or became inactive since call */ return; } settings_show_create_link = g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_SHOW_CREATE_LINK); is_read_only = nautilus_files_view_is_read_only (view); selection_contains_recent = showing_recent_directory (view); selection_contains_starred = showing_starred_directory (view); can_link_from_copied_files = clip != NULL && !nautilus_clipboard_is_cut (clip) && !selection_contains_recent && !selection_contains_starred && !is_read_only; action = g_action_map_lookup_action (G_ACTION_MAP (priv->view_action_group), "create-link"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_link_from_copied_files && settings_show_create_link); action = g_action_map_lookup_action (G_ACTION_MAP (priv->view_action_group), "create-link-shortcut"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_link_from_copied_files && !settings_show_create_link); } static void update_actions_state_for_clipboard_targets (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; GdkClipboard *clipboard; GdkContentFormats *formats; gboolean is_data_copied; GAction *action; priv = nautilus_files_view_get_instance_private (view); clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view)); formats = gdk_clipboard_get_formats (clipboard); is_data_copied = gdk_content_formats_contain_gtype (formats, NAUTILUS_TYPE_CLIPBOARD); action = g_action_map_lookup_action (G_ACTION_MAP (priv->view_action_group), "paste"); /* Take into account if the action was previously disabled for other reasons, * like the directory not being writabble */ g_simple_action_set_enabled (G_SIMPLE_ACTION (action), is_data_copied && g_action_get_enabled (action)); action = g_action_map_lookup_action (G_ACTION_MAP (priv->view_action_group), "paste-into"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), is_data_copied && g_action_get_enabled (action)); action = g_action_map_lookup_action (G_ACTION_MAP (priv->view_action_group), "create-link"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), is_data_copied && g_action_get_enabled (action)); } static void file_should_show_foreach (NautilusFile *file, gboolean *show_mount, gboolean *show_unmount, gboolean *show_eject, gboolean *show_start, gboolean *show_stop, gboolean *show_poll, GDriveStartStopType *start_stop_type) { *show_mount = FALSE; *show_unmount = FALSE; *show_eject = FALSE; *show_start = FALSE; *show_stop = FALSE; *show_poll = FALSE; if (nautilus_file_can_eject (file)) { *show_eject = TRUE; } if (nautilus_file_can_mount (file)) { *show_mount = TRUE; } if (nautilus_file_can_start (file) || nautilus_file_can_start_degraded (file)) { *show_start = TRUE; } if (nautilus_file_can_stop (file)) { *show_stop = TRUE; } /* Dot not show both Unmount and Eject/Safe Removal; too confusing to * have too many menu entries */ if (nautilus_file_can_unmount (file) && !*show_eject && !*show_stop) { *show_unmount = TRUE; } if (nautilus_file_can_poll_for_media (file) && !nautilus_file_is_media_check_automatic (file)) { *show_poll = TRUE; } *start_stop_type = nautilus_file_get_start_stop_type (file); } static gboolean can_restore_from_trash (GList *files) { NautilusFile *original_file; NautilusFile *original_dir; GHashTable *original_dirs_hash; GList *original_dirs; gboolean can_restore; original_file = NULL; original_dir = NULL; original_dirs = NULL; original_dirs_hash = NULL; if (files != NULL) { if (g_list_length (files) == 1) { original_file = nautilus_file_get_trash_original_file (files->data); } else { original_dirs_hash = nautilus_trashed_files_get_original_directories (files, NULL); if (original_dirs_hash != NULL) { original_dirs = g_hash_table_get_keys (original_dirs_hash); if (g_list_length (original_dirs) == 1) { original_dir = nautilus_file_ref (NAUTILUS_FILE (original_dirs->data)); } } } } can_restore = original_file != NULL || original_dirs != NULL; nautilus_file_unref (original_file); nautilus_file_unref (original_dir); g_list_free (original_dirs); if (original_dirs_hash != NULL) { g_hash_table_destroy (original_dirs_hash); } return can_restore; } static void on_clipboard_owner_changed (GdkClipboard *clipboard, gpointer user_data) { NautilusFilesView *self = NAUTILUS_FILES_VIEW (user_data); /* We need to update paste and paste-like actions */ nautilus_files_view_update_actions_state (self); } static gboolean can_delete_all (GList *files) { NautilusFile *file; GList *l; for (l = files; l != NULL; l = l->next) { file = l->data; if (!nautilus_file_can_delete (file)) { return FALSE; } } return TRUE; } static gboolean can_trash_all (GList *files) { NautilusFile *file; GList *l; for (l = files; l != NULL; l = l->next) { file = l->data; if (!nautilus_file_can_trash (file)) { return FALSE; } } return TRUE; } static gboolean all_in_trash (GList *files) { NautilusFile *file; GList *l; for (l = files; l != NULL; l = l->next) { file = l->data; if (!nautilus_file_is_in_trash (file)) { return FALSE; } } return TRUE; } static gboolean can_extract_all (GList *files) { NautilusFile *file; GList *l; for (l = files; l != NULL; l = l->next) { file = l->data; if (!nautilus_file_is_archive (file)) { return FALSE; } } return TRUE; } static gboolean nautilus_handles_all_files_to_extract (GList *files) { NautilusFile *file; GList *l; for (l = files; l != NULL; l = l->next) { file = l->data; if (!nautilus_mime_file_extracts (file)) { return FALSE; } } return TRUE; } GActionGroup * nautilus_files_view_get_action_group (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); return priv->view_action_group; } static void real_update_actions_state (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_autolist (NautilusFile) selection = NULL; GList *l; gint selection_count; gboolean zoom_level_is_default; gboolean selection_contains_home_dir; gboolean selection_contains_recent; gboolean selection_contains_search; gboolean selection_contains_starred; gboolean selection_all_in_trash; gboolean selection_is_read_only; gboolean can_create_files; gboolean can_delete_files; gboolean can_move_files; gboolean can_trash_files; gboolean can_copy_files; gboolean can_paste_files_into; gboolean can_extract_files; gboolean handles_all_files_to_extract; gboolean can_extract_here; gboolean item_opens_in_view; gboolean is_read_only; gboolean is_in_trash; GAction *action; GActionGroup *view_action_group; gboolean show_mount; gboolean show_unmount; gboolean show_eject; gboolean show_start; gboolean show_stop; gboolean show_detect_media; gboolean settings_show_delete_permanently; gboolean settings_show_create_link; GDriveStartStopType start_stop_type; g_autoptr (GFile) current_location = NULL; g_autofree gchar *current_uri = NULL; gboolean can_star_current_directory; gboolean show_star; gboolean show_unstar; gchar *uri; g_autoptr (GAppInfo) app_info_mailto = NULL; priv = nautilus_files_view_get_instance_private (view); view_action_group = priv->view_action_group; selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); selection_count = g_list_length (selection); selection_contains_home_dir = home_dir_in_selection (selection); selection_contains_recent = showing_recent_directory (view); selection_contains_starred = showing_starred_directory (view); selection_contains_search = nautilus_view_is_searching (NAUTILUS_VIEW (view)); selection_is_read_only = selection_count == 1 && (!nautilus_file_can_write (NAUTILUS_FILE (selection->data)) && !nautilus_file_has_activation_uri (NAUTILUS_FILE (selection->data))); selection_all_in_trash = all_in_trash (selection); zoom_level_is_default = nautilus_files_view_is_zoom_level_default (view); is_read_only = nautilus_files_view_is_read_only (view); is_in_trash = showing_trash_directory (view); can_create_files = nautilus_files_view_supports_creating_files (view); can_delete_files = can_delete_all (selection) && selection_count != 0 && !selection_contains_home_dir; can_trash_files = can_trash_all (selection) && selection_count != 0 && !selection_contains_home_dir; can_copy_files = selection_count != 0; can_move_files = can_delete_files && !selection_contains_recent && !selection_contains_starred; can_paste_files_into = (selection_count == 1 && can_paste_into_file (NAUTILUS_FILE (selection->data))); can_extract_files = selection_count != 0 && can_extract_all (selection); can_extract_here = nautilus_files_view_supports_extract_here (view); handles_all_files_to_extract = nautilus_handles_all_files_to_extract (selection); settings_show_delete_permanently = g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_SHOW_DELETE_PERMANENTLY); settings_show_create_link = g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_SHOW_CREATE_LINK); app_info_mailto = g_app_info_get_default_for_uri_scheme ("mailto"); /* Right click actions * Selection menu actions */ action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "new-folder-with-selection"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_create_files && can_delete_files && (selection_count > 1) && !selection_contains_recent && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "rename"); if (selection_count > 1) { g_simple_action_set_enabled (G_SIMPLE_ACTION (action), nautilus_file_can_rename_files (selection)); } else { g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_count == 1 && nautilus_file_can_rename (selection->data)); } action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "extract-here"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_extract_files && !handles_all_files_to_extract && can_extract_here); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "extract-to"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_extract_files && (!handles_all_files_to_extract || can_extract_here)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "compress"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_create_files && can_copy_files); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "open-item-location"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_count == 1 && (selection_contains_recent || selection_contains_search || selection_contains_starred)); item_opens_in_view = selection_count != 0; for (l = selection; l != NULL; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (selection->data); if (!nautilus_file_opens_in_view (file)) { item_opens_in_view = FALSE; } if (!item_opens_in_view) { break; } } action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "open-with-default-application"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_count != 0); /* Allow to select a different application to open the item */ action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "open-with-other-application"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_count > 0); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "open-item-new-tab"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), item_opens_in_view); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "open-item-new-window"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), item_opens_in_view); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "run-in-terminal"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_run_in_terminal (selection)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "set-as-wallpaper"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_set_wallpaper (selection)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "restore-from-trash"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_restore_from_trash (selection)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "move-to-trash"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_trash_files); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "delete-from-trash"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_delete_files && selection_all_in_trash); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "delete-permanently-shortcut"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_delete_files); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "delete-permanently-menu-item"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_delete_files && !can_trash_files && !selection_all_in_trash && !selection_contains_recent && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "permanent-delete-permanently-menu-item"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_delete_files && can_trash_files && settings_show_delete_permanently && !selection_all_in_trash && !selection_contains_recent && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "remove-from-recent"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_contains_recent && selection_count > 0); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "cut"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_move_files && !selection_contains_recent && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "copy"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_copy_files); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "create-link-in-place"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_copy_files && can_create_files && settings_show_create_link); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "create-link-in-place-shortcut"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_copy_files && can_create_files && !settings_show_create_link); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "send-email"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), app_info_mailto != NULL); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "copy-to"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_copy_files); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "move-to"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_move_files && !selection_contains_recent && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "preview-selection"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_count != 0); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "copy-current-location"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !selection_contains_recent && !selection_contains_search && !selection_contains_starred); /* Drive menu */ show_mount = (selection != NULL); show_unmount = (selection != NULL); show_eject = (selection != NULL); show_start = (selection != NULL && selection_count == 1); show_stop = (selection != NULL && selection_count == 1); show_detect_media = (selection != NULL && selection_count == 1); for (l = selection; l != NULL && (show_mount || show_unmount || show_eject || show_start || show_stop || show_detect_media); l = l->next) { NautilusFile *file; gboolean show_mount_one; gboolean show_unmount_one; gboolean show_eject_one; gboolean show_start_one; gboolean show_stop_one; gboolean show_detect_media_one; file = NAUTILUS_FILE (l->data); file_should_show_foreach (file, &show_mount_one, &show_unmount_one, &show_eject_one, &show_start_one, &show_stop_one, &show_detect_media_one, &start_stop_type); show_mount &= show_mount_one; show_unmount &= show_unmount_one; show_eject &= show_eject_one; show_start &= show_start_one; show_stop &= show_stop_one; show_detect_media &= show_detect_media_one; } action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "mount-volume"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_mount); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "unmount-volume"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_unmount); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "eject-volume"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_eject); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "start-volume"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_start); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "stop-volume"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_stop); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "detect-media"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_detect_media); /* Background menu actions */ action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "open-current-directory-with-other-application"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !selection_contains_recent && !selection_contains_search && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "new-folder"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_create_files); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "empty-trash"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !nautilus_trash_monitor_is_empty () && is_in_trash); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "paste"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !is_read_only && !selection_contains_recent && !selection_contains_starred); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "paste-into"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_paste_files_into); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "console"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), selection_count == 1 && nautilus_file_is_directory (selection->data) && nautilus_dbus_launcher_is_available (nautilus_dbus_launcher_get (), NAUTILUS_DBUS_LAUNCHER_CONSOLE)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "current-directory-console"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), nautilus_dbus_launcher_is_available (nautilus_dbus_launcher_get (), NAUTILUS_DBUS_LAUNCHER_CONSOLE)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "properties"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), TRUE); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "current-directory-properties"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !selection_contains_recent && !selection_contains_search && !selection_contains_starred); /* Actions that are related to the clipboard need request, request the data * and update them once we have the data */ update_actions_state_for_clipboard_targets (view); nautilus_files_view_get_clipboard_async (view, update_actions_clipboard_contents_received, NULL); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "select-all"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !nautilus_files_view_is_empty (view) && !priv->loading); /* Toolbar menu actions */ g_action_group_change_action_state (view_action_group, "show-hidden-files", g_variant_new_boolean (priv->show_hidden_files)); /* Zoom */ action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "zoom-in"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), nautilus_files_view_can_zoom_in (view)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "zoom-out"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), nautilus_files_view_can_zoom_out (view)); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "zoom-standard"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), nautilus_files_view_supports_zooming (view) && !zoom_level_is_default); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "zoom-to-level"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), !nautilus_files_view_is_empty (view)); current_location = nautilus_file_get_location (nautilus_files_view_get_directory_as_file (view)); current_uri = g_file_get_uri (current_location); can_star_current_directory = nautilus_tag_manager_can_star_contents (nautilus_tag_manager_get (), current_location); show_star = (selection != NULL) && (can_star_current_directory || selection_contains_starred); show_unstar = (selection != NULL) && (can_star_current_directory || selection_contains_starred); for (l = selection; l != NULL; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (l->data); uri = nautilus_file_get_uri (file); if (!show_star && !show_unstar) { break; } if (nautilus_tag_manager_file_is_starred (nautilus_tag_manager_get (), uri)) { show_star = FALSE; } else { show_unstar = FALSE; } g_free (uri); } action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "star"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_star); action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "unstar"); g_simple_action_set_enabled (G_SIMPLE_ACTION (action), show_unstar && selection_contains_starred); } /* Convenience function to be called when updating menus, * so children can subclass it and it will be called when * they chain up to the parent in update_context_menus * or update_toolbar_menus */ void nautilus_files_view_update_actions_state (NautilusFilesView *view) { g_assert (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->update_actions_state (view); } static void update_selection_menu (NautilusFilesView *view, GtkBuilder *builder) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); g_autolist (NautilusFile) selection = NULL; GList *l; gint selection_count; gboolean show_app; gboolean show_run; gboolean show_extract; gboolean item_opens_in_view; gchar *item_label; GAppInfo *app; GIcon *app_icon; GMenuItem *menu_item; GObject *object; gboolean show_mount; gboolean show_unmount; gboolean show_eject; gboolean show_start; gboolean show_stop; gboolean show_detect_media; gboolean show_scripts = FALSE; gint i; GDriveStartStopType start_stop_type; selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); selection_count = g_list_length (selection); show_mount = (selection != NULL); show_unmount = (selection != NULL); show_eject = (selection != NULL); show_start = (selection != NULL && selection_count == 1); show_stop = (selection != NULL && selection_count == 1); show_detect_media = (selection != NULL && selection_count == 1); start_stop_type = G_DRIVE_START_STOP_TYPE_UNKNOWN; item_label = g_strdup_printf (ngettext ("New Folder with Selection (%'d Item)", "New Folder with Selection (%'d Items)", selection_count), selection_count); menu_item = g_menu_item_new (item_label, "view.new-folder-with-selection"); g_menu_item_set_attribute (menu_item, "hidden-when", "s", "action-disabled"); object = gtk_builder_get_object (builder, "new-folder-with-selection-section"); g_menu_append_item (G_MENU (object), menu_item); g_object_unref (menu_item); g_free (item_label); /* Open With menu item */ show_extract = show_app = show_run = item_opens_in_view = selection_count != 0; for (l = selection; l != NULL; l = l->next) { NautilusFile *file; file = NAUTILUS_FILE (l->data); if (show_extract && !nautilus_mime_file_extracts (file)) { show_extract = FALSE; } if (show_app && !nautilus_mime_file_opens_in_external_app (file)) { show_app = FALSE; } if (show_run && !nautilus_mime_file_launches (file)) { show_run = FALSE; } if (item_opens_in_view && !nautilus_file_opens_in_view (file)) { item_opens_in_view = FALSE; } if (!show_extract && !show_app && !show_run && !item_opens_in_view) { break; } } item_label = NULL; app = NULL; app_icon = NULL; if (show_app) { app = nautilus_mime_get_default_application_for_files (selection); } if (app != NULL) { char *escaped_app; escaped_app = eel_str_double_underscores (g_app_info_get_name (app)); item_label = g_strdup_printf (_("Open With %s"), escaped_app); app_icon = g_app_info_get_icon (app); if (app_icon != NULL) { g_object_ref (app_icon); } g_free (escaped_app); g_object_unref (app); } else if (show_run) { item_label = g_strdup (_("Run")); } else if (show_extract) { item_label = nautilus_files_view_supports_extract_here (view) ? g_strdup (_("Extract")) : g_strdup (_("Extract to…")); } else { item_label = g_strdup (_("Open")); } /* The action already exists in the submenu if item opens in view */ if (!item_opens_in_view) { menu_item = g_menu_item_new (item_label, "view.open-with-default-application"); if (app_icon != NULL) { g_menu_item_set_icon (menu_item, app_icon); } object = gtk_builder_get_object (builder, "open-with-application-section"); g_menu_prepend_item (G_MENU (object), menu_item); g_object_unref (menu_item); } else { object = gtk_builder_get_object (builder, "open-with-application-section"); i = nautilus_g_menu_model_find_by_string (G_MENU_MODEL (object), "nautilus-menu-item", "open_with_in_main_menu"); g_menu_remove (G_MENU (object), i); } /* The "Open" submenu should be hidden if the item doesn't open in the view. */ object = gtk_builder_get_object (builder, "open-with-application-section"); i = nautilus_g_menu_model_find_by_string (G_MENU_MODEL (object), "nautilus-menu-item", "open_in_view_submenu"); nautilus_g_menu_replace_string_in_item (G_MENU (object), i, "hidden-when", (!item_opens_in_view) ? "action-missing" : NULL); g_free (item_label); /* Drives */ for (l = selection; l != NULL && (show_mount || show_unmount || show_eject || show_start || show_stop || show_detect_media); l = l->next) { NautilusFile *file; gboolean show_mount_one; gboolean show_unmount_one; gboolean show_eject_one; gboolean show_start_one; gboolean show_stop_one; gboolean show_detect_media_one; file = NAUTILUS_FILE (l->data); file_should_show_foreach (file, &show_mount_one, &show_unmount_one, &show_eject_one, &show_start_one, &show_stop_one, &show_detect_media_one, &start_stop_type); show_mount &= show_mount_one; show_unmount &= show_unmount_one; show_eject &= show_eject_one; show_start &= show_start_one; show_stop &= show_stop_one; show_detect_media &= show_detect_media_one; } if (show_start) { switch (start_stop_type) { default: case G_DRIVE_START_STOP_TYPE_UNKNOWN: case G_DRIVE_START_STOP_TYPE_SHUTDOWN: { item_label = _("_Start"); } break; case G_DRIVE_START_STOP_TYPE_NETWORK: { item_label = _("_Connect"); } break; case G_DRIVE_START_STOP_TYPE_MULTIDISK: { item_label = _("_Start Multi-disk Drive"); } break; case G_DRIVE_START_STOP_TYPE_PASSWORD: { item_label = _("U_nlock Drive"); } break; } menu_item = g_menu_item_new (item_label, "view.start-volume"); object = gtk_builder_get_object (builder, "drive-section"); g_menu_append_item (G_MENU (object), menu_item); g_object_unref (menu_item); } if (show_stop) { switch (start_stop_type) { default: case G_DRIVE_START_STOP_TYPE_UNKNOWN: { item_label = _("Stop Drive"); } break; case G_DRIVE_START_STOP_TYPE_SHUTDOWN: { item_label = _("_Safely Remove Drive"); } break; case G_DRIVE_START_STOP_TYPE_NETWORK: { item_label = _("_Disconnect"); } break; case G_DRIVE_START_STOP_TYPE_MULTIDISK: { item_label = _("_Stop Multi-disk Drive"); } break; case G_DRIVE_START_STOP_TYPE_PASSWORD: { item_label = _("_Lock Drive"); } break; } menu_item = g_menu_item_new (item_label, "view.stop-volume"); object = gtk_builder_get_object (builder, "drive-section"); g_menu_append_item (G_MENU (object), menu_item); g_object_unref (menu_item); } if (!priv->scripts_menu_updated) { update_scripts_menu (view, builder); priv->scripts_menu_updated = TRUE; } if (priv->scripts_menu != NULL) { show_scripts = TRUE; object = gtk_builder_get_object (builder, "scripts-submenu-section"); nautilus_gmenu_set_from_model (G_MENU (object), priv->scripts_menu); } object = gtk_builder_get_object (builder, "open-with-application-section"); i = nautilus_g_menu_model_find_by_string (G_MENU_MODEL (object), "nautilus-menu-item", "scripts-submenu"); nautilus_g_menu_replace_string_in_item (G_MENU (object), i, "hidden-when", (!show_scripts) ? "action-missing" : NULL); } static void update_background_menu (NautilusFilesView *view, GtkBuilder *builder) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); GObject *object; gboolean remove_submenu = TRUE; gint i; if (nautilus_files_view_supports_creating_files (view) && !showing_recent_directory (view) && !showing_starred_directory (view)) { if (!priv->templates_menu_updated) { update_templates_menu (view, builder); priv->templates_menu_updated = TRUE; } object = gtk_builder_get_object (builder, "templates-submenu"); nautilus_gmenu_set_from_model (G_MENU (object), priv->templates_menu); if (priv->templates_menu != NULL) { remove_submenu = FALSE; } } else { /* This is necessary because the pathbar menu relies on it being NULL * to hide the submenu. */ nautilus_view_set_templates_menu (NAUTILUS_VIEW (view), NULL); /* And this is necessary to regenerate the templates menu when we go * back to a normal folder. */ priv->templates_menu_updated = FALSE; } i = nautilus_g_menu_model_find_by_string (G_MENU_MODEL (priv->background_menu_model), "nautilus-menu-item", "templates-submenu"); nautilus_g_menu_replace_string_in_item (priv->background_menu_model, i, "hidden-when", remove_submenu ? "action-missing" : NULL); } static void real_update_context_menus (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_autoptr (GtkBuilder) builder = NULL; GObject *object; priv = nautilus_files_view_get_instance_private (view); builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/ui/nautilus-files-view-context-menus.ui"); g_clear_object (&priv->background_menu_model); g_clear_object (&priv->selection_menu_model); object = gtk_builder_get_object (builder, "background-menu"); priv->background_menu_model = g_object_ref (G_MENU (object)); object = gtk_builder_get_object (builder, "selection-menu"); priv->selection_menu_model = g_object_ref (G_MENU (object)); update_selection_menu (view, builder); update_background_menu (view, builder); update_extensions_menus (view, builder); nautilus_files_view_update_actions_state (view); } /* Convenience function to reset the context menus owned by the view and update * them with the current state. * Children can subclass it and add items on the menu after chaining up to the * parent, so menus are already reseted. * It will also update the actions state, which will also update children * actions state if the children subclass nautilus_files_view_update_actions_state */ void nautilus_files_view_update_context_menus (NautilusFilesView *view) { g_assert (NAUTILUS_IS_FILES_VIEW (view)); NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->update_context_menus (view); } static void nautilus_files_view_reset_view_menu (NautilusFilesView *view) { NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); NautilusFile *file; GMenuModel *sort_section = priv->toolbar_menu_sections->sort_section; const gchar *action; gint i; file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (view)); /* When not in the special location, set an inexistant action to hide the * menu item. This works under the assumptiont that the menu item has its * "hidden-when" attribute set to "action-disabled", and that an inexistant * action is treated as a disabled action. */ action = nautilus_file_is_in_trash (file) ? "view.sort" : "doesnt-exist"; i = nautilus_g_menu_model_find_by_string (sort_section, "nautilus-menu-item", "last_trashed"); nautilus_g_menu_replace_string_in_item (G_MENU (sort_section), i, "action", action); action = nautilus_file_is_in_recent (file) ? "view.sort" : "doesnt-exist"; i = nautilus_g_menu_model_find_by_string (sort_section, "nautilus-menu-item", "recency"); nautilus_g_menu_replace_string_in_item (G_MENU (sort_section), i, "action", action); action = nautilus_file_is_in_search (file) ? "view.sort" : "doesnt-exist"; i = nautilus_g_menu_model_find_by_string (sort_section, "nautilus-menu-item", "relevance"); nautilus_g_menu_replace_string_in_item (G_MENU (sort_section), i, "action", action); } /* Convenience function to reset the menus owned by the view but managed on * the toolbar, and update them with the current state. * It will also update the actions state, which will also update children * actions state if the children subclass nautilus_files_view_update_actions_state */ void nautilus_files_view_update_toolbar_menus (NautilusFilesView *view) { NautilusWindow *window; NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); /* Don't update after destroy (#349551), * or if we are not active. */ if (priv->in_destruction || !priv->active) { return; } window = nautilus_files_view_get_window (view); nautilus_window_reset_menus (window); nautilus_files_view_update_actions_state (view); nautilus_files_view_reset_view_menu (view); } static GdkRectangle * nautilus_files_view_reveal_for_selection_context_menu (NautilusFilesView *view) { return NAUTILUS_FILES_VIEW_CLASS (G_OBJECT_GET_CLASS (view))->reveal_for_selection_context_menu (view); } /** * nautilus_files_view_pop_up_selection_context_menu * * Pop up a context menu appropriate to the selected items. * @view: NautilusFilesView of interest. * @event: The event that triggered this context menu. * **/ void nautilus_files_view_pop_up_selection_context_menu (NautilusFilesView *view, gdouble x, gdouble y) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); /* Make the context menu items not flash as they update to proper disabled, * etc. states by forcing menus to update now. */ update_context_menus_if_pending (view); /* Destroy old popover and create a new one, to avoid duplicate submenu bugs * and showing old model temporarily. We don't do this when popover is * closed because it wouldn't activate the actions then. */ g_clear_pointer (&priv->selection_menu, gtk_widget_unparent); priv->selection_menu = gtk_popover_menu_new_from_model (NULL); /* There's something related to NautilusFilesView that isn't grabbing the * focus back when the popover is closed. Let's force it as a workaround. */ g_signal_connect_object (priv->selection_menu, "closed", G_CALLBACK (gtk_widget_grab_focus), view, G_CONNECT_SWAPPED); gtk_widget_set_parent (priv->selection_menu, GTK_WIDGET (view)); gtk_popover_set_has_arrow (GTK_POPOVER (priv->selection_menu), FALSE); gtk_widget_set_halign (priv->selection_menu, GTK_ALIGN_START); gtk_popover_menu_set_menu_model (GTK_POPOVER_MENU (priv->selection_menu), G_MENU_MODEL (priv->selection_menu_model)); if (x == -1 && y == -1) { /* If triggered from the keyboard, popup at selection, not pointer */ g_autofree GdkRectangle *rectangle = NULL; rectangle = nautilus_files_view_reveal_for_selection_context_menu (view); g_return_if_fail (rectangle != NULL); gtk_popover_set_pointing_to (GTK_POPOVER (priv->selection_menu), rectangle); } else { gtk_popover_set_pointing_to (GTK_POPOVER (priv->selection_menu), &(GdkRectangle){x, y, 0, 0}); } gtk_popover_popup (GTK_POPOVER (priv->selection_menu)); } /** * nautilus_files_view_pop_up_background_context_menu * * Pop up a context menu appropriate to the location in view. * @view: NautilusFilesView of interest. * **/ void nautilus_files_view_pop_up_background_context_menu (NautilusFilesView *view, gdouble x, gdouble y) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); /* Make the context menu items not flash as they update to proper disabled, * etc. states by forcing menus to update now. */ update_context_menus_if_pending (view); /* Destroy old popover and create a new one, to avoid duplicate submenu bugs * and showing old model temporarily. We don't do this when popover is * closed because it wouldn't activate the actions then. */ g_clear_pointer (&priv->background_menu, gtk_widget_unparent); priv->background_menu = gtk_popover_menu_new_from_model (NULL); /* There's something related to NautilusFilesView that isn't grabbing the * focus back when the popover is closed. Let's force it as a workaround. */ g_signal_connect_object (priv->background_menu, "closed", G_CALLBACK (gtk_widget_grab_focus), view, G_CONNECT_SWAPPED); gtk_widget_set_parent (priv->background_menu, GTK_WIDGET (view)); gtk_popover_set_has_arrow (GTK_POPOVER (priv->background_menu), FALSE); gtk_widget_set_halign (priv->background_menu, GTK_ALIGN_START); gtk_popover_menu_set_menu_model (GTK_POPOVER_MENU (priv->background_menu), G_MENU_MODEL (priv->background_menu_model)); gtk_popover_set_pointing_to (GTK_POPOVER (priv->background_menu), &(GdkRectangle){x, y, 0, 0}); gtk_popover_popup (GTK_POPOVER (priv->background_menu)); } static void schedule_update_context_menus (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); /* Don't schedule updates after destroy (#349551), * or if we are not active. */ if (priv->in_destruction || !priv->active) { return; } /* Schedule a menu update with the current update interval */ if (priv->update_context_menus_timeout_id == 0) { priv->update_context_menus_timeout_id = g_timeout_add (priv->update_interval, update_context_menus_timeout_callback, view); } } static void remove_update_status_idle_callback (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->update_status_idle_id != 0) { g_source_remove (priv->update_status_idle_id); priv->update_status_idle_id = 0; } } static gboolean update_status_idle_callback (gpointer data) { NautilusFilesViewPrivate *priv; NautilusFilesView *view; view = NAUTILUS_FILES_VIEW (data); priv = nautilus_files_view_get_instance_private (view); nautilus_files_view_display_selection_info (view); priv->update_status_idle_id = 0; return FALSE; } static void schedule_update_status (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); /* Make sure we haven't already destroyed it */ if (priv->in_destruction) { return; } if (priv->loading) { /* Don't update status bar while loading the dir */ return; } if (priv->update_status_idle_id == 0) { priv->update_status_idle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE - 20, update_status_idle_callback, view, NULL); } } /** * nautilus_files_view_notify_selection_changed: * * Notify this view that the selection has changed. This is normally * called only by subclasses. * @view: NautilusFilesView whose selection has changed. * **/ void nautilus_files_view_notify_selection_changed (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; GtkWindow *window; g_autolist (NautilusFile) selection = NULL; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); selection = nautilus_view_get_selection (NAUTILUS_VIEW (view)); window = nautilus_files_view_get_containing_window (view); DEBUG_FILES (selection, "Selection changed in window %p", window); priv->selection_was_removed = FALSE; /* Schedule a display of the new selection. */ if (priv->display_selection_idle_id == 0) { priv->display_selection_idle_id = g_idle_add (display_selection_info_idle_callback, view); } schedule_update_context_menus (view); } static void file_changed_callback (NautilusFile *file, gpointer callback_data) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (callback_data); schedule_changes (view); schedule_update_context_menus (view); schedule_update_status (view); } /** * load_directory: * * Switch the displayed location to a new uri. If the uri is not valid, * the location will not be switched; user feedback will be provided instead. * @view: NautilusFilesView whose location will be changed. * @uri: A string representing the uri to switch to. * **/ static void load_directory (NautilusFilesView *view, NautilusDirectory *directory) { NautilusFileAttributes attributes; NautilusFilesViewPrivate *priv; g_assert (NAUTILUS_IS_FILES_VIEW (view)); g_assert (NAUTILUS_IS_DIRECTORY (directory)); priv = nautilus_files_view_get_instance_private (view); nautilus_profile_start (NULL); nautilus_files_view_stop_loading (view); g_signal_emit (view, signals[CLEAR], 0); priv->loading = TRUE; setup_loading_floating_bar (view); /* HACK: Fix for https://gitlab.gnome.org/GNOME/nautilus/-/issues/1452 */ { GtkScrolledWindow *content = GTK_SCROLLED_WINDOW (priv->scrolled_window); /* If we load a new location while the view is still scrolling due to * kinetic deceleration, we get a sudden jump to the same scrolling * position as the previous location, as well as residual scrolling * movement in the new location. * * This is both undesirable and unexpected from a user POV, so we want * to abort deceleration when switching locations. * * However, gtk_scrolled_window_cancel_deceleration() is private. So, * we make use of an undocumented behavior of ::set_kinetic_scrolling(), * which calls ::cancel_deceleration() when set to FALSE. */ gtk_scrolled_window_set_kinetic_scrolling (content, FALSE); gtk_scrolled_window_set_kinetic_scrolling (content, TRUE); } /* Update menus when directory is empty, before going to new * location, so they won't have any false lingering knowledge * of old selection. */ schedule_update_context_menus (view); while (priv->subdirectory_list != NULL) { nautilus_files_view_remove_subdirectory (view, priv->subdirectory_list->data); } /* Avoid freeing it and won't be able to ref it */ if (priv->model != directory) { nautilus_directory_unref (priv->model); priv->model = nautilus_directory_ref (directory); } nautilus_file_unref (priv->directory_as_file); priv->directory_as_file = nautilus_directory_get_corresponding_file (directory); g_clear_object (&priv->location); priv->location = nautilus_directory_get_location (directory); g_object_notify (G_OBJECT (view), "location"); g_object_notify (G_OBJECT (view), "loading"); g_object_notify (G_OBJECT (view), "searching"); /* FIXME bugzilla.gnome.org 45062: In theory, we also need to monitor metadata here (as * well as doing a call when ready), in case external forces * change the directory's file metadata. */ attributes = NAUTILUS_FILE_ATTRIBUTE_INFO | NAUTILUS_FILE_ATTRIBUTE_MOUNT | NAUTILUS_FILE_ATTRIBUTE_FILESYSTEM_INFO; priv->metadata_for_directory_as_file_pending = TRUE; priv->metadata_for_files_in_directory_pending = TRUE; nautilus_file_call_when_ready (priv->directory_as_file, attributes, metadata_for_directory_as_file_ready_callback, view); nautilus_directory_call_when_ready (priv->model, attributes, FALSE, metadata_for_files_in_directory_ready_callback, view); /* If capabilities change, then we need to update the menus * because of New Folder, and relative emblems. */ attributes = NAUTILUS_FILE_ATTRIBUTE_INFO | NAUTILUS_FILE_ATTRIBUTE_FILESYSTEM_INFO; nautilus_file_monitor_add (priv->directory_as_file, &priv->directory_as_file, attributes); priv->file_changed_handler_id = g_signal_connect (priv->directory_as_file, "changed", G_CALLBACK (file_changed_callback), view); nautilus_profile_end (NULL); } static void finish_loading (NautilusFilesView *view) { NautilusFileAttributes attributes; NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); nautilus_profile_start (NULL); /* Tell interested parties that we've begun loading this directory now. * Subclasses use this to know that the new metadata is now available. */ nautilus_profile_start ("BEGIN_LOADING"); g_signal_emit (view, signals[BEGIN_LOADING], 0); nautilus_profile_end ("BEGIN_LOADING"); nautilus_files_view_check_empty_states (view); if (nautilus_directory_are_all_files_seen (priv->model)) { /* Unschedule a pending update and schedule a new one with the minimal * update interval. This gives the view a short chance at gathering the * (cached) deep counts. */ unschedule_display_of_pending_files (view); schedule_timeout_display_of_pending_files (view, UPDATE_INTERVAL_MIN); } /* Start loading. */ /* Connect handlers to learn about loading progress. */ priv->done_loading_handler_id = g_signal_connect (priv->model, "done-loading", G_CALLBACK (done_loading_callback), view); priv->load_error_handler_id = g_signal_connect (priv->model, "load-error", G_CALLBACK (load_error_callback), view); /* Monitor the things needed to get the right icon. Also * monitor a directory's item count because the "size" * attribute is based on that, and the file's metadata * and possible custom name. */ attributes = NAUTILUS_FILE_ATTRIBUTES_FOR_ICON | NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT | NAUTILUS_FILE_ATTRIBUTE_INFO | NAUTILUS_FILE_ATTRIBUTE_MOUNT | NAUTILUS_FILE_ATTRIBUTE_EXTENSION_INFO; priv->files_added_handler_id = g_signal_connect (priv->model, "files-added", G_CALLBACK (files_added_callback), view); priv->files_changed_handler_id = g_signal_connect (priv->model, "files-changed", G_CALLBACK (files_changed_callback), view); nautilus_directory_file_monitor_add (priv->model, &priv->model, priv->show_hidden_files, attributes, files_added_callback, view); nautilus_profile_end (NULL); } static void finish_loading_if_all_metadata_loaded (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (!priv->metadata_for_directory_as_file_pending && !priv->metadata_for_files_in_directory_pending) { finish_loading (view); } } static void metadata_for_directory_as_file_ready_callback (NautilusFile *file, gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = callback_data; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); g_assert (priv->directory_as_file == file); g_assert (priv->metadata_for_directory_as_file_pending); nautilus_profile_start (NULL); priv->metadata_for_directory_as_file_pending = FALSE; finish_loading_if_all_metadata_loaded (view); nautilus_profile_end (NULL); } static void metadata_for_files_in_directory_ready_callback (NautilusDirectory *directory, GList *files, gpointer callback_data) { NautilusFilesView *view; NautilusFilesViewPrivate *priv; view = callback_data; g_assert (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); g_assert (priv->model == directory); g_assert (priv->metadata_for_files_in_directory_pending); nautilus_profile_start (NULL); priv->metadata_for_files_in_directory_pending = FALSE; finish_loading_if_all_metadata_loaded (view); nautilus_profile_end (NULL); } static void disconnect_model_handlers (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); if (priv->model == NULL) { return; } g_clear_signal_handler (&priv->files_added_handler_id, priv->model); g_clear_signal_handler (&priv->files_changed_handler_id, priv->model); g_clear_signal_handler (&priv->done_loading_handler_id, priv->model); g_clear_signal_handler (&priv->load_error_handler_id, priv->model); g_clear_signal_handler (&priv->file_changed_handler_id, priv->directory_as_file); nautilus_file_cancel_call_when_ready (priv->directory_as_file, metadata_for_directory_as_file_ready_callback, view); nautilus_directory_cancel_callback (priv->model, metadata_for_files_in_directory_ready_callback, view); nautilus_directory_file_monitor_remove (priv->model, &priv->model); nautilus_file_monitor_remove (priv->directory_as_file, &priv->directory_as_file); } static void nautilus_files_view_select_file (NautilusFilesView *view, NautilusFile *file) { GList file_list; file_list.data = file; file_list.next = NULL; file_list.prev = NULL; nautilus_files_view_call_set_selection (view, &file_list); } /** * nautilus_files_view_stop_loading: * * Stop the current ongoing process, such as switching to a new uri. * @view: NautilusFilesView in question. * **/ void nautilus_files_view_stop_loading (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_return_if_fail (NAUTILUS_IS_FILES_VIEW (view)); priv = nautilus_files_view_get_instance_private (view); unschedule_display_of_pending_files (view); reset_update_interval (view); /* Free extra undisplayed files */ g_list_free_full (priv->new_added_files, file_and_directory_free); priv->new_added_files = NULL; g_list_free_full (priv->new_changed_files, file_and_directory_free); priv->new_changed_files = NULL; g_hash_table_remove_all (priv->non_ready_files); g_list_free_full (priv->old_added_files, file_and_directory_free); priv->old_added_files = NULL; g_list_free_full (priv->old_changed_files, file_and_directory_free); priv->old_changed_files = NULL; g_list_free_full (priv->pending_selection, g_object_unref); priv->pending_selection = NULL; done_loading (view, FALSE); disconnect_model_handlers (view); } gboolean nautilus_files_view_is_editable (NautilusFilesView *view) { NautilusDirectory *directory; directory = nautilus_files_view_get_model (view); if (directory != NULL) { return nautilus_directory_is_editable (directory); } return TRUE; } static gboolean nautilus_files_view_is_read_only (NautilusFilesView *view) { NautilusFile *file; if (!nautilus_files_view_is_editable (view)) { return TRUE; } file = nautilus_files_view_get_directory_as_file (view); if (file != NULL) { return !nautilus_file_can_write (file); } return FALSE; } /** * nautilus_files_view_should_show_file * * Returns whether or not this file should be displayed based on * current filtering options. */ gboolean nautilus_files_view_should_show_file (NautilusFilesView *view, NautilusFile *file) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); return nautilus_file_should_show (file, priv->show_hidden_files); } void nautilus_files_view_ignore_hidden_file_preferences (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (view); g_return_if_fail (priv->model == NULL); if (priv->ignore_hidden_file_preferences) { return; } priv->show_hidden_files = FALSE; priv->ignore_hidden_file_preferences = TRUE; } char * nautilus_files_view_get_uri (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; g_return_val_if_fail (NAUTILUS_IS_FILES_VIEW (view), NULL); priv = nautilus_files_view_get_instance_private (view); if (priv->model == NULL) { return NULL; } return nautilus_directory_get_uri (priv->model); } void nautilus_files_view_move_copy_items (NautilusFilesView *view, const GList *item_uris, const char *target_uri, int copy_action) { NautilusFile *target_file; target_file = nautilus_file_get_existing_by_uri (target_uri); if (copy_action == GDK_ACTION_COPY && nautilus_is_file_roller_installed () && target_file != NULL && nautilus_file_is_archive (target_file)) { char *command, *quoted_uri, *tmp; const GList *l; GdkDisplay *display; /* Handle dropping onto a file-roller archiver file, instead of starting a move/copy */ nautilus_file_unref (target_file); quoted_uri = g_shell_quote (target_uri); command = g_strconcat ("file-roller -a ", quoted_uri, NULL); g_free (quoted_uri); for (l = item_uris; l != NULL; l = l->next) { quoted_uri = g_shell_quote ((char *) l->data); tmp = g_strconcat (command, " ", quoted_uri, NULL); g_free (command); command = tmp; g_free (quoted_uri); } display = gtk_widget_get_display (GTK_WIDGET (view)); if (display == NULL) { display = gdk_display_get_default (); } nautilus_launch_application_from_command (display, command, FALSE, NULL); g_free (command); return; } nautilus_file_unref (target_file); nautilus_file_operations_copy_move (item_uris, target_uri, copy_action, GTK_WIDGET (view), NULL, copy_move_done_callback, pre_copy_move (view)); } static void nautilus_files_view_trash_state_changed_callback (NautilusTrashMonitor *trash_monitor, gboolean state, gpointer callback_data) { NautilusFilesView *view; view = (NautilusFilesView *) callback_data; g_assert (NAUTILUS_IS_FILES_VIEW (view)); schedule_update_context_menus (view); } static void nautilus_files_view_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NautilusFilesView *view = NAUTILUS_FILES_VIEW (object); NautilusFilesViewPrivate *priv = nautilus_files_view_get_instance_private (view); switch (prop_id) { case PROP_LOADING: { g_value_set_boolean (value, nautilus_view_is_loading (NAUTILUS_VIEW (view))); } break; case PROP_SEARCHING: { g_value_set_boolean (value, nautilus_view_is_searching (NAUTILUS_VIEW (view))); } break; case PROP_LOCATION: { g_value_set_object (value, nautilus_view_get_location (NAUTILUS_VIEW (view))); } break; case PROP_SELECTION: { g_value_set_pointer (value, nautilus_view_get_selection (NAUTILUS_VIEW (view))); } break; case PROP_SEARCH_QUERY: { g_value_set_object (value, priv->search_query); } break; case PROP_EXTENSIONS_BACKGROUND_MENU: { g_value_set_object (value, real_get_extensions_background_menu (NAUTILUS_VIEW (view))); } break; case PROP_TEMPLATES_MENU: { g_value_set_object (value, real_get_templates_menu (NAUTILUS_VIEW (view))); } break; default: { g_assert_not_reached (); } break; } } static void nautilus_files_view_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NautilusFilesView *directory_view; NautilusFilesViewPrivate *priv; NautilusWindowSlot *slot; directory_view = NAUTILUS_FILES_VIEW (object); priv = nautilus_files_view_get_instance_private (directory_view); switch (prop_id) { case PROP_WINDOW_SLOT: { g_assert (priv->slot == NULL); slot = NAUTILUS_WINDOW_SLOT (g_value_get_object (value)); priv->slot = slot; g_signal_connect_object (priv->slot, "notify::active", G_CALLBACK (slot_active_changed), directory_view, 0); } break; case PROP_SUPPORTS_ZOOMING: { priv->supports_zooming = g_value_get_boolean (value); } break; case PROP_LOCATION: { nautilus_view_set_location (NAUTILUS_VIEW (directory_view), g_value_get_object (value)); } break; case PROP_SEARCH_QUERY: { nautilus_view_set_search_query (NAUTILUS_VIEW (directory_view), g_value_get_object (value)); } break; case PROP_SELECTION: { nautilus_view_set_selection (NAUTILUS_VIEW (directory_view), g_value_get_pointer (value)); } break; case PROP_EXTENSIONS_BACKGROUND_MENU: { real_set_extensions_background_menu (NAUTILUS_VIEW (directory_view), g_value_get_object (value)); } break; case PROP_TEMPLATES_MENU: { real_set_templates_menu (NAUTILUS_VIEW (directory_view), g_value_get_object (value)); } break; default: { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } break; } } /* handle Ctrl+Scroll, which will cause a zoom-in/out */ static gboolean on_scroll (GtkEventControllerScroll *scroll, gdouble dx, gdouble dy, gpointer user_data) { NautilusFilesView *directory_view; GdkModifierType state; directory_view = NAUTILUS_FILES_VIEW (user_data); state = gtk_event_controller_get_current_event_state (GTK_EVENT_CONTROLLER (scroll)); if (state & GDK_CONTROL_MASK) { if (dy <= -1) { /* Zoom In */ nautilus_files_view_bump_zoom_level (directory_view, 1); return GDK_EVENT_STOP; } else if (dy >= 1) { /* Zoom Out */ nautilus_files_view_bump_zoom_level (directory_view, -1); return GDK_EVENT_STOP; } } return GDK_EVENT_PROPAGATE; } static void on_scroll_begin (GtkEventControllerScroll *scroll, gpointer user_data) { GdkModifierType state; state = gtk_event_controller_get_current_event_state (GTK_EVENT_CONTROLLER (scroll)); if (state & GDK_CONTROL_MASK) { gtk_event_controller_scroll_set_flags (scroll, GTK_EVENT_CONTROLLER_SCROLL_VERTICAL | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE); } } static void on_scroll_end (GtkEventControllerScroll *scroll, gpointer user_data) { gtk_event_controller_scroll_set_flags (scroll, GTK_EVENT_CONTROLLER_SCROLL_VERTICAL); } static void on_parent_changed (GObject *object, GParamSpec *pspec, gpointer user_data) { GtkWidget *widget; NautilusWindow *window; NautilusFilesView *view; NautilusFilesViewPrivate *priv; GtkWidget *parent; widget = GTK_WIDGET (object); view = NAUTILUS_FILES_VIEW (object); priv = nautilus_files_view_get_instance_private (view); parent = gtk_widget_get_parent (widget); window = nautilus_files_view_get_window (view); if (parent != NULL) { if (priv->slot == nautilus_window_get_active_slot (window)) { priv->active = TRUE; gtk_widget_insert_action_group (GTK_WIDGET (nautilus_files_view_get_window (view)), "view", G_ACTION_GROUP (priv->view_action_group)); } } else { remove_update_context_menus_timeout_callback (view); /* Only remove the action group if this is still the active view. * Otherwise we might be removing an action group set by a different * view i.e. if slot_active_changed() is called before this one. */ if (priv->active) { gtk_widget_insert_action_group (GTK_WIDGET (nautilus_files_view_get_window (view)), "view", NULL); } } } static NautilusQuery * nautilus_files_view_get_search_query (NautilusView *view) { NautilusFilesViewPrivate *priv; priv = nautilus_files_view_get_instance_private (NAUTILUS_FILES_VIEW (view)); return priv->search_query; } static void set_search_query_internal (NautilusFilesView *files_view, NautilusQuery *query, NautilusDirectory *base_model) { GFile *location; NautilusFilesViewPrivate *priv; location = NULL; priv = nautilus_files_view_get_instance_private (files_view); g_set_object (&priv->search_query, query); g_object_notify (G_OBJECT (files_view), "search-query"); if (!nautilus_query_is_empty (query)) { if (nautilus_view_is_searching (NAUTILUS_VIEW (files_view))) { /* * Reuse the search directory and reload it. */ nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (priv->model), query); /* It's important to use load_directory instead of set_location, * since the location is already correct, however we need * to reload the directory with the new query set. But * set_location has a check for wheter the location is a * search directory, so setting the location to a search * directory when is already serching will enter a loop. */ load_directory (files_view, priv->model); } else { NautilusDirectory *directory; gchar *uri; uri = nautilus_search_directory_generate_new_uri (); location = g_file_new_for_uri (uri); directory = nautilus_directory_get (location); g_assert (NAUTILUS_IS_SEARCH_DIRECTORY (directory)); nautilus_search_directory_set_base_model (NAUTILUS_SEARCH_DIRECTORY (directory), base_model); nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory), query); load_directory (files_view, directory); g_object_notify (G_OBJECT (files_view), "searching"); nautilus_directory_unref (directory); g_free (uri); } } else { if (nautilus_view_is_searching (NAUTILUS_VIEW (files_view))) { location = nautilus_directory_get_location (base_model); nautilus_view_set_location (NAUTILUS_VIEW (files_view), location); } } g_clear_object (&location); } static void nautilus_files_view_set_search_query (NautilusView *view, NautilusQuery *query) { NautilusDirectory *base_model; NautilusFilesView *files_view; NautilusFilesViewPrivate *priv; files_view = NAUTILUS_FILES_VIEW (view); priv = nautilus_files_view_get_instance_private (files_view); if (nautilus_view_is_searching (view)) { base_model = nautilus_search_directory_get_base_model (NAUTILUS_SEARCH_DIRECTORY (priv->model)); } else { base_model = priv->model; } set_search_query_internal (NAUTILUS_FILES_VIEW (view), query, base_model); } static GFile * nautilus_files_view_get_location (NautilusView *view) { NautilusFilesViewPrivate *priv; NautilusFilesView *files_view; files_view = NAUTILUS_FILES_VIEW (view); priv = nautilus_files_view_get_instance_private (files_view); return priv->location; } static gboolean nautilus_files_view_is_loading (NautilusView *view) { NautilusFilesViewPrivate *priv; NautilusFilesView *files_view; files_view = NAUTILUS_FILES_VIEW (view); priv = nautilus_files_view_get_instance_private (files_view); return priv->loading; } static void nautilus_files_view_iface_init (NautilusViewInterface *iface) { iface->get_location = nautilus_files_view_get_location; iface->set_location = nautilus_files_view_set_location; iface->get_selection = nautilus_files_view_get_selection; iface->set_selection = nautilus_files_view_set_selection; iface->get_search_query = nautilus_files_view_get_search_query; iface->set_search_query = nautilus_files_view_set_search_query; iface->get_toolbar_menu_sections = nautilus_files_view_get_toolbar_menu_sections; iface->is_searching = nautilus_files_view_is_searching; iface->is_loading = nautilus_files_view_is_loading; iface->get_view_id = nautilus_files_view_get_view_id; iface->get_templates_menu = nautilus_files_view_get_templates_menu; iface->set_templates_menu = nautilus_files_view_set_templates_menu; iface->get_extensions_background_menu = nautilus_files_view_get_extensions_background_menu; iface->set_extensions_background_menu = nautilus_files_view_set_extensions_background_menu; } static void nautilus_files_view_class_init (NautilusFilesViewClass *klass) { GObjectClass *oclass; GtkWidgetClass *widget_class; widget_class = GTK_WIDGET_CLASS (klass); oclass = G_OBJECT_CLASS (klass); oclass->dispose = nautilus_files_view_dispose; oclass->finalize = nautilus_files_view_finalize; oclass->get_property = nautilus_files_view_get_property; oclass->set_property = nautilus_files_view_set_property; widget_class->focus = nautilus_files_view_focus; widget_class->grab_focus = nautilus_files_view_grab_focus; signals[ADD_FILES] = g_signal_new ("add-files", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, add_files), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 1, G_TYPE_POINTER); signals[BEGIN_FILE_CHANGES] = g_signal_new ("begin-file-changes", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, begin_file_changes), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[BEGIN_LOADING] = g_signal_new ("begin-loading", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, begin_loading), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[CLEAR] = g_signal_new ("clear", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, clear), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[END_FILE_CHANGES] = g_signal_new ("end-file-changes", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, end_file_changes), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); signals[END_LOADING] = g_signal_new ("end-loading", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, end_loading), NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN, G_TYPE_NONE, 1, G_TYPE_BOOLEAN); signals[FILE_CHANGED] = g_signal_new ("file-changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, file_changed), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2, NAUTILUS_TYPE_FILE, NAUTILUS_TYPE_DIRECTORY); signals[REMOVE_FILE] = g_signal_new ("remove-file", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (NautilusFilesViewClass, remove_file), NULL, NULL, g_cclosure_marshal_generic, G_TYPE_NONE, 2, NAUTILUS_TYPE_FILE, NAUTILUS_TYPE_DIRECTORY); signals[SELECTION_CHANGED] = g_signal_new ("selection-changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); klass->get_backing_uri = real_get_backing_uri; klass->get_window = nautilus_files_view_get_window; klass->update_context_menus = real_update_context_menus; klass->update_actions_state = real_update_actions_state; klass->check_empty_states = real_check_empty_states; g_object_class_install_property ( oclass, PROP_WINDOW_SLOT, g_param_spec_object ("window-slot", "Window Slot", "The parent window slot reference", NAUTILUS_TYPE_WINDOW_SLOT, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)); g_object_class_install_property ( oclass, PROP_SUPPORTS_ZOOMING, g_param_spec_boolean ("supports-zooming", "Supports zooming", "Whether the view supports zooming", TRUE, G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); g_object_class_override_property (oclass, PROP_LOADING, "loading"); g_object_class_override_property (oclass, PROP_SEARCHING, "searching"); g_object_class_override_property (oclass, PROP_LOCATION, "location"); g_object_class_override_property (oclass, PROP_SELECTION, "selection"); g_object_class_override_property (oclass, PROP_SEARCH_QUERY, "search-query"); g_object_class_override_property (oclass, PROP_EXTENSIONS_BACKGROUND_MENU, "extensions-background-menu"); g_object_class_override_property (oclass, PROP_TEMPLATES_MENU, "templates-menu"); gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/nautilus/ui/nautilus-files-view.ui"); gtk_widget_class_bind_template_child_private (widget_class, NautilusFilesView, overlay); gtk_widget_class_bind_template_child_private (widget_class, NautilusFilesView, stack); gtk_widget_class_bind_template_child_private (widget_class, NautilusFilesView, empty_view_page); gtk_widget_class_bind_template_child_private (widget_class, NautilusFilesView, scrolled_window); gtk_widget_class_bind_template_child_private (widget_class, NautilusFilesView, floating_bar); /* See also the global accelerators in init() in addition to all the local * ones defined below. */ /* Only one delete action is enabled at a time, so we can just activate several * delete or trash actions with the same shortcut without worrying: only the * enabled one will be activated. */ gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Delete, GDK_SHIFT_MASK, "view.delete-permanently-shortcut", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Delete, GDK_SHIFT_MASK, "view.delete-permanently-shortcut", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Delete, GDK_SHIFT_MASK, "view.permanent-delete-permanently-menu-item", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Delete, GDK_SHIFT_MASK, "view.permanent-delete-permanently-menu-item", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Delete, 0, "view.move-to-trash", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Delete, 0, "view.move-to-trash", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Delete, 0, "view.delete-from-trash", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Delete, 0, "view.delete-from-trash", NULL); /* When trash is not available, allow the "Delete" keys to delete permanently, that is, when * the menu item is available, since we never make both the trash and delete-permanently-menu-item * actions active. */ gtk_widget_class_add_binding_action (widget_class, GDK_KEY_KP_Delete, 0, "view.delete-permanently-menu-item", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Delete, 0, "view.delete-permanently-menu-item", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_F2, 0, "view.rename", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Menu, 0, "view.popup-menu", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_F10, GDK_SHIFT_MASK, "view.popup-menu", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_o, GDK_CONTROL_MASK, "view.open-with-default-application", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Down, GDK_ALT_MASK, "view.open-with-default-application", NULL); /* This is not necessary per-se, because it's the default activation * keybinding. But in order for it to appear in the context menu as a * keyboard shortcut, we need to bind it to the menu item action here. */ gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Return, 0, "view.open-with-default-application", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_i, GDK_CONTROL_MASK, "view.properties", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Return, GDK_ALT_MASK, "view.properties", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_a, GDK_CONTROL_MASK, "view.select-all", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_i, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "view.invert-selection", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_m, GDK_CONTROL_MASK, "view.create-link", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_m, GDK_CONTROL_MASK, "view.create-link-shortcut", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_m, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "view.create-link-in-place", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_m, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "view.create-link-in-place-shortcut", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Return, GDK_CONTROL_MASK, "view.open-item-new-tab", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_Return, GDK_SHIFT_MASK, "view.open-item-new-window", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_o, GDK_CONTROL_MASK | GDK_ALT_MASK, "view.open-item-location", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_c, GDK_CONTROL_MASK, "view.copy", NULL); gtk_widget_class_add_binding_action (widget_class, GDK_KEY_x, GDK_CONTROL_MASK, "view.cut", NULL); } static void nautilus_files_view_init (NautilusFilesView *view) { NautilusFilesViewPrivate *priv; GtkBuilder *builder; NautilusDirectory *scripts_directory; NautilusDirectory *templates_directory; GtkEventController *controller; GtkShortcut *shortcut; gchar *templates_uri; GdkClipboard *clipboard; GApplication *app; const gchar *zoom_in_accels[] = { "equal", "plus", "KP_Add", "ZoomIn", NULL }; const gchar *zoom_out_accels[] = { "minus", "KP_Subtract", "ZoomOut", NULL }; const gchar *zoom_standard_accels[] = { "0", "KP_0", NULL }; nautilus_profile_start (NULL); priv = nautilus_files_view_get_instance_private (view); /* Toolbar menu */ builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/ui/nautilus-toolbar-view-menu.ui"); priv->toolbar_menu_sections = g_new0 (NautilusToolbarMenuSections, 1); priv->toolbar_menu_sections->sort_section = G_MENU_MODEL (g_object_ref (gtk_builder_get_object (builder, "sort_section"))); g_signal_connect (view, "end-file-changes", G_CALLBACK (on_end_file_changes), view); g_signal_connect (view, "notify::selection", G_CALLBACK (nautilus_files_view_preview_update), view); g_signal_connect (view, "notify::parent", G_CALLBACK (on_parent_changed), NULL); g_object_unref (builder); g_type_ensure (NAUTILUS_TYPE_FLOATING_BAR); gtk_widget_init_template (GTK_WIDGET (view)); controller = gtk_event_controller_scroll_new (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL); gtk_widget_add_controller (priv->scrolled_window, controller); gtk_event_controller_set_propagation_phase (controller, GTK_PHASE_CAPTURE); g_signal_connect (controller, "scroll", G_CALLBACK (on_scroll), view); g_signal_connect (controller, "scroll-begin", G_CALLBACK (on_scroll_begin), view); g_signal_connect (controller, "scroll-end", G_CALLBACK (on_scroll_end), view); g_signal_connect (priv->floating_bar, "stop", G_CALLBACK (floating_bar_stop_cb), view); priv->non_ready_files = g_hash_table_new_full (file_and_directory_hash, file_and_directory_equal, file_and_directory_free, NULL); priv->pending_reveal = g_hash_table_new (NULL, NULL); if (set_up_scripts_directory_global ()) { scripts_directory = nautilus_directory_get_by_uri (scripts_directory_uri); add_directory_to_scripts_directory_list (view, scripts_directory); nautilus_directory_unref (scripts_directory); } else { g_warning ("Ignoring scripts directory, it may be a broken link\n"); } if (nautilus_should_use_templates_directory ()) { templates_uri = nautilus_get_templates_directory_uri (); templates_directory = nautilus_directory_get_by_uri (templates_uri); g_free (templates_uri); add_directory_to_templates_directory_list (view, templates_directory); nautilus_directory_unref (templates_directory); } update_templates_directory (view); priv->sort_directories_first = g_settings_get_boolean (gtk_filechooser_preferences, NAUTILUS_PREFERENCES_SORT_DIRECTORIES_FIRST); priv->show_hidden_files = g_settings_get_boolean (gtk_filechooser_preferences, NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES); g_signal_connect_object (nautilus_trash_monitor_get (), "trash-state-changed", G_CALLBACK (nautilus_files_view_trash_state_changed_callback), view, 0); /* React to clipboard changes */ clipboard = gdk_display_get_clipboard (gdk_display_get_default ()); g_signal_connect (clipboard, "changed", G_CALLBACK (on_clipboard_owner_changed), view); /* Register to menu provider extension signal managing menu updates */ g_signal_connect_object (nautilus_signaller_get_current (), "popup-menu-changed", G_CALLBACK (schedule_update_context_menus), view, G_CONNECT_SWAPPED); gtk_widget_show (GTK_WIDGET (view)); g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_CLICK_POLICY, G_CALLBACK (click_policy_changed_callback), view); g_signal_connect_swapped (gtk_filechooser_preferences, "changed::" NAUTILUS_PREFERENCES_SORT_DIRECTORIES_FIRST, G_CALLBACK (sort_directories_first_changed_callback), view); g_signal_connect_swapped (gtk_filechooser_preferences, "changed::" NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES, G_CALLBACK (show_hidden_files_changed_callback), view); g_signal_connect_swapped (gnome_lockdown_preferences, "changed::" NAUTILUS_PREFERENCES_LOCKDOWN_COMMAND_LINE, G_CALLBACK (schedule_update_context_menus), view); priv->in_destruction = FALSE; priv->view_action_group = G_ACTION_GROUP (g_simple_action_group_new ()); g_action_map_add_action_entries (G_ACTION_MAP (priv->view_action_group), view_entries, G_N_ELEMENTS (view_entries), view); gtk_widget_insert_action_group (GTK_WIDGET (view), "view", G_ACTION_GROUP (priv->view_action_group)); app = g_application_get_default (); /* NOTE: Please do not add any key here that could interfere with * the rest of the app's use of those keys. Some example of keys set here * that broke keynav include Enter/Return, Menu, F2 and Delete keys. * The accelerators below are set on the whole app level for the sole purpose * of making it more convenient when you don't have the focus exactly on the * files view, but some keys are used in a contextual way, and those should * should be added in nautilus_files_view_class_init() above instead of a * global accelerator, unless it really makes sense to have them globally * (e.g. Zoom in/out shortcuts). */ nautilus_application_set_accelerators (app, "view.zoom-in", zoom_in_accels); nautilus_application_set_accelerators (app, "view.zoom-out", zoom_out_accels); nautilus_application_set_accelerator (app, "view.show-hidden-files", "h"); /* Despite putting copy/cut at the widget scope instead of the global one, * we're putting paste globally so that it's easy to switch between apps * with e.g. Alt+Tab and paste directly the copied file without having to * make sure the focus is on the files view. */ nautilus_application_set_accelerator (app, "view.paste_accel", "v"); nautilus_application_set_accelerator (app, "view.new-folder", "n"); nautilus_application_set_accelerator (app, "view.select-pattern", "s"); nautilus_application_set_accelerators (app, "view.zoom-standard", zoom_standard_accels); /* This one should have been a keybinding, because it should trigger only * when the view is focused. Unfortunately, children can override bindings, * and such is the case of GtkListItemWidget which binds the spacebar to its * `|listitem.select` action. * * So, we make it a local shortcut (like keybindings are), but using the * capture phase instead, to trigger it first (keybindings use bubble phase). */ shortcut = gtk_shortcut_new (gtk_keyval_trigger_new (GDK_KEY_space, 0), gtk_named_action_new ("view.preview-selection")); controller = gtk_shortcut_controller_new (); gtk_widget_add_controller (GTK_WIDGET (view), controller); /* By default, :scope is GTK_SHORTCUT_SCOPE_LOCAL, so no need to set it. */ gtk_event_controller_set_propagation_phase (controller, GTK_PHASE_CAPTURE); gtk_shortcut_controller_add_shortcut (GTK_SHORTCUT_CONTROLLER (controller), shortcut); priv->starred_cancellable = g_cancellable_new (); priv->rename_file_controller = nautilus_rename_file_popover_controller_new (GTK_WIDGET (view)); nautilus_profile_end (NULL); } NautilusFilesView * nautilus_files_view_new (guint id, NautilusWindowSlot *slot) { NautilusFilesView *view = NULL; switch (id) { case NAUTILUS_VIEW_GRID_ID: { view = NAUTILUS_FILES_VIEW (nautilus_grid_view_new (slot)); } break; case NAUTILUS_VIEW_LIST_ID: { view = NAUTILUS_FILES_VIEW (nautilus_list_view_new (slot)); } break; default: { g_critical ("Unknown view type ID: %d. Falling back to list.", id); view = NAUTILUS_FILES_VIEW (nautilus_list_view_new (slot)); } } if (view == NULL) { g_assert_not_reached (); } else if (g_object_is_floating (view)) { g_object_ref_sink (view); } return view; }