summaryrefslogtreecommitdiff
path: root/src/caja-window-manage-views.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-12-01 22:24:23 -0300
committerPerberos <[email protected]>2011-12-01 22:24:23 -0300
commit0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree43261e815529cb9518ed7be37af13b846af8b26b /src/caja-window-manage-views.c
downloadcaja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
moving from https://github.com/perberos/mate-desktop-environment
Diffstat (limited to 'src/caja-window-manage-views.c')
-rw-r--r--src/caja-window-manage-views.c2337
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);
+}
+
generated by cgit v1.2.1 (git 2.18.0) at 2024-05-26 20:45:25 +0000