diff options
Diffstat (limited to '')
| -rw-r--r-- | src/nautilus-window.c | 3100 |
1 files changed, 3100 insertions, 0 deletions
diff --git a/src/nautilus-window.c b/src/nautilus-window.c new file mode 100644 index 0000000..c81d150 --- /dev/null +++ b/src/nautilus-window.c @@ -0,0 +1,3100 @@ +/* + * Nautilus + * + * Copyright (C) 1999, 2000, 2004 Red Hat, Inc. + * Copyright (C) 1999, 2000, 2001 Eazel, Inc. + * + * Nautilus 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. + * + * Nautilus 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 <http://www.gnu.org/licenses/>. + * + * Authors: Elliot Lee <sopwith@redhat.com> + * John Sullivan <sullivan@eazel.com> + * Alexander Larsson <alexl@redhat.com> + */ + +/* nautilus-window.c: Implementation of the main window object */ + +#include "nautilus-window.h" + +#include <eel/eel-debug.h> +#include <eel/eel-gtk-extensions.h> +#include <eel/eel-vfs-extensions.h> +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <gdk/gdkkeysyms.h> +#include <glib/gi18n.h> +#include <gtk/gtk.h> +#include <math.h> +#include <sys/time.h> + +#ifdef GDK_WINDOWING_WAYLAND +#include <gdk/gdkwayland.h> +#endif + +#ifdef GDK_WINDOWING_X11 +#include <gdk/gdkx.h> +#endif + +#define DEBUG_FLAG NAUTILUS_DEBUG_WINDOW +#include "nautilus-debug.h" + +#include "nautilus-application.h" +#include "nautilus-bookmark-list.h" +#include "nautilus-clipboard.h" +#include "nautilus-dnd.h" +#include "nautilus-enums.h" +#include "nautilus-file-operations.h" +#include "nautilus-file-undo-manager.h" +#include "nautilus-file-utilities.h" +#include "nautilus-global-preferences.h" +#include "nautilus-list-view.h" +#include "nautilus-location-entry.h" +#include "nautilus-metadata.h" +#include "nautilus-mime-actions.h" +#include "nautilus-notebook.h" +#include "nautilus-other-locations-window-slot.h" +#include "nautilus-pathbar.h" +#include "nautilus-profile.h" +#include "nautilus-properties-window.h" +#include "nautilus-signaller.h" +#include "nautilus-toolbar.h" +#include "nautilus-trash-monitor.h" +#include "nautilus-ui-utilities.h" +#include "nautilus-window-slot.h" + +/* Forward and back buttons on the mouse */ +static gboolean mouse_extra_buttons = TRUE; +static int mouse_forward_button = 9; +static int mouse_back_button = 8; + +static void mouse_back_button_changed (gpointer callback_data); +static void mouse_forward_button_changed (gpointer callback_data); +static void use_extra_mouse_buttons_changed (gpointer callback_data); +static void nautilus_window_initialize_actions (NautilusWindow *window); +static GtkWidget *nautilus_window_ensure_location_entry (NautilusWindow *window); +static void close_slot (NautilusWindow *window, + NautilusWindowSlot *slot, + gboolean remove_from_notebook); + +/* Sanity check: highest mouse button value I could find was 14. 5 is our + * lower threshold (well-documented to be the one of the button events for the + * scrollwheel), so it's hardcoded in the functions below. However, if you have + * a button that registers higher and want to map it, file a bug and + * we'll move the bar. Makes you wonder why the X guys don't have + * defined values for these like the XKB stuff, huh? + */ +#define UPPER_MOUSE_LIMIT 14 + +#define NOTIFICATION_TIMEOUT 6 /*s */ + +struct _NautilusWindow +{ + GtkApplicationWindow parent_instance; + + GtkWidget *notebook; + + /* available slots, and active slot. + * Both of them may never be NULL. + */ + GList *slots; + NautilusWindowSlot *active_slot; + + GtkWidget *content_paned; + + /* Side Pane */ + int side_pane_width; + GtkWidget *sidebar; /* container for the GtkPlacesSidebar */ + GtkWidget *places_sidebar; /* the actual GtkPlacesSidebar */ + GVolume *selected_volume; /* the selected volume in the sidebar popup callback */ + GFile *selected_file; /* the selected file in the sidebar popup callback */ + + /* Main view */ + GtkWidget *main_view; + + /* Notifications */ + GtkWidget *in_app_notification_undo; + GtkWidget *in_app_notification_undo_label; + GtkWidget *in_app_notification_undo_close_button; + GtkWidget *in_app_notification_undo_undo_button; + guint in_app_notification_undo_timeout_id; + GtkWidget *notification_operation; + GtkWidget *notification_operation_label; + GtkWidget *notification_operation_close; + GtkWidget *notification_operation_open; + guint notification_operation_timeout_id; + GFile *folder_to_open; + + /* Toolbar */ + GtkWidget *toolbar; + gboolean temporary_navigation_bar; + + /* focus widget before the location bar has been shown temporarily */ + GtkWidget *last_focus_widget; + + /* Handle when exported */ + gchar *export_handle; + + guint sidebar_width_handler_id; + gulong bookmarks_id; + + GQueue *tab_data_queue; + + GtkPadController *pad_controller; + + GtkGesture *multi_press_gesture; + GtkGesture *notebook_multi_press_gesture; +}; + +enum +{ + SLOT_ADDED, + SLOT_REMOVED, + ACTIVE_SELECTION_CHANGED, + LAST_SIGNAL +}; + +static guint signals[LAST_SIGNAL] = { 0 }; + +G_DEFINE_TYPE (NautilusWindow, nautilus_window, GTK_TYPE_APPLICATION_WINDOW); + +static const struct +{ + unsigned int keyval; + const char *action; +} extra_window_keybindings [] = +{ + /* Window actions */ + { GDK_KEY_AddFavorite, "bookmark-current-location" }, + { GDK_KEY_Favorites, "bookmarks" }, + { GDK_KEY_Go, "enter-location" }, + { GDK_KEY_HomePage, "go-home" }, + { GDK_KEY_OpenURL, "enter-location" }, + { GDK_KEY_Refresh, "reload" }, + { GDK_KEY_Reload, "reload" }, + { GDK_KEY_Search, "search" }, + { GDK_KEY_Start, "go-home" }, + { GDK_KEY_Stop, "stop" }, + { GDK_KEY_Back, "back" }, + { GDK_KEY_Forward, "forward" }, +}; + +static const GtkPadActionEntry pad_actions[] = +{ + { GTK_PAD_ACTION_BUTTON, 0, -1, N_("Parent folder"), "up" }, + { GTK_PAD_ACTION_BUTTON, 1, -1, N_("Home"), "go-home" }, + { GTK_PAD_ACTION_BUTTON, 2, -1, N_("New tab"), "new-tab" }, + { GTK_PAD_ACTION_BUTTON, 3, -1, N_("Close current view"), "close-current-view" }, + { GTK_PAD_ACTION_BUTTON, 4, -1, N_("Back"), "back" }, + { GTK_PAD_ACTION_BUTTON, 5, -1, N_("Forward"), "forward" }, +}; + +static void +action_close_current_view (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window; + NautilusWindowSlot *slot; + + window = NAUTILUS_WINDOW (user_data); + slot = nautilus_window_get_active_slot (window); + + nautilus_window_slot_close (window, slot); +} + +static void +action_go_home (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window; + GFile *home; + + window = NAUTILUS_WINDOW (user_data); + home = g_file_new_for_path (g_get_home_dir ()); + + nautilus_window_open_location_full (window, home, nautilus_event_get_window_open_flags (), NULL, NULL); + + g_object_unref (home); +} + +static void +action_reload (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindowSlot *slot; + + slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (user_data)); + nautilus_window_slot_queue_reload (slot); +} + +static void +action_stop (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window; + NautilusWindowSlot *slot; + + window = NAUTILUS_WINDOW (user_data); + slot = nautilus_window_get_active_slot (window); + + nautilus_window_slot_stop_loading (slot); +} + +static void +action_up (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindowSlot *slot; + GFile *parent, *location; + + slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (user_data)); + location = nautilus_window_slot_get_location (slot); + + if (location != NULL) + { + parent = g_file_get_parent (location); + if (parent != NULL) + { + nautilus_window_open_location_full (NAUTILUS_WINDOW (user_data), + parent, + nautilus_event_get_window_open_flags (), + NULL, NULL); + } + + g_clear_object (&parent); + } +} + +static void +action_back (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + nautilus_window_back_or_forward (NAUTILUS_WINDOW (user_data), + TRUE, 0, nautilus_event_get_window_open_flags ()); +} + +static void +action_forward (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + nautilus_window_back_or_forward (NAUTILUS_WINDOW (user_data), + FALSE, 0, nautilus_event_get_window_open_flags ()); +} + +static void +action_bookmark_current_location (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + NautilusApplication *app = NAUTILUS_APPLICATION (g_application_get_default ()); + NautilusWindowSlot *slot; + + slot = nautilus_window_get_active_slot (window); + nautilus_bookmark_list_append (nautilus_application_get_bookmarks (app), + nautilus_window_slot_get_bookmark (slot)); +} + +static void +action_new_tab (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + nautilus_window_new_tab (NAUTILUS_WINDOW (user_data)); +} + +static void +action_enter_location (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_window_ensure_location_entry (window); +} + +static void +action_tab_previous (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_notebook_prev_page (NAUTILUS_NOTEBOOK (window->notebook)); +} + +static void +action_tab_next (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_notebook_next_page (NAUTILUS_NOTEBOOK (window->notebook)); +} + +static void +action_tab_move_left (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_notebook_reorder_current_child_relative (NAUTILUS_NOTEBOOK (window->notebook), -1); +} + +static void +action_tab_move_right (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_notebook_reorder_current_child_relative (NAUTILUS_NOTEBOOK (window->notebook), 1); +} + +static void +action_go_to_tab (GSimpleAction *action, + GVariant *value, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + GtkNotebook *notebook; + gint16 num; + + notebook = GTK_NOTEBOOK (window->notebook); + + num = g_variant_get_int32 (value); + if (num < gtk_notebook_get_n_pages (notebook)) + { + gtk_notebook_set_current_page (notebook, num); + } +} + +static void +action_prompt_for_location_root (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + GFile *location; + GtkWidget *entry; + + location = g_file_new_for_path ("/"); + entry = nautilus_window_ensure_location_entry (window); + nautilus_location_entry_set_location (NAUTILUS_LOCATION_ENTRY (entry), location); + + g_object_unref (location); +} + +static void +action_prompt_for_location_home (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + GtkWidget *entry; + + entry = nautilus_window_ensure_location_entry (NAUTILUS_WINDOW (user_data)); + nautilus_location_entry_set_special_text (NAUTILUS_LOCATION_ENTRY (entry), + "~"); + gtk_editable_set_position (GTK_EDITABLE (entry), -1); +} + +static void +action_redo (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_file_undo_manager_redo (GTK_WINDOW (window), NULL); +} + +static void +action_undo (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_file_undo_manager_undo (GTK_WINDOW (window), NULL); +} + +static void +action_toggle_state_view_button (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + GVariant *current_state; + + current_state = g_action_get_state (G_ACTION (action)); + g_action_change_state (G_ACTION (action), + g_variant_new_boolean (!g_variant_get_boolean (current_state))); + g_variant_unref (current_state); +} + +static void +on_location_changed (NautilusWindow *window) +{ + gtk_places_sidebar_set_location (GTK_PLACES_SIDEBAR (window->places_sidebar), + nautilus_window_slot_get_location (nautilus_window_get_active_slot (window))); +} + +static void +on_slot_location_changed (NautilusWindowSlot *slot, + GParamSpec *pspec, + NautilusWindow *window) +{ + if (nautilus_window_get_active_slot (window) == slot) + { + on_location_changed (window); + } +} + + +static void +on_slot_selection_changed (NautilusWindowSlot *slot, + GParamSpec *pspec, + NautilusWindow *window) +{ + if (nautilus_window_get_active_slot (window) == slot) + { + g_signal_emit (window, signals[ACTIVE_SELECTION_CHANGED], 0); + } +} + +static void +notebook_switch_page_cb (GtkNotebook *notebook, + GtkWidget *page, + unsigned int page_num, + NautilusWindow *window) +{ + NautilusWindowSlot *slot; + GtkWidget *widget; + + widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (window->notebook), page_num); + g_assert (widget != NULL); + + /* find slot corresponding to the target page */ + slot = NAUTILUS_WINDOW_SLOT (widget); + g_assert (slot != NULL); + + nautilus_window_set_active_slot (nautilus_window_slot_get_window (slot), + slot); +} + +static void +connect_slot (NautilusWindow *window, + NautilusWindowSlot *slot) +{ + g_signal_connect (slot, "notify::location", + G_CALLBACK (on_slot_location_changed), window); + g_signal_connect (slot, "notify::selection", + G_CALLBACK (on_slot_selection_changed), window); +} + +static void +disconnect_slot (NautilusWindow *window, + NautilusWindowSlot *slot) +{ + g_signal_handlers_disconnect_by_data (slot, window); +} + +static NautilusWindowSlot * +nautilus_window_create_slot (NautilusWindow *window, + GFile *location) +{ + NautilusFile *file = NULL; + NautilusWindowSlot *slot; + + if (location) + { + file = nautilus_file_get (location); + } + /* If not file, assume we open the home directory. We will switch eventually + * to a different location if not. + */ + if (file && nautilus_file_is_other_locations (file)) + { + slot = NAUTILUS_WINDOW_SLOT (nautilus_other_locations_window_slot_new (window)); + } + else + { + slot = nautilus_window_slot_new (window); + } + + nautilus_file_unref (file); + + return slot; +} + +static NautilusWindowSlot * +nautilus_window_create_and_init_slot (NautilusWindow *window, + GFile *location, + NautilusWindowOpenFlags flags) +{ + NautilusWindowSlot *slot; + + slot = nautilus_window_create_slot (window, location); + nautilus_window_initialize_slot (window, slot, flags); + + return slot; +} + +static NautilusWindowSlot * +replace_active_slot (NautilusWindow *window, + GFile *location, + NautilusWindowOpenFlags flags) +{ + NautilusWindowSlot *new_slot; + NautilusWindowSlot *active_slot; + + new_slot = nautilus_window_create_and_init_slot (window, location, flags); + active_slot = nautilus_window_get_active_slot (window); + if (active_slot) + { + close_slot (window, active_slot, TRUE); + } + + return new_slot; +} + +void +nautilus_window_initialize_slot (NautilusWindow *window, + NautilusWindowSlot *slot, + NautilusWindowOpenFlags flags) +{ + g_assert (NAUTILUS_IS_WINDOW (window)); + g_assert (NAUTILUS_IS_WINDOW_SLOT (slot)); + + connect_slot (window, slot); + + g_signal_handlers_block_by_func (window->notebook, + G_CALLBACK (notebook_switch_page_cb), + window); + nautilus_notebook_add_tab (NAUTILUS_NOTEBOOK (window->notebook), + slot, + (flags & NAUTILUS_WINDOW_OPEN_SLOT_APPEND) != 0 ? + -1 : + gtk_notebook_get_current_page (GTK_NOTEBOOK (window->notebook)) + 1, + FALSE); + g_signal_handlers_unblock_by_func (window->notebook, + G_CALLBACK (notebook_switch_page_cb), + window); + + window->slots = g_list_append (window->slots, slot); + g_signal_emit (window, signals[SLOT_ADDED], 0, slot); +} + +void +nautilus_window_open_location_full (NautilusWindow *window, + GFile *location, + NautilusWindowOpenFlags flags, + GList *selection, + NautilusWindowSlot *target_slot) +{ + NautilusWindowSlot *active_slot; + gboolean new_tab_at_end; + NautilusNavigationState *navigation_state = NULL; + + /* The location owner can be one of the slots requesting to handle an + * unhandled location. But this slot can be destroyed when switching to + * a new slot. So keep the location alive. + */ + g_object_ref (location); + + /* Assert that we are not managing new windows */ + g_assert (!(flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW)); + /* if the flags say we want a new tab, open a slot in the current window */ + if ((flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB) != 0) + { + new_tab_at_end = g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_NEW_TAB_POSITION) == NAUTILUS_NEW_TAB_POSITION_END; + if (new_tab_at_end) + { + flags |= NAUTILUS_WINDOW_OPEN_SLOT_APPEND; + } + } + + active_slot = nautilus_window_get_active_slot (window); + if (!target_slot) + { + target_slot = active_slot; + } + + if (target_slot == NULL || (flags & NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB) != 0) + { + target_slot = nautilus_window_create_and_init_slot (window, location, flags); + } + else if (!nautilus_window_slot_handles_location (target_slot, location)) + { + navigation_state = nautilus_window_slot_get_navigation_state (active_slot); + + target_slot = replace_active_slot (window, location, flags); + } + + /* Make the opened location the one active if we weren't ask for the + * oposite, since it's the most usual use case */ + if (!(flags & NAUTILUS_WINDOW_OPEN_FLAG_DONT_MAKE_ACTIVE)) + { + gtk_window_present (GTK_WINDOW (window)); + nautilus_window_set_active_slot (window, target_slot); + } + + if (navigation_state != NULL) + { + nautilus_window_slot_open_location_set_navigation_state (target_slot, + location, flags, selection, + NAUTILUS_LOCATION_CHANGE_STANDARD, + navigation_state, 0); + + free_navigation_state (navigation_state); + } + else + { + nautilus_window_slot_open_location_full (target_slot, location, flags, selection); + } + + g_object_unref (location); +} + +static void +unset_focus_widget (NautilusWindow *window) +{ + if (window->last_focus_widget != NULL) + { + g_object_remove_weak_pointer (G_OBJECT (window->last_focus_widget), + (gpointer *) &window->last_focus_widget); + window->last_focus_widget = NULL; + } +} + +static void +remember_focus_widget (NautilusWindow *window) +{ + GtkWidget *focus_widget; + + focus_widget = gtk_window_get_focus (GTK_WINDOW (window)); + if (focus_widget != NULL) + { + unset_focus_widget (window); + + window->last_focus_widget = focus_widget; + g_object_add_weak_pointer (G_OBJECT (focus_widget), + (gpointer *) &(window->last_focus_widget)); + } +} + +static void +nautilus_window_grab_focus (GtkWidget *widget) +{ + NautilusWindowSlot *slot; + + slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (widget)); + + GTK_WIDGET_CLASS (nautilus_window_parent_class)->grab_focus (widget); + + if (slot) + { + gtk_widget_grab_focus (GTK_WIDGET (slot)); + } +} + +static void +restore_focus_widget (NautilusWindow *window) +{ + if (window->last_focus_widget != NULL) + { + gtk_widget_grab_focus (window->last_focus_widget); + unset_focus_widget (window); + } +} + +static void +location_entry_cancel_callback (GtkWidget *widget, + NautilusWindow *window) +{ + nautilus_toolbar_set_show_location_entry (NAUTILUS_TOOLBAR (window->toolbar), FALSE); + + restore_focus_widget (window); +} + +static void +location_entry_location_changed_callback (GtkWidget *widget, + GFile *location, + NautilusWindow *window) +{ + nautilus_toolbar_set_show_location_entry (NAUTILUS_TOOLBAR (window->toolbar), FALSE); + + restore_focus_widget (window); + + nautilus_window_open_location_full (window, location, 0, NULL, NULL); +} + +static void +close_slot (NautilusWindow *window, + NautilusWindowSlot *slot, + gboolean remove_from_notebook) +{ + int page_num; + GtkNotebook *notebook; + + g_assert (NAUTILUS_IS_WINDOW_SLOT (slot)); + + + DEBUG ("Closing slot %p", slot); + + disconnect_slot (window, slot); + + window->slots = g_list_remove (window->slots, slot); + + g_signal_emit (window, signals[SLOT_REMOVED], 0, slot); + + notebook = GTK_NOTEBOOK (window->notebook); + + if (remove_from_notebook) + { + page_num = gtk_notebook_page_num (notebook, GTK_WIDGET (slot)); + g_assert (page_num >= 0); + + /* this will call gtk_widget_destroy on the slot */ + gtk_notebook_remove_page (notebook, page_num); + } +} + +void +nautilus_window_new_tab (NautilusWindow *window) +{ + NautilusWindowSlot *current_slot; + GFile *location; + g_autofree gchar *uri = NULL; + + current_slot = nautilus_window_get_active_slot (window); + location = nautilus_window_slot_get_location (current_slot); + + if (location != NULL) + { + uri = g_file_get_uri (location); + if (eel_uri_is_search (uri)) + { + location = g_file_new_for_path (g_get_home_dir ()); + } + else + { + g_object_ref (location); + } + + nautilus_window_open_location_full (window, location, + NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB, + NULL, NULL); + g_object_unref (location); + } +} + +static void +update_cursor (NautilusWindow *window) +{ + NautilusWindowSlot *slot; + + slot = nautilus_window_get_active_slot (window); + + if (slot != NULL && + nautilus_window_slot_get_allow_stop (slot)) + { + GdkDisplay *display; + g_autoptr (GdkCursor) cursor = NULL; + + display = gtk_widget_get_display (GTK_WIDGET (window)); + cursor = gdk_cursor_new_from_name (display, "progress"); + gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), cursor); + } + else + { + gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), NULL); + } +} + +void +nautilus_window_reset_menus (NautilusWindow *window) +{ + nautilus_window_sync_allow_stop (window, nautilus_window_get_active_slot (window)); +} + +void +nautilus_window_sync_allow_stop (NautilusWindow *window, + NautilusWindowSlot *slot) +{ + GAction *stop_action; + GAction *reload_action; + gboolean allow_stop, slot_is_active, slot_allow_stop; + + stop_action = g_action_map_lookup_action (G_ACTION_MAP (window), + "stop"); + reload_action = g_action_map_lookup_action (G_ACTION_MAP (window), + "reload"); + allow_stop = g_action_get_enabled (stop_action); + + slot_allow_stop = nautilus_window_slot_get_allow_stop (slot); + slot_is_active = (slot == nautilus_window_get_active_slot (window)); + + + if (!slot_is_active || + allow_stop != slot_allow_stop) + { + if (slot_is_active) + { + g_simple_action_set_enabled (G_SIMPLE_ACTION (stop_action), slot_allow_stop); + g_simple_action_set_enabled (G_SIMPLE_ACTION (reload_action), !slot_allow_stop); + } + if (gtk_widget_get_realized (GTK_WIDGET (window))) + { + update_cursor (window); + } + + /* Avoid updating the notebook if we are calling on dispose or + * on removal of a notebook tab */ + if (nautilus_notebook_contains_slot (NAUTILUS_NOTEBOOK (window->notebook), slot)) + { + nautilus_notebook_sync_loading (NAUTILUS_NOTEBOOK (window->notebook), slot); + } + } +} + +GtkWidget * +nautilus_window_get_notebook (NautilusWindow *window) +{ + g_return_val_if_fail (NAUTILUS_IS_WINDOW (window), NULL); + + return window->notebook; +} + +static gboolean +save_sidebar_width_cb (gpointer user_data) +{ + NautilusWindow *window = user_data; + + + window->sidebar_width_handler_id = 0; + + DEBUG ("Saving sidebar width: %d", window->side_pane_width); + + g_settings_set_int (nautilus_window_state, + NAUTILUS_WINDOW_STATE_SIDEBAR_WIDTH, + window->side_pane_width); + + return FALSE; +} + +/* side pane helpers */ +static void +side_pane_size_allocate_callback (GtkWidget *widget, + GtkAllocation *allocation, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + + if (window->sidebar_width_handler_id != 0) + { + g_source_remove (window->sidebar_width_handler_id); + window->sidebar_width_handler_id = 0; + } + + if (allocation->width != window->side_pane_width && + allocation->width > 1) + { + window->side_pane_width = allocation->width; + + window->sidebar_width_handler_id = + g_idle_add (save_sidebar_width_cb, window); + } +} + +static void +setup_side_pane_width (NautilusWindow *window) +{ + g_return_if_fail (window->sidebar != NULL); + + window->side_pane_width = + g_settings_get_int (nautilus_window_state, + NAUTILUS_WINDOW_STATE_SIDEBAR_WIDTH); + + gtk_paned_set_position (GTK_PANED (window->content_paned), + window->side_pane_width); +} + +/* Callback used when the places sidebar changes location; we need to change the displayed folder */ +static void +open_location_cb (NautilusWindow *window, + GFile *location, + GtkPlacesOpenFlags open_flags) +{ + NautilusWindowOpenFlags flags; + NautilusApplication *application; + + switch (open_flags) + { + case GTK_PLACES_OPEN_NEW_TAB: + { + flags = NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB | + NAUTILUS_WINDOW_OPEN_FLAG_DONT_MAKE_ACTIVE; + } + break; + + case GTK_PLACES_OPEN_NEW_WINDOW: + { + flags = NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW; + } + break; + + case GTK_PLACES_OPEN_NORMAL: /* fall-through */ + default: + { + flags = 0; + } + break; + } + + application = NAUTILUS_APPLICATION (g_application_get_default ()); + /* FIXME: We shouldn't need to provide the window, but seems gtk_application_get_active_window + * is not working properly in GtkApplication, so we cannot rely on that... + */ + nautilus_application_open_location_full (application, location, flags, + NULL, window, NULL); +} + +static void +places_sidebar_unmount_operation_cb (NautilusWindow *window, + GMountOperation *mount_operation) +{ + g_signal_connect (mount_operation, "show-unmount-progress", + G_CALLBACK (show_unmount_progress_cb), NULL); + g_signal_connect (mount_operation, "aborted", + G_CALLBACK (show_unmount_progress_aborted_cb), NULL); +} + +/* Callback used when the places sidebar needs us to present an error message */ +static void +places_sidebar_show_error_message_cb (GtkPlacesSidebar *sidebar, + const char *primary, + const char *secondary, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + + show_dialog (primary, secondary, GTK_WINDOW (window), GTK_MESSAGE_ERROR); +} + +static void +places_sidebar_show_other_locations_with_flags (NautilusWindow *window, + GtkPlacesOpenFlags open_flags) +{ + GFile *location; + + location = g_file_new_for_uri ("other-locations:///"); + + open_location_cb (window, location, open_flags); + + g_object_unref (location); +} + +static void +places_sidebar_show_starred_location (NautilusWindow *window, + GtkPlacesOpenFlags open_flags) +{ + GFile *location; + + location = g_file_new_for_uri ("starred:///"); + + open_location_cb (window, location, open_flags); + + g_object_unref (location); +} + +static GList * +build_selection_list_from_gfile_list (GList *gfile_list) +{ + GList *result; + GList *l; + + result = NULL; + for (l = gfile_list; l; l = l->next) + { + GFile *file; + NautilusDragSelectionItem *item; + + file = l->data; + + item = nautilus_drag_selection_item_new (); + item->uri = g_file_get_uri (file); + item->file = nautilus_file_get_existing (file); + item->got_icon_position = FALSE; + result = g_list_prepend (result, item); + } + + return g_list_reverse (result); +} + +void +nautilus_window_start_dnd (NautilusWindow *window, + GdkDragContext *context) +{ + g_return_if_fail (NAUTILUS_IS_WINDOW (window)); + + gtk_places_sidebar_set_drop_targets_visible (GTK_PLACES_SIDEBAR (window->places_sidebar), + TRUE, + context); +} + +void +nautilus_window_end_dnd (NautilusWindow *window, + GdkDragContext *context) +{ + g_return_if_fail (NAUTILUS_IS_WINDOW (window)); + + gtk_places_sidebar_set_drop_targets_visible (GTK_PLACES_SIDEBAR (window->places_sidebar), + FALSE, + context); +} + +/* Callback used when the places sidebar needs to know the drag action to suggest */ +static GdkDragAction +places_sidebar_drag_action_requested_cb (GtkPlacesSidebar *sidebar, + GdkDragContext *context, + GFile *dest_file, + GList *source_file_list, + gpointer user_data) +{ + GList *items; + char *uri; + int action = 0; + NautilusDragInfo *info; + guint32 source_actions; + + info = nautilus_drag_get_source_data (context); + if (info != NULL) + { + items = info->selection_cache; + source_actions = info->source_actions; + } + else + { + items = build_selection_list_from_gfile_list (source_file_list); + source_actions = 0; + } + uri = g_file_get_uri (dest_file); + + if (items == NULL) + { + goto out; + } + + nautilus_drag_default_drop_action_for_icons (context, uri, items, source_actions, &action); + +out: + if (info == NULL) + { + nautilus_drag_destroy_selection_list (items); + } + + g_free (uri); + + return action; +} + +/* Callback used when the places sidebar needs us to pop up a menu with possible drag actions */ +static GdkDragAction +places_sidebar_drag_action_ask_cb (GtkPlacesSidebar *sidebar, + GdkDragAction actions, + gpointer user_data) +{ + return nautilus_drag_drop_action_ask (GTK_WIDGET (sidebar), actions); +} + +static GList * +build_uri_list_from_gfile_list (GList *file_list) +{ + GList *result; + GList *l; + + result = NULL; + + for (l = file_list; l; l = l->next) + { + GFile *file = l->data; + char *uri; + + uri = g_file_get_uri (file); + result = g_list_prepend (result, uri); + } + + return g_list_reverse (result); +} + +/* Callback used when the places sidebar has URIs dropped into it. We do a normal file operation for them. */ +static void +places_sidebar_drag_perform_drop_cb (GtkPlacesSidebar *sidebar, + GFile *dest_file, + GList *source_file_list, + GdkDragAction action, + gpointer user_data) +{ + char *dest_uri; + GList *source_uri_list; + + dest_uri = g_file_get_uri (dest_file); + source_uri_list = build_uri_list_from_gfile_list (source_file_list); + + nautilus_file_operations_copy_move (source_uri_list, dest_uri, action, GTK_WIDGET (sidebar), NULL, NULL, NULL); + + g_free (dest_uri); + g_list_free_full (source_uri_list, g_free); +} + +/* Callback used in the "empty trash" menu item from the places sidebar */ +static void +action_empty_trash (GSimpleAction *action, + GVariant *variant, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + + nautilus_file_operations_empty_trash (GTK_WIDGET (window), TRUE, NULL); +} + +/* Callback used for the "properties" menu item from the places sidebar */ +static void +action_properties (GSimpleAction *action, + GVariant *variant, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + GList *list; + NautilusFile *file; + + file = nautilus_file_get (window->selected_file); + + list = g_list_append (NULL, file); + nautilus_properties_window_present (list, GTK_WIDGET (window), NULL, NULL, + NULL); + nautilus_file_list_free (list); + + g_clear_object (&window->selected_file); +} + +static gboolean +check_have_gnome_disks (void) +{ + gchar *disks_path; + gboolean res; + + disks_path = g_find_program_in_path ("gnome-disks"); + res = (disks_path != NULL); + g_free (disks_path); + + return res; +} + +static gboolean +should_show_format_command (GVolume *volume) +{ + gchar *unix_device_id; + gboolean show_format; + + unix_device_id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); + show_format = (unix_device_id != NULL) && check_have_gnome_disks (); + g_free (unix_device_id); + + return show_format; +} + +static void +action_restore_tab (GSimpleAction *action, + GVariant *state, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + NautilusWindowOpenFlags flags; + g_autoptr (GFile) location = NULL; + NautilusWindowSlot *slot; + NautilusNavigationState *data; + + if (g_queue_get_length (window->tab_data_queue) == 0) + { + return; + } + + flags = NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB | NAUTILUS_WINDOW_OPEN_FLAG_DONT_MAKE_ACTIVE; + + data = g_queue_pop_head (window->tab_data_queue); + + location = nautilus_file_get_location (data->file); + + slot = nautilus_window_create_and_init_slot (window, location, flags); + + nautilus_window_slot_open_location_full (slot, location, flags, NULL); + nautilus_window_slot_restore_navigation_state (slot, data); + + free_navigation_state (data); +} + +static guint +get_window_xid (NautilusWindow *window) +{ +#ifdef GDK_WINDOWING_X11 + if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window)))) + { + GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window)); + return (guint) gdk_x11_window_get_xid (gdk_window); + } +#endif + return 0; +} + +static void +action_format (GSimpleAction *action, + GVariant *variant, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + GAppInfo *app_info; + gchar *cmdline, *device_identifier, *xid_string; + + device_identifier = g_volume_get_identifier (window->selected_volume, + G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); + xid_string = g_strdup_printf ("%x", get_window_xid (window)); + + cmdline = g_strconcat ("gnome-disks ", + "--block-device ", device_identifier, " ", + "--format-device ", + "--xid ", xid_string, + NULL); + app_info = g_app_info_create_from_commandline (cmdline, NULL, 0, NULL); + g_app_info_launch (app_info, NULL, NULL, NULL); + + g_free (cmdline); + g_free (device_identifier); + g_free (xid_string); + g_clear_object (&app_info); + g_clear_object (&window->selected_volume); +} + +static void +add_menu_separator (GtkWidget *menu) +{ + GtkWidget *separator; + + separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); + gtk_container_add (GTK_CONTAINER (menu), separator); + gtk_widget_show (separator); +} + +static void +places_sidebar_populate_popup_cb (GtkPlacesSidebar *sidebar, + GtkWidget *menu, + GFile *selected_file, + GVolume *selected_volume, + gpointer user_data) +{ + NautilusWindow *window = NAUTILUS_WINDOW (user_data); + GFile *trash; + GtkWidget *menu_item; + GAction *action; + + g_clear_object (&window->selected_file); + g_clear_object (&window->selected_volume); + + if (selected_file) + { + trash = g_file_new_for_uri ("trash:///"); + if (g_file_equal (trash, selected_file)) + { + add_menu_separator (menu); + + menu_item = gtk_model_button_new (); + gtk_actionable_set_action_name (GTK_ACTIONABLE (menu_item), + "win.empty-trash"); + g_object_set (menu_item, "text", _("Empty _Trash"), NULL); + gtk_container_add (GTK_CONTAINER (menu), menu_item); + gtk_widget_show (menu_item); + + action = g_action_map_lookup_action (G_ACTION_MAP (window), + "empty-trash"); + g_simple_action_set_enabled (G_SIMPLE_ACTION (action), + !nautilus_trash_monitor_is_empty ()); + } + g_object_unref (trash); + + if (g_file_is_native (selected_file)) + { + window->selected_file = g_object_ref (selected_file); + add_menu_separator (menu); + + menu_item = gtk_model_button_new (); + gtk_actionable_set_action_name (GTK_ACTIONABLE (menu_item), + "win.properties"); + g_object_set (menu_item, "text", _("_Properties"), NULL); + gtk_container_add (GTK_CONTAINER (menu), menu_item); + gtk_widget_show (menu_item); + } + } + if (selected_volume) + { + if (should_show_format_command (selected_volume)) + { + menu_item = gtk_model_button_new (); + gtk_actionable_set_action_name (GTK_ACTIONABLE (menu_item), + "win.format"); + g_object_set (menu_item, "text", _("_Format…"), NULL); + if (selected_volume != NULL && G_IS_VOLUME (selected_volume)) + { + window->selected_volume = g_object_ref (selected_volume); + } + gtk_container_add (GTK_CONTAINER (menu), menu_item); + gtk_widget_show (menu_item); + + action = g_action_map_lookup_action (G_ACTION_MAP (window), + "format"); + g_simple_action_set_enabled (G_SIMPLE_ACTION (action), + selected_volume != NULL && + G_IS_VOLUME (selected_volume)); + } + } +} + +static void +nautilus_window_set_up_sidebar (NautilusWindow *window) +{ + setup_side_pane_width (window); + g_signal_connect (window->sidebar, + "size-allocate", + G_CALLBACK (side_pane_size_allocate_callback), + window); + + gtk_places_sidebar_set_open_flags (GTK_PLACES_SIDEBAR (window->places_sidebar), + (GTK_PLACES_OPEN_NORMAL + | GTK_PLACES_OPEN_NEW_TAB + | GTK_PLACES_OPEN_NEW_WINDOW)); + + g_signal_connect_swapped (window->places_sidebar, "open-location", + G_CALLBACK (open_location_cb), window); + g_signal_connect (window->places_sidebar, "show-error-message", + G_CALLBACK (places_sidebar_show_error_message_cb), window); + g_signal_connect (window->places_sidebar, "drag-action-requested", + G_CALLBACK (places_sidebar_drag_action_requested_cb), window); + g_signal_connect (window->places_sidebar, "drag-action-ask", + G_CALLBACK (places_sidebar_drag_action_ask_cb), window); + g_signal_connect (window->places_sidebar, "drag-perform-drop", + G_CALLBACK (places_sidebar_drag_perform_drop_cb), window); + g_signal_connect (window->places_sidebar, "populate-popup", + G_CALLBACK (places_sidebar_populate_popup_cb), window); + g_signal_connect (window->places_sidebar, "unmount", + G_CALLBACK (places_sidebar_unmount_operation_cb), window); +} + +void +nautilus_window_hide_sidebar (NautilusWindow *window) +{ + DEBUG ("Called hide_sidebar()"); + + g_return_if_fail (NAUTILUS_IS_WINDOW (window)); + + gtk_widget_hide (window->sidebar); +} + +void +nautilus_window_show_sidebar (NautilusWindow *window) +{ + DEBUG ("Called show_sidebar()"); + + g_return_if_fail (NAUTILUS_IS_WINDOW (window)); + + gtk_widget_show (window->sidebar); + setup_side_pane_width (window); +} + +static inline NautilusWindowSlot * +get_first_inactive_slot (NautilusWindow *window) +{ + GList *l; + NautilusWindowSlot *slot; + + for (l = window->slots; l != NULL; l = l->next) + { + slot = NAUTILUS_WINDOW_SLOT (l->data); + if (slot != window->active_slot) + { + return slot; + } + } + + return NULL; +} + +void +nautilus_window_slot_close (NautilusWindow *window, + NautilusWindowSlot *slot) +{ + NautilusWindowSlot *next_slot; + NautilusNavigationState *data; + + DEBUG ("Requesting to remove slot %p from window %p", slot, window); + if (window == NULL) + { + return; + } + + if (window->active_slot == slot) + { + next_slot = get_first_inactive_slot (window); + nautilus_window_set_active_slot (window, next_slot); + } + + data = nautilus_window_slot_get_navigation_state (slot); + if (data != NULL) + { + g_queue_push_head (window->tab_data_queue, data); + } + + close_slot (window, slot, TRUE); + + /* If that was the last slot in the window, close the window. */ + if (window->slots == NULL) + { + DEBUG ("Last slot removed, closing the window"); + nautilus_window_close (window); + } +} + +static void +nautilus_window_sync_bookmarks (NautilusWindow *window) +{ + gboolean can_bookmark = FALSE; + NautilusWindowSlot *slot; + NautilusBookmarkList *bookmarks; + GAction *action; + GFile *location; + + slot = window->active_slot; + location = nautilus_window_slot_get_location (slot); + + if (location != NULL) + { + bookmarks = nautilus_application_get_bookmarks + (NAUTILUS_APPLICATION (gtk_window_get_application (GTK_WINDOW (window)))); + can_bookmark = nautilus_bookmark_list_can_bookmark_location (bookmarks, location); + } + + action = g_action_map_lookup_action (G_ACTION_MAP (window), "bookmark-current-location"); + g_simple_action_set_enabled (G_SIMPLE_ACTION (action), can_bookmark); +} + +void +nautilus_window_sync_location_widgets (NautilusWindow *window) +{ + NautilusWindowSlot *slot; + GFile *location; + GAction *action; + gboolean enabled; + + slot = window->active_slot; + location = nautilus_window_slot_get_location (slot); + + /* Change the location bar and path bar to match the current location. */ + if (location != NULL) + { + GtkWidget *location_entry; + GtkWidget *path_bar; + + location_entry = nautilus_toolbar_get_location_entry (NAUTILUS_TOOLBAR (window->toolbar)); + nautilus_location_entry_set_location (NAUTILUS_LOCATION_ENTRY (location_entry), location); + + path_bar = nautilus_toolbar_get_path_bar (NAUTILUS_TOOLBAR (window->toolbar)); + nautilus_path_bar_set_path (NAUTILUS_PATH_BAR (path_bar), location); + } + + action = g_action_map_lookup_action (G_ACTION_MAP (window), "back"); + enabled = nautilus_window_slot_get_back_history (slot) != NULL; + g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled); + + action = g_action_map_lookup_action (G_ACTION_MAP (window), "forward"); + enabled = nautilus_window_slot_get_forward_history (slot) != NULL; + g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled); + + nautilus_window_sync_bookmarks (window); +} + +static GtkWidget * +nautilus_window_ensure_location_entry (NautilusWindow *window) +{ + GtkWidget *location_entry; + + remember_focus_widget (window); + + nautilus_toolbar_set_show_location_entry (NAUTILUS_TOOLBAR (window->toolbar), TRUE); + + location_entry = nautilus_toolbar_get_location_entry (NAUTILUS_TOOLBAR (window->toolbar)); + gtk_widget_grab_focus (location_entry); + + return location_entry; +} + +static void +remove_notifications (NautilusWindow *window) +{ + GtkRevealerTransitionType transition_type; + + /* Hide it inmediatily so we can animate the new notification. */ + transition_type = gtk_revealer_get_transition_type (GTK_REVEALER (window->in_app_notification_undo)); + gtk_revealer_set_transition_type (GTK_REVEALER (window->in_app_notification_undo), + GTK_REVEALER_TRANSITION_TYPE_NONE); + gtk_revealer_set_reveal_child (GTK_REVEALER (window->in_app_notification_undo), + FALSE); + gtk_revealer_set_transition_type (GTK_REVEALER (window->in_app_notification_undo), + transition_type); + if (window->in_app_notification_undo_timeout_id != 0) + { + g_source_remove (window->in_app_notification_undo_timeout_id); + window->in_app_notification_undo_timeout_id = 0; + } + + transition_type = gtk_revealer_get_transition_type (GTK_REVEALER (window->notification_operation)); + gtk_revealer_set_transition_type (GTK_REVEALER (window->notification_operation), + GTK_REVEALER_TRANSITION_TYPE_NONE); + gtk_revealer_set_reveal_child (GTK_REVEALER (window->notification_operation), + FALSE); + gtk_revealer_set_transition_type (GTK_REVEALER (window->notification_operation), + transition_type); + if (window->notification_operation_timeout_id != 0) + { + g_source_remove (window->notification_operation_timeout_id); + window->notification_operation_timeout_id = 0; + } +} + +static void +hide_in_app_notification_undo (NautilusWindow *window) +{ + if (window->in_app_notification_undo_timeout_id != 0) + { + g_source_remove (window->in_app_notification_undo_timeout_id); + window->in_app_notification_undo_timeout_id = 0; + } + + gtk_revealer_set_reveal_child (GTK_REVEALER (window->in_app_notification_undo), FALSE); +} + +static void +on_in_app_notification_undo_undo_button_clicked (GtkWidget *notification, + NautilusWindow *window) +{ + hide_in_app_notification_undo (window); + + nautilus_file_undo_manager_undo (GTK_WINDOW (window), NULL); +} + +static void +on_in_app_notification_undo_close_button_clicked (GtkWidget *notification, + NautilusWindow *window) +{ + hide_in_app_notification_undo (window); +} + +static gboolean +on_in_app_notification_undo_timeout (NautilusWindow *window) +{ + hide_in_app_notification_undo (window); + + return G_SOURCE_REMOVE; +} + +static gchar * +in_app_notification_undo_deleted_get_label (NautilusFileUndoInfo *undo_info) +{ + GList *files; + gchar *file_label; + gchar *label; + gint length; + + files = nautilus_file_undo_info_trash_get_files (NAUTILUS_FILE_UNDO_INFO_TRASH (undo_info)); + length = g_list_length (files); + if (length == 1) + { + file_label = g_file_get_basename (files->data); + /* Translators: only one item has been deleted and %s is its name. */ + label = g_markup_printf_escaped (_("“%s” deleted"), file_label); + g_free (file_label); + } + else + { + /* Translators: one or more items might have been deleted, and %d + * is the count. */ + label = g_markup_printf_escaped (ngettext ("%d file deleted", "%d files deleted", length), length); + } + + return label; +} + +static gchar * +in_app_notification_undo_unstar_get_label (NautilusFileUndoInfo *undo_info) +{ + GList *files; + gchar *label; + gint length; + + files = nautilus_file_undo_info_starred_get_files (NAUTILUS_FILE_UNDO_INFO_STARRED (undo_info)); + length = g_list_length (files); + if (length == 1) + { + g_autofree gchar *file_label = NULL; + + file_label = nautilus_file_get_display_name (files->data); + /* Translators: one item has been unstarred and %s is its name. */ + label = g_markup_printf_escaped (_("“%s” unstarred"), file_label); + } + else + { + /* Translators: one or more items have been unstarred, and %d + * is the count. */ + label = g_markup_printf_escaped (ngettext ("%d file unstarred", "%d files unstarred", length), length); + } + + return label; +} + +static void +nautilus_window_on_undo_changed (NautilusFileUndoManager *manager, + NautilusWindow *window) +{ + NautilusFileUndoInfo *undo_info; + NautilusFileUndoManagerState state; + + undo_info = nautilus_file_undo_manager_get_action (); + state = nautilus_file_undo_manager_get_state (); + + if (undo_info != NULL && + state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO) + { + gboolean popup_notification = FALSE; + g_autofree gchar *label = NULL; + + if (nautilus_file_undo_info_get_op_type (undo_info) == NAUTILUS_FILE_UNDO_OP_MOVE_TO_TRASH) + { + g_autoptr (GList) files = NULL; + + files = nautilus_file_undo_info_trash_get_files (NAUTILUS_FILE_UNDO_INFO_TRASH (undo_info)); + + /* Don't pop up a notification if user canceled the operation or the focus + * is not in the this window. This is an easy way to know from which window + * was the delete operation made */ + if (files != NULL && gtk_window_has_toplevel_focus (GTK_WINDOW (window))) + { + popup_notification = TRUE; + label = in_app_notification_undo_deleted_get_label (undo_info); + } + } + else if (nautilus_file_undo_info_get_op_type (undo_info) == NAUTILUS_FILE_UNDO_OP_STARRED) + { + NautilusWindowSlot *active_slot; + GFile *location; + + active_slot = nautilus_window_get_active_slot (window); + location = nautilus_window_slot_get_location (active_slot); + /* Don't pop up a notification if the focus is not in the this + * window. This is an easy way to know from which window was the + * unstart operation made */ + if (eel_uri_is_starred (g_file_get_uri (location)) && + gtk_window_has_toplevel_focus (GTK_WINDOW (window)) && + !nautilus_file_undo_info_starred_is_starred (NAUTILUS_FILE_UNDO_INFO_STARRED (undo_info))) + { + popup_notification = TRUE; + label = in_app_notification_undo_unstar_get_label (undo_info); + } + } + + if (popup_notification) + { + remove_notifications (window); + gtk_label_set_markup (GTK_LABEL (window->in_app_notification_undo_label), + label); + gtk_revealer_set_reveal_child (GTK_REVEALER (window->in_app_notification_undo), + TRUE); + window->in_app_notification_undo_timeout_id = g_timeout_add_seconds (NOTIFICATION_TIMEOUT, + (GSourceFunc) on_in_app_notification_undo_timeout, + window); + } + } + else + { + hide_in_app_notification_undo (window); + } +} + +static void +hide_notification_operation (NautilusWindow *window) +{ + if (window->notification_operation_timeout_id != 0) + { + g_source_remove (window->notification_operation_timeout_id); + window->notification_operation_timeout_id = 0; + } + + gtk_revealer_set_reveal_child (GTK_REVEALER (window->notification_operation), FALSE); + g_clear_object (&window->folder_to_open); +} + +static void +on_notification_operation_open_clicked (GtkWidget *notification, + NautilusWindow *window) +{ + nautilus_window_open_location_full (window, window->folder_to_open, + 0, NULL, NULL); + hide_notification_operation (window); +} + +static void +on_notification_operation_close_clicked (GtkWidget *notification, + NautilusWindow *window) +{ + hide_notification_operation (window); +} + +static gboolean +on_notification_operation_timeout (NautilusWindow *window) +{ + hide_notification_operation (window); + + return FALSE; +} + +void +nautilus_window_show_operation_notification (NautilusWindow *window, + gchar *main_label, + GFile *folder_to_open) +{ + gchar *button_label; + gchar *folder_name; + NautilusFile *folder; + GFile *current_location; + + current_location = nautilus_window_slot_get_location (window->active_slot); + if (gtk_window_has_toplevel_focus (GTK_WINDOW (window))) + { + remove_notifications (window); + gtk_label_set_text (GTK_LABEL (window->notification_operation_label), + main_label); + + if (g_file_equal (folder_to_open, current_location)) + { + gtk_widget_hide (window->notification_operation_open); + } + else + { + gtk_widget_show (window->notification_operation_open); + window->folder_to_open = g_object_ref (folder_to_open); + folder = nautilus_file_get (folder_to_open); + folder_name = nautilus_file_get_display_name (folder); + button_label = g_strdup_printf (_("Open %s"), folder_name); + gtk_button_set_label (GTK_BUTTON (window->notification_operation_open), + button_label); + nautilus_file_unref (folder); + g_free (folder_name); + g_free (button_label); + } + + gtk_revealer_set_reveal_child (GTK_REVEALER (window->notification_operation), TRUE); + window->notification_operation_timeout_id = g_timeout_add_seconds (NOTIFICATION_TIMEOUT, + (GSourceFunc) on_notification_operation_timeout, + window); + } +} + +static void +path_bar_location_changed_callback (GtkWidget *widget, + GFile *location, + NautilusWindow *window) +{ + nautilus_window_open_location_full (window, location, 0, NULL, NULL); +} + +static void +notebook_popup_menu_new_tab_cb (GtkMenuItem *menuitem, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_window_new_tab (window); +} + +static void +notebook_popup_menu_move_left_cb (GtkMenuItem *menuitem, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + nautilus_notebook_reorder_current_child_relative (NAUTILUS_NOTEBOOK (window->notebook), -1); +} + +static void +notebook_popup_menu_move_right_cb (GtkMenuItem *menuitem, + gpointer user_data) +{ + NautilusWindow *window = user_data; + + + nautilus_notebook_reorder_current_child_relative (NAUTILUS_NOTEBOOK (window->notebook), 1); +} + +static void +notebook_popup_menu_close_cb (GtkMenuItem *menuitem, + gpointer user_data) +{ + NautilusWindow *window = user_data; + NautilusWindowSlot *slot; + + slot = window->active_slot; + nautilus_window_slot_close (window, slot); +} + +static void +notebook_popup_menu_show (NautilusWindow *window, + const GdkEvent *event) +{ + GtkWidget *popup; + GtkWidget *item; + gboolean can_move_left, can_move_right; + NautilusNotebook *notebook; + + notebook = NAUTILUS_NOTEBOOK (window->notebook); + + can_move_left = nautilus_notebook_can_reorder_current_child_relative (notebook, -1); + can_move_right = nautilus_notebook_can_reorder_current_child_relative (notebook, 1); + + popup = gtk_menu_new (); + + item = gtk_menu_item_new_with_mnemonic (_("_New Tab")); + g_signal_connect (item, "activate", + G_CALLBACK (notebook_popup_menu_new_tab_cb), + window); + gtk_menu_shell_append (GTK_MENU_SHELL (popup), + item); + + gtk_menu_shell_append (GTK_MENU_SHELL (popup), + gtk_separator_menu_item_new ()); + + item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Left")); + g_signal_connect (item, "activate", + G_CALLBACK (notebook_popup_menu_move_left_cb), + window); + gtk_menu_shell_append (GTK_MENU_SHELL (popup), + item); + gtk_widget_set_sensitive (item, can_move_left); + + item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Right")); + g_signal_connect (item, "activate", + G_CALLBACK (notebook_popup_menu_move_right_cb), + window); + gtk_menu_shell_append (GTK_MENU_SHELL (popup), + item); + gtk_widget_set_sensitive (item, can_move_right); + + gtk_menu_shell_append (GTK_MENU_SHELL (popup), + gtk_separator_menu_item_new ()); + + item = gtk_menu_item_new_with_mnemonic (_("_Close Tab")); + g_signal_connect (item, "activate", + G_CALLBACK (notebook_popup_menu_close_cb), window); + gtk_menu_shell_append (GTK_MENU_SHELL (popup), + item); + + gtk_widget_show_all (popup); + + gtk_menu_popup_at_pointer (GTK_MENU (popup), event); +} + +/* emitted when the user clicks the "close" button of tabs */ +static void +notebook_tab_close_requested (NautilusNotebook *notebook, + NautilusWindowSlot *slot, + NautilusWindow *window) +{ + nautilus_window_slot_close (window, slot); +} + +static void +notebook_button_press_cb (GtkGestureMultiPress *gesture, + gint n_press, + gdouble x, + gdouble y, + gpointer user_data) +{ + NautilusWindow *window; + GdkEventSequence *sequence; + const GdkEvent *event; + + window = NAUTILUS_WINDOW (user_data); + + if (nautilus_notebook_content_area_hit (NAUTILUS_NOTEBOOK (window->notebook), x, y)) + { + return; + } + + sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture)); + event = gtk_gesture_get_last_event (GTK_GESTURE (gesture), sequence); + + notebook_popup_menu_show (window, event); +} + +static gboolean +notebook_popup_menu_cb (GtkWidget *widget, + gpointer user_data) +{ + NautilusWindow *window = user_data; + notebook_popup_menu_show (window, NULL); + return TRUE; +} + +GtkWidget * +nautilus_window_get_toolbar (NautilusWindow *window) +{ + g_return_val_if_fail (NAUTILUS_IS_WINDOW (window), NULL); + + return window->toolbar; +} + +static void +setup_toolbar (NautilusWindow *window) +{ + GtkWidget *path_bar; + GtkWidget *location_entry; + + + g_object_set (window->toolbar, "window", window, NULL); + + /* connect to the pathbar signals */ + path_bar = nautilus_toolbar_get_path_bar (NAUTILUS_TOOLBAR (window->toolbar)); + + g_signal_connect_object (path_bar, "path-clicked", + G_CALLBACK (path_bar_location_changed_callback), window, 0); + g_signal_connect_swapped (path_bar, "open-location", + G_CALLBACK (open_location_cb), window); + + /* connect to the location entry signals */ + location_entry = nautilus_toolbar_get_location_entry (NAUTILUS_TOOLBAR (window->toolbar)); + + g_signal_connect_object (location_entry, "location-changed", + G_CALLBACK (location_entry_location_changed_callback), window, 0); + g_signal_connect_object (location_entry, "cancel", + G_CALLBACK (location_entry_cancel_callback), window, 0); + + gtk_window_set_titlebar (GTK_WINDOW (window), window->toolbar); +} + +static void +notebook_page_removed_cb (GtkNotebook *notebook, + GtkWidget *page, + guint page_num, + gpointer user_data) +{ + NautilusWindow *window = user_data; + NautilusWindowSlot *slot = NAUTILUS_WINDOW_SLOT (page), *next_slot; + gboolean dnd_slot; + + dnd_slot = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (slot), "dnd-window-slot")); + if (!dnd_slot) + { + return; + } + + if (window->active_slot == slot) + { + next_slot = get_first_inactive_slot (window); + nautilus_window_set_active_slot (window, next_slot); + } + + close_slot (window, slot, FALSE); +} + +static void +notebook_page_added_cb (GtkNotebook *notebook, + GtkWidget *page, + guint page_num, + gpointer user_data) +{ + NautilusWindow *window = user_data; + NautilusWindowSlot *slot = NAUTILUS_WINDOW_SLOT (page); + NautilusWindowSlot *dummy_slot; + gboolean dnd_slot; + + dnd_slot = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (slot), "dnd-window-slot")); + if (!dnd_slot) + { + return; + } + + g_object_set_data (G_OBJECT (page), "dnd-window-slot", + GINT_TO_POINTER (FALSE)); + + nautilus_window_slot_set_window (slot, window); + window->slots = g_list_append (window->slots, slot); + g_signal_emit (window, signals[SLOT_ADDED], 0, slot); + + nautilus_window_set_active_slot (window, slot); + + dummy_slot = g_list_nth_data (window->slots, 0); + if (dummy_slot != NULL) + { + close_slot (window, dummy_slot, TRUE); + } + + gtk_widget_show (GTK_WIDGET (window)); +} + +static GtkNotebook * +notebook_create_window_cb (GtkNotebook *notebook, + GtkWidget *page, + gint x, + gint y, + gpointer user_data) +{ + NautilusApplication *app; + NautilusWindow *new_window; + NautilusWindowSlot *slot; + + if (!NAUTILUS_IS_WINDOW_SLOT (page)) + { + return NULL; + } + + app = NAUTILUS_APPLICATION (g_application_get_default ()); + new_window = nautilus_application_create_window + (app, gtk_widget_get_screen (GTK_WIDGET (notebook))); + + slot = NAUTILUS_WINDOW_SLOT (page); + g_object_set_data (G_OBJECT (slot), "dnd-window-slot", + GINT_TO_POINTER (TRUE)); + + gtk_window_set_position (GTK_WINDOW (new_window), GTK_WIN_POS_MOUSE); + + return GTK_NOTEBOOK (new_window->notebook); +} + +static void +setup_notebook (NautilusWindow *window) +{ + g_signal_connect (window->notebook, "tab-close-request", + G_CALLBACK (notebook_tab_close_requested), + window); + g_signal_connect (window->notebook, "popup-menu", + G_CALLBACK (notebook_popup_menu_cb), + window); + g_signal_connect (window->notebook, "switch-page", + G_CALLBACK (notebook_switch_page_cb), + window); + g_signal_connect (window->notebook, "create-window", + G_CALLBACK (notebook_create_window_cb), + window); + g_signal_connect (window->notebook, "page-added", + G_CALLBACK (notebook_page_added_cb), + window); + g_signal_connect (window->notebook, "page-removed", + G_CALLBACK (notebook_page_removed_cb), + window); + + g_signal_connect (window->notebook_multi_press_gesture, "pressed", + G_CALLBACK (notebook_button_press_cb), + window); +} + +const GActionEntry win_entries[] = +{ + { "back", action_back }, + { "forward", action_forward }, + { "up", action_up }, + { "view-menu", action_toggle_state_view_button, NULL, "false", NULL }, + { "reload", action_reload }, + { "stop", action_stop }, + { "new-tab", action_new_tab }, + { "enter-location", action_enter_location }, + { "bookmark-current-location", action_bookmark_current_location }, + { "undo", action_undo }, + { "redo", action_redo }, + /* Only accesible by shorcuts */ + { "close-current-view", action_close_current_view }, + { "go-home", action_go_home }, + { "tab-previous", action_tab_previous }, + { "tab-next", action_tab_next }, + { "tab-move-left", action_tab_move_left }, + { "tab-move-right", action_tab_move_right }, + { "prompt-root-location", action_prompt_for_location_root }, + { "prompt-home-location", action_prompt_for_location_home }, + { "go-to-tab", NULL, "i", "0", action_go_to_tab }, + { "empty-trash", action_empty_trash }, + { "properties", action_properties }, + { "format", action_format }, + { "restore-tab", action_restore_tab }, +}; + +static void +nautilus_window_initialize_actions (NautilusWindow *window) +{ + GApplication *app; + GAction *action; + GVariant *state; + gchar detailed_action[80]; + gchar accel[80]; + gint i; + const gchar *reload_accels[] = + { + "F5", + "<ctrl>r", + NULL + }; + const gchar *prompt_root_location_accels[] = + { + "slash", + "KP_Divide", + NULL + }; + const gchar *prompt_home_location_accels[] = + { + "asciitilde", + "dead_tilde", + NULL + }; + + g_action_map_add_action_entries (G_ACTION_MAP (window), + win_entries, G_N_ELEMENTS (win_entries), + window); + + app = g_application_get_default (); + nautilus_application_set_accelerator (app, "win.back", "<alt>Left"); + nautilus_application_set_accelerator (app, "win.forward", "<alt>Right"); + nautilus_application_set_accelerator (app, "win.enter-location", "<control>l"); + nautilus_application_set_accelerator (app, "win.new-tab", "<control>t"); + nautilus_application_set_accelerator (app, "win.close-current-view", "<control>w"); + + /* Special case reload, since users are used to use two shortcuts instead of one */ + nautilus_application_set_accelerators (app, "win.reload", reload_accels); + + nautilus_application_set_accelerator (app, "win.undo", "<control>z"); + nautilus_application_set_accelerator (app, "win.redo", "<shift><control>z"); + /* Only accesible by shorcuts */ + nautilus_application_set_accelerator (app, "win.bookmark-current-location", "<control>d"); + nautilus_application_set_accelerator (app, "win.up", "<alt>Up"); + nautilus_application_set_accelerator (app, "win.go-home", "<alt>Home"); + nautilus_application_set_accelerator (app, "win.tab-previous", "<control>Page_Up"); + nautilus_application_set_accelerator (app, "win.tab-next", "<control>Page_Down"); + nautilus_application_set_accelerator (app, "win.tab-move-left", "<shift><control>Page_Up"); + nautilus_application_set_accelerator (app, "win.tab-move-right", "<shift><control>Page_Down"); + nautilus_application_set_accelerators (app, "win.prompt-root-location", prompt_root_location_accels); + /* Support keyboard layouts which have a dead tilde key but not a tilde key. */ + nautilus_application_set_accelerators (app, "win.prompt-home-location", prompt_home_location_accels); + nautilus_application_set_accelerator (app, "win.view-menu", "F10"); + nautilus_application_set_accelerator (app, "win.restore-tab", "<shift><control>t"); + + /* Alt+N for the first 9 tabs */ + for (i = 0; i < 9; ++i) + { + g_snprintf (detailed_action, sizeof (detailed_action), "win.go-to-tab(%i)", i); + g_snprintf (accel, sizeof (accel), "<alt>%i", i + 1); + nautilus_application_set_accelerator (app, detailed_action, accel); + } + + action = g_action_map_lookup_action (G_ACTION_MAP (app), "show-hide-sidebar"); + state = g_action_get_state (action); + if (g_variant_get_boolean (state)) + { + nautilus_window_show_sidebar (window); + } + + g_variant_unref (state); +} + + +static void +nautilus_window_constructed (GObject *self) +{ + NautilusWindow *window; + NautilusWindowSlot *slot; + NautilusApplication *application; + + window = NAUTILUS_WINDOW (self); + + nautilus_profile_start (NULL); + + G_OBJECT_CLASS (nautilus_window_parent_class)->constructed (self); + + application = NAUTILUS_APPLICATION (g_application_get_default ()); + gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (application)); + + setup_toolbar (window); + + gtk_window_set_default_size (GTK_WINDOW (window), + NAUTILUS_WINDOW_DEFAULT_WIDTH, + NAUTILUS_WINDOW_DEFAULT_HEIGHT); + + setup_notebook (window); + nautilus_window_set_up_sidebar (window); + + + g_signal_connect_object (nautilus_file_undo_manager_get (), "undo-changed", + G_CALLBACK (nautilus_window_on_undo_changed), self, + G_CONNECT_AFTER); + + /* Is required that the UI is constructed before initializating the actions, since + * some actions trigger UI widgets to show/hide. */ + nautilus_window_initialize_actions (window); + + slot = nautilus_window_create_and_init_slot (window, NULL, 0); + nautilus_window_set_active_slot (window, slot); + + window->bookmarks_id = + g_signal_connect_swapped (nautilus_application_get_bookmarks (application), "changed", + G_CALLBACK (nautilus_window_sync_bookmarks), window); + + nautilus_toolbar_on_window_constructed (NAUTILUS_TOOLBAR (window->toolbar)); + + nautilus_profile_end (NULL); +} + +static gint +sort_slots_active_last (NautilusWindowSlot *a, + NautilusWindowSlot *b, + NautilusWindow *window) +{ + if (window->active_slot == a) + { + return 1; + } + if (window->active_slot == b) + { + return -1; + } + return 0; +} + +static void +destroy_slots_foreach (gpointer data, + gpointer user_data) +{ + NautilusWindowSlot *slot = data; + NautilusWindow *window = user_data; + + close_slot (window, slot, TRUE); +} + +static void +nautilus_window_destroy (GtkWidget *object) +{ + NautilusWindow *window; + NautilusApplication *application; + GList *slots_copy; + + window = NAUTILUS_WINDOW (object); + application = NAUTILUS_APPLICATION (gtk_window_get_application (GTK_WINDOW (window))); + + DEBUG ("Destroying window"); + + /* close all slots safely */ + slots_copy = g_list_copy (window->slots); + if (window->active_slot != NULL) + { + /* Make sure active slot is last one to be closed, to avoid default activation + * of others slots when closing the active one, see bug #741952 */ + slots_copy = g_list_sort_with_data (slots_copy, (GCompareDataFunc) sort_slots_active_last, window); + } + g_list_foreach (slots_copy, (GFunc) destroy_slots_foreach, window); + g_list_free (slots_copy); + + /* the slots list should now be empty */ + g_assert (window->slots == NULL); + + window->active_slot = NULL; + + g_clear_signal_handler (&window->bookmarks_id, nautilus_application_get_bookmarks (application)); + + g_clear_handle_id (&window->in_app_notification_undo_timeout_id, g_source_remove); + + nautilus_window_unexport_handle (window); + + GTK_WIDGET_CLASS (nautilus_window_parent_class)->destroy (object); +} + +static void +nautilus_window_dispose (GObject *object) +{ + NautilusWindow *window; + + window = NAUTILUS_WINDOW (object); + + g_clear_object (&window->notebook_multi_press_gesture); + + G_OBJECT_CLASS (nautilus_window_parent_class)->dispose (object); +} + +static void +nautilus_window_finalize (GObject *object) +{ + NautilusWindow *window; + + window = NAUTILUS_WINDOW (object); + + if (window->sidebar_width_handler_id != 0) + { + g_source_remove (window->sidebar_width_handler_id); + window->sidebar_width_handler_id = 0; + } + + if (window->in_app_notification_undo_timeout_id != 0) + { + g_source_remove (window->in_app_notification_undo_timeout_id); + window->in_app_notification_undo_timeout_id = 0; + } + + if (window->notification_operation_timeout_id != 0) + { + g_source_remove (window->notification_operation_timeout_id); + window->notification_operation_timeout_id = 0; + } + + g_clear_object (&window->selected_file); + g_clear_object (&window->selected_volume); + + g_signal_handlers_disconnect_by_func (nautilus_file_undo_manager_get (), + G_CALLBACK (nautilus_window_on_undo_changed), + window); + + g_queue_free_full (window->tab_data_queue, free_navigation_state); + + g_object_unref (window->pad_controller); + + /* nautilus_window_close() should have run */ + g_assert (window->slots == NULL); + + G_OBJECT_CLASS (nautilus_window_parent_class)->finalize (object); +} + +static void +nautilus_window_save_geometry (NautilusWindow *window) +{ + gboolean is_maximized; + + g_assert (NAUTILUS_IS_WINDOW (window)); + + if (gtk_widget_get_window (GTK_WIDGET (window))) + { + gint width; + gint height; + GVariant *initial_size; + + gtk_window_get_size (GTK_WINDOW (window), &width, &height); + + initial_size = g_variant_new_parsed ("(%i, %i)", width, height); + is_maximized = gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (window))) + & GDK_WINDOW_STATE_MAXIMIZED; + + if (!is_maximized) + { + g_settings_set_value (nautilus_window_state, + NAUTILUS_WINDOW_STATE_INITIAL_SIZE, + initial_size); + } + + g_settings_set_boolean + (nautilus_window_state, NAUTILUS_WINDOW_STATE_MAXIMIZED, + is_maximized); + } +} + +void +nautilus_window_close (NautilusWindow *window) +{ + g_return_if_fail (NAUTILUS_IS_WINDOW (window)); + + nautilus_window_save_geometry (window); + nautilus_window_set_active_slot (window, NULL); + + gtk_widget_destroy (GTK_WIDGET (window)); +} + +void +nautilus_window_set_active_slot (NautilusWindow *window, + NautilusWindowSlot *new_slot) +{ + NautilusWindowSlot *old_slot; + + g_assert (NAUTILUS_IS_WINDOW (window)); + + if (new_slot) + { + g_assert ((window == nautilus_window_slot_get_window (new_slot))); + } + + old_slot = nautilus_window_get_active_slot (window); + + if (old_slot == new_slot) + { + return; + } + + DEBUG ("Setting new slot %p as active, old slot inactive %p", new_slot, old_slot); + + /* make old slot inactive if it exists (may be NULL after init, for example) */ + if (old_slot != NULL) + { + /* inform slot & view */ + nautilus_window_slot_set_active (old_slot, FALSE); + nautilus_toolbar_set_window_slot (NAUTILUS_TOOLBAR (window->toolbar), NULL); + } + + window->active_slot = new_slot; + + /* make new slot active, if it exists */ + if (new_slot) + { + /* inform slot & view */ + nautilus_window_slot_set_active (new_slot, TRUE); + nautilus_toolbar_set_window_slot (NAUTILUS_TOOLBAR (window->toolbar), new_slot); + + on_location_changed (window); + g_signal_emit (window, signals[ACTIVE_SELECTION_CHANGED], 0); + } +} + +static void +nautilus_window_realize (GtkWidget *widget) +{ + GTK_WIDGET_CLASS (nautilus_window_parent_class)->realize (widget); + update_cursor (NAUTILUS_WINDOW (widget)); +} + +static gboolean +nautilus_window_key_press_event (GtkWidget *widget, + GdkEventKey *event) +{ + NautilusWindow *window; + guint keyval; + GtkWidget *focus_widget; + + window = NAUTILUS_WINDOW (widget); + + if (G_UNLIKELY (!gdk_event_get_keyval ((GdkEvent *) event, &keyval))) + { + g_return_val_if_reached (GDK_EVENT_PROPAGATE); + } + + focus_widget = gtk_window_get_focus (GTK_WINDOW (window)); + if (focus_widget != NULL && GTK_IS_EDITABLE (focus_widget)) + { + /* if we have input focus on a GtkEditable (e.g. a GtkEntry), forward + * the event to it before activating accelerator bindings too. + */ + if (gtk_window_propagate_key_event (GTK_WINDOW (window), + (GdkEventKey *) event)) + { + return GDK_EVENT_STOP; + } + } + + for (int i = 0; i < G_N_ELEMENTS (extra_window_keybindings); i++) + { + if (extra_window_keybindings[i].keyval == keyval) + { + GAction *action; + + action = g_action_map_lookup_action (G_ACTION_MAP (window), extra_window_keybindings[i].action); + + g_assert (action != NULL); + if (g_action_get_enabled (action)) + { + g_action_activate (action, NULL); + return GDK_EVENT_STOP; + } + + break; + } + } + + if (GTK_WIDGET_CLASS (nautilus_window_parent_class)->key_press_event (widget, event)) + { + return GDK_EVENT_STOP; + } + + if (nautilus_window_slot_handle_event (window->active_slot, (GdkEvent *) event)) + { + return GDK_EVENT_STOP; + } + + return GDK_EVENT_PROPAGATE; +} + +void +nautilus_window_sync_title (NautilusWindow *window, + NautilusWindowSlot *slot) +{ + g_return_if_fail (NAUTILUS_IS_WINDOW (window)); + g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot)); + + if (slot == nautilus_window_get_active_slot (window)) + { + gtk_window_set_title (GTK_WINDOW (window), nautilus_window_slot_get_title (slot)); + } + + nautilus_notebook_sync_tab_label (NAUTILUS_NOTEBOOK (window->notebook), slot); +} + +#ifdef GDK_WINDOWING_WAYLAND +typedef struct +{ + NautilusWindow *window; + NautilusWindowHandleExported callback; + gpointer user_data; +} WaylandWindowHandleExportedData; + +static void +wayland_window_handle_exported (GdkWindow *window, + const char *wayland_handle_str, + gpointer user_data) +{ + WaylandWindowHandleExportedData *data = user_data; + + data->window->export_handle = g_strdup_printf ("wayland:%s", wayland_handle_str); + data->callback (data->window, data->window->export_handle, 0, data->user_data); +} +#endif + +gboolean +nautilus_window_export_handle (NautilusWindow *window, + NautilusWindowHandleExported callback, + gpointer user_data) +{ + guint xid = get_window_xid (window); + + if (window->export_handle != NULL) + { + callback (window, window->export_handle, xid, user_data); + return TRUE; + } + +#ifdef GDK_WINDOWING_X11 + if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window)))) + { + window->export_handle = g_strdup_printf ("x11:%x", xid); + callback (window, window->export_handle, xid, user_data); + + return TRUE; + } +#endif +#ifdef GDK_WINDOWING_WAYLAND + if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window)))) + { + GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window)); + WaylandWindowHandleExportedData *data; + + data = g_new0 (WaylandWindowHandleExportedData, 1); + data->window = window; + data->callback = callback; + data->user_data = user_data; + + if (!gdk_wayland_window_export_handle (gdk_window, + wayland_window_handle_exported, + data, + g_free)) + { + g_free (data); + return FALSE; + } + else + { + return TRUE; + } + } +#endif + + g_warning ("Couldn't export handle, unsupported windowing system"); + + return FALSE; +} + +void +nautilus_window_unexport_handle (NautilusWindow *window) +{ + if (window->export_handle == NULL) + { + return; + } + +#ifdef GDK_WINDOWING_WAYLAND + if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window)))) + { + GdkWindow *gdk_window = gtk_widget_get_window (GTK_WIDGET (window)); + if (gdk_window != NULL) + { + gdk_wayland_window_unexport_handle (gdk_window); + } + } +#endif + + g_clear_pointer (&window->export_handle, g_free); +} + +/** + * nautilus_window_show: + * @widget: GtkWidget + * + * Call parent and then show/hide window items + * base on user prefs. + */ +static void +nautilus_window_show (GtkWidget *widget) +{ + GTK_WIDGET_CLASS (nautilus_window_parent_class)->show (widget); +} + +NautilusWindowSlot * +nautilus_window_get_active_slot (NautilusWindow *window) +{ + g_assert (NAUTILUS_IS_WINDOW (window)); + + return window->active_slot; +} + +GList * +nautilus_window_get_slots (NautilusWindow *window) +{ + g_assert (NAUTILUS_IS_WINDOW (window)); + + return window->slots; +} + +static void +on_is_maximized_changed (GObject *object, + GParamSpec *pspec, + gpointer user_data) +{ + gboolean is_maximized; + + is_maximized = gtk_window_is_maximized (GTK_WINDOW (object)); + + g_settings_set_boolean (nautilus_window_state, + NAUTILUS_WINDOW_STATE_MAXIMIZED, is_maximized); +} + +static gboolean +nautilus_window_delete_event (GtkWidget *widget, + GdkEventAny *event) +{ + nautilus_window_close (NAUTILUS_WINDOW (widget)); + return FALSE; +} + +static void +on_multi_press_gesture_pressed (GtkGestureMultiPress *gesture, + gint n_press, + gdouble x, + gdouble y, + gpointer user_data) +{ + GtkWidget *widget; + NautilusWindow *window; + guint button; + + widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)); + window = NAUTILUS_WINDOW (widget); + button = gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)); + + if (mouse_extra_buttons && (button == mouse_back_button)) + { + nautilus_window_back_or_forward (window, TRUE, 0, 0); + } + else if (mouse_extra_buttons && (button == mouse_forward_button)) + { + nautilus_window_back_or_forward (window, FALSE, 0, 0); + } +} + +static void +mouse_back_button_changed (gpointer callback_data) +{ + int new_back_button; + + new_back_button = g_settings_get_int (nautilus_preferences, NAUTILUS_PREFERENCES_MOUSE_BACK_BUTTON); + + /* Bounds checking */ + if (new_back_button < 6 || new_back_button > UPPER_MOUSE_LIMIT) + { + return; + } + + mouse_back_button = new_back_button; +} + +static void +mouse_forward_button_changed (gpointer callback_data) +{ + int new_forward_button; + + new_forward_button = g_settings_get_int (nautilus_preferences, NAUTILUS_PREFERENCES_MOUSE_FORWARD_BUTTON); + + /* Bounds checking */ + if (new_forward_button < 6 || new_forward_button > UPPER_MOUSE_LIMIT) + { + return; + } + + mouse_forward_button = new_forward_button; +} + +static void +use_extra_mouse_buttons_changed (gpointer callback_data) +{ + mouse_extra_buttons = g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_MOUSE_USE_EXTRA_BUTTONS); +} + +static void +nautilus_window_init (NautilusWindow *window) +{ + GtkWindowGroup *window_group; + + g_type_ensure (NAUTILUS_TYPE_TOOLBAR); + g_type_ensure (NAUTILUS_TYPE_NOTEBOOK); + gtk_widget_init_template (GTK_WIDGET (window)); + + g_signal_connect (window, "notify::is-maximized", + G_CALLBACK (on_is_maximized_changed), NULL); + + g_signal_connect_object (window->in_app_notification_undo_close_button, "clicked", + G_CALLBACK (on_in_app_notification_undo_close_button_clicked), window, 0); + g_signal_connect_object (window->in_app_notification_undo_undo_button, "clicked", + G_CALLBACK (on_in_app_notification_undo_undo_button_clicked), window, 0); + + window->slots = NULL; + window->active_slot = NULL; + + gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (window)), + "nautilus-window"); + + window->toolbar = nautilus_toolbar_new (); + + window_group = gtk_window_group_new (); + gtk_window_group_add_window (window_group, GTK_WINDOW (window)); + g_object_unref (window_group); + + window->tab_data_queue = g_queue_new (); + + window->pad_controller = gtk_pad_controller_new (GTK_WINDOW (window), + G_ACTION_GROUP (window), + NULL); + gtk_pad_controller_set_action_entries (window->pad_controller, + pad_actions, G_N_ELEMENTS (pad_actions)); + + window->multi_press_gesture = gtk_gesture_multi_press_new (GTK_WIDGET (window)); + + gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (window->multi_press_gesture), + GTK_PHASE_CAPTURE); + gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (window->multi_press_gesture), 0); + + g_signal_connect (window->multi_press_gesture, "pressed", + G_CALLBACK (on_multi_press_gesture_pressed), NULL); + + window->notebook_multi_press_gesture = gtk_gesture_multi_press_new (window->notebook); + + gtk_event_controller_set_propagation_phase (GTK_EVENT_CONTROLLER (window->notebook_multi_press_gesture), + GTK_PHASE_CAPTURE); + gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (window->notebook_multi_press_gesture), + GDK_BUTTON_SECONDARY); +} + +static void +nautilus_window_class_init (NautilusWindowClass *class) +{ + GObjectClass *oclass = G_OBJECT_CLASS (class); + GtkWidgetClass *wclass = GTK_WIDGET_CLASS (class); + + oclass->dispose = nautilus_window_dispose; + oclass->finalize = nautilus_window_finalize; + oclass->constructed = nautilus_window_constructed; + + wclass->destroy = nautilus_window_destroy; + wclass->show = nautilus_window_show; + wclass->realize = nautilus_window_realize; + wclass->key_press_event = nautilus_window_key_press_event; + wclass->delete_event = nautilus_window_delete_event; + wclass->grab_focus = nautilus_window_grab_focus; + + gtk_widget_class_set_template_from_resource (wclass, + "/org/gnome/nautilus/ui/nautilus-window.ui"); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, content_paned); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, sidebar); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, places_sidebar); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, main_view); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, notebook); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, in_app_notification_undo); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, in_app_notification_undo_label); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, in_app_notification_undo_undo_button); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, in_app_notification_undo_close_button); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, notification_operation); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, notification_operation_label); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, notification_operation_open); + gtk_widget_class_bind_template_child (wclass, NautilusWindow, notification_operation_close); + + gtk_widget_class_bind_template_callback (wclass, places_sidebar_show_other_locations_with_flags); + gtk_widget_class_bind_template_callback (wclass, places_sidebar_show_starred_location); + + signals[SLOT_ADDED] = + g_signal_new ("slot-added", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, 1, NAUTILUS_TYPE_WINDOW_SLOT); + signals[SLOT_REMOVED] = + g_signal_new ("slot-removed", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, 1, NAUTILUS_TYPE_WINDOW_SLOT); + signals[ACTIVE_SELECTION_CHANGED] = + g_signal_new ("active-selection-changed", + G_TYPE_FROM_CLASS (class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + 0, + NULL, NULL, NULL, + G_TYPE_NONE, 0); + + g_signal_connect_swapped (nautilus_preferences, + "changed::" NAUTILUS_PREFERENCES_MOUSE_BACK_BUTTON, + G_CALLBACK (mouse_back_button_changed), + NULL); + + g_signal_connect_swapped (nautilus_preferences, + "changed::" NAUTILUS_PREFERENCES_MOUSE_FORWARD_BUTTON, + G_CALLBACK (mouse_forward_button_changed), + NULL); + + g_signal_connect_swapped (nautilus_preferences, + "changed::" NAUTILUS_PREFERENCES_MOUSE_USE_EXTRA_BUTTONS, + G_CALLBACK (use_extra_mouse_buttons_changed), + NULL); + + gtk_widget_class_bind_template_callback (wclass, on_notification_operation_open_clicked); + gtk_widget_class_bind_template_callback (wclass, on_notification_operation_close_clicked); +} + +NautilusWindow * +nautilus_window_new (GdkScreen *screen) +{ + return g_object_new (NAUTILUS_TYPE_WINDOW, + "icon-name", APPLICATION_ID, + "screen", screen, + NULL); +} + +NautilusWindowOpenFlags +nautilus_event_get_window_open_flags (void) +{ + NautilusWindowOpenFlags flags = 0; + GdkEvent *event; + + event = gtk_get_current_event (); + + if (event == NULL) + { + return flags; + } + + if ((event->type == GDK_BUTTON_PRESS || event->type == GDK_BUTTON_RELEASE) && + (event->button.button == GDK_BUTTON_MIDDLE)) + { + flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB; + } + + gdk_event_free (event); + + return flags; +} + +void +nautilus_window_show_about_dialog (NautilusWindow *window) +{ + const gchar *artists[] = + { + "The GNOME Project", + NULL + }; + const gchar *authors[] = + { + "Alexander Larsson", + "Ali Abdin", + "Anders Carlsson", + "Andrew Walton", + "Andy Hertzfeld", + "Arlo Rose", + "Christian Neumair", + "Cosimo Cecchi", + "Darin Adler", + "David Camp", + "Eli Goldberg", + "Elliot Lee", + "Eskil Heyn Olsen", + "Ettore Perazzoli", + "Gene Z. Ragan", + "George Lebl", + "Ian McKellar", + "J Shane Culpepper", + "James Willcox", + "Jan Arne Petersen", + "John Harper", + "John Sullivan", + "Josh Barrow", + "Maciej Stachowiak", + "Mark McLoughlin", + "Mathieu Lacage", + "Mike Engber", + "Mike Fleming", + "Pavel Cisler", + "Ramiro Estrugo", + "Raph Levien", + "Rebecca Schulman", + "Robey Pointer", + "Robin * Slomkowski", + "Seth Nickell", + "Susan Kare", + "Tomas Bzatek", + "William Jon McCann", + NULL + }; + const gchar *documenters[] = + { + "GNOME Documentation Team", + "Sun Microsystems", + NULL + }; + g_autofree gchar *program_name = NULL; + + /* “Files” is the generic application name and the suffix is + * an arbitrary and deliberately unlocalized string only shown + * in development builds. + */ + program_name = g_strconcat (_("Files"), NAME_SUFFIX, NULL); + + gtk_show_about_dialog (window ? GTK_WINDOW (window) : NULL, + "program-name", program_name, + "version", VERSION, + "comments", _("Access and organize your files"), + "website", "https://wiki.gnome.org/action/show/Apps/Files", + "copyright", "© 1999–2018 The Files Authors", + "license-type", GTK_LICENSE_GPL_3_0, + "artists", artists, + "authors", authors, + "documenters", documenters, + /* Translators should localize the following string + * which will be displayed at the bottom of the about + * box to give credit to the translator(s). + */ + "translator-credits", _("translator-credits"), + "logo-icon-name", APPLICATION_ID, + NULL); +} + +void +nautilus_window_search (NautilusWindow *window, + NautilusQuery *query) +{ + NautilusWindowSlot *active_slot; + + active_slot = nautilus_window_get_active_slot (window); + if (active_slot) + { + nautilus_window_slot_search (active_slot, query); + } + else + { + g_warning ("Trying search on a slot but no active slot present"); + } +} + +/* Ideally, this method should be a simple wrapper for the slot method. However, + * going back or forward can result in a new slot (or another subclass), so we + * workaround that by duplicating part of nautilus_window_slot_back_or_forward() + */ +void +nautilus_window_back_or_forward (NautilusWindow *window, + gboolean back, + guint distance, + NautilusWindowOpenFlags flags) +{ + NautilusWindowSlot *slot; + GList *next_location_list, *back_list, *forward_list; + GFile *next_location; + guint len; + NautilusBookmark *next_location_bookmark; + gboolean active_slot_handles_location; + + slot = nautilus_window_get_active_slot (window); + back_list = nautilus_window_slot_get_back_history (slot); + forward_list = nautilus_window_slot_get_forward_history (slot); + + next_location_list = back ? back_list : forward_list; + + len = (guint) g_list_length (next_location_list); + + /* If we can't move in the direction at all, just return. */ + if (len == 0) + { + return; + } + + /* If the distance to move is off the end of the list, go to the end + * of the list. */ + if (distance >= len) + { + distance = len - 1; + } + + next_location_bookmark = g_list_nth_data (next_location_list, distance); + next_location = nautilus_bookmark_get_location (next_location_bookmark); + + active_slot_handles_location = nautilus_window_slot_handles_location (slot, next_location); + + if (!active_slot_handles_location) + { + NautilusNavigationState *navigation_state; + NautilusLocationChangeType location_change_type; + + navigation_state = nautilus_window_slot_get_navigation_state (slot); + + location_change_type = back ? NAUTILUS_LOCATION_CHANGE_BACK : NAUTILUS_LOCATION_CHANGE_FORWARD; + + slot = replace_active_slot (window, next_location, flags); + + nautilus_window_slot_open_location_set_navigation_state (slot, + next_location, flags, NULL, + location_change_type, + navigation_state, distance); + + free_navigation_state (navigation_state); + } + else + { + nautilus_window_slot_back_or_forward (slot, back, distance, flags); + } +} |