[nautilus/wip/csoriano/destktop-split2: 21/47] window-slot: make it derivable class
- From: Carlos Soriano Sánchez <csoriano src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [nautilus/wip/csoriano/destktop-split2: 21/47] window-slot: make it derivable class
- Date: Wed, 30 Mar 2016 19:59:50 +0000 (UTC)
commit 7fc478117e91faf0da4fced3a8cdae23cf0e503c
Author: Carlos Soriano <csoriano gnome org>
Date: Fri Mar 18 19:11:06 2016 +0100
window-slot: make it derivable class
src/nautilus-window-slot.c | 1474 +++++++++++++++++++++++++-------------------
src/nautilus-window-slot.h | 41 +-
2 files changed, 847 insertions(+), 668 deletions(-)
---
diff --git a/src/nautilus-window-slot.c b/src/nautilus-window-slot.c
index 5af90d6..aa54701 100644
--- a/src/nautilus-window-slot.c
+++ b/src/nautilus-window-slot.c
@@ -48,8 +48,6 @@
#include <libnautilus-private/nautilus-profile.h>
#include <libnautilus-extension/nautilus-location-widget-provider.h>
-G_DEFINE_TYPE (NautilusWindowSlot, nautilus_window_slot, GTK_TYPE_BOX);
-
enum {
ACTIVE,
INACTIVE,
@@ -66,7 +64,7 @@ enum {
NUM_PROPERTIES
};
-struct NautilusWindowSlotDetails {
+typedef struct {
NautilusWindow *window;
gboolean active : 1;
@@ -124,37 +122,42 @@ struct NautilusWindowSlotDetails {
gboolean tried_mount;
gint view_mode_before_search;
gint view_mode_before_places;
-};
+} NautilusWindowSlotPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (NautilusWindowSlot, nautilus_window_slot, GTK_TYPE_BOX);
static guint signals[LAST_SIGNAL] = { 0 };
static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
-static void nautilus_window_slot_force_reload (NautilusWindowSlot *slot);
-static void change_view (NautilusWindowSlot *slot);
-static void hide_query_editor (NautilusWindowSlot *slot);
-static void nautilus_window_slot_sync_actions (NautilusWindowSlot *slot);
-static void nautilus_window_slot_connect_new_content_view (NautilusWindowSlot *slot);
-static void nautilus_window_slot_disconnect_content_view (NautilusWindowSlot *slot);
-static gboolean nautilus_window_slot_content_view_matches (NautilusWindowSlot *slot, guint id);
-static NautilusView* nautilus_window_slot_get_view_for_location (NautilusWindowSlot *slot, GFile *location);
-static void nautilus_window_slot_set_content_view (NautilusWindowSlot *slot, guint id);
-static void nautilus_window_slot_set_loading (NautilusWindowSlot *slot, gboolean loading);
-char * nautilus_window_slot_get_location_uri (NautilusWindowSlot *slot);
-static void nautilus_window_slot_set_search_visible (NautilusWindowSlot *slot,
- gboolean visible);
-static gboolean nautilus_window_slot_get_search_visible (NautilusWindowSlot *slot);
-static void nautilus_window_slot_set_location (NautilusWindowSlot *slot,
+static void nautilus_window_slot_force_reload (NautilusWindowSlot *self);
+static void change_view (NautilusWindowSlot *self);
+static void hide_query_editor (NautilusWindowSlot *self);
+static void nautilus_window_slot_sync_actions (NautilusWindowSlot *self);
+static void nautilus_window_slot_connect_new_content_view (NautilusWindowSlot *self);
+static void nautilus_window_slot_disconnect_content_view (NautilusWindowSlot *self);
+static gboolean nautilus_window_slot_content_view_matches (NautilusWindowSlot *self, guint id);
+static NautilusView* nautilus_window_slot_get_view_for_location (NautilusWindowSlot *self, GFile *location);
+static void nautilus_window_slot_set_content_view (NautilusWindowSlot *self, guint id);
+static void nautilus_window_slot_set_loading (NautilusWindowSlot *self, gboolean loading);
+char * nautilus_window_slot_get_location_uri (NautilusWindowSlot *self);
+static void nautilus_window_slot_set_search_visible (NautilusWindowSlot *self,
+ gboolean visible);
+static gboolean nautilus_window_slot_get_search_visible (NautilusWindowSlot *self);
+static void nautilus_window_slot_set_location (NautilusWindowSlot *self,
GFile *location);
static NautilusView*
-nautilus_window_slot_get_view_for_location (NautilusWindowSlot *slot,
+nautilus_window_slot_get_view_for_location (NautilusWindowSlot *self,
GFile *location)
{
+ NautilusWindowSlotPrivate *priv;
+
NautilusWindow *window;
NautilusView *view;
NautilusFile *file;
- window = nautilus_window_slot_get_window (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ window = nautilus_window_slot_get_window (self);
file = nautilus_file_get (location);
view = NULL;
@@ -163,13 +166,13 @@ nautilus_window_slot_get_view_for_location (NautilusWindowSlot *slot,
* for the desktop window.
*/
if (NAUTILUS_IS_DESKTOP_WINDOW (window)) {
- view = NAUTILUS_VIEW (nautilus_files_view_new (NAUTILUS_VIEW_DESKTOP_ID, slot));
+ view = NAUTILUS_VIEW (nautilus_files_view_new (NAUTILUS_VIEW_DESKTOP_ID, self));
} else if (nautilus_file_is_other_locations (file)) {
view = NAUTILUS_VIEW (nautilus_places_view_new ());
/* Save the current view, so we can go back after places view */
- if (slot->details->content_view && NAUTILUS_IS_FILES_VIEW (slot->details->content_view)) {
- slot->details->view_mode_before_places = nautilus_files_view_get_view_id
(NAUTILUS_FILES_VIEW (slot->details->content_view));
+ if (priv->content_view && NAUTILUS_IS_FILES_VIEW (priv->content_view)) {
+ priv->view_mode_before_places = nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW
(priv->content_view));
}
} else {
guint view_id;
@@ -181,22 +184,22 @@ nautilus_window_slot_get_view_for_location (NautilusWindowSlot *slot,
/* If it's already set, is because we already made the change to search mode,
* so the view mode of the current view will be the one search is using,
* which is not the one we are interested in */
- if (slot->details->view_mode_before_search == NAUTILUS_VIEW_INVALID_ID) {
- slot->details->view_mode_before_search = nautilus_files_view_get_view_id
(NAUTILUS_FILES_VIEW (slot->details->content_view));
+ if (priv->view_mode_before_search == NAUTILUS_VIEW_INVALID_ID) {
+ priv->view_mode_before_search = nautilus_files_view_get_view_id
(NAUTILUS_FILES_VIEW (priv->content_view));
}
view_id = g_settings_get_enum (nautilus_preferences,
NAUTILUS_PREFERENCES_SEARCH_VIEW);
- } else if (slot->details->content_view != NULL) {
+ } else if (priv->content_view != NULL) {
/* If there is already a view, just use the view mode that it's currently using, or
* if we were on search before, use what we were using before entering
* search mode */
- if (slot->details->view_mode_before_search != NAUTILUS_VIEW_INVALID_ID) {
- view_id = slot->details->view_mode_before_search;
- slot->details->view_mode_before_search = NAUTILUS_VIEW_INVALID_ID;
- } else if (NAUTILUS_IS_PLACES_VIEW (slot->details->content_view)) {
- view_id = slot->details->view_mode_before_places;
- slot->details->view_mode_before_places = NAUTILUS_VIEW_INVALID_ID;
+ if (priv->view_mode_before_search != NAUTILUS_VIEW_INVALID_ID) {
+ view_id = priv->view_mode_before_search;
+ priv->view_mode_before_search = NAUTILUS_VIEW_INVALID_ID;
+ } else if (NAUTILUS_IS_PLACES_VIEW (priv->content_view)) {
+ view_id = priv->view_mode_before_places;
+ priv->view_mode_before_places = NAUTILUS_VIEW_INVALID_ID;
} else {
- view_id = nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW
(slot->details->content_view));
+ view_id = nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW
(priv->content_view));
}
}
@@ -207,10 +210,10 @@ nautilus_window_slot_get_view_for_location (NautilusWindowSlot *slot,
}
/* Try to reuse the current view */
- if (nautilus_window_slot_content_view_matches (slot, view_id)) {
- view = slot->details->content_view;
+ if (nautilus_window_slot_content_view_matches (self, view_id)) {
+ view = priv->content_view;
} else {
- view = NAUTILUS_VIEW (nautilus_files_view_new (view_id, slot));
+ view = NAUTILUS_VIEW (nautilus_files_view_new (view_id, self));
}
}
@@ -220,83 +223,92 @@ nautilus_window_slot_get_view_for_location (NautilusWindowSlot *slot,
}
static gboolean
-nautilus_window_slot_content_view_matches (NautilusWindowSlot *slot,
+nautilus_window_slot_content_view_matches (NautilusWindowSlot *self,
guint id)
{
- if (slot->details->content_view == NULL) {
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->content_view == NULL) {
return FALSE;
}
- if (id == NAUTILUS_VIEW_INVALID_ID && NAUTILUS_IS_PLACES_VIEW (slot->details->content_view)) {
+ if (id == NAUTILUS_VIEW_INVALID_ID && NAUTILUS_IS_PLACES_VIEW (priv->content_view)) {
return TRUE;
- } else if (id != NAUTILUS_VIEW_INVALID_ID && NAUTILUS_IS_FILES_VIEW (slot->details->content_view)){
- return nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW (slot->details->content_view))
== id;
+ } else if (id != NAUTILUS_VIEW_INVALID_ID && NAUTILUS_IS_FILES_VIEW (priv->content_view)){
+ return nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW (priv->content_view)) == id;
} else {
return FALSE;
}
}
static void
-update_search_visible (NautilusWindowSlot *slot)
+update_search_visible (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
NautilusQuery *query;
NautilusView *view;
GAction *action;
- action = g_action_map_lookup_action (G_ACTION_MAP (slot->details->slot_action_group),
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ action = g_action_map_lookup_action (G_ACTION_MAP (priv->slot_action_group),
"search-visible");
/* Don't allow search on desktop */
g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
- !NAUTILUS_IS_DESKTOP_CANVAS_VIEW
(nautilus_window_slot_get_current_view (slot)));
+ !NAUTILUS_IS_DESKTOP_CANVAS_VIEW
(nautilus_window_slot_get_current_view (self)));
- view = nautilus_window_slot_get_current_view (slot);
+ view = nautilus_window_slot_get_current_view (self);
/* If we changed location just to another search location, for example,
* when changing the query, just keep the search visible.
* Make sure the search is visible though, since we could be returning
* from a previous search location when using the history */
if (nautilus_view_is_searching (view)) {
- nautilus_window_slot_set_search_visible (slot, TRUE);
+ nautilus_window_slot_set_search_visible (self, TRUE);
return;
}
- query = nautilus_query_editor_get_query (slot->details->query_editor);
+ query = nautilus_query_editor_get_query (priv->query_editor);
if (query) {
/* If the view is not searching, but search is visible, and the
* query is empty, we don't hide it. Some users enable the search
* and then change locations, then they search. */
if (!nautilus_query_is_empty (query))
- nautilus_window_slot_set_search_visible (slot, FALSE);
+ nautilus_window_slot_set_search_visible (self, FALSE);
g_object_unref (query);
}
- if (slot->details->pending_search_text)
- nautilus_window_slot_search (slot, g_strdup (slot->details->pending_search_text));
+ if (priv->pending_search_text)
+ nautilus_window_slot_search (self, g_strdup (priv->pending_search_text));
}
static void
-nautilus_window_slot_sync_actions (NautilusWindowSlot *slot)
+nautilus_window_slot_sync_actions (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
+
GAction *action;
GVariant *variant;
- if (!nautilus_window_slot_get_active (slot)) {
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (!nautilus_window_slot_get_active (self)) {
return;
}
- if (slot->details->content_view == NULL || slot->details->new_content_view != NULL) {
+ if (priv->content_view == NULL || priv->new_content_view != NULL) {
return;
}
/* Check if we need to close the search or show search after changing the location.
* Needs to be done after the change has been done, if not, a loop happens,
* because setting the search enabled or not actually opens a location */
- update_search_visible (slot);
+ update_search_visible (self);
/* Files view mode */
- action = g_action_map_lookup_action (G_ACTION_MAP (slot->details->slot_action_group),
"files-view-mode");
- if (NAUTILUS_IS_FILES_VIEW (nautilus_window_slot_get_current_view (slot)) &&
- !NAUTILUS_IS_DESKTOP_CANVAS_VIEW (nautilus_window_slot_get_current_view (slot))) {
- variant = g_variant_new_uint32 (nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW
(nautilus_window_slot_get_current_view (slot))));
+ action = g_action_map_lookup_action (G_ACTION_MAP (priv->slot_action_group), "files-view-mode");
+ if (NAUTILUS_IS_FILES_VIEW (nautilus_window_slot_get_current_view (self)) &&
+ !NAUTILUS_IS_DESKTOP_CANVAS_VIEW (nautilus_window_slot_get_current_view (self))) {
+ variant = g_variant_new_uint32 (nautilus_files_view_get_view_id (NAUTILUS_FILES_VIEW
(nautilus_window_slot_get_current_view (self))));
g_simple_action_set_enabled (G_SIMPLE_ACTION (action), TRUE);
g_action_change_state (action, variant);
} else {
@@ -306,61 +318,66 @@ nautilus_window_slot_sync_actions (NautilusWindowSlot *slot)
static void
query_editor_cancel_callback (NautilusQueryEditor *editor,
- NautilusWindowSlot *slot)
+ NautilusWindowSlot *self)
{
- nautilus_window_slot_set_search_visible (slot, FALSE);
+ nautilus_window_slot_set_search_visible (self, FALSE);
}
static void
query_editor_activated_callback (NautilusQueryEditor *editor,
- NautilusWindowSlot *slot)
+ NautilusWindowSlot *self)
{
- if (slot->details->content_view != NULL) {
- if (NAUTILUS_IS_FILES_VIEW (slot->details->content_view)) {
- nautilus_files_view_activate_selection (NAUTILUS_FILES_VIEW
(slot->details->content_view));
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->content_view != NULL) {
+ if (NAUTILUS_IS_FILES_VIEW (priv->content_view)) {
+ nautilus_files_view_activate_selection (NAUTILUS_FILES_VIEW (priv->content_view));
}
- nautilus_window_slot_set_search_visible (slot, FALSE);
+ nautilus_window_slot_set_search_visible (self, FALSE);
}
}
static void
query_editor_changed_callback (NautilusQueryEditor *editor,
- NautilusQuery *query,
- gboolean reload,
- NautilusWindowSlot *slot)
+ NautilusQuery *query,
+ gboolean reload,
+ NautilusWindowSlot *self)
{
NautilusView *view;
- view = nautilus_window_slot_get_current_view (slot);
+ view = nautilus_window_slot_get_current_view (self);
nautilus_view_set_search_query (view, query);
- nautilus_window_slot_open_location_full (slot, nautilus_view_get_location (view), 0, NULL);
+ nautilus_window_slot_open_location_full (self, nautilus_view_get_location (view), 0, NULL);
}
static void
-hide_query_editor (NautilusWindowSlot *slot)
+hide_query_editor (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
NautilusView *view;
- view = nautilus_window_slot_get_current_view (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ view = nautilus_window_slot_get_current_view (self);
- gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (slot->details->query_editor), FALSE);
+ gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (priv->query_editor), FALSE);
- if (slot->details->qe_changed_id > 0) {
- g_signal_handler_disconnect (slot->details->query_editor, slot->details->qe_changed_id);
- slot->details->qe_changed_id = 0;
+ if (priv->qe_changed_id > 0) {
+ g_signal_handler_disconnect (priv->query_editor, priv->qe_changed_id);
+ priv->qe_changed_id = 0;
}
- if (slot->details->qe_cancel_id > 0) {
- g_signal_handler_disconnect (slot->details->query_editor, slot->details->qe_cancel_id);
- slot->details->qe_cancel_id = 0;
+ if (priv->qe_cancel_id > 0) {
+ g_signal_handler_disconnect (priv->query_editor, priv->qe_cancel_id);
+ priv->qe_cancel_id = 0;
}
- if (slot->details->qe_activated_id > 0) {
- g_signal_handler_disconnect (slot->details->query_editor, slot->details->qe_activated_id);
- slot->details->qe_activated_id = 0;
+ if (priv->qe_activated_id > 0) {
+ g_signal_handler_disconnect (priv->query_editor, priv->qe_activated_id);
+ priv->qe_activated_id = 0;
}
- nautilus_query_editor_set_query (slot->details->query_editor, NULL);
+ nautilus_query_editor_set_query (priv->query_editor, NULL);
if (nautilus_view_is_searching (view)) {
GList *selection;
@@ -368,7 +385,7 @@ hide_query_editor (NautilusWindowSlot *slot)
selection = nautilus_view_get_selection (view);
nautilus_view_set_search_query (view, NULL);
- nautilus_window_slot_open_location_full (slot,
+ nautilus_window_slot_open_location_full (self,
nautilus_view_get_location (view),
0,
selection);
@@ -376,31 +393,36 @@ hide_query_editor (NautilusWindowSlot *slot)
nautilus_file_list_free (selection);
}
- if (nautilus_window_slot_get_active (slot)) {
- gtk_widget_grab_focus (GTK_WIDGET (slot->details->window));
+ if (nautilus_window_slot_get_active (self)) {
+ gtk_widget_grab_focus (GTK_WIDGET (priv->window));
}
}
static GFile *
-nautilus_window_slot_get_current_location (NautilusWindowSlot *slot)
+nautilus_window_slot_get_current_location (NautilusWindowSlot *self)
{
- if (slot->details->pending_location != NULL) {
- return slot->details->pending_location;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->pending_location != NULL) {
+ return priv->pending_location;
}
- if (slot->details->location != NULL) {
- return slot->details->location;
+ if (priv->location != NULL) {
+ return priv->location;
}
return NULL;
}
static void
-show_query_editor (NautilusWindowSlot *slot)
+show_query_editor (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
NautilusView *view;
- view = nautilus_window_slot_get_current_view (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ view = nautilus_window_slot_get_current_view (self);
if (nautilus_view_is_searching (view)) {
NautilusQuery *query;
@@ -408,49 +430,54 @@ show_query_editor (NautilusWindowSlot *slot)
query = nautilus_view_get_search_query (view);
if (query != NULL) {
- nautilus_query_editor_set_query (slot->details->query_editor, query);
+ nautilus_query_editor_set_query (priv->query_editor, query);
}
}
- gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (slot->details->query_editor), TRUE);
- gtk_widget_grab_focus (GTK_WIDGET (slot->details->query_editor));
+ gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (priv->query_editor), TRUE);
+ gtk_widget_grab_focus (GTK_WIDGET (priv->query_editor));
- if (slot->details->qe_changed_id == 0) {
- slot->details->qe_changed_id =
- g_signal_connect (slot->details->query_editor, "changed",
- G_CALLBACK (query_editor_changed_callback), slot);
+ if (priv->qe_changed_id == 0) {
+ priv->qe_changed_id =
+ g_signal_connect (priv->query_editor, "changed",
+ G_CALLBACK (query_editor_changed_callback), self);
}
- if (slot->details->qe_cancel_id == 0) {
- slot->details->qe_cancel_id =
- g_signal_connect (slot->details->query_editor, "cancel",
- G_CALLBACK (query_editor_cancel_callback), slot);
+ if (priv->qe_cancel_id == 0) {
+ priv->qe_cancel_id =
+ g_signal_connect (priv->query_editor, "cancel",
+ G_CALLBACK (query_editor_cancel_callback), self);
}
- if (slot->details->qe_activated_id == 0) {
- slot->details->qe_activated_id =
- g_signal_connect (slot->details->query_editor, "activated",
- G_CALLBACK (query_editor_activated_callback), slot);
+ if (priv->qe_activated_id == 0) {
+ priv->qe_activated_id =
+ g_signal_connect (priv->query_editor, "activated",
+ G_CALLBACK (query_editor_activated_callback), self);
}
}
static void
-nautilus_window_slot_set_search_visible (NautilusWindowSlot *slot,
+nautilus_window_slot_set_search_visible (NautilusWindowSlot *self,
gboolean visible)
{
+ NautilusWindowSlotPrivate *priv;
GAction *action;
- action = g_action_map_lookup_action (G_ACTION_MAP (slot->details->slot_action_group),
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ action = g_action_map_lookup_action (G_ACTION_MAP (priv->slot_action_group),
"search-visible");
g_action_change_state (action, g_variant_new_boolean (visible));
}
static gboolean
-nautilus_window_slot_get_search_visible (NautilusWindowSlot *slot)
+nautilus_window_slot_get_search_visible (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
GAction *action;
GVariant *state;
gboolean searching;
- action = g_action_map_lookup_action (G_ACTION_MAP (slot->details->slot_action_group),
+ priv = nautilus_window_slot_get_instance_private (self);
+ action = g_action_map_lookup_action (G_ACTION_MAP (priv->slot_action_group),
"search-visible");
state = g_action_get_state (action);
searching = g_variant_get_boolean (state);
@@ -461,78 +488,84 @@ nautilus_window_slot_get_search_visible (NautilusWindowSlot *slot)
}
void
-nautilus_window_slot_search (NautilusWindowSlot *slot,
+nautilus_window_slot_search (NautilusWindowSlot *self,
const gchar *text)
{
+ NautilusWindowSlotPrivate *priv;
NautilusView *view;
- if (slot->details->pending_search_text) {
- g_free (slot->details->pending_search_text);
- slot->details->pending_search_text = NULL;
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->pending_search_text) {
+ g_free (priv->pending_search_text);
+ priv->pending_search_text = NULL;
}
- view = nautilus_window_slot_get_current_view (slot);
+ view = nautilus_window_slot_get_current_view (self);
/* We could call this when the location is still being checked in the
* window slot. For that, save the search we want to do for once we have
* a view set up */
if (view) {
- nautilus_window_slot_set_search_visible (slot, TRUE);
- nautilus_query_editor_set_text (slot->details->query_editor, text);
+ nautilus_window_slot_set_search_visible (self, TRUE);
+ nautilus_query_editor_set_text (priv->query_editor, text);
} else {
- slot->details->pending_search_text = g_strdup (text);
+ priv->pending_search_text = g_strdup (text);
}
}
gboolean
-nautilus_window_slot_handle_event (NautilusWindowSlot *slot,
+nautilus_window_slot_handle_event (NautilusWindowSlot *self,
GdkEventKey *event)
{
+ NautilusWindowSlotPrivate *priv;
NautilusWindow *window;
gboolean retval;
+ priv = nautilus_window_slot_get_instance_private (self);
retval = FALSE;
- window = nautilus_window_slot_get_window (slot);
+ window = nautilus_window_slot_get_window (self);
if (!NAUTILUS_IS_DESKTOP_WINDOW (window)) {
- retval = gtk_search_bar_handle_event (GTK_SEARCH_BAR (slot->details->query_editor),
+ retval = gtk_search_bar_handle_event (GTK_SEARCH_BAR (priv->query_editor),
(GdkEvent*) event);
}
if (retval) {
- nautilus_window_slot_set_search_visible (slot, TRUE);
+ nautilus_window_slot_set_search_visible (self, TRUE);
}
return retval;
}
static void
-real_active (NautilusWindowSlot *slot)
+real_active (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
NautilusWindow *window;
int page_num;
- window = slot->details->window;
+ priv = nautilus_window_slot_get_instance_private (self);
+ window = priv->window;
page_num = gtk_notebook_page_num (GTK_NOTEBOOK (nautilus_window_get_notebook (window)),
- GTK_WIDGET (slot));
+ GTK_WIDGET (self));
g_assert (page_num >= 0);
gtk_notebook_set_current_page (GTK_NOTEBOOK (nautilus_window_get_notebook (window)), page_num);
/* sync window to new slot */
- nautilus_window_sync_allow_stop (window, slot);
- nautilus_window_sync_title (window, slot);
+ nautilus_window_sync_allow_stop (window, self);
+ nautilus_window_sync_title (window, self);
nautilus_window_sync_location_widgets (window);
- nautilus_window_slot_sync_actions (slot);
+ nautilus_window_slot_sync_actions (self);
- gtk_widget_insert_action_group (GTK_WIDGET (window), "slot", slot->details->slot_action_group);
+ gtk_widget_insert_action_group (GTK_WIDGET (window), "slot", priv->slot_action_group);
}
static void
-real_inactive (NautilusWindowSlot *slot)
+real_inactive (NautilusWindowSlot *self)
{
NautilusWindow *window;
- window = nautilus_window_slot_get_window (slot);
- g_assert (slot == nautilus_window_get_active_slot (window));
+ window = nautilus_window_slot_get_window (self);
+ g_assert (self == nautilus_window_get_active_slot (window));
gtk_widget_insert_action_group (GTK_WIDGET (window), "slot", NULL);
}
@@ -541,32 +574,40 @@ static void
remove_all_extra_location_widgets (GtkWidget *widget,
gpointer data)
{
- NautilusWindowSlot *slot = data;
+ NautilusWindowSlotPrivate *priv;
+ NautilusWindowSlot *self = data;
NautilusDirectory *directory;
- directory = nautilus_directory_get (slot->details->location);
- if (widget != GTK_WIDGET (slot->details->query_editor)) {
- gtk_container_remove (GTK_CONTAINER (slot->details->extra_location_widgets), widget);
+ priv = nautilus_window_slot_get_instance_private (self);
+ directory = nautilus_directory_get (priv->location);
+ if (widget != GTK_WIDGET (priv->query_editor)) {
+ gtk_container_remove (GTK_CONTAINER (priv->extra_location_widgets), widget);
}
nautilus_directory_unref (directory);
}
static void
-nautilus_window_slot_remove_extra_location_widgets (NautilusWindowSlot *slot)
+nautilus_window_slot_remove_extra_location_widgets (NautilusWindowSlot *self)
{
- gtk_container_foreach (GTK_CONTAINER (slot->details->extra_location_widgets),
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ gtk_container_foreach (GTK_CONTAINER (priv->extra_location_widgets),
remove_all_extra_location_widgets,
- slot);
+ self);
}
static void
-nautilus_window_slot_add_extra_location_widget (NautilusWindowSlot *slot,
- GtkWidget *widget)
+nautilus_window_slot_add_extra_location_widget (NautilusWindowSlot *self,
+ GtkWidget *widget)
{
- gtk_box_pack_start (GTK_BOX (slot->details->extra_location_widgets),
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ gtk_box_pack_start (GTK_BOX (priv->extra_location_widgets),
widget, FALSE, TRUE, 0);
- gtk_widget_show (slot->details->extra_location_widgets);
+ gtk_widget_show (priv->extra_location_widgets);
}
static void
@@ -575,17 +616,17 @@ nautilus_window_slot_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
- NautilusWindowSlot *slot = NAUTILUS_WINDOW_SLOT (object);
+ NautilusWindowSlot *self = NAUTILUS_WINDOW_SLOT (object);
switch (property_id) {
case PROP_ACTIVE:
- nautilus_window_slot_set_active (slot, g_value_get_boolean (value));
+ nautilus_window_slot_set_active (self, g_value_get_boolean (value));
break;
case PROP_WINDOW:
- nautilus_window_slot_set_window (slot, g_value_get_object (value));
+ nautilus_window_slot_set_window (self, g_value_get_object (value));
break;
case PROP_LOCATION:
- nautilus_window_slot_set_location (slot, g_value_get_object (value));
+ nautilus_window_slot_set_location (self, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@@ -599,26 +640,29 @@ nautilus_window_slot_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
- NautilusWindowSlot *slot = NAUTILUS_WINDOW_SLOT (object);
+ NautilusWindowSlot *self = NAUTILUS_WINDOW_SLOT (object);
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
switch (property_id) {
case PROP_ACTIVE:
- g_value_set_boolean (value, nautilus_window_slot_get_active (slot));
+ g_value_set_boolean (value, nautilus_window_slot_get_active (self));
break;
case PROP_WINDOW:
- g_value_set_object (value, slot->details->window);
+ g_value_set_object (value, priv->window);
break;
case PROP_ICON:
- g_value_set_object (value, nautilus_window_slot_get_icon (slot));
+ g_value_set_object (value, nautilus_window_slot_get_icon (self));
break;
case PROP_VIEW_WIDGET:
- g_value_set_object (value, nautilus_window_slot_get_view_widget (slot));
+ g_value_set_object (value, nautilus_window_slot_get_view_widget (self));
break;
case PROP_LOADING:
- g_value_set_boolean (value, nautilus_window_slot_get_loading (slot));
+ g_value_set_boolean (value, nautilus_window_slot_get_loading (self));
break;
case PROP_LOCATION:
- g_value_set_object (value, nautilus_window_slot_get_current_location (slot));
+ g_value_set_object (value, nautilus_window_slot_get_current_location (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
@@ -629,32 +673,34 @@ nautilus_window_slot_get_property (GObject *object,
static void
nautilus_window_slot_constructed (GObject *object)
{
- NautilusWindowSlot *slot = NAUTILUS_WINDOW_SLOT (object);
+ NautilusWindowSlotPrivate *priv;
+ NautilusWindowSlot *self = NAUTILUS_WINDOW_SLOT (object);
GtkWidget *extras_vbox;
GtkStyleContext *style_context;
+ priv = nautilus_window_slot_get_instance_private (self);
G_OBJECT_CLASS (nautilus_window_slot_parent_class)->constructed (object);
- gtk_orientable_set_orientation (GTK_ORIENTABLE (slot),
+ gtk_orientable_set_orientation (GTK_ORIENTABLE (self),
GTK_ORIENTATION_VERTICAL);
- gtk_widget_show (GTK_WIDGET (slot));
+ gtk_widget_show (GTK_WIDGET (self));
extras_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
style_context = gtk_widget_get_style_context (extras_vbox);
gtk_style_context_add_class (style_context, "searchbar-container");
- slot->details->extra_location_widgets = extras_vbox;
- gtk_box_pack_start (GTK_BOX (slot), extras_vbox, FALSE, FALSE, 0);
+ priv->extra_location_widgets = extras_vbox;
+ gtk_box_pack_start (GTK_BOX (self), extras_vbox, FALSE, FALSE, 0);
gtk_widget_show (extras_vbox);
- slot->details->query_editor = NAUTILUS_QUERY_EDITOR (nautilus_query_editor_new ());
- gtk_widget_show (GTK_WIDGET (slot->details->query_editor));
- nautilus_window_slot_add_extra_location_widget (slot, GTK_WIDGET (slot->details->query_editor));
+ priv->query_editor = NAUTILUS_QUERY_EDITOR (nautilus_query_editor_new ());
+ gtk_widget_show (GTK_WIDGET (priv->query_editor));
+ nautilus_window_slot_add_extra_location_widget (self, GTK_WIDGET (priv->query_editor));
- g_object_bind_property (slot, "location",
- slot->details->query_editor, "location",
+ g_object_bind_property (self, "location",
+ priv->query_editor, "location",
G_BINDING_DEFAULT);
- slot->details->title = g_strdup (_("Loading…"));
+ priv->title = g_strdup (_("Loading…"));
}
static void
@@ -662,18 +708,18 @@ action_search_visible (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
GVariant *current_state;
- slot = NAUTILUS_WINDOW_SLOT (user_data);
+ self = NAUTILUS_WINDOW_SLOT (user_data);
current_state = g_action_get_state (G_ACTION (action));
if (g_variant_get_boolean (current_state) != g_variant_get_boolean (state)) {
g_simple_action_set_state (action, state);
if (g_variant_get_boolean (state)) {
- show_query_editor (slot);
+ show_query_editor (self);
} else {
- hide_query_editor (slot);
+ hide_query_editor (self);
}
}
@@ -685,18 +731,18 @@ action_files_view_mode (GSimpleAction *action,
GVariant *value,
gpointer user_data)
{
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
const gchar *preferences_key;
guint view_id;
view_id = g_variant_get_uint32 (value);
- slot = NAUTILUS_WINDOW_SLOT (user_data);
+ self = NAUTILUS_WINDOW_SLOT (user_data);
- if (!NAUTILUS_IS_FILES_VIEW (nautilus_window_slot_get_current_view (slot)))
+ if (!NAUTILUS_IS_FILES_VIEW (nautilus_window_slot_get_current_view (self)))
return;
- nautilus_window_slot_set_content_view (slot, view_id);
- preferences_key = nautilus_view_is_searching (nautilus_window_slot_get_current_view (slot)) ?
+ nautilus_window_slot_set_content_view (self, view_id);
+ preferences_key = nautilus_view_is_searching (nautilus_window_slot_get_current_view (self)) ?
NAUTILUS_PREFERENCES_SEARCH_VIEW :
NAUTILUS_PREFERENCES_DEFAULT_FOLDER_VIEWER;
@@ -712,28 +758,27 @@ const GActionEntry slot_entries[] = {
};
static void
-nautilus_window_slot_init (NautilusWindowSlot *slot)
+nautilus_window_slot_init (NautilusWindowSlot *self)
{
GApplication *app;
+ NautilusWindowSlotPrivate *priv;
+ priv = nautilus_window_slot_get_instance_private (self);
app = g_application_get_default ();
- slot->details = G_TYPE_INSTANCE_GET_PRIVATE
- (slot, NAUTILUS_TYPE_WINDOW_SLOT, NautilusWindowSlotDetails);
-
- slot->details->slot_action_group = G_ACTION_GROUP (g_simple_action_group_new ());
- g_action_map_add_action_entries (G_ACTION_MAP (slot->details->slot_action_group),
+ priv->slot_action_group = G_ACTION_GROUP (g_simple_action_group_new ());
+ g_action_map_add_action_entries (G_ACTION_MAP (priv->slot_action_group),
slot_entries,
G_N_ELEMENTS (slot_entries),
- slot);
- gtk_widget_insert_action_group (GTK_WIDGET (slot),
+ self);
+ gtk_widget_insert_action_group (GTK_WIDGET (self),
"slot",
- G_ACTION_GROUP (slot->details->slot_action_group));
+ G_ACTION_GROUP (priv->slot_action_group));
nautilus_application_add_accelerator (app, "slot.files-view-mode(uint32 1)", "<control>1");
nautilus_application_add_accelerator (app, "slot.files-view-mode(uint32 0)", "<control>2");
nautilus_application_add_accelerator (app, "slot.search-visible", "<control>f");
- slot->details->view_mode_before_search = NAUTILUS_VIEW_INVALID_ID;
+ priv->view_mode_before_search = NAUTILUS_VIEW_INVALID_ID;
}
#define DEBUG_FLAG NAUTILUS_DEBUG_WINDOW
@@ -752,11 +797,11 @@ static void begin_location_change (NautilusWindowSlot
NautilusLocationChangeType type,
guint distance,
const char *scroll_pos);
-static void free_location_change (NautilusWindowSlot *slot);
-static void end_location_change (NautilusWindowSlot *slot);
+static void free_location_change (NautilusWindowSlot *self);
+static void end_location_change (NautilusWindowSlot *self);
static void got_file_info_for_view_selection_callback (NautilusFile *file,
gpointer callback_data);
-static gboolean setup_view (NautilusWindowSlot *slot,
+static gboolean setup_view (NautilusWindowSlot *self,
NautilusView *view);
static void load_new_location (NautilusWindowSlot *slot,
GFile *location,
@@ -765,30 +810,32 @@ static void load_new_location (NautilusWindowSlot
gboolean tell_new_content_view);
void
-nautilus_window_slot_open_location_full (NautilusWindowSlot *slot,
+nautilus_window_slot_open_location_full (NautilusWindowSlot *self,
GFile *location,
NautilusWindowOpenFlags flags,
GList *new_selection)
{
+ NautilusWindowSlotPrivate *priv;
GFile *old_location;
GList *old_selection;
NautilusWindow *window;
gboolean is_desktop;
+ priv = nautilus_window_slot_get_instance_private (self);
old_selection = NULL;
- old_location = nautilus_window_slot_get_location (slot);
- window = nautilus_window_slot_get_window (slot);
+ old_location = nautilus_window_slot_get_location (self);
+ window = nautilus_window_slot_get_window (self);
is_desktop = NAUTILUS_IS_DESKTOP_CANVAS_VIEW (window);
- if (slot->details->content_view) {
- old_selection = nautilus_view_get_selection (slot->details->content_view);
+ if (priv->content_view) {
+ old_selection = nautilus_view_get_selection (priv->content_view);
}
if (!is_desktop &&
old_location && g_file_equal (old_location, location) &&
nautilus_file_selection_equal (old_selection, new_selection))
goto done;
- begin_location_change (slot, location, old_location, new_selection,
+ begin_location_change (self, location, old_location, new_selection,
NAUTILUS_LOCATION_CHANGE_STANDARD, 0, NULL);
done:
@@ -861,15 +908,18 @@ check_force_reload (GFile *location,
}
static void
-save_scroll_position_for_history (NautilusWindowSlot *slot)
+save_scroll_position_for_history (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
char *current_pos;
/* Set current_bookmark scroll pos */
- if (slot->details->current_location_bookmark != NULL &&
- slot->details->content_view != NULL &&
- NAUTILUS_IS_FILES_VIEW (slot->details->content_view)) {
- current_pos = nautilus_files_view_get_first_visible_file (NAUTILUS_FILES_VIEW
(slot->details->content_view));
- nautilus_bookmark_set_scroll_pos (slot->details->current_location_bookmark, current_pos);
+ if (priv->current_location_bookmark != NULL &&
+ priv->content_view != NULL &&
+ NAUTILUS_IS_FILES_VIEW (priv->content_view)) {
+ current_pos = nautilus_files_view_get_first_visible_file (NAUTILUS_FILES_VIEW
(priv->content_view));
+ nautilus_bookmark_set_scroll_pos (priv->current_location_bookmark, current_pos);
g_free (current_pos);
}
}
@@ -891,7 +941,7 @@ save_scroll_position_for_history (NautilusWindowSlot *slot)
* location begins here.
*/
static void
-begin_location_change (NautilusWindowSlot *slot,
+begin_location_change (NautilusWindowSlot *self,
GFile *location,
GFile *previous_location,
GList *new_selection,
@@ -899,7 +949,9 @@ begin_location_change (NautilusWindowSlot *slot,
guint distance,
const char *scroll_pos)
{
- g_assert (slot != NULL);
+ NautilusWindowSlotPrivate *priv;
+
+ g_assert (self != NULL);
g_assert (location != NULL);
g_assert (type == NAUTILUS_LOCATION_CHANGE_BACK
|| type == NAUTILUS_LOCATION_CHANGE_FORWARD
@@ -907,95 +959,101 @@ begin_location_change (NautilusWindowSlot *slot,
nautilus_profile_start (NULL);
+ priv = nautilus_window_slot_get_instance_private (self);
/* Avoid to update status from the current view in our async calls */
- nautilus_window_slot_disconnect_content_view (slot);
+ nautilus_window_slot_disconnect_content_view (self);
/* We are going to change the location, so make sure we stop any loading
* or searching of the previous view, so we avoid to be slow */
- nautilus_window_slot_stop_loading (slot);
+ nautilus_window_slot_stop_loading (self);
- nautilus_window_slot_set_allow_stop (slot, TRUE);
+ nautilus_window_slot_set_allow_stop (self, TRUE);
new_selection = check_select_old_location_containing_folder (new_selection, location,
previous_location);
- g_assert (slot->details->pending_location == NULL);
+ g_assert (priv->pending_location == NULL);
- slot->details->pending_location = g_object_ref (location);
- slot->details->location_change_type = type;
- slot->details->location_change_distance = distance;
- slot->details->tried_mount = FALSE;
- slot->details->pending_selection = nautilus_file_list_copy (new_selection);
+ priv->pending_location = g_object_ref (location);
+ priv->location_change_type = type;
+ priv->location_change_distance = distance;
+ priv->tried_mount = FALSE;
+ priv->pending_selection = nautilus_file_list_copy (new_selection);
- slot->details->pending_scroll_to = g_strdup (scroll_pos);
+ priv->pending_scroll_to = g_strdup (scroll_pos);
check_force_reload (location, type);
- save_scroll_position_for_history (slot);
+ save_scroll_position_for_history (self);
/* Get the info needed to make decisions about how to open the new location */
- slot->details->determine_view_file = nautilus_file_get (location);
- g_assert (slot->details->determine_view_file != NULL);
+ priv->determine_view_file = nautilus_file_get (location);
+ g_assert (priv->determine_view_file != NULL);
- nautilus_file_call_when_ready (slot->details->determine_view_file,
+ nautilus_file_call_when_ready (priv->determine_view_file,
NAUTILUS_FILE_ATTRIBUTE_INFO |
NAUTILUS_FILE_ATTRIBUTE_MOUNT,
got_file_info_for_view_selection_callback,
- slot);
+ self);
nautilus_profile_end (NULL);
}
static void
-nautilus_window_slot_set_location (NautilusWindowSlot *slot,
- GFile *location)
+nautilus_window_slot_set_location (NautilusWindowSlot *self,
+ GFile *location)
{
+ NautilusWindowSlotPrivate *priv;
GFile *old_location;
- if (slot->details->location &&
- g_file_equal (location, slot->details->location)) {
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->location &&
+ g_file_equal (location, priv->location)) {
/* The location name could be updated even if the location
* wasn't changed. This is the case for a search.
*/
- nautilus_window_slot_update_title (slot);
+ nautilus_window_slot_update_title (self);
return;
}
- old_location = slot->details->location;
- slot->details->location = g_object_ref (location);
+ old_location = priv->location;
+ priv->location = g_object_ref (location);
- if (nautilus_window_slot_get_active (slot)) {
- nautilus_window_sync_location_widgets (slot->details->window);
+ if (nautilus_window_slot_get_active (self)) {
+ nautilus_window_sync_location_widgets (priv->window);
}
- nautilus_window_slot_update_title (slot);
+ nautilus_window_slot_update_title (self);
if (old_location) {
g_object_unref (old_location);
}
- g_object_notify_by_pspec (G_OBJECT (slot), properties[PROP_LOCATION]);
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LOCATION]);
}
static void
-viewed_file_changed_callback (NautilusFile *file,
- NautilusWindowSlot *slot)
+viewed_file_changed_callback (NautilusFile *file,
+ NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
GFile *new_location;
gboolean is_in_trash, was_in_trash;
g_assert (NAUTILUS_IS_FILE (file));
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
- g_assert (file == slot->details->viewed_file);
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ g_assert (file == priv->viewed_file);
if (!nautilus_file_is_not_yet_confirmed (file)) {
- slot->details->viewed_file_seen = TRUE;
+ priv->viewed_file_seen = TRUE;
}
- was_in_trash = slot->details->viewed_file_in_trash;
+ was_in_trash = priv->viewed_file_in_trash;
- slot->details->viewed_file_in_trash = is_in_trash = nautilus_file_is_in_trash (file);
+ priv->viewed_file_in_trash = is_in_trash = nautilus_file_is_in_trash (file);
if (nautilus_file_is_gone (file) || (is_in_trash && !was_in_trash)) {
- if (slot->details->viewed_file_seen) {
+ if (priv->viewed_file_seen) {
GFile *go_to_file;
GFile *parent;
GFile *location;
@@ -1021,7 +1079,7 @@ viewed_file_changed_callback (NautilusFile *file,
go_to_file = g_file_new_for_path (g_get_home_dir ());
}
- nautilus_window_slot_open_location_full (slot, go_to_file, 0, NULL);
+ nautilus_window_slot_open_location_full (self, go_to_file, 0, NULL);
g_clear_object (&parent);
g_object_unref (go_to_file);
@@ -1029,56 +1087,58 @@ viewed_file_changed_callback (NautilusFile *file,
}
} else {
new_location = nautilus_file_get_location (file);
- nautilus_window_slot_set_location (slot, new_location);
+ nautilus_window_slot_set_location (self, new_location);
g_object_unref (new_location);
}
}
static void
-nautilus_window_slot_go_home (NautilusWindowSlot *slot,
- NautilusWindowOpenFlags flags)
+nautilus_window_slot_go_home (NautilusWindowSlot *self,
+ NautilusWindowOpenFlags flags)
{
GFile *home;
- g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot));
+ g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (self));
home = g_file_new_for_path (g_get_home_dir ());
- nautilus_window_slot_open_location_full (slot, home, flags, NULL);
+ nautilus_window_slot_open_location_full (self, home, flags, NULL);
g_object_unref (home);
}
static void
-nautilus_window_slot_set_viewed_file (NautilusWindowSlot *slot,
- NautilusFile *file)
+nautilus_window_slot_set_viewed_file (NautilusWindowSlot *self,
+ NautilusFile *file)
{
+ NautilusWindowSlotPrivate *priv;
NautilusFileAttributes attributes;
- if (slot->details->viewed_file == file) {
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->viewed_file == file) {
return;
}
nautilus_file_ref (file);
- if (slot->details->viewed_file != NULL) {
- g_signal_handlers_disconnect_by_func (slot->details->viewed_file,
+ if (priv->viewed_file != NULL) {
+ g_signal_handlers_disconnect_by_func (priv->viewed_file,
G_CALLBACK (viewed_file_changed_callback),
- slot);
- nautilus_file_monitor_remove (slot->details->viewed_file,
- slot);
+ self);
+ nautilus_file_monitor_remove (priv->viewed_file,
+ self);
}
if (file != NULL) {
attributes =
NAUTILUS_FILE_ATTRIBUTE_INFO |
NAUTILUS_FILE_ATTRIBUTE_LINK_INFO;
- nautilus_file_monitor_add (file, slot, attributes);
+ nautilus_file_monitor_add (file, self, attributes);
g_signal_connect_object (file, "changed",
- G_CALLBACK (viewed_file_changed_callback), slot, 0);
+ G_CALLBACK (viewed_file_changed_callback), self, 0);
}
- nautilus_file_unref (slot->details->viewed_file);
- slot->details->viewed_file = file;
+ nautilus_file_unref (priv->viewed_file);
+ priv->viewed_file = file;
}
typedef struct {
@@ -1087,17 +1147,19 @@ typedef struct {
} MountNotMountedData;
static void
-mount_not_mounted_callback (GObject *source_object,
- GAsyncResult *res,
- gpointer user_data)
+mount_not_mounted_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
{
+ NautilusWindowSlotPrivate *priv;
MountNotMountedData *data;
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
GError *error;
GCancellable *cancellable;
data = user_data;
- slot = data->slot;
+ self = data->slot;
+ priv = nautilus_window_slot_get_instance_private (self);
cancellable = data->cancellable;
g_free (data);
@@ -1107,23 +1169,23 @@ mount_not_mounted_callback (GObject *source_object,
return;
}
- slot->details->mount_cancellable = NULL;
+ priv->mount_cancellable = NULL;
- slot->details->determine_view_file = nautilus_file_get (slot->details->pending_location);
+ priv->determine_view_file = nautilus_file_get (priv->pending_location);
error = NULL;
if (!g_file_mount_enclosing_volume_finish (G_FILE (source_object), res, &error)) {
- slot->details->mount_error = error;
- got_file_info_for_view_selection_callback (slot->details->determine_view_file, slot);
- slot->details->mount_error = NULL;
+ priv->mount_error = error;
+ got_file_info_for_view_selection_callback (priv->determine_view_file, self);
+ priv->mount_error = NULL;
g_error_free (error);
} else {
- nautilus_file_invalidate_all_attributes (slot->details->determine_view_file);
- nautilus_file_call_when_ready (slot->details->determine_view_file,
+ nautilus_file_invalidate_all_attributes (priv->determine_view_file);
+ nautilus_file_call_when_ready (priv->determine_view_file,
NAUTILUS_FILE_ATTRIBUTE_INFO |
NAUTILUS_FILE_ATTRIBUTE_MOUNT,
got_file_info_for_view_selection_callback,
- slot);
+ self);
}
g_object_unref (cancellable);
@@ -1214,9 +1276,10 @@ nautilus_window_slot_display_view_selection_failure (NautilusWindow *window,
* akwnoledge by it either by adding a reference to its parent volume monitor
* or with another solution. */
static gboolean
-handle_mount_if_needed (NautilusWindowSlot *slot,
+handle_mount_if_needed (NautilusWindowSlot *self,
NautilusFile *file)
{
+ NautilusWindowSlotPrivate *priv;
NautilusWindow *window;
GMountOperation *mount_op;
MountNotMountedData *data;
@@ -1224,25 +1287,26 @@ handle_mount_if_needed (NautilusWindowSlot *slot,
GError *error = NULL;
gboolean needs_mount_handling = FALSE;
- window = nautilus_window_slot_get_window (slot);
- if (slot->details->mount_error) {
- error = g_error_copy (slot->details->mount_error);
+ priv = nautilus_window_slot_get_instance_private (self);
+ window = nautilus_window_slot_get_window (self);
+ if (priv->mount_error) {
+ error = g_error_copy (priv->mount_error);
} else if (nautilus_file_get_file_info_error (file) != NULL) {
error = g_error_copy (nautilus_file_get_file_info_error (file));
}
if (error && error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_MOUNTED &&
- !slot->details->tried_mount) {
- slot->details->tried_mount = TRUE;
+ !priv->tried_mount) {
+ priv->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 = nautilus_file_get_location (file);
data = g_new0 (MountNotMountedData, 1);
data->cancellable = g_cancellable_new ();
- data->slot = slot;
- slot->details->mount_cancellable = data->cancellable;
- g_file_mount_enclosing_volume (location, 0, mount_op, slot->details->mount_cancellable,
+ data->slot = self;
+ priv->mount_cancellable = data->cancellable;
+ g_file_mount_enclosing_volume (location, 0, mount_op, priv->mount_cancellable,
mount_not_mounted_callback, data);
g_object_unref (location);
g_object_unref (mount_op);
@@ -1256,33 +1320,35 @@ handle_mount_if_needed (NautilusWindowSlot *slot,
}
static gboolean
-handle_regular_file_if_needed (NautilusWindowSlot *slot,
+handle_regular_file_if_needed (NautilusWindowSlot *self,
NautilusFile *file)
{
NautilusFile *parent_file;
gboolean needs_regular_file_handling = FALSE;
+ NautilusWindowSlotPrivate *priv;
+ priv = nautilus_window_slot_get_instance_private (self);
parent_file = nautilus_file_get_parent (file);
if ((parent_file != NULL) &&
nautilus_file_get_file_type (file) == G_FILE_TYPE_REGULAR) {
- if (slot->details->pending_selection != NULL) {
- nautilus_file_list_free (slot->details->pending_selection);
+ if (priv->pending_selection != NULL) {
+ nautilus_file_list_free (priv->pending_selection);
}
- g_clear_object (&slot->details->pending_location);
- g_free (slot->details->pending_scroll_to);
+ g_clear_object (&priv->pending_location);
+ g_free (priv->pending_scroll_to);
- slot->details->pending_location = nautilus_file_get_parent_location (file);
- slot->details->pending_selection = g_list_prepend (NULL, nautilus_file_ref (file));
- slot->details->determine_view_file = nautilus_file_ref (parent_file);
- slot->details->pending_scroll_to = nautilus_file_get_uri (file);
+ priv->pending_location = nautilus_file_get_parent_location (file);
+ priv->pending_selection = g_list_prepend (NULL, nautilus_file_ref (file));
+ priv->determine_view_file = nautilus_file_ref (parent_file);
+ priv->pending_scroll_to = nautilus_file_get_uri (file);
- nautilus_file_invalidate_all_attributes (slot->details->determine_view_file);
- nautilus_file_call_when_ready (slot->details->determine_view_file,
+ nautilus_file_invalidate_all_attributes (priv->determine_view_file);
+ nautilus_file_call_when_ready (priv->determine_view_file,
NAUTILUS_FILE_ATTRIBUTE_INFO |
NAUTILUS_FILE_ATTRIBUTE_MOUNT,
got_file_info_for_view_selection_callback,
- slot);
+ self);
needs_regular_file_handling = TRUE;
}
@@ -1294,44 +1360,46 @@ handle_regular_file_if_needed (NautilusWindowSlot *slot,
static void
got_file_info_for_view_selection_callback (NautilusFile *file,
- gpointer callback_data)
+ gpointer callback_data)
{
+ NautilusWindowSlotPrivate *priv;
GError *error = NULL;
NautilusWindow *window;
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
NautilusFile *viewed_file;
NautilusView *view;
GFile *location;
NautilusApplication *app;
- slot = callback_data;
- window = nautilus_window_slot_get_window (slot);
+ self = callback_data;
+ priv = nautilus_window_slot_get_instance_private (self);
+ window = nautilus_window_slot_get_window (self);
- g_assert (slot->details->determine_view_file == file);
- slot->details->determine_view_file = NULL;
+ g_assert (priv->determine_view_file == file);
+ priv->determine_view_file = NULL;
nautilus_profile_start (NULL);
- if (handle_mount_if_needed (slot, file))
+ if (handle_mount_if_needed (self, file))
goto done;
- if (handle_regular_file_if_needed (slot, file))
+ if (handle_regular_file_if_needed (self, file))
goto done;
- if (slot->details->mount_error) {
- error = g_error_copy (slot->details->mount_error);
+ if (priv->mount_error) {
+ error = g_error_copy (priv->mount_error);
} else if (nautilus_file_get_file_info_error (file) != NULL) {
error = g_error_copy (nautilus_file_get_file_info_error (file));
}
- location = slot->details->pending_location;
+ location = priv->pending_location;
/* desktop and other-locations GFile operations report G_IO_ERROR_NOT_SUPPORTED,
* but it's not an actual error for Nautilus */
if (!error || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) {
- view = nautilus_window_slot_get_view_for_location (slot, location);
- setup_view (slot, view);
+ view = nautilus_window_slot_get_view_for_location (self, location);
+ setup_view (self, view);
} else {
if (error == NULL) {
error = g_error_new (G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
@@ -1357,13 +1425,13 @@ got_file_info_for_view_selection_callback (NautilusFile *file,
if (!nautilus_is_root_directory (location)) {
if (!nautilus_is_home_directory (location)) {
- nautilus_window_slot_go_home (slot, FALSE);
+ nautilus_window_slot_go_home (self, 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! */
- nautilus_window_slot_open_location_full (slot, location, 0,
NULL);
+ nautilus_window_slot_open_location_full (self, location, 0,
NULL);
g_object_unref (root);
}
} else {
@@ -1377,17 +1445,17 @@ got_file_info_for_view_selection_callback (NautilusFile *file,
GFile *slot_location;
/* Clean up state of already-showing window */
- end_location_change (slot);
- slot_location = nautilus_window_slot_get_location (slot);
+ end_location_change (self);
+ slot_location = nautilus_window_slot_get_location (self);
/* We're missing a previous location (if opened location
* in a new tab) so close it and return */
if (slot_location == NULL) {
- nautilus_window_slot_close (window, slot);
+ nautilus_window_slot_close (window, self);
} else {
/* We disconnected this, so we need to re-connect it */
viewed_file = nautilus_file_get (slot_location);
- nautilus_window_slot_set_viewed_file (slot, viewed_file);
+ nautilus_window_slot_set_viewed_file (self, viewed_file);
nautilus_file_unref (viewed_file);
/* Leave the location bar showing the bad location that the user
@@ -1414,39 +1482,41 @@ got_file_info_for_view_selection_callback (NautilusFile *file,
* view, and the current location will be used.
*/
static gboolean
-setup_view (NautilusWindowSlot *slot,
+setup_view (NautilusWindowSlot *self,
NautilusView *view)
{
gboolean ret = TRUE;
GFile *old_location;
+ NautilusWindowSlotPrivate *priv;
nautilus_profile_start (NULL);
- nautilus_window_slot_disconnect_content_view (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ nautilus_window_slot_disconnect_content_view (self);
- slot->details->new_content_view = view;
+ priv->new_content_view = view;
- nautilus_window_slot_connect_new_content_view (slot);
+ nautilus_window_slot_connect_new_content_view (self);
/* Forward search selection and state before loading the new model */
- old_location = slot->details->content_view ? nautilus_view_get_location
(slot->details->content_view) : NULL;
+ old_location = priv->content_view ? nautilus_view_get_location (priv->content_view) : NULL;
/* Actually load the pending location and selection: */
- if (slot->details->pending_location != NULL) {
- load_new_location (slot,
- slot->details->pending_location,
- slot->details->pending_selection,
+ if (priv->pending_location != NULL) {
+ load_new_location (self,
+ priv->pending_location,
+ priv->pending_selection,
FALSE,
TRUE);
- nautilus_file_list_free (slot->details->pending_selection);
- slot->details->pending_selection = NULL;
+ nautilus_file_list_free (priv->pending_selection);
+ priv->pending_selection = NULL;
} else if (old_location != NULL) {
GList *selection;
- selection = nautilus_view_get_selection (slot->details->content_view);
+ selection = nautilus_view_get_selection (priv->content_view);
- load_new_location (slot,
+ load_new_location (self,
old_location,
selection,
FALSE,
@@ -1457,8 +1527,8 @@ setup_view (NautilusWindowSlot *slot,
goto out;
}
- change_view (slot);
- gtk_widget_show (GTK_WIDGET (slot->details->window));
+ change_view (self);
+ gtk_widget_show (GTK_WIDGET (priv->window));
out:
nautilus_profile_end (NULL);
@@ -1467,31 +1537,33 @@ out:
}
static void
-load_new_location (NautilusWindowSlot *slot,
- GFile *location,
- GList *selection,
- gboolean tell_current_content_view,
- gboolean tell_new_content_view)
+load_new_location (NautilusWindowSlot *self,
+ GFile *location,
+ GList *selection,
+ gboolean tell_current_content_view,
+ gboolean tell_new_content_view)
{
NautilusView *view;
+ NautilusWindowSlotPrivate *priv;
- g_assert (slot != NULL);
+ g_assert (self != NULL);
g_assert (location != NULL);
view = NULL;
+ priv = nautilus_window_slot_get_instance_private (self);
nautilus_profile_start (NULL);
/* Note, these may recurse into report_load_underway */
- if (slot->details->content_view != NULL && tell_current_content_view) {
- view = slot->details->content_view;
- nautilus_view_set_location (slot->details->content_view, location);
+ if (priv->content_view != NULL && tell_current_content_view) {
+ view = priv->content_view;
+ nautilus_view_set_location (priv->content_view, location);
}
- if (slot->details->new_content_view != NULL && tell_new_content_view &&
+ if (priv->new_content_view != NULL && tell_new_content_view &&
(!tell_current_content_view ||
- slot->details->new_content_view != slot->details->content_view) ) {
- view = slot->details->new_content_view;
- nautilus_view_set_location (slot->details->new_content_view, location);
+ priv->new_content_view != priv->content_view) ) {
+ view = priv->new_content_view;
+ nautilus_view_set_location (priv->new_content_view, location);
}
if (view) {
/* new_content_view might have changed here if
@@ -1503,87 +1575,94 @@ load_new_location (NautilusWindowSlot *slot,
}
static void
-end_location_change (NautilusWindowSlot *slot)
+end_location_change (NautilusWindowSlot *self)
{
char *uri;
+ NautilusWindowSlotPrivate *priv;
- uri = nautilus_window_slot_get_location_uri (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ uri = nautilus_window_slot_get_location_uri (self);
if (uri) {
DEBUG ("Finished loading window for uri %s", uri);
g_free (uri);
}
- nautilus_window_slot_set_allow_stop (slot, FALSE);
+ nautilus_window_slot_set_allow_stop (self, FALSE);
/* Now we can free details->pending_scroll_to, since the load_complete
* callback already has been emitted.
*/
- g_free (slot->details->pending_scroll_to);
- slot->details->pending_scroll_to = NULL;
+ g_free (priv->pending_scroll_to);
+ priv->pending_scroll_to = NULL;
- free_location_change (slot);
+ free_location_change (self);
}
static void
-free_location_change (NautilusWindowSlot *slot)
+free_location_change (NautilusWindowSlot *self)
{
- g_clear_object (&slot->details->pending_location);
- nautilus_file_list_free (slot->details->pending_selection);
- slot->details->pending_selection = NULL;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ g_clear_object (&priv->pending_location);
+ nautilus_file_list_free (priv->pending_selection);
+ priv->pending_selection = NULL;
/* Don't free details->pending_scroll_to, since thats needed until
* the load_complete callback.
*/
- if (slot->details->mount_cancellable != NULL) {
- g_cancellable_cancel (slot->details->mount_cancellable);
- slot->details->mount_cancellable = NULL;
+ if (priv->mount_cancellable != NULL) {
+ g_cancellable_cancel (priv->mount_cancellable);
+ priv->mount_cancellable = NULL;
}
- if (slot->details->determine_view_file != NULL) {
+ if (priv->determine_view_file != NULL) {
nautilus_file_cancel_call_when_ready
- (slot->details->determine_view_file,
- got_file_info_for_view_selection_callback, slot);
- slot->details->determine_view_file = NULL;
+ (priv->determine_view_file,
+ got_file_info_for_view_selection_callback, self);
+ priv->determine_view_file = NULL;
}
}
static void
-nautilus_window_slot_set_content_view (NautilusWindowSlot *slot,
+nautilus_window_slot_set_content_view (NautilusWindowSlot *self,
guint id)
{
NautilusFilesView *view;
GList *selection;
char *uri;
+ NautilusWindowSlotPrivate *priv;
- g_assert (slot != NULL);
+ g_assert (self != NULL);
- uri = nautilus_window_slot_get_location_uri (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ uri = nautilus_window_slot_get_location_uri (self);
DEBUG ("Change view of window %s to %d", uri, id);
g_free (uri);
- if (nautilus_window_slot_content_view_matches (slot, id)) {
+ if (nautilus_window_slot_content_view_matches (self, id)) {
return;
}
- selection = nautilus_view_get_selection (slot->details->content_view);
- view = nautilus_files_view_new (id, slot);
+ selection = nautilus_view_get_selection (priv->content_view);
+ view = nautilus_files_view_new (id, self);
- nautilus_window_slot_stop_loading (slot);
+ nautilus_window_slot_stop_loading (self);
- nautilus_window_slot_set_allow_stop (slot, TRUE);
+ nautilus_window_slot_set_allow_stop (self, TRUE);
- if (g_list_length (selection) == 0 && NAUTILUS_IS_FILES_VIEW (slot->details->content_view)) {
+ if (g_list_length (selection) == 0 && NAUTILUS_IS_FILES_VIEW (priv->content_view)) {
/* If there is no selection, queue a scroll to the same icon that
* is currently visible */
- slot->details->pending_scroll_to = nautilus_files_view_get_first_visible_file
(NAUTILUS_FILES_VIEW (slot->details->content_view));
+ priv->pending_scroll_to = nautilus_files_view_get_first_visible_file (NAUTILUS_FILES_VIEW
(priv->content_view));
}
- slot->details->location_change_type = NAUTILUS_LOCATION_CHANGE_RELOAD;
+ priv->location_change_type = NAUTILUS_LOCATION_CHANGE_RELOAD;
- if (!setup_view (slot, NAUTILUS_VIEW (view))) {
+ if (!setup_view (self, NAUTILUS_VIEW (view))) {
/* Just load the homedir. */
- nautilus_window_slot_go_home (slot, FALSE);
+ nautilus_window_slot_go_home (self, FALSE);
}
}
@@ -1593,15 +1672,17 @@ nautilus_window_back_or_forward (NautilusWindow *window,
guint distance,
NautilusWindowOpenFlags flags)
{
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
GList *list;
GFile *location;
guint len;
NautilusBookmark *bookmark;
GFile *old_location;
+ NautilusWindowSlotPrivate *priv;
- slot = nautilus_window_get_active_slot (window);
- list = back ? slot->details->back_list : slot->details->forward_list;
+ self = nautilus_window_get_active_slot (window);
+ priv = nautilus_window_slot_get_instance_private (self);
+ list = back ? priv->back_list : priv->forward_list;
len = (guint) g_list_length (list);
@@ -1618,14 +1699,14 @@ nautilus_window_back_or_forward (NautilusWindow *window,
location = nautilus_bookmark_get_location (bookmark);
if (flags != 0) {
- nautilus_window_slot_open_location_full (slot, location, flags, NULL);
+ nautilus_window_slot_open_location_full (self, location, flags, NULL);
} else {
char *scroll_pos;
- old_location = nautilus_window_slot_get_location (slot);
+ old_location = nautilus_window_slot_get_location (self);
scroll_pos = nautilus_bookmark_get_scroll_pos (bookmark);
begin_location_change
- (slot,
+ (self,
location, old_location, NULL,
back ? NAUTILUS_LOCATION_CHANGE_BACK : NAUTILUS_LOCATION_CHANGE_FORWARD,
distance,
@@ -1639,15 +1720,17 @@ nautilus_window_back_or_forward (NautilusWindow *window,
/* reload the contents of the window */
static void
-nautilus_window_slot_force_reload (NautilusWindowSlot *slot)
+nautilus_window_slot_force_reload (NautilusWindowSlot *self)
{
GFile *location;
char *current_pos;
GList *selection;
+ NautilusWindowSlotPrivate *priv;
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
- location = nautilus_window_slot_get_location (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ location = nautilus_window_slot_get_location (self);
if (location == NULL) {
return;
}
@@ -1658,15 +1741,15 @@ nautilus_window_slot_force_reload (NautilusWindowSlot *slot)
g_object_ref (location);
current_pos = NULL;
selection = NULL;
- if (slot->details->new_content_view) {
- selection = nautilus_view_get_selection (slot->details->content_view);
+ if (priv->new_content_view) {
+ selection = nautilus_view_get_selection (priv->content_view);
- if (NAUTILUS_IS_FILES_VIEW (slot->details->new_content_view)) {
- current_pos = nautilus_files_view_get_first_visible_file (NAUTILUS_FILES_VIEW
(slot->details->content_view));
+ if (NAUTILUS_IS_FILES_VIEW (priv->new_content_view)) {
+ current_pos = nautilus_files_view_get_first_visible_file (NAUTILUS_FILES_VIEW
(priv->content_view));
}
}
begin_location_change
- (slot, location, location, selection,
+ (self, location, location, selection,
NAUTILUS_LOCATION_CHANGE_RELOAD, 0, current_pos);
g_free (current_pos);
g_object_unref (location);
@@ -1674,56 +1757,68 @@ nautilus_window_slot_force_reload (NautilusWindowSlot *slot)
}
void
-nautilus_window_slot_queue_reload (NautilusWindowSlot *slot)
+nautilus_window_slot_queue_reload (NautilusWindowSlot *self)
{
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
+
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
- if (nautilus_window_slot_get_location (slot) == NULL) {
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (nautilus_window_slot_get_location (self) == NULL) {
return;
}
- if (slot->details->pending_location != NULL
- || slot->details->content_view == NULL
- || nautilus_view_is_loading (slot->details->content_view)) {
+ if (priv->pending_location != NULL
+ || priv->content_view == NULL
+ || nautilus_view_is_loading (priv->content_view)) {
/* there is a reload in flight */
- slot->details->needs_reload = TRUE;
+ priv->needs_reload = TRUE;
return;
}
- nautilus_window_slot_force_reload (slot);
+ nautilus_window_slot_force_reload (self);
}
static void
-nautilus_window_slot_clear_forward_list (NautilusWindowSlot *slot)
+nautilus_window_slot_clear_forward_list (NautilusWindowSlot *self)
{
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
- g_list_free_full (slot->details->forward_list, g_object_unref);
- slot->details->forward_list = NULL;
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ g_list_free_full (priv->forward_list, g_object_unref);
+ priv->forward_list = NULL;
}
static void
-nautilus_window_slot_clear_back_list (NautilusWindowSlot *slot)
+nautilus_window_slot_clear_back_list (NautilusWindowSlot *self)
{
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
+
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
- g_list_free_full (slot->details->back_list, g_object_unref);
- slot->details->back_list = NULL;
+ priv = nautilus_window_slot_get_instance_private (self);
+ g_list_free_full (priv->back_list, g_object_unref);
+ priv->back_list = NULL;
}
static void
-nautilus_window_slot_update_bookmark (NautilusWindowSlot *slot, NautilusFile *file)
+nautilus_window_slot_update_bookmark (NautilusWindowSlot *self,
+ NautilusFile *file)
{
gboolean recreate;
GFile *new_location;
+ NautilusWindowSlotPrivate *priv;
+ priv = nautilus_window_slot_get_instance_private (self);
new_location = nautilus_file_get_location (file);
- if (slot->details->current_location_bookmark == NULL) {
+ if (priv->current_location_bookmark == NULL) {
recreate = TRUE;
} else {
GFile *bookmark_location;
- bookmark_location = nautilus_bookmark_get_location (slot->details->current_location_bookmark);
+ bookmark_location = nautilus_bookmark_get_location (priv->current_location_bookmark);
recreate = !g_file_equal (bookmark_location, new_location);
g_object_unref (bookmark_location);
}
@@ -1732,11 +1827,11 @@ nautilus_window_slot_update_bookmark (NautilusWindowSlot *slot, NautilusFile *fi
char *display_name = NULL;
/* We've changed locations, must recreate bookmark for current location. */
- g_clear_object (&slot->details->last_location_bookmark);
- slot->details->last_location_bookmark = slot->details->current_location_bookmark;
+ g_clear_object (&priv->last_location_bookmark);
+ priv->last_location_bookmark = priv->current_location_bookmark;
display_name = nautilus_file_get_display_name (file);
- slot->details->current_location_bookmark = nautilus_bookmark_new (new_location, display_name);
+ priv->current_location_bookmark = nautilus_bookmark_new (new_location, display_name);
g_free (display_name);
}
@@ -1744,7 +1839,8 @@ nautilus_window_slot_update_bookmark (NautilusWindowSlot *slot, NautilusFile *fi
}
static void
-check_bookmark_location_matches (NautilusBookmark *bookmark, GFile *location)
+check_bookmark_location_matches (NautilusBookmark *bookmark,
+ GFile *location)
{
GFile *bookmark_location;
char *bookmark_uri, *uri;
@@ -1765,14 +1861,17 @@ check_bookmark_location_matches (NautilusBookmark *bookmark, GFile *location)
* Back or Forward list.
*/
static void
-check_last_bookmark_location_matches_slot (NautilusWindowSlot *slot)
+check_last_bookmark_location_matches_slot (NautilusWindowSlot *self)
{
- check_bookmark_location_matches (slot->details->last_location_bookmark,
- nautilus_window_slot_get_location (slot));
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ check_bookmark_location_matches (priv->last_location_bookmark,
+ nautilus_window_slot_get_location (self));
}
static void
-handle_go_direction (NautilusWindowSlot *slot,
+handle_go_direction (NautilusWindowSlot *self,
GFile *location,
gboolean forward)
{
@@ -1780,27 +1879,29 @@ handle_go_direction (NautilusWindowSlot *slot,
GList *list, *other_list, *link;
NautilusBookmark *bookmark;
gint i;
+ NautilusWindowSlotPrivate *priv;
- list_ptr = (forward) ? (&slot->details->forward_list) : (&slot->details->back_list);
- other_list_ptr = (forward) ? (&slot->details->back_list) : (&slot->details->forward_list);
+ priv = nautilus_window_slot_get_instance_private (self);
+ list_ptr = (forward) ? (&priv->forward_list) : (&priv->back_list);
+ other_list_ptr = (forward) ? (&priv->back_list) : (&priv->forward_list);
list = *list_ptr;
other_list = *other_list_ptr;
/* Move items from the list to the other list. */
- g_assert (g_list_length (list) > slot->details->location_change_distance);
- check_bookmark_location_matches (g_list_nth_data (list, slot->details->location_change_distance),
+ g_assert (g_list_length (list) > priv->location_change_distance);
+ check_bookmark_location_matches (g_list_nth_data (list, priv->location_change_distance),
location);
- g_assert (nautilus_window_slot_get_location (slot) != NULL);
+ g_assert (nautilus_window_slot_get_location (self) != NULL);
/* Move current location to list */
- check_last_bookmark_location_matches_slot (slot);
+ check_last_bookmark_location_matches_slot (self);
/* Use the first bookmark in the history list rather than creating a new one. */
- other_list = g_list_prepend (other_list, slot->details->last_location_bookmark);
+ other_list = g_list_prepend (other_list, priv->last_location_bookmark);
g_object_ref (other_list->data);
/* Move extra links from the list to the other list */
- for (i = 0; i < slot->details->location_change_distance; ++i) {
+ for (i = 0; i < priv->location_change_distance; ++i) {
bookmark = NAUTILUS_BOOKMARK (list->data);
list = g_list_remove (list, bookmark);
other_list = g_list_prepend (other_list, bookmark);
@@ -1817,14 +1918,16 @@ handle_go_direction (NautilusWindowSlot *slot,
}
static void
-handle_go_elsewhere (NautilusWindowSlot *slot,
- GFile *location)
+handle_go_elsewhere (NautilusWindowSlot *self,
+ GFile *location)
{
GFile *slot_location;
+ NautilusWindowSlotPrivate *priv;
+ priv = nautilus_window_slot_get_instance_private (self);
/* Clobber the entire forward list, and move displayed location to back list */
- nautilus_window_slot_clear_forward_list (slot);
- slot_location = nautilus_window_slot_get_location (slot);
+ nautilus_window_slot_clear_forward_list (self);
+ slot_location = nautilus_window_slot_get_location (self);
if (slot_location != NULL) {
/* If we're returning to the same uri somehow, don't put this uri on back list.
@@ -1833,32 +1936,32 @@ handle_go_elsewhere (NautilusWindowSlot *slot,
*/
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);
+ check_last_bookmark_location_matches_slot (self);
/* Use the first bookmark in the history list rather than creating a new one. */
- slot->details->back_list = g_list_prepend (slot->details->back_list,
- slot->details->last_location_bookmark);
- g_object_ref (slot->details->back_list->data);
+ priv->back_list = g_list_prepend (priv->back_list,
+ priv->last_location_bookmark);
+ g_object_ref (priv->back_list->data);
}
}
}
static void
-update_history (NautilusWindowSlot *slot,
- NautilusLocationChangeType type,
- GFile *new_location)
+update_history (NautilusWindowSlot *self,
+ NautilusLocationChangeType type,
+ GFile *new_location)
{
switch (type) {
case NAUTILUS_LOCATION_CHANGE_STANDARD:
- handle_go_elsewhere (slot, new_location);
+ handle_go_elsewhere (self, new_location);
return;
case NAUTILUS_LOCATION_CHANGE_RELOAD:
/* for reload there is no work to do */
return;
case NAUTILUS_LOCATION_CHANGE_BACK:
- handle_go_direction (slot, new_location, FALSE);
+ handle_go_direction (self, new_location, FALSE);
return;
case NAUTILUS_LOCATION_CHANGE_FORWARD:
- handle_go_direction (slot, new_location, TRUE);
+ handle_go_direction (self, new_location, TRUE);
return;
}
g_return_if_fail (FALSE);
@@ -1871,38 +1974,43 @@ typedef struct {
} FindMountData;
static void
-nautilus_window_slot_show_x_content_bar (NautilusWindowSlot *slot, GMount *mount, const char * const
*x_content_types)
+nautilus_window_slot_show_x_content_bar (NautilusWindowSlot *self,
+ GMount *mount,
+ const char * const *x_content_types)
{
GtkWidget *bar;
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
if (!should_handle_content_types (x_content_types))
return;
bar = nautilus_x_content_bar_new (mount, x_content_types);
gtk_widget_show (bar);
- nautilus_window_slot_add_extra_location_widget (slot, bar);
+ nautilus_window_slot_add_extra_location_widget (self, bar);
}
static void
found_content_type_cb (const char **x_content_types,
- gpointer user_data)
+ gpointer user_data)
{
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
FindMountData *data = user_data;
+ NautilusWindowSlotPrivate *priv;
+
+ self = data->slot;
+ priv = nautilus_window_slot_get_instance_private (self);
if (g_cancellable_is_cancelled (data->cancellable)) {
goto out;
}
- slot = data->slot;
if (x_content_types != NULL && x_content_types[0] != NULL) {
- nautilus_window_slot_show_x_content_bar (slot, data->mount, (const char* const *)
x_content_types);
+ nautilus_window_slot_show_x_content_bar (self, data->mount, (const char* const *)
x_content_types);
}
- slot->details->find_mount_cancellable = NULL;
+ priv->find_mount_cancellable = NULL;
out:
g_object_unref (data->mount);
@@ -1911,13 +2019,17 @@ found_content_type_cb (const char **x_content_types,
}
static void
-found_mount_cb (GObject *source_object,
- GAsyncResult *res,
- gpointer user_data)
+found_mount_cb (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
{
FindMountData *data = user_data;
+ NautilusWindowSlot *self;
GMount *mount;
+ NautilusWindowSlotPrivate *priv;
+ self = NAUTILUS_WINDOW_SLOT (data->slot);
+ priv = nautilus_window_slot_get_instance_private (self);
if (g_cancellable_is_cancelled (data->cancellable)) {
goto out;
}
@@ -1934,7 +2046,7 @@ found_mount_cb (GObject *source_object,
return;
}
- data->slot->details->find_mount_cancellable = NULL;
+ priv->find_mount_cancellable = NULL;
out:
g_object_unref (data->cancellable);
@@ -1942,32 +2054,32 @@ found_mount_cb (GObject *source_object,
}
static void
-nautilus_window_slot_show_trash_bar (NautilusWindowSlot *slot)
+nautilus_window_slot_show_trash_bar (NautilusWindowSlot *self)
{
GtkWidget *bar;
NautilusView *view;
- view = nautilus_window_slot_get_current_view (slot);
+ view = nautilus_window_slot_get_current_view (self);
bar = nautilus_trash_bar_new (NAUTILUS_FILES_VIEW (view));
gtk_widget_show (bar);
- nautilus_window_slot_add_extra_location_widget (slot, bar);
+ nautilus_window_slot_add_extra_location_widget (self, bar);
}
static void
-nautilus_window_slot_show_special_location_bar (NautilusWindowSlot *slot,
- NautilusSpecialLocation special_location)
+nautilus_window_slot_show_special_location_bar (NautilusWindowSlot *self,
+ NautilusSpecialLocation special_location)
{
GtkWidget *bar;
bar = nautilus_special_location_bar_new (special_location);
gtk_widget_show (bar);
- nautilus_window_slot_add_extra_location_widget (slot, bar);
+ nautilus_window_slot_add_extra_location_widget (self, bar);
}
static void
-slot_add_extension_extra_widgets (NautilusWindowSlot *slot)
+slot_add_extension_extra_widgets (NautilusWindowSlot *self)
{
GList *providers, *l;
GtkWidget *widget;
@@ -1975,16 +2087,16 @@ slot_add_extension_extra_widgets (NautilusWindowSlot *slot)
NautilusWindow *window;
providers = nautilus_module_get_extensions_for_type (NAUTILUS_TYPE_LOCATION_WIDGET_PROVIDER);
- window = nautilus_window_slot_get_window (slot);
+ window = nautilus_window_slot_get_window (self);
- uri = nautilus_window_slot_get_location_uri (slot);
+ uri = nautilus_window_slot_get_location_uri (self);
for (l = providers; l != NULL; l = l->next) {
NautilusLocationWidgetProvider *provider;
provider = NAUTILUS_LOCATION_WIDGET_PROVIDER (l->data);
widget = nautilus_location_widget_provider_get_widget (provider, uri, GTK_WIDGET (window));
if (widget != NULL) {
- nautilus_window_slot_add_extra_location_widget (slot, widget);
+ nautilus_window_slot_add_extra_location_widget (self, widget);
}
}
g_free (uri);
@@ -1993,74 +2105,82 @@ slot_add_extension_extra_widgets (NautilusWindowSlot *slot)
}
static void
-nautilus_window_slot_update_for_new_location (NautilusWindowSlot *slot)
+nautilus_window_slot_update_for_new_location (NautilusWindowSlot *self)
{
GFile *new_location;
NautilusFile *file;
+ NautilusWindowSlotPrivate *priv;
- new_location = slot->details->pending_location;
- slot->details->pending_location = NULL;
+ priv = nautilus_window_slot_get_instance_private (self);
+ new_location = priv->pending_location;
+ priv->pending_location = NULL;
file = nautilus_file_get (new_location);
- nautilus_window_slot_update_bookmark (slot, file);
+ nautilus_window_slot_update_bookmark (self, file);
- update_history (slot, slot->details->location_change_type, new_location);
+ update_history (self, priv->location_change_type, new_location);
/* Create a NautilusFile for this location, so we can catch it
* if it goes away.
*/
- nautilus_window_slot_set_viewed_file (slot, file);
- slot->details->viewed_file_seen = !nautilus_file_is_not_yet_confirmed (file);
- slot->details->viewed_file_in_trash = nautilus_file_is_in_trash (file);
+ nautilus_window_slot_set_viewed_file (self, file);
+ priv->viewed_file_seen = !nautilus_file_is_not_yet_confirmed (file);
+ priv->viewed_file_in_trash = nautilus_file_is_in_trash (file);
nautilus_file_unref (file);
- nautilus_window_slot_set_location (slot, new_location);
+ nautilus_window_slot_set_location (self, new_location);
/* Sync the actions for this new location. */
- nautilus_window_slot_sync_actions (slot);
+ nautilus_window_slot_sync_actions (self);
}
static void
-view_started_loading (NautilusWindowSlot *slot,
+view_started_loading (NautilusWindowSlot *self,
NautilusView *view)
{
- if (view == slot->details->content_view) {
- nautilus_window_slot_set_allow_stop (slot, TRUE);
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (view == priv->content_view) {
+ nautilus_window_slot_set_allow_stop (self, TRUE);
}
- gtk_widget_grab_focus (GTK_WIDGET (slot->details->window));
+ gtk_widget_grab_focus (GTK_WIDGET (priv->window));
- gtk_widget_show (GTK_WIDGET (slot->details->window));
+ gtk_widget_show (GTK_WIDGET (priv->window));
- nautilus_window_slot_set_loading (slot, TRUE);
+ nautilus_window_slot_set_loading (self, TRUE);
}
static void
-view_ended_loading (NautilusWindowSlot *slot,
+view_ended_loading (NautilusWindowSlot *self,
NautilusView *view)
{
- if (view == slot->details->content_view) {
- if (NAUTILUS_IS_FILES_VIEW (view) && slot->details->pending_scroll_to != NULL) {
- nautilus_files_view_scroll_to_file (NAUTILUS_FILES_VIEW
(slot->details->content_view), slot->details->pending_scroll_to);
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (view == priv->content_view) {
+ if (NAUTILUS_IS_FILES_VIEW (view) && priv->pending_scroll_to != NULL) {
+ nautilus_files_view_scroll_to_file (NAUTILUS_FILES_VIEW (priv->content_view),
priv->pending_scroll_to);
}
- end_location_change (slot);
+ end_location_change (self);
}
- if (slot->details->needs_reload) {
- nautilus_window_slot_queue_reload (slot);
- slot->details->needs_reload = FALSE;
+ if (priv->needs_reload) {
+ nautilus_window_slot_queue_reload (self);
+ priv->needs_reload = FALSE;
}
- nautilus_window_slot_set_allow_stop (slot, FALSE);
+ nautilus_window_slot_set_allow_stop (self, FALSE);
- nautilus_window_slot_set_loading (slot, FALSE);
+ nautilus_window_slot_set_loading (self, FALSE);
}
static void
view_is_loading_changed_cb (GObject *object,
GParamSpec *pspec,
- NautilusWindowSlot *slot)
+ NautilusWindowSlot *self)
{
NautilusView *view;
@@ -2069,22 +2189,24 @@ view_is_loading_changed_cb (GObject *object,
nautilus_profile_start (NULL);
if (nautilus_view_is_loading (view)) {
- view_started_loading (slot, view);
+ view_started_loading (self, view);
} else {
- view_ended_loading (slot, view);
+ view_ended_loading (self, view);
}
nautilus_profile_end (NULL);
}
static void
-nautilus_window_slot_setup_extra_location_widgets (NautilusWindowSlot *slot)
+nautilus_window_slot_setup_extra_location_widgets (NautilusWindowSlot *self)
{
GFile *location;
FindMountData *data;
NautilusDirectory *directory;
+ NautilusWindowSlotPrivate *priv;
- location = nautilus_window_slot_get_current_location (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ location = nautilus_window_slot_get_current_location (self);
if (location == NULL) {
return;
@@ -2093,7 +2215,7 @@ nautilus_window_slot_setup_extra_location_widgets (NautilusWindowSlot *slot)
directory = nautilus_directory_get (location);
if (nautilus_directory_is_in_trash (directory)) {
- nautilus_window_slot_show_trash_bar (slot);
+ nautilus_window_slot_show_trash_bar (self);
} else {
NautilusFile *file;
GFile *scripts_file;
@@ -2106,9 +2228,9 @@ nautilus_window_slot_setup_extra_location_widgets (NautilusWindowSlot *slot)
if (nautilus_should_use_templates_directory () &&
nautilus_file_is_user_special_directory (file, G_USER_DIRECTORY_TEMPLATES)) {
- nautilus_window_slot_show_special_location_bar (slot,
NAUTILUS_SPECIAL_LOCATION_TEMPLATES);
+ nautilus_window_slot_show_special_location_bar (self,
NAUTILUS_SPECIAL_LOCATION_TEMPLATES);
} else if (g_file_equal (location, scripts_file)) {
- nautilus_window_slot_show_special_location_bar (slot,
NAUTILUS_SPECIAL_LOCATION_SCRIPTS);
+ nautilus_window_slot_show_special_location_bar (self,
NAUTILUS_SPECIAL_LOCATION_SCRIPTS);
}
g_object_unref (scripts_file);
@@ -2116,17 +2238,17 @@ nautilus_window_slot_setup_extra_location_widgets (NautilusWindowSlot *slot)
}
/* need the mount to determine if we should put up the x-content cluebar */
- if (slot->details->find_mount_cancellable != NULL) {
- g_cancellable_cancel (slot->details->find_mount_cancellable);
- slot->details->find_mount_cancellable = NULL;
+ if (priv->find_mount_cancellable != NULL) {
+ g_cancellable_cancel (priv->find_mount_cancellable);
+ priv->find_mount_cancellable = NULL;
}
data = g_new (FindMountData, 1);
- data->slot = slot;
+ data->slot = self;
data->cancellable = g_cancellable_new ();
data->mount = NULL;
- slot->details->find_mount_cancellable = data->cancellable;
+ priv->find_mount_cancellable = data->cancellable;
g_file_find_enclosing_mount_async (location,
G_PRIORITY_DEFAULT,
data->cancellable,
@@ -2135,142 +2257,155 @@ nautilus_window_slot_setup_extra_location_widgets (NautilusWindowSlot *slot)
nautilus_directory_unref (directory);
- slot_add_extension_extra_widgets (slot);
+ slot_add_extension_extra_widgets (self);
}
static void
-nautilus_window_slot_connect_new_content_view (NautilusWindowSlot *slot)
+nautilus_window_slot_connect_new_content_view (NautilusWindowSlot *self)
{
- if (slot->details->new_content_view) {
- g_signal_connect (slot->details->new_content_view,
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->new_content_view) {
+ g_signal_connect (priv->new_content_view,
"notify::is-loading",
G_CALLBACK (view_is_loading_changed_cb),
- slot);
+ self);
}
}
static void
-nautilus_window_slot_disconnect_content_view (NautilusWindowSlot *slot)
+nautilus_window_slot_disconnect_content_view (NautilusWindowSlot *self)
{
- if (slot->details->new_content_view && NAUTILUS_IS_FILES_VIEW (slot->details->new_content_view)) {
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->new_content_view && NAUTILUS_IS_FILES_VIEW (priv->new_content_view)) {
/* disconnect old view */
- g_signal_handlers_disconnect_by_func (slot->details->content_view,
+ g_signal_handlers_disconnect_by_func (priv->content_view,
G_CALLBACK (view_is_loading_changed_cb),
- slot);
+ self);
}
}
static void
-nautilus_window_slot_switch_new_content_view (NautilusWindowSlot *slot)
+nautilus_window_slot_switch_new_content_view (NautilusWindowSlot *self)
{
GtkWidget *widget;
gboolean reusing_view;
+ NautilusWindowSlotPrivate *priv;
- reusing_view = slot->details->new_content_view &&
- gtk_widget_get_parent (GTK_WIDGET (slot->details->new_content_view)) != NULL;
+ priv = nautilus_window_slot_get_instance_private (self);
+ reusing_view = priv->new_content_view &&
+ gtk_widget_get_parent (GTK_WIDGET (priv->new_content_view)) != NULL;
/* We are either reusing the view, so new_content_view and content_view
* are the same, or the new_content_view is invalid */
- if (slot->details->new_content_view == NULL || reusing_view)
+ if (priv->new_content_view == NULL || reusing_view)
goto done;
- if (slot->details->content_view != NULL) {
- widget = GTK_WIDGET (slot->details->content_view);
+ if (priv->content_view != NULL) {
+ widget = GTK_WIDGET (priv->content_view);
gtk_widget_destroy (widget);
- g_object_unref (slot->details->content_view);
- slot->details->content_view = NULL;
+ g_object_unref (priv->content_view);
+ priv->content_view = NULL;
}
- if (slot->details->new_content_view != NULL) {
- slot->details->content_view = slot->details->new_content_view;
- slot->details->new_content_view = NULL;
+ if (priv->new_content_view != NULL) {
+ priv->content_view = priv->new_content_view;
+ priv->new_content_view = NULL;
- widget = GTK_WIDGET (slot->details->content_view);
- gtk_container_add (GTK_CONTAINER (slot), widget);
+ widget = GTK_WIDGET (priv->content_view);
+ gtk_container_add (GTK_CONTAINER (self), widget);
gtk_widget_set_vexpand (widget, TRUE);
gtk_widget_show (widget);
- g_object_notify_by_pspec (G_OBJECT (slot), properties[PROP_ICON]);
- g_object_notify_by_pspec (G_OBJECT (slot), properties[PROP_VIEW_WIDGET]);
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ICON]);
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_VIEW_WIDGET]);
}
done:
/* Clean up, so we don't confuse having a new_content_view available or
* just that we didn't care about it here */
- slot->details->new_content_view = NULL;
+ priv->new_content_view = NULL;
}
/* This is called when we have decided we can actually change to the new view/location situation. */
static void
-change_view (NautilusWindowSlot *slot)
+change_view (NautilusWindowSlot *self)
{
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
/* Switch to the new content view.
* Destroy the extra location widgets first, since they might hold
* a pointer to the old view, which will possibly be destroyed inside
* nautilus_window_slot_switch_new_content_view().
*/
- nautilus_window_slot_remove_extra_location_widgets (slot);
- nautilus_window_slot_switch_new_content_view (slot);
+ nautilus_window_slot_remove_extra_location_widgets (self);
+ nautilus_window_slot_switch_new_content_view (self);
- if (slot->details->pending_location != NULL) {
+ if (priv->pending_location != NULL) {
/* Tell the window we are finished. */
- nautilus_window_slot_update_for_new_location (slot);
+ nautilus_window_slot_update_for_new_location (self);
}
/* Now that we finished switching to the new location,
* add back the extra location widgets.
*/
- nautilus_window_slot_setup_extra_location_widgets (slot);
+ nautilus_window_slot_setup_extra_location_widgets (self);
}
static void
nautilus_window_slot_dispose (GObject *object)
{
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
GtkWidget *widget;
+ NautilusWindowSlotPrivate *priv;
- slot = NAUTILUS_WINDOW_SLOT (object);
+ self = NAUTILUS_WINDOW_SLOT (object);
+ priv = nautilus_window_slot_get_instance_private (self);
- nautilus_window_slot_clear_forward_list (slot);
- nautilus_window_slot_clear_back_list (slot);
+ nautilus_window_slot_clear_forward_list (self);
+ nautilus_window_slot_clear_back_list (self);
- nautilus_window_slot_remove_extra_location_widgets (slot);
+ nautilus_window_slot_remove_extra_location_widgets (self);
- if (slot->details->content_view) {
- widget = GTK_WIDGET (slot->details->content_view);
+ if (priv->content_view) {
+ widget = GTK_WIDGET (priv->content_view);
gtk_widget_destroy (widget);
- g_object_unref (slot->details->content_view);
- slot->details->content_view = NULL;
+ g_object_unref (priv->content_view);
+ priv->content_view = NULL;
}
- if (slot->details->new_content_view) {
- widget = GTK_WIDGET (slot->details->new_content_view);
+ if (priv->new_content_view) {
+ widget = GTK_WIDGET (priv->new_content_view);
gtk_widget_destroy (widget);
- g_object_unref (slot->details->new_content_view);
- slot->details->new_content_view = NULL;
+ g_object_unref (priv->new_content_view);
+ priv->new_content_view = NULL;
}
- nautilus_window_slot_set_viewed_file (slot, NULL);
+ nautilus_window_slot_set_viewed_file (self, NULL);
- g_clear_object (&slot->details->location);
+ g_clear_object (&priv->location);
- nautilus_file_list_free (slot->details->pending_selection);
- slot->details->pending_selection = NULL;
+ nautilus_file_list_free (priv->pending_selection);
+ priv->pending_selection = NULL;
- g_clear_object (&slot->details->current_location_bookmark);
- g_clear_object (&slot->details->last_location_bookmark);
+ g_clear_object (&priv->current_location_bookmark);
+ g_clear_object (&priv->last_location_bookmark);
- if (slot->details->find_mount_cancellable != NULL) {
- g_cancellable_cancel (slot->details->find_mount_cancellable);
- slot->details->find_mount_cancellable = NULL;
+ if (priv->find_mount_cancellable != NULL) {
+ g_cancellable_cancel (priv->find_mount_cancellable);
+ priv->find_mount_cancellable = NULL;
}
- slot->details->window = NULL;
+ priv->window = NULL;
- g_free (slot->details->title);
- slot->details->title = NULL;
+ g_free (priv->title);
+ priv->title = NULL;
- free_location_change (slot);
+ free_location_change (self);
G_OBJECT_CLASS (nautilus_window_slot_parent_class)->dispose (object);
}
@@ -2278,18 +2413,20 @@ nautilus_window_slot_dispose (GObject *object)
static void
nautilus_window_slot_grab_focus (GtkWidget *widget)
{
- NautilusWindowSlot *slot;
+ NautilusWindowSlot *self;
+ NautilusWindowSlotPrivate *priv;
- slot = NAUTILUS_WINDOW_SLOT (widget);
+ self = NAUTILUS_WINDOW_SLOT (widget);
+ priv = nautilus_window_slot_get_instance_private (self);
GTK_WIDGET_CLASS (nautilus_window_slot_parent_class)->grab_focus (widget);
- if (nautilus_window_slot_get_search_visible (slot)) {
- gtk_widget_grab_focus (GTK_WIDGET (slot->details->query_editor));
- } else if (slot->details->content_view) {
- gtk_widget_grab_focus (GTK_WIDGET (slot->details->content_view));
- } else if (slot->details->new_content_view) {
- gtk_widget_grab_focus (GTK_WIDGET (slot->details->new_content_view));
+ if (nautilus_window_slot_get_search_visible (self)) {
+ gtk_widget_grab_focus (GTK_WIDGET (priv->query_editor));
+ } else if (priv->content_view) {
+ gtk_widget_grab_focus (GTK_WIDGET (priv->content_view));
+ } else if (priv->new_content_view) {
+ gtk_widget_grab_focus (GTK_WIDGET (priv->new_content_view));
}
}
@@ -2369,51 +2506,69 @@ nautilus_window_slot_class_init (NautilusWindowSlotClass *klass)
G_PARAM_READWRITE);
g_object_class_install_properties (oclass, NUM_PROPERTIES, properties);
- g_type_class_add_private (klass, sizeof (NautilusWindowSlotDetails));
}
GFile *
-nautilus_window_slot_get_location (NautilusWindowSlot *slot)
+nautilus_window_slot_get_location (NautilusWindowSlot *self)
{
- g_assert (slot != NULL);
+ NautilusWindowSlotPrivate *priv;
- return slot->details->location;
+ g_assert (self != NULL);
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->location;
}
const gchar *
-nautilus_window_slot_get_title (NautilusWindowSlot *slot)
+nautilus_window_slot_get_title (NautilusWindowSlot *self)
{
- return slot->details->title;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->title;
}
char *
-nautilus_window_slot_get_location_uri (NautilusWindowSlot *slot)
+nautilus_window_slot_get_location_uri (NautilusWindowSlot *self)
{
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
- if (slot->details->location) {
- return g_file_get_uri (slot->details->location);
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->location) {
+ return g_file_get_uri (priv->location);
}
return NULL;
}
NautilusWindow *
-nautilus_window_slot_get_window (NautilusWindowSlot *slot)
+nautilus_window_slot_get_window (NautilusWindowSlot *self)
{
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
- return slot->details->window;
+ NautilusWindowSlotPrivate *priv;
+
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->window;
}
void
-nautilus_window_slot_set_window (NautilusWindowSlot *slot,
- NautilusWindow *window)
+nautilus_window_slot_set_window (NautilusWindowSlot *self,
+ NautilusWindow *window)
{
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
+
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
g_assert (NAUTILUS_IS_WINDOW (window));
- if (slot->details->window != window) {
- slot->details->window = window;
- g_object_notify_by_pspec (G_OBJECT (slot), properties[PROP_WINDOW]);
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->window != window) {
+ priv->window = window;
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_WINDOW]);
}
}
@@ -2425,29 +2580,31 @@ nautilus_window_slot_set_window (NautilusWindowSlot *slot,
*
*/
void
-nautilus_window_slot_update_title (NautilusWindowSlot *slot)
+nautilus_window_slot_update_title (NautilusWindowSlot *self)
{
NautilusWindow *window;
char *title;
gboolean do_sync = FALSE;
+ NautilusWindowSlotPrivate *priv;
- title = nautilus_compute_title_for_location (slot->details->location);
- window = nautilus_window_slot_get_window (slot);
+ priv = nautilus_window_slot_get_instance_private (self);
+ title = nautilus_compute_title_for_location (priv->location);
+ window = nautilus_window_slot_get_window (self);
- if (g_strcmp0 (title, slot->details->title) != 0) {
+ if (g_strcmp0 (title, priv->title) != 0) {
do_sync = TRUE;
- g_free (slot->details->title);
- slot->details->title = title;
+ g_free (priv->title);
+ priv->title = title;
title = NULL;
}
- if (strlen (slot->details->title) > 0) {
+ if (strlen (priv->title) > 0) {
do_sync = TRUE;
}
if (do_sync) {
- nautilus_window_sync_title (window, slot);
+ nautilus_window_sync_title (window, self);
}
if (title != NULL) {
@@ -2456,53 +2613,61 @@ nautilus_window_slot_update_title (NautilusWindowSlot *slot)
}
gboolean
-nautilus_window_slot_get_allow_stop (NautilusWindowSlot *slot)
+nautilus_window_slot_get_allow_stop (NautilusWindowSlot *self)
{
- return slot->details->allow_stop;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->allow_stop;
}
void
-nautilus_window_slot_set_allow_stop (NautilusWindowSlot *slot,
- gboolean allow)
+nautilus_window_slot_set_allow_stop (NautilusWindowSlot *self,
+ gboolean allow)
{
NautilusWindow *window;
+ NautilusWindowSlotPrivate *priv;
- g_assert (NAUTILUS_IS_WINDOW_SLOT (slot));
+ g_assert (NAUTILUS_IS_WINDOW_SLOT (self));
- slot->details->allow_stop = allow;
+ priv = nautilus_window_slot_get_instance_private (self);
- window = nautilus_window_slot_get_window (slot);
- nautilus_window_sync_allow_stop (window, slot);
+ priv->allow_stop = allow;
+
+ window = nautilus_window_slot_get_window (self);
+ nautilus_window_sync_allow_stop (window, self);
}
void
-nautilus_window_slot_stop_loading (NautilusWindowSlot *slot)
+nautilus_window_slot_stop_loading (NautilusWindowSlot *self)
{
GList *selection;
GFile *location;
NautilusDirectory *directory;
+ NautilusWindowSlotPrivate *priv;
- location = nautilus_window_slot_get_location (slot);
-
- directory = nautilus_directory_get (slot->details->location);
+ priv = nautilus_window_slot_get_instance_private (self);
+ location = nautilus_window_slot_get_location (self);
+ directory = nautilus_directory_get (priv->location);
- if (NAUTILUS_IS_FILES_VIEW (slot->details->content_view)) {
- nautilus_files_view_stop_loading (NAUTILUS_FILES_VIEW (slot->details->content_view));
+ if (NAUTILUS_IS_FILES_VIEW (priv->content_view)) {
+ nautilus_files_view_stop_loading (NAUTILUS_FILES_VIEW (priv->content_view));
}
nautilus_directory_unref (directory);
- if (slot->details->pending_location != NULL &&
+ if (priv->pending_location != NULL &&
location != NULL &&
- slot->details->content_view != NULL &&
- NAUTILUS_IS_FILES_VIEW (slot->details->content_view)) {
+ priv->content_view != NULL &&
+ NAUTILUS_IS_FILES_VIEW (priv->content_view)) {
/* 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 = nautilus_view_get_selection (slot->details->content_view);
- load_new_location (slot,
+ selection = nautilus_view_get_selection (priv->content_view);
+ load_new_location (self,
location,
selection,
TRUE,
@@ -2510,42 +2675,57 @@ nautilus_window_slot_stop_loading (NautilusWindowSlot *slot)
nautilus_file_list_free (selection);
}
- end_location_change (slot);
+ end_location_change (self);
- if (slot->details->new_content_view) {
- g_object_unref (slot->details->new_content_view);
- slot->details->new_content_view = NULL;
+ if (priv->new_content_view) {
+ g_object_unref (priv->new_content_view);
+ priv->new_content_view = NULL;
}
}
NautilusView*
-nautilus_window_slot_get_current_view (NautilusWindowSlot *slot)
+nautilus_window_slot_get_current_view (NautilusWindowSlot *self)
{
- if (slot->details->content_view != NULL) {
- return slot->details->content_view;
- } else if (slot->details->new_content_view) {
- return slot->details->new_content_view;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->content_view != NULL) {
+ return priv->content_view;
+ } else if (priv->new_content_view) {
+ return priv->new_content_view;
}
return NULL;
}
NautilusBookmark *
-nautilus_window_slot_get_bookmark (NautilusWindowSlot *slot)
+nautilus_window_slot_get_bookmark (NautilusWindowSlot *self)
{
- return slot->details->current_location_bookmark;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->current_location_bookmark;
}
GList *
-nautilus_window_slot_get_back_history (NautilusWindowSlot *slot)
+nautilus_window_slot_get_back_history (NautilusWindowSlot *self)
{
- return slot->details->back_list;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->back_list;
}
GList *
-nautilus_window_slot_get_forward_history (NautilusWindowSlot *slot)
+nautilus_window_slot_get_forward_history (NautilusWindowSlot *self)
{
- return slot->details->forward_list;
+ NautilusWindowSlotPrivate *priv;
+
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->forward_list;
}
NautilusWindowSlot *
@@ -2557,71 +2737,85 @@ nautilus_window_slot_new (NautilusWindow *window)
}
GIcon*
-nautilus_window_slot_get_icon (NautilusWindowSlot *slot)
+nautilus_window_slot_get_icon (NautilusWindowSlot *self)
{
NautilusView *view;
- g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot), NULL);
+ g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (self), NULL);
- view = nautilus_window_slot_get_current_view (slot);
+ view = nautilus_window_slot_get_current_view (self);
return view ? nautilus_view_get_icon (view) : NULL;
}
GtkWidget*
-nautilus_window_slot_get_view_widget (NautilusWindowSlot *slot)
+nautilus_window_slot_get_view_widget (NautilusWindowSlot *self)
{
NautilusView *view;
- g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot), NULL);
+ g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (self), NULL);
- view = nautilus_window_slot_get_current_view (slot);
+ view = nautilus_window_slot_get_current_view (self);
return view ? nautilus_view_get_view_widget (view) : NULL;
}
gboolean
-nautilus_window_slot_get_active (NautilusWindowSlot *slot)
+nautilus_window_slot_get_active (NautilusWindowSlot *self)
{
- g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot), FALSE);
+ NautilusWindowSlotPrivate *priv;
+
+ g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (self), FALSE);
- return slot->details->active;
+ priv = nautilus_window_slot_get_instance_private (self);
+
+ return priv->active;
}
void
-nautilus_window_slot_set_active (NautilusWindowSlot *slot,
+nautilus_window_slot_set_active (NautilusWindowSlot *self,
gboolean active)
{
- g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
+
+ g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (self));
- if (slot->details->active != active) {
- slot->details->active = active;
+ priv = nautilus_window_slot_get_instance_private (self);
+ if (priv->active != active) {
+ priv->active = active;
if (active) {
- g_signal_emit (slot, signals[ACTIVE], 0);
+ g_signal_emit (self, signals[ACTIVE], 0);
} else {
- g_signal_emit (slot, signals[INACTIVE], 0);
+ g_signal_emit (self, signals[INACTIVE], 0);
}
- g_object_notify_by_pspec (G_OBJECT (slot), properties[PROP_ACTIVE]);
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ACTIVE]);
}
}
static void
-nautilus_window_slot_set_loading (NautilusWindowSlot *slot,
+nautilus_window_slot_set_loading (NautilusWindowSlot *self,
gboolean loading)
{
- g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot));
+ NautilusWindowSlotPrivate *priv;
- slot->details->loading = loading;
+ g_return_if_fail (NAUTILUS_IS_WINDOW_SLOT (self));
- g_object_notify_by_pspec (G_OBJECT (slot), properties[PROP_LOADING]);
+ priv = nautilus_window_slot_get_instance_private (self);
+ priv->loading = loading;
+
+ g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_LOADING]);
}
gboolean
-nautilus_window_slot_get_loading (NautilusWindowSlot *slot)
+nautilus_window_slot_get_loading (NautilusWindowSlot *self)
{
- g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (slot), FALSE);
+ NautilusWindowSlotPrivate *priv;
+
+ g_return_val_if_fail (NAUTILUS_IS_WINDOW_SLOT (self), FALSE);
+
+ priv = nautilus_window_slot_get_instance_private (self);
- return slot->details->loading;
+ return priv->loading;
}
diff --git a/src/nautilus-window-slot.h b/src/nautilus-window-slot.h
index 4c7f564..09fafbf 100644
--- a/src/nautilus-window-slot.h
+++ b/src/nautilus-window-slot.h
@@ -23,22 +23,9 @@
#ifndef NAUTILUS_WINDOW_SLOT_H
#define NAUTILUS_WINDOW_SLOT_H
-#include "nautilus-query-editor.h"
-
-typedef struct NautilusWindowSlot NautilusWindowSlot;
-typedef struct NautilusWindowSlotClass NautilusWindowSlotClass;
-typedef struct NautilusWindowSlotDetails NautilusWindowSlotDetails;
-
-#include "nautilus-files-view.h"
-#include "nautilus-view.h"
-#include "nautilus-window.h"
-
-#define NAUTILUS_TYPE_WINDOW_SLOT (nautilus_window_slot_get_type())
-#define NAUTILUS_WINDOW_SLOT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), NAUTILUS_TYPE_WINDOW_SLOT,
NautilusWindowSlotClass))
-#define NAUTILUS_WINDOW_SLOT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NAUTILUS_TYPE_WINDOW_SLOT,
NautilusWindowSlot))
-#define NAUTILUS_IS_WINDOW_SLOT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NAUTILUS_TYPE_WINDOW_SLOT))
-#define NAUTILUS_IS_WINDOW_SLOT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NAUTILUS_TYPE_WINDOW_SLOT))
-#define NAUTILUS_WINDOW_SLOT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NAUTILUS_TYPE_WINDOW_SLOT,
NautilusWindowSlotClass))
+#include <gdk/gdk.h>
+#include <gio/gio.h>
+#include <gtk/gtk.h>
typedef enum {
NAUTILUS_LOCATION_CHANGE_STANDARD,
@@ -47,7 +34,16 @@ typedef enum {
NAUTILUS_LOCATION_CHANGE_RELOAD
} NautilusLocationChangeType;
-struct NautilusWindowSlotClass {
+#define NAUTILUS_TYPE_WINDOW_SLOT (nautilus_window_slot_get_type ())
+G_DECLARE_DERIVABLE_TYPE (NautilusWindowSlot, nautilus_window_slot, NAUTILUS, WINDOW_SLOT, GtkBox)
+
+#include "nautilus-query-editor.h"
+#include "nautilus-files-view.h"
+#include "nautilus-view.h"
+#include "nautilus-window.h"
+
+
+struct _NautilusWindowSlotClass {
GtkBoxClass parent_class;
/* wrapped NautilusWindowInfo signals, for overloading */
@@ -55,17 +51,6 @@ struct NautilusWindowSlotClass {
void (* inactive) (NautilusWindowSlot *slot);
};
-/* Each NautilusWindowSlot corresponds to a location in the window
- * for displaying a NautilusFilesView, i.e. a tab.
- */
-struct NautilusWindowSlot {
- GtkBox parent;
-
- NautilusWindowSlotDetails *details;
-};
-
-GType nautilus_window_slot_get_type (void);
-
NautilusWindowSlot * nautilus_window_slot_new (NautilusWindow *window);
NautilusWindow * nautilus_window_slot_get_window (NautilusWindowSlot *slot);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
