diff options
Diffstat (limited to 'src/caja-window-manage-views.c')
| -rw-r--r-- | src/caja-window-manage-views.c | 2337 |
1 files changed, 2337 insertions, 0 deletions
diff --git a/src/caja-window-manage-views.c b/src/caja-window-manage-views.c new file mode 100644 index 00000000..df36f821 --- /dev/null +++ b/src/caja-window-manage-views.c @@ -0,0 +1,2337 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ + +/* + * Caja + * + * Copyright (C) 1999, 2000 Red Hat, Inc. + * Copyright (C) 1999, 2000, 2001 Eazel, Inc. + * + * Caja 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. + * + * Caja is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * Authors: Elliot Lee <[email protected]> + * John Sullivan <[email protected]> + * Darin Adler <[email protected]> + */ + +#include <config.h> +#include "caja-window-manage-views.h" + +#include "caja-actions.h" +#include "caja-application.h" +#include "caja-location-bar.h" +#include "caja-search-bar.h" +#include "caja-pathbar.h" +#include "caja-main.h" +#include "caja-window-private.h" +#include "caja-window-slot.h" +#include "caja-navigation-window-slot.h" +#include "caja-trash-bar.h" +#include "caja-x-content-bar.h" +#include "caja-zoom-control.h" +#include "caja-navigation-window-pane.h" +#include <eel/eel-accessibility.h> +#include <eel/eel-debug.h> +#include <eel/eel-gdk-extensions.h> +#include <eel/eel-glib-extensions.h> +#include <eel/eel-gtk-extensions.h> +#include <eel/eel-gtk-macros.h> +#include <eel/eel-stock-dialogs.h> +#include <eel/eel-string.h> +#include <gtk/gtk.h> +#include <gdk/gdkx.h> +#include <glib/gi18n.h> +#include <libcaja-extension/caja-location-widget-provider.h> +#include <libcaja-private/caja-debug-log.h> +#include <libcaja-private/caja-file-attributes.h> +#include <libcaja-private/caja-file-utilities.h> +#include <libcaja-private/caja-file.h> +#include <libcaja-private/caja-global-preferences.h> +#include <libcaja-private/caja-metadata.h> +#include <libcaja-private/caja-mime-actions.h> +#include <libcaja-private/caja-module.h> +#include <libcaja-private/caja-monitor.h> +#include <libcaja-private/caja-search-directory.h> +#include <libcaja-private/caja-view-factory.h> +#include <libcaja-private/caja-window-info.h> +#include <libcaja-private/caja-window-slot-info.h> +#include <libcaja-private/caja-autorun.h> + +/* FIXME bugzilla.gnome.org 41243: + * We should use inheritance instead of these special cases + * for the desktop window. + */ +#include "caja-desktop-window.h" + +/* This number controls a maximum character count for a URL that is + * displayed as part of a dialog. It's fairly arbitrary -- big enough + * to allow most "normal" URIs to display in full, but small enough to + * prevent the dialog from getting insanely wide. + */ +#define MAX_URI_IN_DIALOG_LENGTH 60 + +static void begin_location_change (CajaWindowSlot *slot, + GFile *location, + GList *new_selection, + CajaLocationChangeType type, + guint distance, + const char *scroll_pos); +static void free_location_change (CajaWindowSlot *slot); +static void end_location_change (CajaWindowSlot *slot); +static void cancel_location_change (CajaWindowSlot *slot); +static void got_file_info_for_view_selection_callback (CajaFile *file, + gpointer callback_data); +static void create_content_view (CajaWindowSlot *slot, + const char *view_id); +static void display_view_selection_failure (CajaWindow *window, + CajaFile *file, + GFile *location, + GError *error); +static void load_new_location (CajaWindowSlot *slot, + GFile *location, + GList *selection, + gboolean tell_current_content_view, + gboolean tell_new_content_view); +static void location_has_really_changed (CajaWindowSlot *slot); +static void update_for_new_location (CajaWindowSlot *slot); + +void +caja_window_report_selection_changed (CajaWindowInfo *window) +{ + if (window->details->temporarily_ignore_view_signals) + { + return; + } + + g_signal_emit_by_name (window, "selection_changed"); +} + +/* set_displayed_location: + */ +static void +set_displayed_location (CajaWindowSlot *slot, GFile *location) +{ + CajaWindow *window; + GFile *bookmark_location; + gboolean recreate; + char *name; + + window = slot->pane->window; + + if (slot->current_location_bookmark == NULL || location == NULL) + { + recreate = TRUE; + } + else + { + bookmark_location = caja_bookmark_get_location (slot->current_location_bookmark); + recreate = !g_file_equal (bookmark_location, location); + g_object_unref (bookmark_location); + } + + if (recreate) + { + /* We've changed locations, must recreate bookmark for current location. */ + if (slot->last_location_bookmark != NULL) + { + g_object_unref (slot->last_location_bookmark); + } + slot->last_location_bookmark = slot->current_location_bookmark; + name = g_file_get_basename (location); + slot->current_location_bookmark = (location == NULL) ? NULL + : caja_bookmark_new (location, name, FALSE, NULL); + g_free (name); + } +} + +static void +check_bookmark_location_matches (CajaBookmark *bookmark, GFile *location) +{ + GFile *bookmark_location; + char *bookmark_uri, *uri; + + bookmark_location = caja_bookmark_get_location (bookmark); + if (!g_file_equal (location, bookmark_location)) + { + bookmark_uri = g_file_get_uri (bookmark_location); + uri = g_file_get_uri (location); + g_warning ("bookmark uri is %s, but expected %s", bookmark_uri, uri); + g_free (uri); + g_free (bookmark_uri); + } + g_object_unref (bookmark_location); +} + +/* Debugging function used to verify that the last_location_bookmark + * is in the state we expect when we're about to use it to update the + * Back or Forward list. + */ +static void +check_last_bookmark_location_matches_slot (CajaWindowSlot *slot) +{ + check_bookmark_location_matches (slot->last_location_bookmark, + slot->location); +} + +static void +handle_go_back (CajaNavigationWindowSlot *navigation_slot, + GFile *location) +{ + CajaWindowSlot *slot; + guint i; + GList *link; + CajaBookmark *bookmark; + + slot = CAJA_WINDOW_SLOT (navigation_slot); + + /* Going back. Move items from the back list to the forward list. */ + g_assert (g_list_length (navigation_slot->back_list) > slot->location_change_distance); + check_bookmark_location_matches (CAJA_BOOKMARK (g_list_nth_data (navigation_slot->back_list, + slot->location_change_distance)), + location); + g_assert (slot->location != NULL); + + /* Move current location to Forward list */ + + check_last_bookmark_location_matches_slot (slot); + + /* Use the first bookmark in the history list rather than creating a new one. */ + navigation_slot->forward_list = g_list_prepend (navigation_slot->forward_list, + slot->last_location_bookmark); + g_object_ref (navigation_slot->forward_list->data); + + /* Move extra links from Back to Forward list */ + for (i = 0; i < slot->location_change_distance; ++i) + { + bookmark = CAJA_BOOKMARK (navigation_slot->back_list->data); + navigation_slot->back_list = + g_list_remove (navigation_slot->back_list, bookmark); + navigation_slot->forward_list = + g_list_prepend (navigation_slot->forward_list, bookmark); + } + + /* One bookmark falls out of back/forward lists and becomes viewed location */ + link = navigation_slot->back_list; + navigation_slot->back_list = g_list_remove_link (navigation_slot->back_list, link); + g_object_unref (link->data); + g_list_free_1 (link); +} + +static void +handle_go_forward (CajaNavigationWindowSlot *navigation_slot, + GFile *location) +{ + CajaWindowSlot *slot; + guint i; + GList *link; + CajaBookmark *bookmark; + + slot = CAJA_WINDOW_SLOT (navigation_slot); + + /* Going forward. Move items from the forward list to the back list. */ + g_assert (g_list_length (navigation_slot->forward_list) > slot->location_change_distance); + check_bookmark_location_matches (CAJA_BOOKMARK (g_list_nth_data (navigation_slot->forward_list, + slot->location_change_distance)), + location); + g_assert (slot->location != NULL); + + /* Move current location to Back list */ + check_last_bookmark_location_matches_slot (slot); + + /* Use the first bookmark in the history list rather than creating a new one. */ + navigation_slot->back_list = g_list_prepend (navigation_slot->back_list, + slot->last_location_bookmark); + g_object_ref (navigation_slot->back_list->data); + + /* Move extra links from Forward to Back list */ + for (i = 0; i < slot->location_change_distance; ++i) + { + bookmark = CAJA_BOOKMARK (navigation_slot->forward_list->data); + navigation_slot->forward_list = + g_list_remove (navigation_slot->back_list, bookmark); + navigation_slot->back_list = + g_list_prepend (navigation_slot->forward_list, bookmark); + } + + /* One bookmark falls out of back/forward lists and becomes viewed location */ + link = navigation_slot->forward_list; + navigation_slot->forward_list = g_list_remove_link (navigation_slot->forward_list, link); + g_object_unref (link->data); + g_list_free_1 (link); +} + +static void +handle_go_elsewhere (CajaWindowSlot *slot, GFile *location) +{ +#if !NEW_UI_COMPLETE + CajaNavigationWindowSlot *navigation_slot; + + if (CAJA_IS_NAVIGATION_WINDOW_SLOT (slot)) + { + navigation_slot = CAJA_NAVIGATION_WINDOW_SLOT (slot); + + /* Clobber the entire forward list, and move displayed location to back list */ + caja_navigation_window_slot_clear_forward_list (navigation_slot); + + if (slot->location != NULL) + { + /* If we're returning to the same uri somehow, don't put this uri on back list. + * This also avoids a problem where set_displayed_location + * didn't update last_location_bookmark since the uri didn't change. + */ + if (!g_file_equal (slot->location, location)) + { + /* Store bookmark for current location in back list, unless there is no current location */ + check_last_bookmark_location_matches_slot (slot); + /* Use the first bookmark in the history list rather than creating a new one. */ + navigation_slot->back_list = g_list_prepend (navigation_slot->back_list, + slot->last_location_bookmark); + g_object_ref (navigation_slot->back_list->data); + } + } + } +#endif +} + +void +caja_window_update_up_button (CajaWindow *window) +{ + CajaWindowSlot *slot; + gboolean allowed; + GFile *parent; + + slot = window->details->active_pane->active_slot; + + allowed = FALSE; + if (slot->location != NULL) + { + parent = g_file_get_parent (slot->location); + allowed = parent != NULL; + if (parent != NULL) + { + g_object_unref (parent); + } + } + + caja_window_allow_up (window, allowed); +} + +static void +viewed_file_changed_callback (CajaFile *file, + CajaWindowSlot *slot) +{ + CajaWindow *window; + GFile *new_location; + gboolean is_in_trash, was_in_trash; + + window = slot->pane->window; + + g_assert (CAJA_IS_FILE (file)); + g_assert (CAJA_IS_WINDOW_PANE (slot->pane)); + g_assert (CAJA_IS_WINDOW (window)); + + g_assert (file == slot->viewed_file); + + if (!caja_file_is_not_yet_confirmed (file)) + { + slot->viewed_file_seen = TRUE; + } + + was_in_trash = slot->viewed_file_in_trash; + + slot->viewed_file_in_trash = is_in_trash = caja_file_is_in_trash (file); + + /* Close window if the file it's viewing has been deleted or moved to trash. */ + if (caja_file_is_gone (file) || (is_in_trash && !was_in_trash)) + { + /* Don't close the window in the case where the + * file was never seen in the first place. + */ + if (slot->viewed_file_seen) + { + /* Detecting a file is gone may happen in the + * middle of a pending location change, we + * need to cancel it before closing the window + * or things break. + */ + /* FIXME: It makes no sense that this call is + * needed. When the window is destroyed, it + * calls caja_window_manage_views_destroy, + * which calls free_location_change, which + * should be sufficient. Also, if this was + * really needed, wouldn't it be needed for + * all other caja_window_close callers? + */ + end_location_change (slot); + + if (CAJA_IS_NAVIGATION_WINDOW (window)) + { + /* auto-show existing parent. */ + GFile *go_to_file, *parent, *location; + + go_to_file = NULL; + location = caja_file_get_location (file); + parent = g_file_get_parent (location); + g_object_unref (location); + if (parent) + { + go_to_file = caja_find_existing_uri_in_hierarchy (parent); + g_object_unref (parent); + } + + if (go_to_file != NULL) + { + /* the path bar URI will be set to go_to_uri immediately + * in begin_location_change, but we don't want the + * inexistant children to show up anymore */ + if (slot == slot->pane->active_slot) + { + /* multiview-TODO also update CajaWindowSlot + * [which as of writing doesn't save/store any path bar state] + */ + caja_path_bar_clear_buttons (CAJA_PATH_BAR (CAJA_NAVIGATION_WINDOW_PANE (slot->pane)->path_bar)); + } + + caja_window_slot_go_to (slot, go_to_file, FALSE); + g_object_unref (go_to_file); + } + else + { + caja_window_slot_go_home (slot, FALSE); + } + } + else + { + caja_window_close (window); + } + } + } + else + { + new_location = caja_file_get_location (file); + + /* If the file was renamed, update location and/or + * title. */ + if (!g_file_equal (new_location, + slot->location)) + { + g_object_unref (slot->location); + slot->location = new_location; + if (slot == slot->pane->active_slot) + { + caja_window_pane_sync_location_widgets (slot->pane); + } + } + else + { + /* TODO? + * why do we update title & icon at all in this case? */ + g_object_unref (new_location); + } + + caja_window_slot_update_title (slot); + caja_window_slot_update_icon (slot); + } +} + +static void +update_history (CajaWindowSlot *slot, + CajaLocationChangeType type, + GFile *new_location) +{ + switch (type) + { + case CAJA_LOCATION_CHANGE_STANDARD: + case CAJA_LOCATION_CHANGE_FALLBACK: + caja_window_slot_add_current_location_to_history_list (slot); + handle_go_elsewhere (slot, new_location); + return; + case CAJA_LOCATION_CHANGE_RELOAD: + /* for reload there is no work to do */ + return; + case CAJA_LOCATION_CHANGE_BACK: + caja_window_slot_add_current_location_to_history_list (slot); + handle_go_back (CAJA_NAVIGATION_WINDOW_SLOT (slot), new_location); + return; + case CAJA_LOCATION_CHANGE_FORWARD: + caja_window_slot_add_current_location_to_history_list (slot); + handle_go_forward (CAJA_NAVIGATION_WINDOW_SLOT (slot), new_location); + return; + case CAJA_LOCATION_CHANGE_REDIRECT: + /* for the redirect case, the caller can do the updating */ + return; + } + g_return_if_fail (FALSE); +} + +static void +cancel_viewed_file_changed_callback (CajaWindowSlot *slot) +{ + CajaFile *file; + + file = slot->viewed_file; + if (file != NULL) + { + g_signal_handlers_disconnect_by_func (G_OBJECT (file), + G_CALLBACK (viewed_file_changed_callback), + slot); + caja_file_monitor_remove (file, &slot->viewed_file); + } +} + +static void +new_window_show_callback (GtkWidget *widget, + gpointer user_data) +{ + CajaWindow *window; + + window = CAJA_WINDOW (user_data); + + caja_window_close (window); + + g_signal_handlers_disconnect_by_func (widget, + G_CALLBACK (new_window_show_callback), + user_data); +} + + +void +caja_window_slot_open_location_full (CajaWindowSlot *slot, + GFile *location, + CajaWindowOpenMode mode, + CajaWindowOpenFlags flags, + GList *new_selection) +{ + CajaWindow *window; + CajaWindow *target_window; + CajaWindowPane *pane; + CajaWindowSlot *target_slot; + CajaWindowOpenFlags slot_flags; + gboolean do_load_location = TRUE; + GFile *old_location; + char *old_uri, *new_uri; + int new_slot_position; + GList *l; + + window = slot->pane->window; + + target_window = NULL; + target_slot = NULL; + + old_uri = caja_window_slot_get_location_uri (slot); + if (old_uri == NULL) + { + old_uri = g_strdup ("(none)"); + } + new_uri = g_file_get_uri (location); + caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER, + "window %p open location: old=\"%s\", new=\"%s\"", + window, + old_uri, + new_uri); + g_free (old_uri); + g_free (new_uri); + + g_assert (!((flags & CAJA_WINDOW_OPEN_FLAG_NEW_WINDOW) != 0 && + (flags & CAJA_WINDOW_OPEN_FLAG_NEW_TAB) != 0)); + + + old_location = caja_window_slot_get_location (slot); + switch (mode) + { + case CAJA_WINDOW_OPEN_ACCORDING_TO_MODE : + if (eel_preferences_get_boolean (CAJA_PREFERENCES_ALWAYS_USE_BROWSER)) + { + target_window = window; + if (CAJA_IS_SPATIAL_WINDOW (window)) + { + if (!CAJA_SPATIAL_WINDOW (window)->affect_spatial_window_on_next_location_change) + { + target_window = caja_application_create_navigation_window + (window->application, + NULL, + gtk_window_get_screen (GTK_WINDOW (window))); + } + else + { + CAJA_SPATIAL_WINDOW (window)->affect_spatial_window_on_next_location_change = FALSE; + } + } + else if ((flags & CAJA_WINDOW_OPEN_FLAG_NEW_WINDOW) != 0) + { + target_window = caja_application_create_navigation_window + (window->application, + NULL, + gtk_window_get_screen (GTK_WINDOW (window))); + } + } + else if (CAJA_IS_SPATIAL_WINDOW (window)) + { + if (!CAJA_SPATIAL_WINDOW (window)->affect_spatial_window_on_next_location_change) + { + target_window = caja_application_present_spatial_window_with_selection ( + window->application, + window, + NULL, + location, + new_selection, + gtk_window_get_screen (GTK_WINDOW (window))); + do_load_location = FALSE; + } + else + { + CAJA_SPATIAL_WINDOW (window)->affect_spatial_window_on_next_location_change = FALSE; + target_window = window; + } + } + else if (flags & CAJA_WINDOW_OPEN_FLAG_NEW_WINDOW) + { + target_window = caja_application_create_navigation_window + (window->application, + NULL, + gtk_window_get_screen (GTK_WINDOW (window))); + } + else + { + target_window = window; + } + break; + case CAJA_WINDOW_OPEN_IN_SPATIAL : + target_window = caja_application_present_spatial_window ( + window->application, + window, + NULL, + location, + gtk_window_get_screen (GTK_WINDOW (window))); + break; + case CAJA_WINDOW_OPEN_IN_NAVIGATION : + target_window = caja_application_create_navigation_window + (window->application, + NULL, + gtk_window_get_screen (GTK_WINDOW (window))); + break; + default : + g_warning ("Unknown open location mode"); + g_object_unref (old_location); + return; + } + + g_assert (target_window != NULL); + + if ((flags & CAJA_WINDOW_OPEN_FLAG_NEW_TAB) != 0 && + CAJA_IS_NAVIGATION_WINDOW (window)) + { + g_assert (target_window == window); + + slot_flags = 0; + + new_slot_position = eel_preferences_get_enum (CAJA_PREFERENCES_NEW_TAB_POSITION); + if (new_slot_position == CAJA_NEW_TAB_POSITION_END) + { + slot_flags = CAJA_WINDOW_OPEN_SLOT_APPEND; + } + + target_slot = caja_window_open_slot (window->details->active_pane, slot_flags); + } + + if ((flags & CAJA_WINDOW_OPEN_FLAG_CLOSE_BEHIND) != 0) + { + if (CAJA_IS_SPATIAL_WINDOW (window) && !CAJA_IS_DESKTOP_WINDOW (window)) + { + if (gtk_widget_get_visible (GTK_WIDGET (target_window))) + { + caja_window_close (window); + } + else + { + g_signal_connect_object (target_window, + "show", + G_CALLBACK (new_window_show_callback), + window, + G_CONNECT_AFTER); + } + } + } + + if (target_slot == NULL) + { + if (target_window == window) + { + target_slot = slot; + } + else + { + target_slot = target_window->details->active_pane->active_slot; + } + } + + if ((!do_load_location) || + (target_window == window && target_slot == slot && + old_location && g_file_equal (old_location, location))) + { + if (old_location) + { + g_object_unref (old_location); + } + return; + } + + if (old_location) + { + g_object_unref (old_location); + } + + begin_location_change (target_slot, location, new_selection, + CAJA_LOCATION_CHANGE_STANDARD, 0, NULL); + + /* Additionally, load this in all slots that have no location, this means + we load both panes in e.g. a newly opened dual pane window. */ + for (l = target_window->details->panes; l != NULL; l = l->next) + { + pane = l->data; + slot = pane->active_slot; + if (slot->location == NULL && slot->pending_location == NULL) + { + begin_location_change (slot, location, new_selection, + CAJA_LOCATION_CHANGE_STANDARD, 0, NULL); + } + } +} + +void +caja_window_slot_open_location (CajaWindowSlot *slot, + GFile *location, + gboolean close_behind) +{ + CajaWindowOpenFlags flags; + + flags = 0; + if (close_behind) + { + flags = CAJA_WINDOW_OPEN_FLAG_CLOSE_BEHIND; + } + + caja_window_slot_open_location_full (slot, location, + CAJA_WINDOW_OPEN_ACCORDING_TO_MODE, + flags, NULL); +} + +void +caja_window_slot_open_location_with_selection (CajaWindowSlot *slot, + GFile *location, + GList *selection, + gboolean close_behind) +{ + CajaWindowOpenFlags flags; + + flags = 0; + if (close_behind) + { + flags = CAJA_WINDOW_OPEN_FLAG_CLOSE_BEHIND; + } + caja_window_slot_open_location_full (slot, location, + CAJA_WINDOW_OPEN_ACCORDING_TO_MODE, + flags, selection); +} + + +void +caja_window_slot_go_home (CajaWindowSlot *slot, gboolean new_tab) +{ + GFile *home; + CajaWindowOpenFlags flags; + + g_return_if_fail (CAJA_IS_WINDOW_SLOT (slot)); + + if (new_tab) + { + flags = CAJA_WINDOW_OPEN_FLAG_NEW_TAB; + } + else + { + flags = 0; + } + + home = g_file_new_for_path (g_get_home_dir ()); + caja_window_slot_open_location_full (slot, home, + CAJA_WINDOW_OPEN_ACCORDING_TO_MODE, + flags, NULL); + g_object_unref (home); +} + +#if 0 +static char * +caja_window_slot_get_view_label (CajaWindowSlot *slot) +{ + const CajaViewInfo *info; + + info = caja_view_factory_lookup (caja_window_slot_get_content_view_id (slot)); + + return g_strdup (info->label); +} +#endif + +static char * +caja_window_slot_get_view_error_label (CajaWindowSlot *slot) +{ + const CajaViewInfo *info; + + info = caja_view_factory_lookup (caja_window_slot_get_content_view_id (slot)); + + return g_strdup (info->error_label); +} + +static char * +caja_window_slot_get_view_startup_error_label (CajaWindowSlot *slot) +{ + const CajaViewInfo *info; + + info = caja_view_factory_lookup (caja_window_slot_get_content_view_id (slot)); + + return g_strdup (info->startup_error_label); +} + +static void +report_current_content_view_failure_to_user (CajaWindowSlot *slot) +{ + CajaWindow *window; + char *message; + + window = slot->pane->window; + + message = caja_window_slot_get_view_startup_error_label (slot); + eel_show_error_dialog (message, + _("You can choose another view or go to a different location."), + GTK_WINDOW (window)); + g_free (message); +} + +static void +report_nascent_content_view_failure_to_user (CajaWindowSlot *slot, + CajaView *view) +{ + CajaWindow *window; + char *message; + + window = slot->pane->window; + + /* TODO? why are we using the current view's error label here, instead of the next view's? + * This behavior has already been present in pre-slot days. + */ + message = caja_window_slot_get_view_error_label (slot); + eel_show_error_dialog (message, + _("The location cannot be displayed with this viewer."), + GTK_WINDOW (window)); + g_free (message); +} + + +const char * +caja_window_slot_get_content_view_id (CajaWindowSlot *slot) +{ + if (slot->content_view == NULL) + { + return NULL; + } + return caja_view_get_view_id (slot->content_view); +} + +gboolean +caja_window_slot_content_view_matches_iid (CajaWindowSlot *slot, + const char *iid) +{ + if (slot->content_view == NULL) + { + return FALSE; + } + return eel_strcmp (caja_view_get_view_id (slot->content_view), iid) == 0; +} + + +/* + * begin_location_change + * + * Change a window's location. + * @window: The CajaWindow whose location should be changed. + * @location: A url specifying the location to load + * @new_selection: The initial selection to present after loading the location + * @type: Which type of location change is this? Standard, back, forward, or reload? + * @distance: If type is back or forward, the index into the back or forward chain. If + * type is standard or reload, this is ignored, and must be 0. + * @scroll_pos: The file to scroll to when the location is loaded. + * + * This is the core function for changing the location of a window. Every change to the + * location begins here. + */ +static void +begin_location_change (CajaWindowSlot *slot, + GFile *location, + GList *new_selection, + CajaLocationChangeType type, + guint distance, + const char *scroll_pos) +{ + CajaWindow *window; + CajaDirectory *directory; + CajaFile *file; + gboolean force_reload; + char *current_pos; + + g_assert (slot != NULL); + g_assert (location != NULL); + g_assert (type == CAJA_LOCATION_CHANGE_BACK + || type == CAJA_LOCATION_CHANGE_FORWARD + || distance == 0); + + window = slot->pane->window; + g_assert (CAJA_IS_WINDOW (window)); + g_object_ref (window); + + end_location_change (slot); + + caja_window_slot_set_allow_stop (slot, TRUE); + caja_window_slot_set_status (slot, " "); + + g_assert (slot->pending_location == NULL); + g_assert (slot->pending_selection == NULL); + + slot->pending_location = g_object_ref (location); + slot->location_change_type = type; + slot->location_change_distance = distance; + slot->tried_mount = FALSE; + slot->pending_selection = eel_g_object_list_copy (new_selection); + + slot->pending_scroll_to = g_strdup (scroll_pos); + + directory = caja_directory_get (location); + + /* The code to force a reload is here because if we do it + * after determining an initial view (in the components), then + * we end up fetching things twice. + */ + if (type == CAJA_LOCATION_CHANGE_RELOAD) + { + force_reload = TRUE; + } + else if (!caja_monitor_active ()) + { + force_reload = TRUE; + } + else + { + force_reload = !caja_directory_is_local (directory); + } + + if (force_reload) + { + caja_directory_force_reload (directory); + file = caja_directory_get_corresponding_file (directory); + caja_file_invalidate_all_attributes (file); + caja_file_unref (file); + } + + caja_directory_unref (directory); + + /* Set current_bookmark scroll pos */ + if (slot->current_location_bookmark != NULL && + slot->content_view != NULL) + { + current_pos = caja_view_get_first_visible_file (slot->content_view); + caja_bookmark_set_scroll_pos (slot->current_location_bookmark, current_pos); + g_free (current_pos); + } + + /* Get the info needed for view selection */ + + slot->determine_view_file = caja_file_get (location); + g_assert (slot->determine_view_file != NULL); + + /* if the currently viewed file is marked gone while loading the new location, + * this ensures that the window isn't destroyed */ + cancel_viewed_file_changed_callback (slot); + + caja_file_call_when_ready (slot->determine_view_file, + CAJA_FILE_ATTRIBUTE_INFO | + CAJA_FILE_ATTRIBUTE_MOUNT, + got_file_info_for_view_selection_callback, + slot); + + g_object_unref (window); +} + +static void +setup_new_spatial_window (CajaWindowSlot *slot, CajaFile *file) +{ + CajaWindow *window; + char *show_hidden_file_setting; + char *geometry_string; + char *scroll_string; + gboolean maximized, sticky, above; + GtkAction *action; + + window = slot->pane->window; + + if (CAJA_IS_SPATIAL_WINDOW (window) && !CAJA_IS_DESKTOP_WINDOW (window)) + { + /* load show hidden state */ + show_hidden_file_setting = caja_file_get_metadata + (file, CAJA_METADATA_KEY_WINDOW_SHOW_HIDDEN_FILES, + NULL); + if (show_hidden_file_setting != NULL) + { + if (strcmp (show_hidden_file_setting, "1") == 0) + { + window->details->show_hidden_files_mode = CAJA_WINDOW_SHOW_HIDDEN_FILES_ENABLE; + } + else + { + window->details->show_hidden_files_mode = CAJA_WINDOW_SHOW_HIDDEN_FILES_DISABLE; + } + + /* Update the UI, since we initialize it to the default */ + action = gtk_action_group_get_action (window->details->main_action_group, CAJA_ACTION_SHOW_HIDDEN_FILES); + gtk_action_block_activate (action); + gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), + window->details->show_hidden_files_mode == CAJA_WINDOW_SHOW_HIDDEN_FILES_ENABLE); + gtk_action_unblock_activate (action); + } + else + { + CAJA_WINDOW (window)->details->show_hidden_files_mode = CAJA_WINDOW_SHOW_HIDDEN_FILES_DEFAULT; + } + g_free (show_hidden_file_setting); + + /* load the saved window geometry */ + maximized = caja_file_get_boolean_metadata + (file, CAJA_METADATA_KEY_WINDOW_MAXIMIZED, FALSE); + if (maximized) + { + gtk_window_maximize (GTK_WINDOW (window)); + } + else + { + gtk_window_unmaximize (GTK_WINDOW (window)); + } + + sticky = caja_file_get_boolean_metadata + (file, CAJA_METADATA_KEY_WINDOW_STICKY, FALSE); + if (sticky) + { + gtk_window_stick (GTK_WINDOW (window)); + } + else + { + gtk_window_unstick (GTK_WINDOW (window)); + } + + above = caja_file_get_boolean_metadata + (file, CAJA_METADATA_KEY_WINDOW_KEEP_ABOVE, FALSE); + if (above) + { + gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); + } + else + { + gtk_window_set_keep_above (GTK_WINDOW (window), FALSE); + } + + geometry_string = caja_file_get_metadata + (file, CAJA_METADATA_KEY_WINDOW_GEOMETRY, NULL); + if (geometry_string != NULL) + { + eel_gtk_window_set_initial_geometry_from_string + (GTK_WINDOW (window), + geometry_string, + CAJA_SPATIAL_WINDOW_MIN_WIDTH, + CAJA_SPATIAL_WINDOW_MIN_HEIGHT, + FALSE); + } + g_free (geometry_string); + + if (slot->pending_selection == NULL) + { + /* If there is no pending selection, then load the saved scroll position. */ + scroll_string = caja_file_get_metadata + (file, CAJA_METADATA_KEY_WINDOW_SCROLL_POSITION, + NULL); + } + else + { + /* If there is a pending selection, we want to scroll to an item in + * the pending selection list. */ + scroll_string = g_file_get_uri (slot->pending_selection->data); + } + + /* scroll_string might be NULL if there was no saved scroll position. */ + if (scroll_string != NULL) + { + slot->pending_scroll_to = scroll_string; + } + } +} + +typedef struct +{ + GCancellable *cancellable; + CajaWindowSlot *slot; +} MountNotMountedData; + +static void +mount_not_mounted_callback (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + MountNotMountedData *data; + CajaWindow *window; + CajaWindowSlot *slot; + GError *error; + GCancellable *cancellable; + + data = user_data; + slot = data->slot; + window = slot->pane->window; + cancellable = data->cancellable; + g_free (data); + + if (g_cancellable_is_cancelled (cancellable)) + { + /* Cancelled, don't call back */ + g_object_unref (cancellable); + return; + } + + slot->mount_cancellable = NULL; + + slot->determine_view_file = caja_file_get (slot->pending_location); + + error = NULL; + if (!g_file_mount_enclosing_volume_finish (G_FILE (source_object), res, &error)) + { + slot->mount_error = error; + got_file_info_for_view_selection_callback (slot->determine_view_file, slot); + slot->mount_error = NULL; + g_error_free (error); + } + else + { + caja_file_invalidate_all_attributes (slot->determine_view_file); + caja_file_call_when_ready (slot->determine_view_file, + CAJA_FILE_ATTRIBUTE_INFO, + got_file_info_for_view_selection_callback, + slot); + } + + g_object_unref (cancellable); +} + +static void +got_file_info_for_view_selection_callback (CajaFile *file, + gpointer callback_data) +{ + GError *error; + char *view_id; + char *mimetype; + CajaWindow *window; + CajaWindowSlot *slot; + CajaFile *viewed_file; + GFile *location; + GMountOperation *mount_op; + MountNotMountedData *data; + + slot = callback_data; + g_assert (CAJA_IS_WINDOW_SLOT (slot)); + g_assert (slot->determine_view_file == file); + + window = slot->pane->window; + g_assert (CAJA_IS_WINDOW (window)); + + slot->determine_view_file = NULL; + + if (slot->mount_error) + { + error = slot->mount_error; + } + else + { + error = caja_file_get_file_info_error (file); + } + + if (error && error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_MOUNTED && + !slot->tried_mount) + { + slot->tried_mount = TRUE; + + mount_op = gtk_mount_operation_new (GTK_WINDOW (window)); + g_mount_operation_set_password_save (mount_op, G_PASSWORD_SAVE_FOR_SESSION); + location = caja_file_get_location (file); + data = g_new0 (MountNotMountedData, 1); + data->cancellable = g_cancellable_new (); + data->slot = slot; + slot->mount_cancellable = data->cancellable; + g_file_mount_enclosing_volume (location, 0, mount_op, slot->mount_cancellable, + mount_not_mounted_callback, data); + g_object_unref (location); + g_object_unref (mount_op); + + caja_file_unref (file); + + return; + } + + location = slot->pending_location; + + view_id = NULL; + + if (error == NULL || + (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_SUPPORTED)) + { + /* We got the information we need, now pick what view to use: */ + + mimetype = caja_file_get_mime_type (file); + + /* If fallback, don't use view from metadata */ + if (slot->location_change_type != CAJA_LOCATION_CHANGE_FALLBACK) + { + /* Look in metadata for view */ + view_id = caja_file_get_metadata + (file, CAJA_METADATA_KEY_DEFAULT_VIEW, NULL); + if (view_id != NULL && + !caja_view_factory_view_supports_uri (view_id, + location, + caja_file_get_file_type (file), + mimetype)) + { + g_free (view_id); + view_id = NULL; + } + } + + /* Otherwise, use default */ + if (view_id == NULL) + { + view_id = caja_global_preferences_get_default_folder_viewer_preference_as_iid (); + + if (view_id != NULL && + !caja_view_factory_view_supports_uri (view_id, + location, + caja_file_get_file_type (file), + mimetype)) + { + g_free (view_id); + view_id = NULL; + } + } + + g_free (mimetype); + } + + if (view_id != NULL) + { + if (!gtk_widget_get_visible (GTK_WIDGET (window)) && CAJA_IS_SPATIAL_WINDOW (window)) + { + /* We now have the metadata to set up the window position, etc */ + setup_new_spatial_window (slot, file); + } + create_content_view (slot, view_id); + g_free (view_id); + } + else + { + display_view_selection_failure (window, file, + location, error); + + if (!gtk_widget_get_visible (GTK_WIDGET (window))) + { + /* Destroy never-had-a-chance-to-be-seen window. This case + * happens when a new window cannot display its initial URI. + */ + /* if this is the only window, we don't want to quit, so we redirect it to home */ + if (caja_application_get_n_windows () <= 1) + { + g_assert (caja_application_get_n_windows () == 1); + + /* Make sure we re-use this window */ + if (CAJA_IS_SPATIAL_WINDOW (window)) + { + CAJA_SPATIAL_WINDOW (window)->affect_spatial_window_on_next_location_change = TRUE; + } + /* the user could have typed in a home directory that doesn't exist, + in which case going home would cause an infinite loop, so we + better test for that */ + + if (!caja_is_root_directory (location)) + { + if (!caja_is_home_directory (location)) + { + caja_window_slot_go_home (slot, FALSE); + } + else + { + GFile *root; + + root = g_file_new_for_path ("/"); + /* the last fallback is to go to a known place that can't be deleted! */ + caja_window_slot_go_to (slot, location, FALSE); + g_object_unref (root); + } + } + else + { + gtk_object_destroy (GTK_OBJECT (window)); + } + } + else + { + /* Since this is a window, destroying it will also unref it. */ + gtk_object_destroy (GTK_OBJECT (window)); + } + } + else + { + /* Clean up state of already-showing window */ + end_location_change (slot); + + /* TODO? shouldn't we call + * cancel_viewed_file_changed_callback (slot); + * at this point, or in end_location_change() + */ + /* We're missing a previous location (if opened location + * in a new tab) so close it and return */ + if (slot->location == NULL) + { + caja_window_slot_close (slot); + } + else + { + /* We disconnected this, so we need to re-connect it */ + viewed_file = caja_file_get (slot->location); + caja_window_slot_set_viewed_file (slot, viewed_file); + caja_file_monitor_add (viewed_file, &slot->viewed_file, 0); + g_signal_connect_object (viewed_file, "changed", + G_CALLBACK (viewed_file_changed_callback), slot, 0); + caja_file_unref (viewed_file); + + /* Leave the location bar showing the bad location that the user + * typed (or maybe achieved by dragging or something). Many times + * the mistake will just be an easily-correctable typo. The user + * can choose "Refresh" to get the original URI back in the location bar. + */ + } + } + } + + caja_file_unref (file); +} + +/* Load a view into the window, either reusing the old one or creating + * a new one. This happens when you want to load a new location, or just + * switch to a different view. + * If pending_location is set we're loading a new location and + * pending_location/selection will be used. If not, we're just switching + * view, and the current location will be used. + */ +static void +create_content_view (CajaWindowSlot *slot, + const char *view_id) +{ + CajaWindow *window; + CajaView *view; + GList *selection; + + window = slot->pane->window; + + /* FIXME bugzilla.gnome.org 41243: + * We should use inheritance instead of these special cases + * for the desktop window. + */ + if (CAJA_IS_DESKTOP_WINDOW (window)) + { + /* We force the desktop to use a desktop_icon_view. It's simpler + * to fix it here than trying to make it pick the right view in + * the first place. + */ + view_id = CAJA_DESKTOP_ICON_VIEW_IID; + } + + if (slot->content_view != NULL && + eel_strcmp (caja_view_get_view_id (slot->content_view), + view_id) == 0) + { + /* reuse existing content view */ + view = slot->content_view; + slot->new_content_view = view; + g_object_ref (view); + } + else + { + /* create a new content view */ + view = caja_view_factory_create (view_id, + CAJA_WINDOW_SLOT_INFO (slot)); + + eel_accessibility_set_name (view, _("Content View")); + eel_accessibility_set_description (view, _("View of the current folder")); + + slot->new_content_view = view; + caja_window_slot_connect_content_view (slot, slot->new_content_view); + } + + /* Actually load the pending location and selection: */ + + if (slot->pending_location != NULL) + { + load_new_location (slot, + slot->pending_location, + slot->pending_selection, + FALSE, + TRUE); + + eel_g_object_list_free (slot->pending_selection); + slot->pending_selection = NULL; + } + else if (slot->location != NULL) + { + selection = caja_view_get_selection (slot->content_view); + load_new_location (slot, + slot->location, + selection, + FALSE, + TRUE); + eel_g_object_list_free (selection); + } + else + { + /* Something is busted, there was no location to load. + Just load the homedir. */ + caja_window_slot_go_home (slot, FALSE); + + } +} + +static void +load_new_location (CajaWindowSlot *slot, + GFile *location, + GList *selection, + gboolean tell_current_content_view, + gboolean tell_new_content_view) +{ + CajaWindow *window; + GList *selection_copy; + CajaView *view; + char *uri; + + g_assert (slot != NULL); + g_assert (location != NULL); + + window = slot->pane->window; + g_assert (CAJA_IS_WINDOW (window)); + + selection_copy = eel_g_object_list_copy (selection); + + view = NULL; + + /* Note, these may recurse into report_load_underway */ + if (slot->content_view != NULL && tell_current_content_view) + { + view = slot->content_view; + uri = g_file_get_uri (location); + caja_view_load_location (slot->content_view, uri); + g_free (uri); + } + + if (slot->new_content_view != NULL && tell_new_content_view && + (!tell_current_content_view || + slot->new_content_view != slot->content_view) ) + { + view = slot->new_content_view; + uri = g_file_get_uri (location); + caja_view_load_location (slot->new_content_view, uri); + g_free (uri); + } + if (view != NULL) + { + /* slot->new_content_view might have changed here if + report_load_underway was called from load_location */ + caja_view_set_selection (view, selection_copy); + } + + eel_g_object_list_free (selection_copy); +} + +/* A view started to load the location its viewing, either due to + * a load_location request, or some internal reason. Expect + * a matching load_compete later + */ +void +caja_window_report_load_underway (CajaWindow *window, + CajaView *view) +{ + CajaWindowSlot *slot; + + g_assert (CAJA_IS_WINDOW (window)); + + if (window->details->temporarily_ignore_view_signals) + { + return; + } + + slot = caja_window_get_slot_for_view (window, view); + g_assert (slot != NULL); + + if (view == slot->new_content_view) + { + location_has_really_changed (slot); + } + else + { + caja_window_slot_set_allow_stop (slot, TRUE); + } +} + +static void +caja_window_emit_location_change (CajaWindow *window, + GFile *location) +{ + char *uri; + + uri = g_file_get_uri (location); + g_signal_emit_by_name (window, "loading_uri", uri); + g_free (uri); +} + +/* reports location change to window's "loading-uri" clients, i.e. + * sidebar panels [used when switching tabs]. It will emit the pending + * location, or the existing location if none is pending. + */ +void +caja_window_report_location_change (CajaWindow *window) +{ + CajaWindowSlot *slot; + GFile *location; + + g_assert (CAJA_IS_WINDOW (window)); + + slot = window->details->active_pane->active_slot; + g_assert (CAJA_IS_WINDOW_SLOT (slot)); + + location = NULL; + + if (slot->pending_location != NULL) + { + location = slot->pending_location; + } + + if (location == NULL && slot->location != NULL) + { + location = slot->location; + } + + if (location != NULL) + { + caja_window_emit_location_change (window, location); + } +} + +/* This is called when we have decided we can actually change to the new view/location situation. */ +static void +location_has_really_changed (CajaWindowSlot *slot) +{ + CajaWindow *window; + GtkWidget *widget; + GFile *location_copy; + + window = slot->pane->window; + + if (slot->new_content_view != NULL) + { + widget = caja_view_get_widget (slot->new_content_view); + /* Switch to the new content view. */ + if (gtk_widget_get_parent (widget) == NULL) + { + if (slot->content_view != NULL) + { + caja_window_slot_disconnect_content_view (slot, slot->content_view); + } + caja_window_slot_set_content_view_widget (slot, slot->new_content_view); + } + g_object_unref (slot->new_content_view); + slot->new_content_view = NULL; + } + + if (slot->pending_location != NULL) + { + /* Tell the window we are finished. */ + update_for_new_location (slot); + } + + location_copy = NULL; + if (slot->location != NULL) + { + location_copy = g_object_ref (slot->location); + } + + free_location_change (slot); + + if (location_copy != NULL) + { + if (slot == caja_window_get_active_slot (window)) + { + caja_window_emit_location_change (window, location_copy); + } + + g_object_unref (location_copy); + } +} + +static void +slot_add_extension_extra_widgets (CajaWindowSlot *slot) +{ + GList *providers, *l; + GtkWidget *widget; + char *uri; + + providers = caja_module_get_extensions_for_type (CAJA_TYPE_LOCATION_WIDGET_PROVIDER); + + uri = g_file_get_uri (slot->location); + for (l = providers; l != NULL; l = l->next) + { + CajaLocationWidgetProvider *provider; + + provider = CAJA_LOCATION_WIDGET_PROVIDER (l->data); + widget = caja_location_widget_provider_get_widget (provider, uri, GTK_WIDGET (slot->pane->window)); + if (widget != NULL) + { + caja_window_slot_add_extra_location_widget (slot, widget); + } + } + g_free (uri); + + caja_module_extension_list_free (providers); +} + +static void +caja_window_slot_show_x_content_bar (CajaWindowSlot *slot, GMount *mount, const char **x_content_types) +{ + unsigned int n; + + g_assert (CAJA_IS_WINDOW_SLOT (slot)); + + for (n = 0; x_content_types[n] != NULL; n++) + { + GAppInfo *default_app; + + /* skip blank media; the burn:/// location will provide it's own cluebar */ + if (g_str_has_prefix (x_content_types[n], "x-content/blank-")) + { + continue; + } + + /* don't show the cluebar for windows software */ + if (g_content_type_is_a (x_content_types[n], "x-content/win32-software")) + { + continue; + } + + /* only show the cluebar if a default app is available */ + default_app = g_app_info_get_default_for_type (x_content_types[n], FALSE); + if (default_app != NULL) + { + GtkWidget *bar; + bar = caja_x_content_bar_new (mount, x_content_types[n]); + gtk_widget_show (bar); + caja_window_slot_add_extra_location_widget (slot, bar); + g_object_unref (default_app); + } + } +} + +static void +caja_window_slot_show_trash_bar (CajaWindowSlot *slot, + CajaWindow *window) +{ + GtkWidget *bar; + + bar = caja_trash_bar_new (window); + gtk_widget_show (bar); + + caja_window_slot_add_extra_location_widget (slot, bar); +} + +typedef struct +{ + CajaWindowSlot *slot; + GCancellable *cancellable; + GMount *mount; +} FindMountData; + +static void +found_content_type_cb (const char **x_content_types, FindMountData *data) +{ + CajaWindowSlot *slot; + + if (g_cancellable_is_cancelled (data->cancellable)) + { + goto out; + } + + slot = data->slot; + + if (x_content_types != NULL && x_content_types[0] != NULL) + { + caja_window_slot_show_x_content_bar (slot, data->mount, x_content_types); + } + + slot->find_mount_cancellable = NULL; + +out: + g_object_unref (data->mount); + g_object_unref (data->cancellable); + g_free (data); +} + +static void +found_mount_cb (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + FindMountData *data = user_data; + GMount *mount; + CajaWindowSlot *slot; + + if (g_cancellable_is_cancelled (data->cancellable)) + { + goto out; + } + + slot = data->slot; + + mount = g_file_find_enclosing_mount_finish (G_FILE (source_object), + res, + NULL); + if (mount != NULL) + { + data->mount = mount; + caja_autorun_get_x_content_types_for_mount_async (mount, + (CajaAutorunGetContent)found_content_type_cb, + data->cancellable, + data); + return; + } + + data->slot->find_mount_cancellable = NULL; + +out: + g_object_unref (data->cancellable); + g_free (data); +} + +/* Handle the changes for the CajaWindow itself. */ +static void +update_for_new_location (CajaWindowSlot *slot) +{ + CajaWindow *window; + GFile *new_location; + CajaFile *file; + CajaDirectory *directory; + gboolean location_really_changed; + FindMountData *data; + + window = slot->pane->window; + + new_location = slot->pending_location; + slot->pending_location = NULL; + + set_displayed_location (slot, new_location); + + update_history (slot, slot->location_change_type, new_location); + + location_really_changed = + slot->location == NULL || + !g_file_equal (slot->location, new_location); + + /* Set the new location. */ + if (slot->location) + { + g_object_unref (slot->location); + } + slot->location = new_location; + + /* Create a CajaFile for this location, so we can catch it + * if it goes away. + */ + cancel_viewed_file_changed_callback (slot); + file = caja_file_get (slot->location); + caja_window_slot_set_viewed_file (slot, file); + slot->viewed_file_seen = !caja_file_is_not_yet_confirmed (file); + slot->viewed_file_in_trash = caja_file_is_in_trash (file); + caja_file_monitor_add (file, &slot->viewed_file, 0); + g_signal_connect_object (file, "changed", + G_CALLBACK (viewed_file_changed_callback), slot, 0); + caja_file_unref (file); + + if (slot == window->details->active_pane->active_slot) + { + /* Check if we can go up. */ + caja_window_update_up_button (window); + + caja_window_sync_zoom_widgets (window); + + /* Set up the content view menu for this new location. */ + caja_window_load_view_as_menus (window); + + /* Load menus from caja extensions for this location */ + caja_window_load_extension_menus (window); + } + + if (location_really_changed) + { + caja_window_slot_remove_extra_location_widgets (slot); + + directory = caja_directory_get (slot->location); + + caja_window_slot_update_query_editor (slot); + + if (caja_directory_is_in_trash (directory)) + { + caja_window_slot_show_trash_bar (slot, window); + } + + /* need the mount to determine if we should put up the x-content cluebar */ + if (slot->find_mount_cancellable != NULL) + { + g_cancellable_cancel (slot->find_mount_cancellable); + slot->find_mount_cancellable = NULL; + } + + data = g_new (FindMountData, 1); + data->slot = slot; + data->cancellable = g_cancellable_new (); + data->mount = NULL; + + slot->find_mount_cancellable = data->cancellable; + g_file_find_enclosing_mount_async (slot->location, + G_PRIORITY_DEFAULT, + data->cancellable, + found_mount_cb, + data); + + caja_directory_unref (directory); + + slot_add_extension_extra_widgets (slot); + } + + caja_window_slot_update_title (slot); + caja_window_slot_update_icon (slot); + + if (slot == slot->pane->active_slot) + { + caja_window_pane_sync_location_widgets (slot->pane); + + if (location_really_changed) + { + caja_window_pane_sync_search_widgets (slot->pane); + } + + if (CAJA_IS_NAVIGATION_WINDOW (window) && + slot->pane == window->details->active_pane) + { + caja_navigation_window_load_extension_toolbar_items (CAJA_NAVIGATION_WINDOW (window)); + } + } +} + +/* A location load previously announced by load_underway + * has been finished */ +void +caja_window_report_load_complete (CajaWindow *window, + CajaView *view) +{ + CajaWindowSlot *slot; + + g_assert (CAJA_IS_WINDOW (window)); + + if (window->details->temporarily_ignore_view_signals) + { + return; + } + + slot = caja_window_get_slot_for_view (window, view); + g_assert (slot != NULL); + + /* Only handle this if we're expecting it. + * Don't handle it if its from an old view we've switched from */ + if (view == slot->content_view) + { + if (slot->pending_scroll_to != NULL) + { + caja_view_scroll_to_file (slot->content_view, + slot->pending_scroll_to); + } + end_location_change (slot); + } +} + +static void +end_location_change (CajaWindowSlot *slot) +{ + CajaWindow *window; + char *uri; + + window = slot->pane->window; + + uri = caja_window_slot_get_location_uri (slot); + if (uri) + { + caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER, + "finished loading window %p: %s", window, uri); + g_free (uri); + } + + caja_window_slot_set_allow_stop (slot, FALSE); + + /* Now we can free pending_scroll_to, since the load_complete + * callback already has been emitted. + */ + g_free (slot->pending_scroll_to); + slot->pending_scroll_to = NULL; + + free_location_change (slot); +} + +static void +free_location_change (CajaWindowSlot *slot) +{ + CajaWindow *window; + + window = slot->pane->window; + g_assert (CAJA_IS_WINDOW (window)); + + if (slot->pending_location) + { + g_object_unref (slot->pending_location); + } + slot->pending_location = NULL; + + eel_g_object_list_free (slot->pending_selection); + slot->pending_selection = NULL; + + /* Don't free pending_scroll_to, since thats needed until + * the load_complete callback. + */ + + if (slot->mount_cancellable != NULL) + { + g_cancellable_cancel (slot->mount_cancellable); + slot->mount_cancellable = NULL; + } + + if (slot->determine_view_file != NULL) + { + caja_file_cancel_call_when_ready + (slot->determine_view_file, + got_file_info_for_view_selection_callback, slot); + slot->determine_view_file = NULL; + } + + if (slot->new_content_view != NULL) + { + window->details->temporarily_ignore_view_signals = TRUE; + caja_view_stop_loading (slot->new_content_view); + window->details->temporarily_ignore_view_signals = FALSE; + + caja_window_slot_disconnect_content_view (slot, slot->new_content_view); + g_object_unref (slot->new_content_view); + slot->new_content_view = NULL; + } +} + +static void +cancel_location_change (CajaWindowSlot *slot) +{ + GList *selection; + + if (slot->pending_location != NULL + && slot->location != NULL + && slot->content_view != NULL) + { + + /* No need to tell the new view - either it is the + * same as the old view, in which case it will already + * be told, or it is the very pending change we wish + * to cancel. + */ + selection = caja_view_get_selection (slot->content_view); + load_new_location (slot, + slot->location, + selection, + TRUE, + FALSE); + eel_g_object_list_free (selection); + } + + end_location_change (slot); +} + +void +caja_window_report_view_failed (CajaWindow *window, + CajaView *view) +{ + CajaWindowSlot *slot; + gboolean do_close_window; + GFile *fallback_load_location; + + if (window->details->temporarily_ignore_view_signals) + { + return; + } + + slot = caja_window_get_slot_for_view (window, view); + g_assert (slot != NULL); + + g_warning ("A view failed. The UI will handle this with a dialog but this should be debugged."); + + do_close_window = FALSE; + fallback_load_location = NULL; + + if (view == slot->content_view) + { + caja_window_slot_disconnect_content_view (slot, view); + caja_window_slot_set_content_view_widget (slot, NULL); + + report_current_content_view_failure_to_user (slot); + } + else + { + /* Only report error on first try */ + if (slot->location_change_type != CAJA_LOCATION_CHANGE_FALLBACK) + { + report_nascent_content_view_failure_to_user (slot, view); + + fallback_load_location = g_object_ref (slot->pending_location); + } + else + { + if (!gtk_widget_get_visible (GTK_WIDGET (window))) + { + do_close_window = TRUE; + } + } + } + + cancel_location_change (slot); + + if (fallback_load_location != NULL) + { + /* We loose the pending selection change here, but who cares... */ + begin_location_change (slot, fallback_load_location, NULL, + CAJA_LOCATION_CHANGE_FALLBACK, 0, NULL); + g_object_unref (fallback_load_location); + } + + if (do_close_window) + { + gtk_widget_destroy (GTK_WIDGET (window)); + } +} + +static void +display_view_selection_failure (CajaWindow *window, CajaFile *file, + GFile *location, GError *error) +{ + char *full_uri_for_display; + char *uri_for_display; + char *error_message; + char *detail_message; + char *scheme_string; + GtkDialog *dialog; + + /* Some sort of failure occurred. How 'bout we tell the user? */ + full_uri_for_display = g_file_get_parse_name (location); + /* Truncate the URI so it doesn't get insanely wide. Note that even + * though the dialog uses wrapped text, if the URI doesn't contain + * white space then the text-wrapping code is too stupid to wrap it. + */ + uri_for_display = eel_str_middle_truncate + (full_uri_for_display, MAX_URI_IN_DIALOG_LENGTH); + g_free (full_uri_for_display); + + error_message = NULL; + detail_message = NULL; + if (error == NULL) + { + if (caja_file_is_directory (file)) + { + error_message = g_strdup_printf + (_("Could not display \"%s\"."), + uri_for_display); + detail_message = g_strdup + (_("Caja has no installed viewer capable of displaying the folder.")); + } + else + { + error_message = g_strdup_printf + (_("Could not display \"%s\"."), + uri_for_display); + detail_message = g_strdup + (_("The location is not a folder.")); + } + } + else if (error->domain == G_IO_ERROR) + { + switch (error->code) + { + case G_IO_ERROR_NOT_FOUND: + error_message = g_strdup_printf + (_("Could not find \"%s\"."), + uri_for_display); + detail_message = g_strdup + (_("Please check the spelling and try again.")); + break; + case G_IO_ERROR_NOT_SUPPORTED: + scheme_string = g_file_get_uri_scheme (location); + + error_message = g_strdup_printf (_("Could not display \"%s\"."), + uri_for_display); + if (scheme_string != NULL) + { + detail_message = g_strdup_printf (_("Caja cannot handle \"%s\" locations."), + scheme_string); + } + else + { + detail_message = g_strdup (_("Caja cannot handle this kind of location.")); + } + g_free (scheme_string); + break; + case G_IO_ERROR_NOT_MOUNTED: + error_message = g_strdup_printf (_("Could not display \"%s\"."), + uri_for_display); + detail_message = g_strdup (_("Unable to mount the location.")); + break; + + case G_IO_ERROR_PERMISSION_DENIED: + error_message = g_strdup_printf (_("Could not display \"%s\"."), + uri_for_display); + detail_message = g_strdup (_("Access was denied.")); + break; + + case G_IO_ERROR_HOST_NOT_FOUND: + /* This case can be hit for user-typed strings like "foo" due to + * the code that guesses web addresses when there's no initial "/". + * But this case is also hit for legitimate web addresses when + * the proxy is set up wrong. + */ + error_message = g_strdup_printf (_("Could not display \"%s\", because the host could not be found."), + uri_for_display); + detail_message = g_strdup (_("Check that the spelling is correct and that your proxy settings are correct.")); + break; + case G_IO_ERROR_CANCELLED: + case G_IO_ERROR_FAILED_HANDLED: + g_free (uri_for_display); + return; + + default: + break; + } + } + + if (error_message == NULL) + { + error_message = g_strdup_printf (_("Could not display \"%s\"."), + uri_for_display); + detail_message = g_strdup_printf (_("Error: %s\nPlease select another viewer and try again."), error->message); + } + + dialog = eel_show_error_dialog (error_message, detail_message, NULL); + + g_free (uri_for_display); + g_free (error_message); + g_free (detail_message); +} + + +void +caja_window_slot_stop_loading (CajaWindowSlot *slot) +{ + CajaWindow *window; + + window = CAJA_WINDOW (slot->pane->window); + g_assert (CAJA_IS_WINDOW (window)); + + caja_view_stop_loading (slot->content_view); + + if (slot->new_content_view != NULL) + { + window->details->temporarily_ignore_view_signals = TRUE; + caja_view_stop_loading (slot->new_content_view); + window->details->temporarily_ignore_view_signals = FALSE; + } + + cancel_location_change (slot); +} + +void +caja_window_slot_set_content_view (CajaWindowSlot *slot, + const char *id) +{ + CajaWindow *window; + CajaFile *file; + char *uri; + + g_assert (slot != NULL); + g_assert (slot->location != NULL); + g_assert (id != NULL); + + window = slot->pane->window; + g_assert (CAJA_IS_WINDOW (window)); + + uri = caja_window_slot_get_location_uri (slot); + caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER, + "change view of window %p: \"%s\" to \"%s\"", + window, uri, id); + g_free (uri); + + if (caja_window_slot_content_view_matches_iid (slot, id)) + { + return; + } + + end_location_change (slot); + + file = caja_file_get (slot->location); + caja_file_set_metadata + (file, CAJA_METADATA_KEY_DEFAULT_VIEW, NULL, id); + caja_file_unref (file); + + caja_window_slot_set_allow_stop (slot, TRUE); + + if (caja_view_get_selection_count (slot->content_view) == 0) + { + /* If there is no selection, queue a scroll to the same icon that + * is currently visible */ + slot->pending_scroll_to = caja_view_get_first_visible_file (slot->content_view); + } + slot->location_change_type = CAJA_LOCATION_CHANGE_RELOAD; + + create_content_view (slot, id); +} + +void +caja_window_manage_views_close_slot (CajaWindowPane *pane, + CajaWindowSlot *slot) +{ + if (slot->content_view != NULL) + { + caja_window_slot_disconnect_content_view (slot, slot->content_view); + } + + free_location_change (slot); + cancel_viewed_file_changed_callback (slot); +} + +void +caja_navigation_window_back_or_forward (CajaNavigationWindow *window, + gboolean back, guint distance, gboolean new_tab) +{ + CajaWindowSlot *slot; + CajaNavigationWindowSlot *navigation_slot; + GList *list; + GFile *location; + guint len; + CajaBookmark *bookmark; + + slot = CAJA_WINDOW (window)->details->active_pane->active_slot; + navigation_slot = (CajaNavigationWindowSlot *) slot; + list = back ? navigation_slot->back_list : navigation_slot->forward_list; + + len = (guint) g_list_length (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; + + bookmark = g_list_nth_data (list, distance); + location = caja_bookmark_get_location (bookmark); + + if (new_tab) + { + caja_window_slot_open_location_full (slot, location, + CAJA_WINDOW_OPEN_ACCORDING_TO_MODE, + CAJA_WINDOW_OPEN_FLAG_NEW_TAB, + NULL); + } + else + { + char *scroll_pos; + + scroll_pos = caja_bookmark_get_scroll_pos (bookmark); + begin_location_change + (slot, + location, NULL, + back ? CAJA_LOCATION_CHANGE_BACK : CAJA_LOCATION_CHANGE_FORWARD, + distance, + scroll_pos); + + g_free (scroll_pos); + } + + g_object_unref (location); +} + +/* reload the contents of the window */ +void +caja_window_slot_reload (CajaWindowSlot *slot) +{ + GFile *location; + char *current_pos; + GList *selection; + + g_assert (CAJA_IS_WINDOW_SLOT (slot)); + + if (slot->location == NULL) + { + return; + } + + /* peek_slot_field (window, location) can be free'd during the processing + * of begin_location_change, so make a copy + */ + location = g_object_ref (slot->location); + current_pos = NULL; + selection = NULL; + if (slot->content_view != NULL) + { + current_pos = caja_view_get_first_visible_file (slot->content_view); + selection = caja_view_get_selection (slot->content_view); + } + begin_location_change + (slot, location, selection, + CAJA_LOCATION_CHANGE_RELOAD, 0, current_pos); + g_free (current_pos); + g_object_unref (location); + eel_g_object_list_free (selection); +} + +void +caja_window_reload (CajaWindow *window) +{ + g_assert (CAJA_IS_WINDOW (window)); + + caja_window_slot_reload (window->details->active_pane->active_slot); +} + |