general: run uncrustify

And make the style of Nautilus the same for all files.
Hopefully we can fix all the style issues we can find in the next days,
so expect a little of movement on this.

https://bugzilla.gnome.org/show_bug.cgi?id=770564

1 files changed, 1350 insertions, 1228 deletions

diff --git a/src/nautilus-canvas-view.c b/src/nautilus-canvas-view.c
index 2867358a4..28233d58f 100644
--- a/src/nautilus-canvas-view.c
+++ b/src/nautilus-canvas-view.c
@@ -1,24 +1,23 @@
-
 /* fm-canvas-view.c - implementation of canvas view of directory.
-
-   Copyright (C) 2000, 2001 Eazel, Inc.
-
-   The Gnome Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The Gnome Library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the Gnome Library; see the file COPYING.LIB.  If not,
-   see <http://www.gnu.org/licenses/>.
-
-   Authors: John Sullivan <sullivan@eazel.com>
-*/
+ *
+ *  Copyright (C) 2000, 2001 Eazel, Inc.
+ *
+ *  The Gnome Library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public License as
+ *  published by the Free Software Foundation; either version 2 of the
+ *  License, or (at your option) any later version.
+ *
+ *  The Gnome Library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public
+ *  License along with the Gnome Library; see the file COPYING.LIB.  If not,
+ *  see <http://www.gnu.org/licenses/>.
+ *
+ *  Authors: John Sullivan <sullivan@eazel.com>
+ */
 
 #include <config.h>
 
@@ -57,232 +56,243 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-enum 
+enum
 {
-	PROP_SUPPORTS_AUTO_LAYOUT = 1,
-	PROP_SUPPORTS_SCALING,
-	PROP_SUPPORTS_KEEP_ALIGNED,
-	PROP_SUPPORTS_MANUAL_LAYOUT,
-	NUM_PROPERTIES
+    PROP_SUPPORTS_AUTO_LAYOUT = 1,
+    PROP_SUPPORTS_SCALING,
+    PROP_SUPPORTS_KEEP_ALIGNED,
+    PROP_SUPPORTS_MANUAL_LAYOUT,
+    NUM_PROPERTIES
 };
 
 static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };
 
-typedef gboolean (* SortCriterionMatchFunc) (NautilusFile *file);
+typedef gboolean (*SortCriterionMatchFunc) (NautilusFile *file);
 
-typedef struct {
-	const NautilusFileSortType sort_type;
-	const char *metadata_text;
-	const char *action_target_name;
-        const gboolean reverse_order;
-	SortCriterionMatchFunc match_func;
+typedef struct
+{
+    const NautilusFileSortType sort_type;
+    const char *metadata_text;
+    const char *action_target_name;
+    const gboolean reverse_order;
+    SortCriterionMatchFunc match_func;
 } SortCriterion;
 
-typedef enum {
-	MENU_ITEM_TYPE_STANDARD,
-	MENU_ITEM_TYPE_CHECK,
-	MENU_ITEM_TYPE_RADIO,
-	MENU_ITEM_TYPE_TREE
+typedef enum
+{
+    MENU_ITEM_TYPE_STANDARD,
+    MENU_ITEM_TYPE_CHECK,
+    MENU_ITEM_TYPE_RADIO,
+    MENU_ITEM_TYPE_TREE
 } MenuItemType;
 
 struct NautilusCanvasViewDetails
 {
-	GList *icons_not_positioned;
+    GList *icons_not_positioned;
 
-	guint react_to_canvas_change_idle_id;
+    guint react_to_canvas_change_idle_id;
 
-	const SortCriterion *sort;
+    const SortCriterion *sort;
 
-	gulong clipboard_handler_id;
+    gulong clipboard_handler_id;
 
-	GtkWidget *canvas_container;
+    GtkWidget *canvas_container;
 
-	gboolean supports_auto_layout;
-	gboolean supports_manual_layout;
-	gboolean supports_scaling;
-	gboolean supports_keep_aligned;
+    gboolean supports_auto_layout;
+    gboolean supports_manual_layout;
+    gboolean supports_scaling;
+    gboolean supports_keep_aligned;
 
-        GIcon *icon;
+    GIcon *icon;
 };
 
 /* Note that the first item in this list is the default sort,
  * and that the items show up in the menu in the order they
  * appear in this list.
  */
-static const SortCriterion sort_criteria[] = {
-	{
-		NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
-		"name",
-		"name",
-                FALSE
-	},
-        {
-                NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
-                "name",
-                "name-desc",
-                TRUE
-        },
-	{
-		NAUTILUS_FILE_SORT_BY_SIZE,
-		"size",
-		"size",
-                TRUE
-	},
-	{
-		NAUTILUS_FILE_SORT_BY_TYPE,
-		"type",
-		"type",
-                FALSE
-	},
-	{
-		NAUTILUS_FILE_SORT_BY_MTIME,
-		"modification date",
-		"modification-date",
-                FALSE
-	},
-        {
-                NAUTILUS_FILE_SORT_BY_MTIME,
-                "modification date",
-                "modification-date-desc",
-                TRUE
-        },
-	{
-		NAUTILUS_FILE_SORT_BY_ATIME,
-		"access date",
-		"access-date",
-                FALSE
-	},
-        {
-                NAUTILUS_FILE_SORT_BY_ATIME,
-                "access date",
-                "access-date-desc",
-                TRUE
-        },
-	{
-		NAUTILUS_FILE_SORT_BY_TRASHED_TIME,
-		"trashed",
-		"trash-time",
-                TRUE,
-		nautilus_file_is_in_trash
-	},
-	{
-		NAUTILUS_FILE_SORT_BY_SEARCH_RELEVANCE,
-		NULL,
-		"search-relevance",
-                TRUE,
-		nautilus_file_is_in_search
-	}
+static const SortCriterion sort_criteria[] =
+{
+    {
+     NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
+     "name",
+     "name",
+     FALSE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
+     "name",
+     "name-desc",
+     TRUE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_SIZE,
+     "size",
+     "size",
+     TRUE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_TYPE,
+     "type",
+     "type",
+     FALSE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_MTIME,
+     "modification date",
+     "modification-date",
+     FALSE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_MTIME,
+     "modification date",
+     "modification-date-desc",
+     TRUE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_ATIME,
+     "access date",
+     "access-date",
+     FALSE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_ATIME,
+     "access date",
+     "access-date-desc",
+     TRUE
+},
+    {
+     NAUTILUS_FILE_SORT_BY_TRASHED_TIME,
+     "trashed",
+     "trash-time",
+     TRUE,
+     nautilus_file_is_in_trash
+},
+    {
+     NAUTILUS_FILE_SORT_BY_SEARCH_RELEVANCE,
+     NULL,
+     "search-relevance",
+     TRUE,
+     nautilus_file_is_in_search
+}
 };
 
-static void                 nautilus_canvas_view_set_directory_sort_by        (NautilusCanvasView           *canvas_view,
-									     NautilusFile         *file,
-                                                                               const SortCriterion *sort);
-static void                 nautilus_canvas_view_update_click_mode            (NautilusCanvasView           *canvas_view);
-static gboolean             nautilus_canvas_view_supports_scaling	      (NautilusCanvasView           *canvas_view);
-static void                 nautilus_canvas_view_reveal_selection       (NautilusFilesView               *view);
-static const SortCriterion *get_sort_criterion_by_metadata_text       (const char *metadata_text,
-                                                                       gboolean    reversed);
-static const SortCriterion *get_sort_criterion_by_sort_type           (NautilusFileSortType  sort_type,
-                                                                       gboolean              reversed);
-static void                 switch_to_manual_layout                   (NautilusCanvasView     *view);
-static const SortCriterion *get_default_sort_order                    (NautilusFile         *file);
-static void                 nautilus_canvas_view_clear                  (NautilusFilesView         *view);
+static void                 nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView  *canvas_view,
+                                                                        NautilusFile        *file,
+                                                                        const SortCriterion *sort);
+static void                 nautilus_canvas_view_update_click_mode (NautilusCanvasView *canvas_view);
+static gboolean             nautilus_canvas_view_supports_scaling (NautilusCanvasView *canvas_view);
+static void                 nautilus_canvas_view_reveal_selection (NautilusFilesView *view);
+static const SortCriterion *get_sort_criterion_by_metadata_text (const char *metadata_text,
+                                                                 gboolean    reversed);
+static const SortCriterion *get_sort_criterion_by_sort_type (NautilusFileSortType sort_type,
+                                                             gboolean             reversed);
+static void                 switch_to_manual_layout (NautilusCanvasView *view);
+static const SortCriterion *get_default_sort_order (NautilusFile *file);
+static void                 nautilus_canvas_view_clear (NautilusFilesView *view);
 
 G_DEFINE_TYPE (NautilusCanvasView, nautilus_canvas_view, NAUTILUS_TYPE_FILES_VIEW);
 
 static void
 nautilus_canvas_view_destroy (GtkWidget *object)
 {
-	NautilusCanvasView *canvas_view;
+    NautilusCanvasView *canvas_view;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (object);
+    canvas_view = NAUTILUS_CANVAS_VIEW (object);
 
-	nautilus_canvas_view_clear (NAUTILUS_FILES_VIEW (object));
+    nautilus_canvas_view_clear (NAUTILUS_FILES_VIEW (object));
 
-        if (canvas_view->details->react_to_canvas_change_idle_id != 0) {
-                g_source_remove (canvas_view->details->react_to_canvas_change_idle_id);
-		canvas_view->details->react_to_canvas_change_idle_id = 0;
-        }
+    if (canvas_view->details->react_to_canvas_change_idle_id != 0)
+    {
+        g_source_remove (canvas_view->details->react_to_canvas_change_idle_id);
+        canvas_view->details->react_to_canvas_change_idle_id = 0;
+    }
 
-	if (canvas_view->details->clipboard_handler_id != 0) {
-		g_signal_handler_disconnect (nautilus_clipboard_monitor_get (),
-					     canvas_view->details->clipboard_handler_id);
-		canvas_view->details->clipboard_handler_id = 0;
-	}
+    if (canvas_view->details->clipboard_handler_id != 0)
+    {
+        g_signal_handler_disconnect (nautilus_clipboard_monitor_get (),
+                                     canvas_view->details->clipboard_handler_id);
+        canvas_view->details->clipboard_handler_id = 0;
+    }
 
-	if (canvas_view->details->icons_not_positioned) {
-		nautilus_file_list_free (canvas_view->details->icons_not_positioned);
-		canvas_view->details->icons_not_positioned = NULL;
-	}
+    if (canvas_view->details->icons_not_positioned)
+    {
+        nautilus_file_list_free (canvas_view->details->icons_not_positioned);
+        canvas_view->details->icons_not_positioned = NULL;
+    }
 
-	GTK_WIDGET_CLASS (nautilus_canvas_view_parent_class)->destroy (object);
+    GTK_WIDGET_CLASS (nautilus_canvas_view_parent_class)->destroy (object);
 }
 
 static NautilusCanvasContainer *
 get_canvas_container (NautilusCanvasView *canvas_view)
 {
-	return NAUTILUS_CANVAS_CONTAINER (canvas_view->details->canvas_container);
+    return NAUTILUS_CANVAS_CONTAINER (canvas_view->details->canvas_container);
 }
 
 NautilusCanvasContainer *
 nautilus_canvas_view_get_canvas_container (NautilusCanvasView *canvas_view)
 {
-	return get_canvas_container (canvas_view);
+    return get_canvas_container (canvas_view);
 }
 
 static gboolean
 nautilus_canvas_view_supports_manual_layout (NautilusCanvasView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return view->details->supports_manual_layout;
+    return view->details->supports_manual_layout;
 }
 
 static gboolean
 get_stored_icon_position_callback (NautilusCanvasContainer *container,
-				   NautilusFile *file,
-				   NautilusCanvasPosition *position,
-				   NautilusCanvasView *canvas_view)
-{
-	char *position_string, *scale_string;
-	gboolean position_good;
-	char c;
-
-	g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
-	g_assert (NAUTILUS_IS_FILE (file));
-	g_assert (position != NULL);
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-
-	if (!nautilus_canvas_view_supports_manual_layout (canvas_view)) {
-		return FALSE;
-	}
-
-	/* Get the current position of this canvas from the metadata. */
-	position_string = nautilus_file_get_metadata
-		(file, NAUTILUS_METADATA_KEY_ICON_POSITION, "");
-	position_good = sscanf
-		(position_string, " %d , %d %c",
-		 &position->x, &position->y, &c) == 2;
-	g_free (position_string);
-
-	/* If it is the desktop directory, maybe the gnome-libs metadata has information about it */
-
-	/* Disable scaling if not on the desktop */
-	if (nautilus_canvas_view_supports_scaling (canvas_view)) {
-		/* Get the scale of the canvas from the metadata. */
-		scale_string = nautilus_file_get_metadata
-			(file, NAUTILUS_METADATA_KEY_ICON_SCALE, "1");
-		position->scale = g_ascii_strtod (scale_string, NULL);
-		if (errno != 0) {
-			position->scale = 1.0;
-		}
-
-		g_free (scale_string);
-	} else {
-		position->scale = 1.0;
-	}
-	
-	return position_good;
+                                   NautilusFile            *file,
+                                   NautilusCanvasPosition  *position,
+                                   NautilusCanvasView      *canvas_view)
+{
+    char *position_string, *scale_string;
+    gboolean position_good;
+    char c;
+
+    g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
+    g_assert (NAUTILUS_IS_FILE (file));
+    g_assert (position != NULL);
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+
+    if (!nautilus_canvas_view_supports_manual_layout (canvas_view))
+    {
+        return FALSE;
+    }
+
+    /* Get the current position of this canvas from the metadata. */
+    position_string = nautilus_file_get_metadata
+                          (file, NAUTILUS_METADATA_KEY_ICON_POSITION, "");
+    position_good = sscanf
+                        (position_string, " %d , %d %c",
+                        &position->x, &position->y, &c) == 2;
+    g_free (position_string);
+
+    /* If it is the desktop directory, maybe the gnome-libs metadata has information about it */
+
+    /* Disable scaling if not on the desktop */
+    if (nautilus_canvas_view_supports_scaling (canvas_view))
+    {
+        /* Get the scale of the canvas from the metadata. */
+        scale_string = nautilus_file_get_metadata
+                           (file, NAUTILUS_METADATA_KEY_ICON_SCALE, "1");
+        position->scale = g_ascii_strtod (scale_string, NULL);
+        if (errno != 0)
+        {
+            position->scale = 1.0;
+        }
+
+        g_free (scale_string);
+    }
+    else
+    {
+        position->scale = 1.0;
+    }
+
+    return position_good;
 }
 
 static void
@@ -290,910 +300,969 @@ update_sort_criterion (NautilusCanvasView  *canvas_view,
                        const SortCriterion *sort,
                        gboolean             set_metadata)
 {
-	NautilusFile *file;
-        const SortCriterion *overrided_sort_criterion;
-
-	file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
-
-        /* Make sure we use the default one and not one that the user used previously
-         * of the change to not allow sorting on search and recent, or the
-         * case that the user or some app modified directly the metadata */
-        if (nautilus_file_is_in_search (file) || nautilus_file_is_in_recent (file)) {
-                overrided_sort_criterion = get_default_sort_order (file);
-        } else if (sort != NULL && canvas_view->details->sort != sort) {
-                overrided_sort_criterion = sort;
-                if (set_metadata) {
-	                /* Store the new sort setting. */
-                        nautilus_canvas_view_set_directory_sort_by (canvas_view,
-			                                            file,
-                                                                    sort);
-                }
-	} else {
-                return;
+    NautilusFile *file;
+    const SortCriterion *overrided_sort_criterion;
+
+    file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
+
+    /* Make sure we use the default one and not one that the user used previously
+     * of the change to not allow sorting on search and recent, or the
+     * case that the user or some app modified directly the metadata */
+    if (nautilus_file_is_in_search (file) || nautilus_file_is_in_recent (file))
+    {
+        overrided_sort_criterion = get_default_sort_order (file);
+    }
+    else if (sort != NULL && canvas_view->details->sort != sort)
+    {
+        overrided_sort_criterion = sort;
+        if (set_metadata)
+        {
+            /* Store the new sort setting. */
+            nautilus_canvas_view_set_directory_sort_by (canvas_view,
+                                                        file,
+                                                        sort);
         }
+    }
+    else
+    {
+        return;
+    }
 
-        canvas_view->details->sort = overrided_sort_criterion;
+    canvas_view->details->sort = overrided_sort_criterion;
 }
 
 void
 nautilus_canvas_view_clean_up_by_name (NautilusCanvasView *canvas_view)
 {
-	NautilusCanvasContainer *canvas_container;
+    NautilusCanvasContainer *canvas_container;
 
-	canvas_container = get_canvas_container (canvas_view);
+    canvas_container = get_canvas_container (canvas_view);
 
-	update_sort_criterion (canvas_view, &sort_criteria[0], FALSE);
+    update_sort_criterion (canvas_view, &sort_criteria[0], FALSE);
 
-	nautilus_canvas_container_sort (canvas_container);
-	nautilus_canvas_container_freeze_icon_positions (canvas_container);
+    nautilus_canvas_container_sort (canvas_container);
+    nautilus_canvas_container_freeze_icon_positions (canvas_container);
 }
 
 static gboolean
 nautilus_canvas_view_using_auto_layout (NautilusCanvasView *canvas_view)
 {
-	return nautilus_canvas_container_is_auto_layout 
-		(get_canvas_container (canvas_view));
+    return nautilus_canvas_container_is_auto_layout
+               (get_canvas_container (canvas_view));
 }
 
 static void
-list_covers (NautilusCanvasIconData *data, gpointer callback_data)
+list_covers (NautilusCanvasIconData *data,
+             gpointer                callback_data)
 {
-	GSList **file_list;
+    GSList **file_list;
 
-	file_list = callback_data;
+    file_list = callback_data;
 
-	*file_list = g_slist_prepend (*file_list, data);
+    *file_list = g_slist_prepend (*file_list, data);
 }
 
 static void
-unref_cover (NautilusCanvasIconData *data, gpointer callback_data)
+unref_cover (NautilusCanvasIconData *data,
+             gpointer                callback_data)
 {
-	nautilus_file_unref (NAUTILUS_FILE (data));
+    nautilus_file_unref (NAUTILUS_FILE (data));
 }
 
 static void
 nautilus_canvas_view_clear (NautilusFilesView *view)
 {
-	NautilusCanvasContainer *canvas_container;
-	GSList *file_list;
-	
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    NautilusCanvasContainer *canvas_container;
+    GSList *file_list;
+
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
-	if (!canvas_container)
-		return;
+    canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
+    if (!canvas_container)
+    {
+        return;
+    }
 
-	/* Clear away the existing icons. */
-	file_list = NULL;
-	nautilus_canvas_container_for_each (canvas_container, list_covers, &file_list);
-	nautilus_canvas_container_clear (canvas_container);
-	g_slist_foreach (file_list, (GFunc)unref_cover, NULL);
-	g_slist_free (file_list);
+    /* Clear away the existing icons. */
+    file_list = NULL;
+    nautilus_canvas_container_for_each (canvas_container, list_covers, &file_list);
+    nautilus_canvas_container_clear (canvas_container);
+    g_slist_foreach (file_list, (GFunc) unref_cover, NULL);
+    g_slist_free (file_list);
 }
 
 static void
-nautilus_canvas_view_remove_file (NautilusFilesView *view, NautilusFile *file, NautilusDirectory *directory)
-{
-	NautilusCanvasView *canvas_view;
-
-	/* This used to assert that 'directory == nautilus_files_view_get_model (view)', but that
-	 * resulted in a lot of crash reports (bug #352592). I don't see how that trace happens.
-	 * It seems that somehow we get a files_changed event sent to the view from a directory
-	 * that isn't the model, but the code disables the monitor and signal callback handlers when
-	 * changing directories. Maybe we can get some more information when this happens.
-	 * Further discussion in bug #368178.
-	 */
-	if (directory != nautilus_files_view_get_model (view)) {
-		char *file_uri, *dir_uri, *model_uri;
-		file_uri = nautilus_file_get_uri (file);
-		dir_uri = nautilus_directory_get_uri (directory);
-		model_uri = nautilus_directory_get_uri (nautilus_files_view_get_model (view));
-		g_warning ("nautilus_canvas_view_remove_file() - directory not canvas view model, shouldn't happen.\n"
-			   "file: %p:%s, dir: %p:%s, model: %p:%s, view loading: %d\n"
-			   "If you see this, please add this info to http://bugzilla.gnome.org/show_bug.cgi?id=368178",
-			   file, file_uri, directory, dir_uri, nautilus_files_view_get_model (view), model_uri, nautilus_files_view_get_loading (view));
-		g_free (file_uri);
-		g_free (dir_uri);
-		g_free (model_uri);
-	}
-	
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
-
-	if (nautilus_canvas_container_remove (get_canvas_container (canvas_view),
-					      NAUTILUS_CANVAS_ICON_DATA (file))) {
-		nautilus_file_unref (file);
-	}
+nautilus_canvas_view_remove_file (NautilusFilesView *view,
+                                  NautilusFile      *file,
+                                  NautilusDirectory *directory)
+{
+    NautilusCanvasView *canvas_view;
+
+    /* This used to assert that 'directory == nautilus_files_view_get_model (view)', but that
+     * resulted in a lot of crash reports (bug #352592). I don't see how that trace happens.
+     * It seems that somehow we get a files_changed event sent to the view from a directory
+     * that isn't the model, but the code disables the monitor and signal callback handlers when
+     * changing directories. Maybe we can get some more information when this happens.
+     * Further discussion in bug #368178.
+     */
+    if (directory != nautilus_files_view_get_model (view))
+    {
+        char *file_uri, *dir_uri, *model_uri;
+        file_uri = nautilus_file_get_uri (file);
+        dir_uri = nautilus_directory_get_uri (directory);
+        model_uri = nautilus_directory_get_uri (nautilus_files_view_get_model (view));
+        g_warning ("nautilus_canvas_view_remove_file() - directory not canvas view model, shouldn't happen.\n"
+                   "file: %p:%s, dir: %p:%s, model: %p:%s, view loading: %d\n"
+                   "If you see this, please add this info to http://bugzilla.gnome.org/show_bug.cgi?id=368178",
+                   file, file_uri, directory, dir_uri, nautilus_files_view_get_model (view), model_uri, nautilus_files_view_get_loading (view));
+        g_free (file_uri);
+        g_free (dir_uri);
+        g_free (model_uri);
+    }
+
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
+
+    if (nautilus_canvas_container_remove (get_canvas_container (canvas_view),
+                                          NAUTILUS_CANVAS_ICON_DATA (file)))
+    {
+        nautilus_file_unref (file);
+    }
 }
 
 static void
-nautilus_canvas_view_add_file (NautilusFilesView *view, NautilusFile *file, NautilusDirectory *directory)
+nautilus_canvas_view_add_file (NautilusFilesView *view,
+                               NautilusFile      *file,
+                               NautilusDirectory *directory)
 {
-	NautilusCanvasView *canvas_view;
-	NautilusCanvasContainer *canvas_container;
+    NautilusCanvasView *canvas_view;
+    NautilusCanvasContainer *canvas_container;
 
-	g_assert (directory == nautilus_files_view_get_model (view));
-	
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
-	canvas_container = get_canvas_container (canvas_view);
+    g_assert (directory == nautilus_files_view_get_model (view));
 
-	/* Reset scroll region for the first canvas added when loading a directory. */
-	if (nautilus_files_view_get_loading (view) && nautilus_canvas_container_is_empty (canvas_container)) {
-		nautilus_canvas_container_reset_scroll_region (canvas_container);
-	}
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
+    canvas_container = get_canvas_container (canvas_view);
 
-	if (nautilus_canvas_container_add (canvas_container,
-					 NAUTILUS_CANVAS_ICON_DATA (file))) {
-		nautilus_file_ref (file);
-	}
+    /* Reset scroll region for the first canvas added when loading a directory. */
+    if (nautilus_files_view_get_loading (view) && nautilus_canvas_container_is_empty (canvas_container))
+    {
+        nautilus_canvas_container_reset_scroll_region (canvas_container);
+    }
+
+    if (nautilus_canvas_container_add (canvas_container,
+                                       NAUTILUS_CANVAS_ICON_DATA (file)))
+    {
+        nautilus_file_ref (file);
+    }
 }
 
 static void
-nautilus_canvas_view_file_changed (NautilusFilesView *view, NautilusFile *file, NautilusDirectory *directory)
+nautilus_canvas_view_file_changed (NautilusFilesView *view,
+                                   NautilusFile      *file,
+                                   NautilusDirectory *directory)
 {
-	NautilusCanvasView *canvas_view;
+    NautilusCanvasView *canvas_view;
+
+    g_assert (directory == nautilus_files_view_get_model (view));
 
-	g_assert (directory == nautilus_files_view_get_model (view));
-	
-	g_return_if_fail (view != NULL);
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
+    g_return_if_fail (view != NULL);
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
 
-	nautilus_canvas_container_request_update
-		(get_canvas_container (canvas_view),
-		 NAUTILUS_CANVAS_ICON_DATA (file));
+    nautilus_canvas_container_request_update
+        (get_canvas_container (canvas_view),
+        NAUTILUS_CANVAS_ICON_DATA (file));
 }
 
 static gboolean
 nautilus_canvas_view_supports_auto_layout (NautilusCanvasView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return view->details->supports_auto_layout;
+    return view->details->supports_auto_layout;
 }
 
 static gboolean
 nautilus_canvas_view_supports_scaling (NautilusCanvasView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return view->details->supports_scaling;
+    return view->details->supports_scaling;
 }
 
 static gboolean
 nautilus_canvas_view_supports_keep_aligned (NautilusCanvasView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return view->details->supports_keep_aligned;
+    return view->details->supports_keep_aligned;
 }
 
 static const SortCriterion *
 nautilus_canvas_view_get_directory_sort_by (NautilusCanvasView *canvas_view,
-					  NautilusFile *file)
+                                            NautilusFile       *file)
 {
-        const SortCriterion *default_sort;
-        g_autofree char *sort_by = NULL;
-        gboolean reversed;
+    const SortCriterion *default_sort;
+    g_autofree char *sort_by = NULL;
+    gboolean reversed;
 
-	if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) {
-                return get_sort_criterion_by_metadata_text ("name", FALSE);
-	}
+    if (!nautilus_canvas_view_supports_auto_layout (canvas_view))
+    {
+        return get_sort_criterion_by_metadata_text ("name", FALSE);
+    }
 
-        default_sort = get_default_sort_order (file);
-        g_return_val_if_fail (default_sort != NULL, NULL);
+    default_sort = get_default_sort_order (file);
+    g_return_val_if_fail (default_sort != NULL, NULL);
 
-        sort_by = nautilus_file_get_metadata (file,
-                                              NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY,
-                                              default_sort->metadata_text);
+    sort_by = nautilus_file_get_metadata (file,
+                                          NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY,
+                                          default_sort->metadata_text);
 
-        reversed = nautilus_file_get_boolean_metadata (file,
-                                                       NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED,
-                                                       default_sort->reverse_order);
+    reversed = nautilus_file_get_boolean_metadata (file,
+                                                   NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED,
+                                                   default_sort->reverse_order);
 
-        return get_sort_criterion_by_metadata_text (sort_by, reversed);
+    return get_sort_criterion_by_metadata_text (sort_by, reversed);
 }
 
 static const SortCriterion *
 get_default_sort_order (NautilusFile *file)
 {
-        NautilusFileSortType sort_type, default_sort_order;
-        gboolean reversed;
+    NautilusFileSortType sort_type, default_sort_order;
+    gboolean reversed;
 
-	default_sort_order = g_settings_get_enum (nautilus_preferences,
-						  NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER);
-        reversed = g_settings_get_boolean (nautilus_preferences,
-                                           NAUTILUS_PREFERENCES_DEFAULT_SORT_IN_REVERSE_ORDER);
+    default_sort_order = g_settings_get_enum (nautilus_preferences,
+                                              NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER);
+    reversed = g_settings_get_boolean (nautilus_preferences,
+                                       NAUTILUS_PREFERENCES_DEFAULT_SORT_IN_REVERSE_ORDER);
 
-        /* If this is a special folder (e.g. search or recent), override the sort
-         * order and reversed flag with values appropriate for the folder */
-        sort_type = nautilus_file_get_default_sort_type (file, &reversed);
+    /* If this is a special folder (e.g. search or recent), override the sort
+     * order and reversed flag with values appropriate for the folder */
+    sort_type = nautilus_file_get_default_sort_type (file, &reversed);
 
-        if (sort_type == NAUTILUS_FILE_SORT_NONE) {
-                sort_type = CLAMP (default_sort_order,
-                                   NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
-                                   NAUTILUS_FILE_SORT_BY_ATIME);
-	}
+    if (sort_type == NAUTILUS_FILE_SORT_NONE)
+    {
+        sort_type = CLAMP (default_sort_order,
+                           NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
+                           NAUTILUS_FILE_SORT_BY_ATIME);
+    }
 
-        return get_sort_criterion_by_sort_type (sort_type, reversed);
+    return get_sort_criterion_by_sort_type (sort_type, reversed);
 }
 
 static void
-nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView *canvas_view, 
-					  NautilusFile *file, 
+nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView  *canvas_view,
+                                            NautilusFile        *file,
                                             const SortCriterion *sort)
 {
-	const SortCriterion *default_sort_criterion;
+    const SortCriterion *default_sort_criterion;
 
-	if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) {
-		return;
-	}
+    if (!nautilus_canvas_view_supports_auto_layout (canvas_view))
+    {
+        return;
+    }
 
-        default_sort_criterion = get_default_sort_order (file);
-	g_return_if_fail (default_sort_criterion != NULL);
+    default_sort_criterion = get_default_sort_order (file);
+    g_return_if_fail (default_sort_criterion != NULL);
 
-	nautilus_file_set_metadata
-		(file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY,
-		 default_sort_criterion->metadata_text,
-                 sort->metadata_text);
-        nautilus_file_set_boolean_metadata (file,
-                                            NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED,
-                                            default_sort_criterion->reverse_order,
-                                            sort->reverse_order);
+    nautilus_file_set_metadata
+        (file, NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_BY,
+        default_sort_criterion->metadata_text,
+        sort->metadata_text);
+    nautilus_file_set_boolean_metadata (file,
+                                        NAUTILUS_METADATA_KEY_ICON_VIEW_SORT_REVERSED,
+                                        default_sort_criterion->reverse_order,
+                                        sort->reverse_order);
 }
 
 static gboolean
 get_default_directory_keep_aligned (void)
 {
-	return TRUE;
+    return TRUE;
 }
 
 static gboolean
 nautilus_canvas_view_get_directory_keep_aligned (NautilusCanvasView *canvas_view,
-					       NautilusFile *file)
+                                                 NautilusFile       *file)
 {
-	if (!nautilus_canvas_view_supports_keep_aligned (canvas_view)) {
-		return FALSE;
-	}
-	
-	return  nautilus_file_get_boolean_metadata
-		(file,
-		 NAUTILUS_METADATA_KEY_ICON_VIEW_KEEP_ALIGNED,
-		 get_default_directory_keep_aligned ());
+    if (!nautilus_canvas_view_supports_keep_aligned (canvas_view))
+    {
+        return FALSE;
+    }
+
+    return nautilus_file_get_boolean_metadata
+               (file,
+               NAUTILUS_METADATA_KEY_ICON_VIEW_KEEP_ALIGNED,
+               get_default_directory_keep_aligned ());
 }
 
 static void
 nautilus_canvas_view_set_directory_keep_aligned (NautilusCanvasView *canvas_view,
-					       NautilusFile *file,
-					       gboolean keep_aligned)
+                                                 NautilusFile       *file,
+                                                 gboolean            keep_aligned)
 {
-	if (!nautilus_canvas_view_supports_keep_aligned (canvas_view)) {
-		return;
-	}
+    if (!nautilus_canvas_view_supports_keep_aligned (canvas_view))
+    {
+        return;
+    }
 
-	nautilus_file_set_boolean_metadata
-		(file, NAUTILUS_METADATA_KEY_ICON_VIEW_KEEP_ALIGNED,
-		 get_default_directory_keep_aligned (),
-		 keep_aligned);
+    nautilus_file_set_boolean_metadata
+        (file, NAUTILUS_METADATA_KEY_ICON_VIEW_KEEP_ALIGNED,
+        get_default_directory_keep_aligned (),
+        keep_aligned);
 }
 
 static gboolean
 nautilus_canvas_view_get_directory_auto_layout (NautilusCanvasView *canvas_view,
-					      NautilusFile *file)
+                                                NautilusFile       *file)
 {
-	if (!nautilus_canvas_view_supports_auto_layout (canvas_view)) {
-		return FALSE;
-	}
+    if (!nautilus_canvas_view_supports_auto_layout (canvas_view))
+    {
+        return FALSE;
+    }
 
-	if (!nautilus_canvas_view_supports_manual_layout (canvas_view)) {
-		return TRUE;
-	}
+    if (!nautilus_canvas_view_supports_manual_layout (canvas_view))
+    {
+        return TRUE;
+    }
 
-	return nautilus_file_get_boolean_metadata
-		(file, NAUTILUS_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT, TRUE);
+    return nautilus_file_get_boolean_metadata
+               (file, NAUTILUS_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT, TRUE);
 }
 
 static void
 nautilus_canvas_view_set_directory_auto_layout (NautilusCanvasView *canvas_view,
-					      NautilusFile *file,
-					gboolean auto_layout)
+                                                NautilusFile       *file,
+                                                gboolean            auto_layout)
 {
-	if (!nautilus_canvas_view_supports_auto_layout (canvas_view) ||
-	    !nautilus_canvas_view_supports_manual_layout (canvas_view)) {
-		return;
-	}
+    if (!nautilus_canvas_view_supports_auto_layout (canvas_view) ||
+        !nautilus_canvas_view_supports_manual_layout (canvas_view))
+    {
+        return;
+    }
 
-	nautilus_file_set_boolean_metadata
-		(file, NAUTILUS_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT,
-		 TRUE,
-		 auto_layout);
+    nautilus_file_set_boolean_metadata
+        (file, NAUTILUS_METADATA_KEY_ICON_VIEW_AUTO_LAYOUT,
+        TRUE,
+        auto_layout);
 }
 
 static const SortCriterion *
-get_sort_criterion_by_metadata_text (const char *metadata_text, gboolean reversed)
+get_sort_criterion_by_metadata_text (const char *metadata_text,
+                                     gboolean    reversed)
 {
-	guint i;
+    guint i;
 
-	/* Figure out what the new sort setting should be. */
-	for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++) {
-                if (g_strcmp0 (sort_criteria[i].metadata_text, metadata_text) == 0
-                    && reversed == sort_criteria[i].reverse_order) {
-			return &sort_criteria[i];
-		}
-	}
-        return &sort_criteria[0];
+    /* Figure out what the new sort setting should be. */
+    for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++)
+    {
+        if (g_strcmp0 (sort_criteria[i].metadata_text, metadata_text) == 0
+            && reversed == sort_criteria[i].reverse_order)
+        {
+            return &sort_criteria[i];
+        }
+    }
+    return &sort_criteria[0];
 }
 
 static const SortCriterion *
 get_sort_criterion_by_action_target_name (const char *action_target_name)
 {
-	guint i;
-	/* Figure out what the new sort setting should be. */
-	for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++) {
-		if (g_strcmp0 (sort_criteria[i].action_target_name, action_target_name) == 0) {
-			return &sort_criteria[i];
-		}
-	}
-	return NULL;
+    guint i;
+    /* Figure out what the new sort setting should be. */
+    for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++)
+    {
+        if (g_strcmp0 (sort_criteria[i].action_target_name, action_target_name) == 0)
+        {
+            return &sort_criteria[i];
+        }
+    }
+    return NULL;
 }
 
 static const SortCriterion *
-get_sort_criterion_by_sort_type (NautilusFileSortType sort_type, gboolean reversed)
+get_sort_criterion_by_sort_type (NautilusFileSortType sort_type,
+                                 gboolean             reversed)
 {
-	guint i;
+    guint i;
 
-	/* Figure out what the new sort setting should be. */
-	for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++) {
-                if (sort_type == sort_criteria[i].sort_type
-                    && reversed == sort_criteria[i].reverse_order) {
-			return &sort_criteria[i];
-		}
-	}
+    /* Figure out what the new sort setting should be. */
+    for (i = 0; i < G_N_ELEMENTS (sort_criteria); i++)
+    {
+        if (sort_type == sort_criteria[i].sort_type
+            && reversed == sort_criteria[i].reverse_order)
+        {
+            return &sort_criteria[i];
+        }
+    }
 
-	return &sort_criteria[0];
+    return &sort_criteria[0];
 }
 
 static NautilusCanvasZoomLevel
 get_default_zoom_level (NautilusCanvasView *canvas_view)
 {
-	NautilusCanvasZoomLevel default_zoom_level;
+    NautilusCanvasZoomLevel default_zoom_level;
 
-	default_zoom_level = g_settings_get_enum (nautilus_icon_view_preferences,
-						  NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL);
+    default_zoom_level = g_settings_get_enum (nautilus_icon_view_preferences,
+                                              NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL);
 
-	return CLAMP (default_zoom_level, NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL, NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER);
+    return CLAMP (default_zoom_level, NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL, NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER);
 }
 
 static void
 nautilus_canvas_view_begin_loading (NautilusFilesView *view)
 {
-	NautilusCanvasView *canvas_view;
-	GtkWidget *canvas_container;
-	NautilusFile *file;
-        char *uri;
-        const SortCriterion *sort;
+    NautilusCanvasView *canvas_view;
+    GtkWidget *canvas_container;
+    NautilusFile *file;
+    char *uri;
+    const SortCriterion *sort;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
-	file = nautilus_files_view_get_directory_as_file (view);
-	uri = nautilus_file_get_uri (file);
-	canvas_container = GTK_WIDGET (get_canvas_container (canvas_view));
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
+    file = nautilus_files_view_get_directory_as_file (view);
+    uri = nautilus_file_get_uri (file);
+    canvas_container = GTK_WIDGET (get_canvas_container (canvas_view));
 
-	nautilus_canvas_container_begin_loading (NAUTILUS_CANVAS_CONTAINER (canvas_container));
+    nautilus_canvas_container_begin_loading (NAUTILUS_CANVAS_CONTAINER (canvas_container));
 
-	g_free (uri);
+    g_free (uri);
 
-	/* Set the sort mode.
-	 * It's OK not to resort the icons because the
-	 * container doesn't have any icons at this point.
-	 */
-        sort = nautilus_canvas_view_get_directory_sort_by (canvas_view, file);
-        update_sort_criterion (canvas_view, sort, FALSE);
+    /* Set the sort mode.
+     * It's OK not to resort the icons because the
+     * container doesn't have any icons at this point.
+     */
+    sort = nautilus_canvas_view_get_directory_sort_by (canvas_view, file);
+    update_sort_criterion (canvas_view, sort, FALSE);
 
-	nautilus_canvas_container_set_keep_aligned
-		(get_canvas_container (canvas_view), 
-		 nautilus_canvas_view_get_directory_keep_aligned (canvas_view, file));
+    nautilus_canvas_container_set_keep_aligned
+        (get_canvas_container (canvas_view),
+        nautilus_canvas_view_get_directory_keep_aligned (canvas_view, file));
 
-	/* We must set auto-layout last, because it invokes the layout_changed 
-	 * callback, which works incorrectly if the other layout criteria are
-	 * not already set up properly (see bug 6500, e.g.)
-	 */
-	nautilus_canvas_container_set_auto_layout
-		(get_canvas_container (canvas_view), 
-		 nautilus_canvas_view_get_directory_auto_layout (canvas_view, file));
+    /* We must set auto-layout last, because it invokes the layout_changed
+     * callback, which works incorrectly if the other layout criteria are
+     * not already set up properly (see bug 6500, e.g.)
+     */
+    nautilus_canvas_container_set_auto_layout
+        (get_canvas_container (canvas_view),
+        nautilus_canvas_view_get_directory_auto_layout (canvas_view, file));
 
-	/* We could have changed to the trash directory or to searching, and then
-	 * we need to update the menus */
-	nautilus_files_view_update_context_menus(view);
-	nautilus_files_view_update_toolbar_menus(view);
+    /* We could have changed to the trash directory or to searching, and then
+     * we need to update the menus */
+    nautilus_files_view_update_context_menus (view);
+    nautilus_files_view_update_toolbar_menus (view);
 }
 
 static void
 canvas_view_notify_clipboard_info (NautilusClipboardMonitor *monitor,
-                                 NautilusClipboardInfo *info,
-                                 NautilusCanvasView *canvas_view)
+                                   NautilusClipboardInfo    *info,
+                                   NautilusCanvasView       *canvas_view)
 {
-	GList *icon_data;
+    GList *icon_data;
 
-	icon_data = NULL;
-	if (info && info->cut) {
-		icon_data = info->files;
-	}
+    icon_data = NULL;
+    if (info && info->cut)
+    {
+        icon_data = info->files;
+    }
 
-	nautilus_canvas_container_set_highlighted_for_clipboard (
-							       get_canvas_container (canvas_view), icon_data);
+    nautilus_canvas_container_set_highlighted_for_clipboard (
+        get_canvas_container (canvas_view), icon_data);
 }
 
 static void
 nautilus_canvas_view_end_loading (NautilusFilesView *view,
-			  gboolean all_files_seen)
+                                  gboolean           all_files_seen)
 {
-	NautilusCanvasView *canvas_view;
-	GtkWidget *canvas_container;
-	NautilusClipboardMonitor *monitor;
-	NautilusClipboardInfo *info;
+    NautilusCanvasView *canvas_view;
+    GtkWidget *canvas_container;
+    NautilusClipboardMonitor *monitor;
+    NautilusClipboardInfo *info;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
 
-	canvas_container = GTK_WIDGET (get_canvas_container (canvas_view));
-	nautilus_canvas_container_end_loading (NAUTILUS_CANVAS_CONTAINER (canvas_container), all_files_seen);
+    canvas_container = GTK_WIDGET (get_canvas_container (canvas_view));
+    nautilus_canvas_container_end_loading (NAUTILUS_CANVAS_CONTAINER (canvas_container), all_files_seen);
 
-	monitor = nautilus_clipboard_monitor_get ();
-	info = nautilus_clipboard_monitor_get_clipboard_info (monitor);
+    monitor = nautilus_clipboard_monitor_get ();
+    info = nautilus_clipboard_monitor_get_clipboard_info (monitor);
 
-	canvas_view_notify_clipboard_info (monitor, info, canvas_view);
+    canvas_view_notify_clipboard_info (monitor, info, canvas_view);
 }
 
 static NautilusCanvasZoomLevel
 nautilus_canvas_view_get_zoom_level (NautilusFilesView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NAUTILUS_CANVAS_ZOOM_LEVEL_STANDARD);
-	
-	return nautilus_canvas_container_get_zoom_level (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NAUTILUS_CANVAS_ZOOM_LEVEL_STANDARD);
+
+    return nautilus_canvas_container_get_zoom_level (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
 }
 
 static void
 nautilus_canvas_view_zoom_to_level (NautilusFilesView *view,
-				    gint          new_level)
+                                    gint               new_level)
 {
-	NautilusCanvasView *canvas_view;
-	NautilusCanvasContainer *canvas_container;
+    NautilusCanvasView *canvas_view;
+    NautilusCanvasContainer *canvas_container;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
-	g_return_if_fail (new_level >= NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL &&
-			  new_level <= NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER);
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (new_level >= NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL &&
+                      new_level <= NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER);
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
-	canvas_container = get_canvas_container (canvas_view);
-	if (nautilus_canvas_container_get_zoom_level (canvas_container) == new_level)
-		return;
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
+    canvas_container = get_canvas_container (canvas_view);
+    if (nautilus_canvas_container_get_zoom_level (canvas_container) == new_level)
+    {
+        return;
+    }
 
-	nautilus_canvas_container_set_zoom_level (canvas_container, new_level);
-	g_action_group_change_action_state (nautilus_files_view_get_action_group (view),
-					    "zoom-to-level", g_variant_new_int32 (new_level));
+    nautilus_canvas_container_set_zoom_level (canvas_container, new_level);
+    g_action_group_change_action_state (nautilus_files_view_get_action_group (view),
+                                        "zoom-to-level", g_variant_new_int32 (new_level));
 
-	nautilus_files_view_update_toolbar_menus (view);
+    nautilus_files_view_update_toolbar_menus (view);
 }
 
 static void
-nautilus_canvas_view_bump_zoom_level (NautilusFilesView *view, int zoom_increment)
+nautilus_canvas_view_bump_zoom_level (NautilusFilesView *view,
+                                      int                zoom_increment)
 {
-	NautilusCanvasZoomLevel new_level;
+    NautilusCanvasZoomLevel new_level;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
-	if (!nautilus_files_view_supports_zooming (view)) {
-		return;
-	}
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    if (!nautilus_files_view_supports_zooming (view))
+    {
+        return;
+    }
 
-	new_level = nautilus_canvas_view_get_zoom_level (view) + zoom_increment;
+    new_level = nautilus_canvas_view_get_zoom_level (view) + zoom_increment;
 
-	if (new_level >= NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL &&
-	    new_level <= NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER) {
-		nautilus_canvas_view_zoom_to_level (view, new_level);
-	}
+    if (new_level >= NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL &&
+        new_level <= NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER)
+    {
+        nautilus_canvas_view_zoom_to_level (view, new_level);
+    }
 }
 
 static void
 nautilus_canvas_view_restore_standard_zoom_level (NautilusFilesView *view)
 {
-        nautilus_canvas_view_zoom_to_level (view, NAUTILUS_CANVAS_ZOOM_LEVEL_LARGE);
+    nautilus_canvas_view_zoom_to_level (view, NAUTILUS_CANVAS_ZOOM_LEVEL_LARGE);
 }
 
-static gboolean 
+static gboolean
 nautilus_canvas_view_can_zoom_in (NautilusFilesView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return nautilus_canvas_view_get_zoom_level (view) 
-		< NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER;
+    return nautilus_canvas_view_get_zoom_level (view)
+           < NAUTILUS_CANVAS_ZOOM_LEVEL_LARGER;
 }
 
-static gboolean 
+static gboolean
 nautilus_canvas_view_can_zoom_out (NautilusFilesView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return nautilus_canvas_view_get_zoom_level (view) 
-		> NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL;
+    return nautilus_canvas_view_get_zoom_level (view)
+           > NAUTILUS_CANVAS_ZOOM_LEVEL_SMALL;
 }
 
 static gfloat
 nautilus_canvas_view_get_zoom_level_percentage (NautilusFilesView *view)
 {
-        guint icon_size;
-        NautilusCanvasZoomLevel zoom_level;
+    guint icon_size;
+    NautilusCanvasZoomLevel zoom_level;
 
-        zoom_level = nautilus_canvas_view_get_zoom_level (view);
-        icon_size = nautilus_canvas_container_get_icon_size_for_zoom_level (zoom_level);
+    zoom_level = nautilus_canvas_view_get_zoom_level (view);
+    icon_size = nautilus_canvas_container_get_icon_size_for_zoom_level (zoom_level);
 
-        return (gfloat) icon_size / NAUTILUS_CANVAS_ICON_SIZE_LARGE;
+    return (gfloat) icon_size / NAUTILUS_CANVAS_ICON_SIZE_LARGE;
 }
 
 static gboolean
 nautilus_canvas_view_is_empty (NautilusFilesView *view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	return nautilus_canvas_container_is_empty 
-		(get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
+    return nautilus_canvas_container_is_empty
+               (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
 }
 
 static GList *
 nautilus_canvas_view_get_selection (NautilusFilesView *view)
 {
-	GList *list;
+    GList *list;
 
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL);
 
-	list = nautilus_canvas_container_get_selection
-		(get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
-	nautilus_file_list_ref (list);
-	return list;
+    list = nautilus_canvas_container_get_selection
+               (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
+    nautilus_file_list_ref (list);
+    return list;
 }
 
 static void
 action_keep_aligned (GSimpleAction *action,
-		     GVariant      *state,
-		     gpointer       user_data)
+                     GVariant      *state,
+                     gpointer       user_data)
 {
-	NautilusFile *file;
-	NautilusCanvasView *canvas_view;
-	gboolean keep_aligned;
+    NautilusFile *file;
+    NautilusCanvasView *canvas_view;
+    gboolean keep_aligned;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (user_data);
-	file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
-	keep_aligned = g_variant_get_boolean (state);
+    canvas_view = NAUTILUS_CANVAS_VIEW (user_data);
+    file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
+    keep_aligned = g_variant_get_boolean (state);
 
-	nautilus_canvas_view_set_directory_keep_aligned (canvas_view,
-							 file,
-							 keep_aligned);
-	nautilus_canvas_container_set_keep_aligned (get_canvas_container (canvas_view),
-						    keep_aligned);
+    nautilus_canvas_view_set_directory_keep_aligned (canvas_view,
+                                                     file,
+                                                     keep_aligned);
+    nautilus_canvas_container_set_keep_aligned (get_canvas_container (canvas_view),
+                                                keep_aligned);
 
-	g_simple_action_set_state (action, state);
+    g_simple_action_set_state (action, state);
 }
 
 static void
 action_sort_order_changed (GSimpleAction *action,
-			   GVariant      *value,
-			   gpointer       user_data)
+                           GVariant      *value,
+                           gpointer       user_data)
 {
-	const gchar *target_name;
-	const SortCriterion *sort_criterion;
+    const gchar *target_name;
+    const SortCriterion *sort_criterion;
 
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (user_data));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (user_data));
 
-	target_name = g_variant_get_string (value, NULL);
-	sort_criterion = get_sort_criterion_by_action_target_name (target_name);
+    target_name = g_variant_get_string (value, NULL);
+    sort_criterion = get_sort_criterion_by_action_target_name (target_name);
 
-	g_assert (sort_criterion != NULL);
-	/* Note that id might be a toggle item.
-	 * Ignore non-sort ids so that they don't cause sorting.
-	 */
-	if (sort_criterion->sort_type == NAUTILUS_FILE_SORT_NONE) {
-		switch_to_manual_layout (user_data);
-	} else {
-		update_sort_criterion (user_data, sort_criterion, TRUE);
+    g_assert (sort_criterion != NULL);
+    /* Note that id might be a toggle item.
+     * Ignore non-sort ids so that they don't cause sorting.
+     */
+    if (sort_criterion->sort_type == NAUTILUS_FILE_SORT_NONE)
+    {
+        switch_to_manual_layout (user_data);
+    }
+    else
+    {
+        update_sort_criterion (user_data, sort_criterion, TRUE);
 
-		nautilus_canvas_container_sort (get_canvas_container (user_data));
-		nautilus_canvas_view_reveal_selection (NAUTILUS_FILES_VIEW (user_data));
-	}
+        nautilus_canvas_container_sort (get_canvas_container (user_data));
+        nautilus_canvas_view_reveal_selection (NAUTILUS_FILES_VIEW (user_data));
+    }
 
-	g_simple_action_set_state (action, value);
+    g_simple_action_set_state (action, value);
 }
 
 static void
 action_zoom_to_level (GSimpleAction *action,
-		      GVariant      *state,
-		      gpointer       user_data)
+                      GVariant      *state,
+                      gpointer       user_data)
 {
-	NautilusFilesView *view;
-	NautilusCanvasZoomLevel zoom_level;
+    NautilusFilesView *view;
+    NautilusCanvasZoomLevel zoom_level;
 
-	g_assert (NAUTILUS_IS_FILES_VIEW (user_data));
+    g_assert (NAUTILUS_IS_FILES_VIEW (user_data));
 
-	view = NAUTILUS_FILES_VIEW (user_data);
-	zoom_level = g_variant_get_int32 (state);
-	nautilus_canvas_view_zoom_to_level (view, zoom_level);
+    view = NAUTILUS_FILES_VIEW (user_data);
+    zoom_level = g_variant_get_int32 (state);
+    nautilus_canvas_view_zoom_to_level (view, zoom_level);
 
-	g_simple_action_set_state (G_SIMPLE_ACTION (action), state);
-	if (g_settings_get_enum (nautilus_icon_view_preferences,
-                             NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL) != zoom_level) {
-		g_settings_set_enum (nautilus_icon_view_preferences,
-                                     NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL,
-                                     zoom_level);
-	}
+    g_simple_action_set_state (G_SIMPLE_ACTION (action), state);
+    if (g_settings_get_enum (nautilus_icon_view_preferences,
+                             NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL) != zoom_level)
+    {
+        g_settings_set_enum (nautilus_icon_view_preferences,
+                             NAUTILUS_PREFERENCES_ICON_VIEW_DEFAULT_ZOOM_LEVEL,
+                             zoom_level);
+    }
 }
 
 static void
 switch_to_manual_layout (NautilusCanvasView *canvas_view)
 {
-	if (!nautilus_canvas_view_using_auto_layout (canvas_view) ||
-	    !nautilus_files_view_is_editable (NAUTILUS_FILES_VIEW (canvas_view))) {
-		return;
-	}
+    if (!nautilus_canvas_view_using_auto_layout (canvas_view) ||
+        !nautilus_files_view_is_editable (NAUTILUS_FILES_VIEW (canvas_view)))
+    {
+        return;
+    }
+
+    canvas_view->details->sort = &sort_criteria[0];
 
-	canvas_view->details->sort = &sort_criteria[0];
-	
-	nautilus_canvas_container_set_auto_layout
-		(get_canvas_container (canvas_view), FALSE);
+    nautilus_canvas_container_set_auto_layout
+        (get_canvas_container (canvas_view), FALSE);
 }
 
 static void
 layout_changed_callback (NautilusCanvasContainer *container,
-			 NautilusCanvasView *canvas_view)
+                         NautilusCanvasView      *canvas_view)
 {
-	NautilusFile *file;
+    NautilusFile *file;
 
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
 
-	file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
+    file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
 
-	if (file != NULL) {
-		nautilus_canvas_view_set_directory_auto_layout
-			(canvas_view,
-			 file,
-			 nautilus_canvas_view_using_auto_layout (canvas_view));
-	}
+    if (file != NULL)
+    {
+        nautilus_canvas_view_set_directory_auto_layout
+            (canvas_view,
+            file,
+            nautilus_canvas_view_using_auto_layout (canvas_view));
+    }
 }
 
-const GActionEntry canvas_view_entries[] = {
-	{ "keep-aligned", NULL, NULL, "true", action_keep_aligned },
-	{ "sort", NULL, "s", "'name'", action_sort_order_changed },
-	{ "zoom-to-level", NULL, NULL, "1", action_zoom_to_level }
+const GActionEntry canvas_view_entries[] =
+{
+    { "keep-aligned", NULL, NULL, "true", action_keep_aligned },
+    { "sort", NULL, "s", "'name'", action_sort_order_changed },
+    { "zoom-to-level", NULL, NULL, "1", action_zoom_to_level }
 };
 
 static void
 update_sort_action_state_hint (NautilusCanvasView *canvas_view)
 {
-	NautilusFile *file;
-	GVariantBuilder builder;
-	GActionGroup *action_group;
-	GAction *action;
-	GVariant *state_hint;
-	gint idx;
+    NautilusFile *file;
+    GVariantBuilder builder;
+    GActionGroup *action_group;
+    GAction *action;
+    GVariant *state_hint;
+    gint idx;
 
-	file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
-	g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
+    file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
+    g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
 
-	for (idx = 0; idx < G_N_ELEMENTS (sort_criteria); idx++) {
-		if (sort_criteria[idx].match_func == NULL ||
-		    (file != NULL && sort_criteria[idx].match_func (file)))
-			g_variant_builder_add (&builder, "s", sort_criteria[idx].action_target_name);
-	}
+    for (idx = 0; idx < G_N_ELEMENTS (sort_criteria); idx++)
+    {
+        if (sort_criteria[idx].match_func == NULL ||
+            (file != NULL && sort_criteria[idx].match_func (file)))
+        {
+            g_variant_builder_add (&builder, "s", sort_criteria[idx].action_target_name);
+        }
+    }
 
-	state_hint = g_variant_builder_end (&builder);
+    state_hint = g_variant_builder_end (&builder);
 
-	action_group = nautilus_files_view_get_action_group (NAUTILUS_FILES_VIEW (canvas_view));
-	action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "sort");
-	g_simple_action_set_state_hint (G_SIMPLE_ACTION (action), state_hint);
+    action_group = nautilus_files_view_get_action_group (NAUTILUS_FILES_VIEW (canvas_view));
+    action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "sort");
+    g_simple_action_set_state_hint (G_SIMPLE_ACTION (action), state_hint);
 
-	g_variant_unref (state_hint);
+    g_variant_unref (state_hint);
 }
 
 static gboolean
 showing_recent_directory (NautilusFilesView *view)
 {
-	NautilusFile *file;
+    NautilusFile *file;
 
-	file = nautilus_files_view_get_directory_as_file (view);
-	if (file != NULL) {
-		return nautilus_file_is_in_recent (file);
-	}
-	return FALSE;
+    file = nautilus_files_view_get_directory_as_file (view);
+    if (file != NULL)
+    {
+        return nautilus_file_is_in_recent (file);
+    }
+    return FALSE;
 }
 
 static gboolean
 showing_search_directory (NautilusFilesView *view)
 {
-	NautilusFile *file;
+    NautilusFile *file;
 
-	file = nautilus_files_view_get_directory_as_file (view);
-	if (file != NULL) {
-		return nautilus_file_is_in_search (file);
-	}
-	return FALSE;
+    file = nautilus_files_view_get_directory_as_file (view);
+    if (file != NULL)
+    {
+        return nautilus_file_is_in_search (file);
+    }
+    return FALSE;
 }
 
 static void
 nautilus_canvas_view_update_actions_state (NautilusFilesView *view)
 {
-	GActionGroup *view_action_group;
-	GAction *action;
-	gboolean keep_aligned;
-	NautilusCanvasView *canvas_view;
-
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
-
-	NAUTILUS_FILES_VIEW_CLASS (nautilus_canvas_view_parent_class)->update_actions_state (view);
-
-	view_action_group = nautilus_files_view_get_action_group (view);
-	if (nautilus_canvas_view_supports_auto_layout (canvas_view)) {
-		GVariant *sort_state;
-
-		/* When we change the sort action state, even using the same value, it triggers
-		 * the sort action changed handler, which reveals the selection, since we expect
-		 * the selection to be visible when the user changes the sort order. But we may
-		 * need to update the actions state for others reason than an actual sort change,
-		 * so we need to prevent to trigger the sort action changed handler for those cases.
-		 * To achieve this, check if the action state value actually changed before setting
-                 * it
-		 */
-		sort_state = g_action_group_get_action_state (view_action_group, "sort");
-
-		if (g_strcmp0 (g_variant_get_string (sort_state, NULL),
-                               NAUTILUS_CANVAS_VIEW (view)->details->sort->action_target_name) != 0) {
-			g_action_group_change_action_state (view_action_group,
-                                                            "sort",
-                                                             g_variant_new_string (NAUTILUS_CANVAS_VIEW (view)->details->sort->action_target_name));
-		}
-
-		g_variant_unref (sort_state);
-	}
-
-	action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "sort");
-	g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
-				     !showing_recent_directory (view) &&
-                                     !showing_search_directory (view));
-        action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "keep-aligned");
-        g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
-                                     canvas_view->details->supports_keep_aligned);
-	if (canvas_view->details->supports_keep_aligned) {
-		keep_aligned = nautilus_canvas_container_is_keep_aligned (get_canvas_container (canvas_view));
-		g_action_change_state (action, g_variant_new_boolean (keep_aligned));
-	}
-
-	update_sort_action_state_hint (canvas_view);
+    GActionGroup *view_action_group;
+    GAction *action;
+    gboolean keep_aligned;
+    NautilusCanvasView *canvas_view;
+
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
+
+    NAUTILUS_FILES_VIEW_CLASS (nautilus_canvas_view_parent_class)->update_actions_state (view);
+
+    view_action_group = nautilus_files_view_get_action_group (view);
+    if (nautilus_canvas_view_supports_auto_layout (canvas_view))
+    {
+        GVariant *sort_state;
+
+        /* When we change the sort action state, even using the same value, it triggers
+         * the sort action changed handler, which reveals the selection, since we expect
+         * the selection to be visible when the user changes the sort order. But we may
+         * need to update the actions state for others reason than an actual sort change,
+         * so we need to prevent to trigger the sort action changed handler for those cases.
+         * To achieve this, check if the action state value actually changed before setting
+         * it
+         */
+        sort_state = g_action_group_get_action_state (view_action_group, "sort");
+
+        if (g_strcmp0 (g_variant_get_string (sort_state, NULL),
+                       NAUTILUS_CANVAS_VIEW (view)->details->sort->action_target_name) != 0)
+        {
+            g_action_group_change_action_state (view_action_group,
+                                                "sort",
+                                                g_variant_new_string (NAUTILUS_CANVAS_VIEW (view)->details->sort->action_target_name));
+        }
+
+        g_variant_unref (sort_state);
+    }
+
+    action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "sort");
+    g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
+                                 !showing_recent_directory (view) &&
+                                 !showing_search_directory (view));
+    action = g_action_map_lookup_action (G_ACTION_MAP (view_action_group), "keep-aligned");
+    g_simple_action_set_enabled (G_SIMPLE_ACTION (action),
+                                 canvas_view->details->supports_keep_aligned);
+    if (canvas_view->details->supports_keep_aligned)
+    {
+        keep_aligned = nautilus_canvas_container_is_keep_aligned (get_canvas_container (canvas_view));
+        g_action_change_state (action, g_variant_new_boolean (keep_aligned));
+    }
+
+    update_sort_action_state_hint (canvas_view);
 }
 
 static void
 nautilus_canvas_view_select_all (NautilusFilesView *view)
 {
-	NautilusCanvasContainer *canvas_container;
+    NautilusCanvasContainer *canvas_container;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
-        nautilus_canvas_container_select_all (canvas_container);
+    canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
+    nautilus_canvas_container_select_all (canvas_container);
 }
 
 static void
 nautilus_canvas_view_select_first (NautilusFilesView *view)
 {
-	NautilusCanvasContainer *canvas_container;
+    NautilusCanvasContainer *canvas_container;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
-        nautilus_canvas_container_select_first (canvas_container);
+    canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
+    nautilus_canvas_container_select_first (canvas_container);
 }
 
 static void
 nautilus_canvas_view_reveal_selection (NautilusFilesView *view)
 {
-	GList *selection;
+    GList *selection;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-        selection = nautilus_view_get_selection (NAUTILUS_VIEW (view));
+    selection = nautilus_view_get_selection (NAUTILUS_VIEW (view));
 
-	/* Make sure at least one of the selected items is scrolled into view */
-	if (selection != NULL) {
-                /* Update the icon ordering to reveal the rigth selection */
-                nautilus_canvas_container_layout_now (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
-		nautilus_canvas_container_reveal 
-			(get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), 
-			 selection->data);
-	}
+    /* Make sure at least one of the selected items is scrolled into view */
+    if (selection != NULL)
+    {
+        /* Update the icon ordering to reveal the rigth selection */
+        nautilus_canvas_container_layout_now (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
+        nautilus_canvas_container_reveal
+            (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)),
+            selection->data);
+    }
 
-        nautilus_file_list_free (selection);
+    nautilus_file_list_free (selection);
 }
 
-static GdkRectangle*
+static GdkRectangle *
 nautilus_canvas_view_compute_rename_popover_pointing_to (NautilusFilesView *view)
 {
-        GArray *bounding_boxes;
-        GdkRectangle *bounding_box;
-        NautilusCanvasContainer *canvas_container;
-        GtkAdjustment *vadjustment, *hadjustment;
-        GtkWidget *parent_container;
+    GArray *bounding_boxes;
+    GdkRectangle *bounding_box;
+    NautilusCanvasContainer *canvas_container;
+    GtkAdjustment *vadjustment, *hadjustment;
+    GtkWidget *parent_container;
 
-        canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
-        bounding_boxes = nautilus_canvas_container_get_selected_icons_bounding_box (canvas_container);
-        /* We only allow renaming one item at once */
-        bounding_box = &g_array_index (bounding_boxes, GdkRectangle, 0);
-        parent_container = nautilus_files_view_get_content_widget (view);
-        vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (parent_container));
-        hadjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (parent_container));
+    canvas_container = get_canvas_container (NAUTILUS_CANVAS_VIEW (view));
+    bounding_boxes = nautilus_canvas_container_get_selected_icons_bounding_box (canvas_container);
+    /* We only allow renaming one item at once */
+    bounding_box = &g_array_index (bounding_boxes, GdkRectangle, 0);
+    parent_container = nautilus_files_view_get_content_widget (view);
+    vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (parent_container));
+    hadjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (parent_container));
 
-        bounding_box->x -= gtk_adjustment_get_value (hadjustment);
-        bounding_box->y -= gtk_adjustment_get_value (vadjustment);
+    bounding_box->x -= gtk_adjustment_get_value (hadjustment);
+    bounding_box->y -= gtk_adjustment_get_value (vadjustment);
 
-        g_array_free (bounding_boxes, FALSE);
+    g_array_free (bounding_boxes, FALSE);
 
-        return bounding_box;
+    return bounding_box;
 }
 
 static void
-nautilus_canvas_view_set_selection (NautilusFilesView *view, GList *selection)
+nautilus_canvas_view_set_selection (NautilusFilesView *view,
+                                    GList             *selection)
 {
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	nautilus_canvas_container_set_selection
-		(get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), selection);
+    nautilus_canvas_container_set_selection
+        (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), selection);
 }
 
 static void
 nautilus_canvas_view_invert_selection (NautilusFilesView *view)
 {
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	nautilus_canvas_container_invert_selection
-		(get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
+    nautilus_canvas_container_invert_selection
+        (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)));
 }
 
 static gboolean
 nautilus_canvas_view_using_manual_layout (NautilusFilesView *view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
 
-	return !nautilus_canvas_view_using_auto_layout (NAUTILUS_CANVAS_VIEW (view));
+    return !nautilus_canvas_view_using_auto_layout (NAUTILUS_CANVAS_VIEW (view));
 }
 
 static void
 nautilus_canvas_view_widget_to_file_operation_position (NautilusFilesView *view,
-						GdkPoint *position)
+                                                        GdkPoint          *position)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (view));
 
-	nautilus_canvas_container_widget_to_file_operation_position
-		(get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), position);
+    nautilus_canvas_container_widget_to_file_operation_position
+        (get_canvas_container (NAUTILUS_CANVAS_VIEW (view)), position);
 }
 
 static void
 canvas_container_activate_callback (NautilusCanvasContainer *container,
-				  GList *file_list,
-				  NautilusCanvasView *canvas_view)
+                                    GList                   *file_list,
+                                    NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
 
-	nautilus_files_view_activate_files (NAUTILUS_FILES_VIEW (canvas_view),
-				      file_list, 
-				      0, TRUE);
+    nautilus_files_view_activate_files (NAUTILUS_FILES_VIEW (canvas_view),
+                                        file_list,
+                                        0, TRUE);
 }
 
 static void
 canvas_container_activate_previewer_callback (NautilusCanvasContainer *container,
-					    GList *file_list,
-					    GArray *locations,
-					    NautilusCanvasView *canvas_view)
+                                              GList                   *file_list,
+                                              GArray                  *locations,
+                                              NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
 
-	nautilus_files_view_preview_files (NAUTILUS_FILES_VIEW (canvas_view),
-				     file_list, locations);
+    nautilus_files_view_preview_files (NAUTILUS_FILES_VIEW (canvas_view),
+                                       file_list, locations);
 }
 
 /* this is called in one of these cases:
@@ -1211,737 +1280,790 @@ canvas_container_activate_previewer_callback (NautilusCanvasContainer *container
  */
 static void
 canvas_container_activate_alternate_callback (NautilusCanvasContainer *container,
-					    GList *file_list,
-					    NautilusCanvasView *canvas_view)
-{
-	GdkEvent *event;
-	GdkEventButton *button_event;
-	GdkEventKey *key_event;
-	gboolean open_in_tab, open_in_window, close_behind;
-	NautilusWindowOpenFlags flags;
-
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
-
-	flags = 0;
-	event = gtk_get_current_event ();
-	open_in_tab = FALSE;
-	open_in_window = FALSE;
-	close_behind = FALSE;
-
-	if (event->type == GDK_BUTTON_PRESS ||
-	    event->type == GDK_BUTTON_RELEASE ||
-	    event->type == GDK_2BUTTON_PRESS ||
-	    event->type == GDK_3BUTTON_PRESS) {
-		button_event = (GdkEventButton *) event;
-		open_in_window = ((button_event->state & GDK_SHIFT_MASK) != 0);
-		open_in_tab = !open_in_window;
-	} else if (event->type == GDK_KEY_PRESS ||
-		   event->type == GDK_KEY_RELEASE) {
-		key_event = (GdkEventKey *) event;
-		open_in_tab = ((key_event->state & GDK_SHIFT_MASK) != 0);
-	}
-
-	if (open_in_tab) {
-		flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB;
-		flags |= NAUTILUS_WINDOW_OPEN_FLAG_DONT_MAKE_ACTIVE;
-	}
-
-	if (open_in_window) {
-		flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW;
-	}
-
-	if (close_behind) {
-		flags |= NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND;
-	}
-
-	DEBUG ("Activate alternate, open in tab %d, close behind %d, new window %d\n",
-	       open_in_tab, close_behind, open_in_window);
-
-	nautilus_files_view_activate_files (NAUTILUS_FILES_VIEW (canvas_view),
-				      file_list, 
-				      flags,
-				      TRUE);
+                                              GList                   *file_list,
+                                              NautilusCanvasView      *canvas_view)
+{
+    GdkEvent *event;
+    GdkEventButton *button_event;
+    GdkEventKey *key_event;
+    gboolean open_in_tab, open_in_window, close_behind;
+    NautilusWindowOpenFlags flags;
+
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
+
+    flags = 0;
+    event = gtk_get_current_event ();
+    open_in_tab = FALSE;
+    open_in_window = FALSE;
+    close_behind = FALSE;
+
+    if (event->type == GDK_BUTTON_PRESS ||
+        event->type == GDK_BUTTON_RELEASE ||
+        event->type == GDK_2BUTTON_PRESS ||
+        event->type == GDK_3BUTTON_PRESS)
+    {
+        button_event = (GdkEventButton *) event;
+        open_in_window = ((button_event->state & GDK_SHIFT_MASK) != 0);
+        open_in_tab = !open_in_window;
+    }
+    else if (event->type == GDK_KEY_PRESS ||
+             event->type == GDK_KEY_RELEASE)
+    {
+        key_event = (GdkEventKey *) event;
+        open_in_tab = ((key_event->state & GDK_SHIFT_MASK) != 0);
+    }
+
+    if (open_in_tab)
+    {
+        flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_TAB;
+        flags |= NAUTILUS_WINDOW_OPEN_FLAG_DONT_MAKE_ACTIVE;
+    }
+
+    if (open_in_window)
+    {
+        flags |= NAUTILUS_WINDOW_OPEN_FLAG_NEW_WINDOW;
+    }
+
+    if (close_behind)
+    {
+        flags |= NAUTILUS_WINDOW_OPEN_FLAG_CLOSE_BEHIND;
+    }
+
+    DEBUG ("Activate alternate, open in tab %d, close behind %d, new window %d\n",
+           open_in_tab, close_behind, open_in_window);
+
+    nautilus_files_view_activate_files (NAUTILUS_FILES_VIEW (canvas_view),
+                                        file_list,
+                                        flags,
+                                        TRUE);
 }
 
 static void
 band_select_started_callback (NautilusCanvasContainer *container,
-			      NautilusCanvasView *canvas_view)
+                              NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
 
-	nautilus_files_view_start_batching_selection_changes (NAUTILUS_FILES_VIEW (canvas_view));
+    nautilus_files_view_start_batching_selection_changes (NAUTILUS_FILES_VIEW (canvas_view));
 }
 
 static void
 band_select_ended_callback (NautilusCanvasContainer *container,
-			    NautilusCanvasView *canvas_view)
+                            NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
 
-	nautilus_files_view_stop_batching_selection_changes (NAUTILUS_FILES_VIEW (canvas_view));
+    nautilus_files_view_stop_batching_selection_changes (NAUTILUS_FILES_VIEW (canvas_view));
 }
 
 int
-nautilus_canvas_view_compare_files (NautilusCanvasView   *canvas_view,
-				  NautilusFile *a,
-				  NautilusFile *b)
+nautilus_canvas_view_compare_files (NautilusCanvasView *canvas_view,
+                                    NautilusFile       *a,
+                                    NautilusFile       *b)
 {
-	return nautilus_file_compare_for_sort
-		(a, b, canvas_view->details->sort->sort_type,
-		 /* Use type-unsafe cast for performance */
-		 nautilus_files_view_should_sort_directories_first ((NautilusFilesView *)canvas_view),
-                 canvas_view->details->sort->reverse_order);
+    return nautilus_file_compare_for_sort
+               (a, b, canvas_view->details->sort->sort_type,
+               /* Use type-unsafe cast for performance */
+               nautilus_files_view_should_sort_directories_first ((NautilusFilesView *) canvas_view),
+               canvas_view->details->sort->reverse_order);
 }
 
 static int
-compare_files (NautilusFilesView   *canvas_view,
-	       NautilusFile *a,
-	       NautilusFile *b)
+compare_files (NautilusFilesView *canvas_view,
+               NautilusFile      *a,
+               NautilusFile      *b)
 {
-	return nautilus_canvas_view_compare_files ((NautilusCanvasView *)canvas_view, a, b);
+    return nautilus_canvas_view_compare_files ((NautilusCanvasView *) canvas_view, a, b);
 }
 
 static void
 selection_changed_callback (NautilusCanvasContainer *container,
-			    NautilusCanvasView *canvas_view)
+                            NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
 
-	nautilus_files_view_notify_selection_changed (NAUTILUS_FILES_VIEW (canvas_view));
+    nautilus_files_view_notify_selection_changed (NAUTILUS_FILES_VIEW (canvas_view));
 }
 
 static void
 canvas_container_context_click_selection_callback (NautilusCanvasContainer *container,
-						 GdkEventButton *event,
-						 NautilusCanvasView *canvas_view)
+                                                   GdkEventButton          *event,
+                                                   NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
 
-	nautilus_files_view_pop_up_selection_context_menu (NAUTILUS_FILES_VIEW (canvas_view), event);
+    nautilus_files_view_pop_up_selection_context_menu (NAUTILUS_FILES_VIEW (canvas_view), event);
 }
 
 static void
 canvas_container_context_click_background_callback (NautilusCanvasContainer *container,
-						  GdkEventButton *event,
-						  NautilusCanvasView *canvas_view)
+                                                    GdkEventButton          *event,
+                                                    NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
 
-	nautilus_files_view_pop_up_background_context_menu (NAUTILUS_FILES_VIEW (canvas_view), event);
+    nautilus_files_view_pop_up_background_context_menu (NAUTILUS_FILES_VIEW (canvas_view), event);
 }
 
 static void
-icon_position_changed_callback (NautilusCanvasContainer *container,
-				NautilusFile *file,
-				const NautilusCanvasPosition *position,
-				NautilusCanvasView *canvas_view)
+icon_position_changed_callback (NautilusCanvasContainer      *container,
+                                NautilusFile                 *file,
+                                const NautilusCanvasPosition *position,
+                                NautilusCanvasView           *canvas_view)
 {
-	char *position_string;
-	char scale_string[G_ASCII_DTOSTR_BUF_SIZE];
+    char *position_string;
+    char scale_string[G_ASCII_DTOSTR_BUF_SIZE];
 
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
-	g_assert (container == get_canvas_container (canvas_view));
-	g_assert (NAUTILUS_IS_FILE (file));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (container == get_canvas_container (canvas_view));
+    g_assert (NAUTILUS_IS_FILE (file));
 
-	/* Store the new position of the canvas in the metadata. */
-	if (!nautilus_canvas_view_using_auto_layout (canvas_view)) {
-		position_string = g_strdup_printf
-			("%d,%d", position->x, position->y);
-		nautilus_file_set_metadata
-			(file, NAUTILUS_METADATA_KEY_ICON_POSITION, 
-			 NULL, position_string);
-		g_free (position_string);
-	}
+    /* Store the new position of the canvas in the metadata. */
+    if (!nautilus_canvas_view_using_auto_layout (canvas_view))
+    {
+        position_string = g_strdup_printf
+                              ("%d,%d", position->x, position->y);
+        nautilus_file_set_metadata
+            (file, NAUTILUS_METADATA_KEY_ICON_POSITION,
+            NULL, position_string);
+        g_free (position_string);
+    }
 
 
-	g_ascii_dtostr (scale_string, sizeof (scale_string), position->scale);
-	nautilus_file_set_metadata
-		(file, NAUTILUS_METADATA_KEY_ICON_SCALE,
-		 "1.0", scale_string);
+    g_ascii_dtostr (scale_string, sizeof (scale_string), position->scale);
+    nautilus_file_set_metadata
+        (file, NAUTILUS_METADATA_KEY_ICON_SCALE,
+        "1.0", scale_string);
 }
 
 static char *
 get_icon_uri_callback (NautilusCanvasContainer *container,
-		       NautilusFile *file,
-		       NautilusCanvasView *canvas_view)
+                       NautilusFile            *file,
+                       NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
-	g_assert (NAUTILUS_IS_FILE (file));
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
+    g_assert (NAUTILUS_IS_FILE (file));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
 
-	return nautilus_file_get_uri (file);
+    return nautilus_file_get_uri (file);
 }
 
 static char *
 get_icon_activation_uri_callback (NautilusCanvasContainer *container,
-				  NautilusFile *file,
-				  NautilusCanvasView *canvas_view)
+                                  NautilusFile            *file,
+                                  NautilusCanvasView      *canvas_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
-	g_assert (NAUTILUS_IS_FILE (file));
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
+    g_assert (NAUTILUS_IS_CANVAS_CONTAINER (container));
+    g_assert (NAUTILUS_IS_FILE (file));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (canvas_view));
 
-	return nautilus_file_get_activation_uri (file);
+    return nautilus_file_get_activation_uri (file);
 }
 
 static char *
 get_icon_drop_target_uri_callback (NautilusCanvasContainer *container,
-		       		   NautilusFile *file,
-		       		   NautilusCanvasView *canvas_view)
+                                   NautilusFile            *file,
+                                   NautilusCanvasView      *canvas_view)
 {
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (container), NULL);
-	g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
-	g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (canvas_view), NULL);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (container), NULL);
+    g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (canvas_view), NULL);
 
-	return nautilus_file_get_target_uri (file);
+    return nautilus_file_get_target_uri (file);
 }
 
 /* Preferences changed callbacks */
 static void
 nautilus_canvas_view_click_policy_changed (NautilusFilesView *directory_view)
 {
-	g_assert (NAUTILUS_IS_CANVAS_VIEW (directory_view));
+    g_assert (NAUTILUS_IS_CANVAS_VIEW (directory_view));
 
-	nautilus_canvas_view_update_click_mode (NAUTILUS_CANVAS_VIEW (directory_view));
+    nautilus_canvas_view_update_click_mode (NAUTILUS_CANVAS_VIEW (directory_view));
 }
 
 static void
 image_display_policy_changed_callback (gpointer callback_data)
 {
-	NautilusCanvasView *canvas_view;
+    NautilusCanvasView *canvas_view;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (callback_data);
+    canvas_view = NAUTILUS_CANVAS_VIEW (callback_data);
 
-	nautilus_canvas_container_request_update_all (get_canvas_container (canvas_view));
+    nautilus_canvas_container_request_update_all (get_canvas_container (canvas_view));
 }
 
 static void
 text_attribute_names_changed_callback (gpointer callback_data)
 {
-	NautilusCanvasView *canvas_view;
+    NautilusCanvasView *canvas_view;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (callback_data);
+    canvas_view = NAUTILUS_CANVAS_VIEW (callback_data);
 
-	nautilus_canvas_container_request_update_all (get_canvas_container (canvas_view));
+    nautilus_canvas_container_request_update_all (get_canvas_container (canvas_view));
 }
 
 static void
 default_sort_order_changed_callback (gpointer callback_data)
 {
-	NautilusCanvasView *canvas_view;
-	NautilusFile *file;
-        const SortCriterion *sort;
-	NautilusCanvasContainer *canvas_container;
+    NautilusCanvasView *canvas_view;
+    NautilusFile *file;
+    const SortCriterion *sort;
+    NautilusCanvasContainer *canvas_container;
 
-	g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (callback_data));
+    g_return_if_fail (NAUTILUS_IS_CANVAS_VIEW (callback_data));
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (callback_data);
+    canvas_view = NAUTILUS_CANVAS_VIEW (callback_data);
 
-	file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
-        sort = nautilus_canvas_view_get_directory_sort_by (canvas_view, file);
-        update_sort_criterion (canvas_view, sort, FALSE);
+    file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
+    sort = nautilus_canvas_view_get_directory_sort_by (canvas_view, file);
+    update_sort_criterion (canvas_view, sort, FALSE);
 
-	canvas_container = get_canvas_container (canvas_view);
-	g_return_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (canvas_container));
+    canvas_container = get_canvas_container (canvas_view);
+    g_return_if_fail (NAUTILUS_IS_CANVAS_CONTAINER (canvas_container));
 
-	nautilus_canvas_container_request_update_all (canvas_container);
+    nautilus_canvas_container_request_update_all (canvas_container);
 }
 
 static void
 nautilus_canvas_view_sort_directories_first_changed (NautilusFilesView *directory_view)
 {
-	NautilusCanvasView *canvas_view;
+    NautilusCanvasView *canvas_view;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (directory_view);
+    canvas_view = NAUTILUS_CANVAS_VIEW (directory_view);
 
-	if (nautilus_canvas_view_using_auto_layout (canvas_view)) {
-		nautilus_canvas_container_sort 
-			(get_canvas_container (canvas_view));
-	}
+    if (nautilus_canvas_view_using_auto_layout (canvas_view))
+    {
+        nautilus_canvas_container_sort
+            (get_canvas_container (canvas_view));
+    }
 }
 
 static gboolean
 canvas_view_can_accept_item (NautilusCanvasContainer *container,
-			   NautilusFile *target_item,
-			   const char *item_uri,
-			   NautilusFilesView *view)
+                             NautilusFile            *target_item,
+                             const char              *item_uri,
+                             NautilusFilesView       *view)
 {
-	return nautilus_drag_can_accept_item (target_item, item_uri);
+    return nautilus_drag_can_accept_item (target_item, item_uri);
 }
 
 static char *
 canvas_view_get_container_uri (NautilusCanvasContainer *container,
-			     NautilusFilesView *view)
+                               NautilusFilesView       *view)
 {
-	return nautilus_files_view_get_uri (view);
+    return nautilus_files_view_get_uri (view);
 }
 
 static void
 canvas_view_move_copy_items (NautilusCanvasContainer *container,
-			   const GList *item_uris,
-			   GArray *relative_item_points,
-			   const char *target_dir,
-			   int copy_action,
-			   int x, int y,
-			   NautilusFilesView *view)
+                             const GList             *item_uris,
+                             GArray                  *relative_item_points,
+                             const char              *target_dir,
+                             int                      copy_action,
+                             int                      x,
+                             int                      y,
+                             NautilusFilesView       *view)
 {
-	nautilus_clipboard_clear_if_colliding_uris (GTK_WIDGET (view),
-						    item_uris,
-						    nautilus_files_view_get_copied_files_atom (view));
-	nautilus_files_view_move_copy_items (view, item_uris, relative_item_points, target_dir,
-				       copy_action, x, y);
+    nautilus_clipboard_clear_if_colliding_uris (GTK_WIDGET (view),
+                                                item_uris,
+                                                nautilus_files_view_get_copied_files_atom (view));
+    nautilus_files_view_move_copy_items (view, item_uris, relative_item_points, target_dir,
+                                         copy_action, x, y);
 }
 
 static void
 nautilus_canvas_view_update_click_mode (NautilusCanvasView *canvas_view)
 {
-	NautilusCanvasContainer	*canvas_container;
-	int			click_mode;
+    NautilusCanvasContainer *canvas_container;
+    int click_mode;
 
-	canvas_container = get_canvas_container (canvas_view);
-	g_assert (canvas_container != NULL);
+    canvas_container = get_canvas_container (canvas_view);
+    g_assert (canvas_container != NULL);
 
-	click_mode = g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_CLICK_POLICY);
+    click_mode = g_settings_get_enum (nautilus_preferences, NAUTILUS_PREFERENCES_CLICK_POLICY);
 
-	nautilus_canvas_container_set_single_click_mode (canvas_container,
-						       click_mode == NAUTILUS_CLICK_POLICY_SINGLE);
+    nautilus_canvas_container_set_single_click_mode (canvas_container,
+                                                     click_mode == NAUTILUS_CLICK_POLICY_SINGLE);
 }
 
 static gboolean
 get_stored_layout_timestamp (NautilusCanvasContainer *container,
-			     NautilusCanvasIconData *icon_data,
-			     time_t *timestamp,
-			     NautilusCanvasView *view)
+                             NautilusCanvasIconData  *icon_data,
+                             time_t                  *timestamp,
+                             NautilusCanvasView      *view)
 {
-	NautilusFile *file;
-	NautilusDirectory *directory;
+    NautilusFile *file;
+    NautilusDirectory *directory;
 
-	if (icon_data == NULL) {
-		directory = nautilus_files_view_get_model (NAUTILUS_FILES_VIEW (view));
-		if (directory == NULL) {
-			return FALSE;
-		}
+    if (icon_data == NULL)
+    {
+        directory = nautilus_files_view_get_model (NAUTILUS_FILES_VIEW (view));
+        if (directory == NULL)
+        {
+            return FALSE;
+        }
 
-		file = nautilus_directory_get_corresponding_file (directory);
-		*timestamp = nautilus_file_get_time_metadata (file,
-							      NAUTILUS_METADATA_KEY_ICON_VIEW_LAYOUT_TIMESTAMP);
-		nautilus_file_unref (file);
-	} else {
-		*timestamp = nautilus_file_get_time_metadata (NAUTILUS_FILE (icon_data),
-							      NAUTILUS_METADATA_KEY_ICON_POSITION_TIMESTAMP);
-	}
+        file = nautilus_directory_get_corresponding_file (directory);
+        *timestamp = nautilus_file_get_time_metadata (file,
+                                                      NAUTILUS_METADATA_KEY_ICON_VIEW_LAYOUT_TIMESTAMP);
+        nautilus_file_unref (file);
+    }
+    else
+    {
+        *timestamp = nautilus_file_get_time_metadata (NAUTILUS_FILE (icon_data),
+                                                      NAUTILUS_METADATA_KEY_ICON_POSITION_TIMESTAMP);
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 static gboolean
 store_layout_timestamp (NautilusCanvasContainer *container,
-			NautilusCanvasIconData *icon_data,
-			const time_t *timestamp,
-			NautilusCanvasView *view)
+                        NautilusCanvasIconData  *icon_data,
+                        const time_t            *timestamp,
+                        NautilusCanvasView      *view)
 {
-	NautilusFile *file;
-	NautilusDirectory *directory;
+    NautilusFile *file;
+    NautilusDirectory *directory;
 
-	if (icon_data == NULL) {
-		directory = nautilus_files_view_get_model (NAUTILUS_FILES_VIEW (view));
-		if (directory == NULL) {
-			return FALSE;
-		}
+    if (icon_data == NULL)
+    {
+        directory = nautilus_files_view_get_model (NAUTILUS_FILES_VIEW (view));
+        if (directory == NULL)
+        {
+            return FALSE;
+        }
 
-		file = nautilus_directory_get_corresponding_file (directory);
-		nautilus_file_set_time_metadata (file,
-						 NAUTILUS_METADATA_KEY_ICON_VIEW_LAYOUT_TIMESTAMP,
-						 (time_t) *timestamp);
-		nautilus_file_unref (file);
-	} else {
-		nautilus_file_set_time_metadata (NAUTILUS_FILE (icon_data),
-						 NAUTILUS_METADATA_KEY_ICON_POSITION_TIMESTAMP,
-						 (time_t) *timestamp);
-	}
+        file = nautilus_directory_get_corresponding_file (directory);
+        nautilus_file_set_time_metadata (file,
+                                         NAUTILUS_METADATA_KEY_ICON_VIEW_LAYOUT_TIMESTAMP,
+                                         (time_t) *timestamp);
+        nautilus_file_unref (file);
+    }
+    else
+    {
+        nautilus_file_set_time_metadata (NAUTILUS_FILE (icon_data),
+                                         NAUTILUS_METADATA_KEY_ICON_POSITION_TIMESTAMP,
+                                         (time_t) *timestamp);
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 static NautilusCanvasContainer *
 create_canvas_container (NautilusCanvasView *canvas_view)
 {
-        return NAUTILUS_CANVAS_VIEW_CLASS (G_OBJECT_GET_CLASS (canvas_view))->create_canvas_container (canvas_view);
+    return NAUTILUS_CANVAS_VIEW_CLASS (G_OBJECT_GET_CLASS (canvas_view))->create_canvas_container (canvas_view);
 }
 
 static NautilusCanvasContainer *
 real_create_canvas_container (NautilusCanvasView *canvas_view)
 {
-        return nautilus_canvas_view_container_new (canvas_view);
+    return nautilus_canvas_view_container_new (canvas_view);
 }
 
 static void
 initialize_canvas_container (NautilusCanvasView      *canvas_view,
                              NautilusCanvasContainer *canvas_container)
 {
-        GtkWidget *content_widget;
-
-        content_widget = nautilus_files_view_get_content_widget (NAUTILUS_FILES_VIEW (canvas_view));
-	canvas_view->details->canvas_container = GTK_WIDGET (canvas_container);
-	g_object_add_weak_pointer (G_OBJECT (canvas_container),
-				   (gpointer *) &canvas_view->details->canvas_container);
-	
-	gtk_widget_set_can_focus (GTK_WIDGET (canvas_container), TRUE);
-	
-	g_signal_connect_object (canvas_container, "activate",	
-				 G_CALLBACK (canvas_container_activate_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "activate-alternate",	
-				 G_CALLBACK (canvas_container_activate_alternate_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "activate-previewer",
-				 G_CALLBACK (canvas_container_activate_previewer_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "band-select-started",
-				 G_CALLBACK (band_select_started_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "band-select-ended",
-				 G_CALLBACK (band_select_ended_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "context-click-selection",
-				 G_CALLBACK (canvas_container_context_click_selection_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "context-click-background",
-				 G_CALLBACK (canvas_container_context_click_background_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "icon-position-changed",
-				 G_CALLBACK (icon_position_changed_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "selection-changed",
-				 G_CALLBACK (selection_changed_callback), canvas_view, 0);
-	/* FIXME: many of these should move into fm-canvas-container as virtual methods */
-	g_signal_connect_object (canvas_container, "get-icon-uri",
-				 G_CALLBACK (get_icon_uri_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "get-icon-activation-uri",
-				 G_CALLBACK (get_icon_activation_uri_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "get-icon-drop-target-uri",
-				 G_CALLBACK (get_icon_drop_target_uri_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "move-copy-items",
-				 G_CALLBACK (canvas_view_move_copy_items), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "get-container-uri",
-				 G_CALLBACK (canvas_view_get_container_uri), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "can-accept-item",
-				 G_CALLBACK (canvas_view_can_accept_item), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "get-stored-icon-position",
-				 G_CALLBACK (get_stored_icon_position_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "layout-changed",
-				 G_CALLBACK (layout_changed_callback), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "icon-stretch-started",
-				 G_CALLBACK (nautilus_files_view_update_context_menus), canvas_view,
-				 G_CONNECT_SWAPPED);
-	g_signal_connect_object (canvas_container, "icon-stretch-ended",
-				 G_CALLBACK (nautilus_files_view_update_context_menus), canvas_view,
-				 G_CONNECT_SWAPPED);
-
-	g_signal_connect_object (canvas_container, "get-stored-layout-timestamp",
-				 G_CALLBACK (get_stored_layout_timestamp), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "store-layout-timestamp",
-				 G_CALLBACK (store_layout_timestamp), canvas_view, 0);
-
-        gtk_container_add (GTK_CONTAINER (content_widget),
-			   GTK_WIDGET (canvas_container));
-
-	nautilus_canvas_view_update_click_mode (canvas_view);
-	nautilus_canvas_container_set_zoom_level (canvas_container,
-						  get_default_zoom_level (canvas_view));
-
-	gtk_widget_show (GTK_WIDGET (canvas_container));
+    GtkWidget *content_widget;
+
+    content_widget = nautilus_files_view_get_content_widget (NAUTILUS_FILES_VIEW (canvas_view));
+    canvas_view->details->canvas_container = GTK_WIDGET (canvas_container);
+    g_object_add_weak_pointer (G_OBJECT (canvas_container),
+                               (gpointer *) &canvas_view->details->canvas_container);
+
+    gtk_widget_set_can_focus (GTK_WIDGET (canvas_container), TRUE);
+
+    g_signal_connect_object (canvas_container, "activate",
+                             G_CALLBACK (canvas_container_activate_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "activate-alternate",
+                             G_CALLBACK (canvas_container_activate_alternate_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "activate-previewer",
+                             G_CALLBACK (canvas_container_activate_previewer_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "band-select-started",
+                             G_CALLBACK (band_select_started_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "band-select-ended",
+                             G_CALLBACK (band_select_ended_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "context-click-selection",
+                             G_CALLBACK (canvas_container_context_click_selection_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "context-click-background",
+                             G_CALLBACK (canvas_container_context_click_background_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "icon-position-changed",
+                             G_CALLBACK (icon_position_changed_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "selection-changed",
+                             G_CALLBACK (selection_changed_callback), canvas_view, 0);
+    /* FIXME: many of these should move into fm-canvas-container as virtual methods */
+    g_signal_connect_object (canvas_container, "get-icon-uri",
+                             G_CALLBACK (get_icon_uri_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "get-icon-activation-uri",
+                             G_CALLBACK (get_icon_activation_uri_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "get-icon-drop-target-uri",
+                             G_CALLBACK (get_icon_drop_target_uri_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "move-copy-items",
+                             G_CALLBACK (canvas_view_move_copy_items), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "get-container-uri",
+                             G_CALLBACK (canvas_view_get_container_uri), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "can-accept-item",
+                             G_CALLBACK (canvas_view_can_accept_item), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "get-stored-icon-position",
+                             G_CALLBACK (get_stored_icon_position_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "layout-changed",
+                             G_CALLBACK (layout_changed_callback), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "icon-stretch-started",
+                             G_CALLBACK (nautilus_files_view_update_context_menus), canvas_view,
+                             G_CONNECT_SWAPPED);
+    g_signal_connect_object (canvas_container, "icon-stretch-ended",
+                             G_CALLBACK (nautilus_files_view_update_context_menus), canvas_view,
+                             G_CONNECT_SWAPPED);
+
+    g_signal_connect_object (canvas_container, "get-stored-layout-timestamp",
+                             G_CALLBACK (get_stored_layout_timestamp), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "store-layout-timestamp",
+                             G_CALLBACK (store_layout_timestamp), canvas_view, 0);
+
+    gtk_container_add (GTK_CONTAINER (content_widget),
+                       GTK_WIDGET (canvas_container));
+
+    nautilus_canvas_view_update_click_mode (canvas_view);
+    nautilus_canvas_container_set_zoom_level (canvas_container,
+                                              get_default_zoom_level (canvas_view));
+
+    gtk_widget_show (GTK_WIDGET (canvas_container));
 }
 
 /* Handles an URL received from Mozilla */
 static void
-canvas_view_handle_netscape_url (NautilusCanvasContainer *container, const char *encoded_url,
-			       const char *target_uri,
-			       GdkDragAction action, int x, int y, NautilusCanvasView *view)
+canvas_view_handle_netscape_url (NautilusCanvasContainer *container,
+                                 const char              *encoded_url,
+                                 const char              *target_uri,
+                                 GdkDragAction            action,
+                                 int                      x,
+                                 int                      y,
+                                 NautilusCanvasView      *view)
 {
-	nautilus_files_view_handle_netscape_url_drop (NAUTILUS_FILES_VIEW (view),
-						encoded_url, target_uri, action, x, y);
+    nautilus_files_view_handle_netscape_url_drop (NAUTILUS_FILES_VIEW (view),
+                                                  encoded_url, target_uri, action, x, y);
 }
 
 static void
-canvas_view_handle_uri_list (NautilusCanvasContainer *container, const char *item_uris,
-			   const char *target_uri,
-			   GdkDragAction action, int x, int y, NautilusCanvasView *view)
+canvas_view_handle_uri_list (NautilusCanvasContainer *container,
+                             const char              *item_uris,
+                             const char              *target_uri,
+                             GdkDragAction            action,
+                             int                      x,
+                             int                      y,
+                             NautilusCanvasView      *view)
 {
-	nautilus_files_view_handle_uri_list_drop (NAUTILUS_FILES_VIEW (view),
-					    item_uris, target_uri, action, x, y);
+    nautilus_files_view_handle_uri_list_drop (NAUTILUS_FILES_VIEW (view),
+                                              item_uris, target_uri, action, x, y);
 }
 
 static void
-canvas_view_handle_text (NautilusCanvasContainer *container, const char *text,
-		       const char *target_uri,
-		       GdkDragAction action, int x, int y, NautilusCanvasView *view)
+canvas_view_handle_text (NautilusCanvasContainer *container,
+                         const char              *text,
+                         const char              *target_uri,
+                         GdkDragAction            action,
+                         int                      x,
+                         int                      y,
+                         NautilusCanvasView      *view)
 {
-	nautilus_files_view_handle_text_drop (NAUTILUS_FILES_VIEW (view),
-					text, target_uri, action, x, y);
+    nautilus_files_view_handle_text_drop (NAUTILUS_FILES_VIEW (view),
+                                          text, target_uri, action, x, y);
 }
 
 static void
-canvas_view_handle_raw (NautilusCanvasContainer *container, const char *raw_data,
-		      int length, const char *target_uri, const char *direct_save_uri,
-		      GdkDragAction action, int x, int y, NautilusCanvasView *view)
+canvas_view_handle_raw (NautilusCanvasContainer *container,
+                        const char              *raw_data,
+                        int                      length,
+                        const char              *target_uri,
+                        const char              *direct_save_uri,
+                        GdkDragAction            action,
+                        int                      x,
+                        int                      y,
+                        NautilusCanvasView      *view)
 {
-	nautilus_files_view_handle_raw_drop (NAUTILUS_FILES_VIEW (view),
-				       raw_data, length, target_uri, direct_save_uri, action, x, y);
+    nautilus_files_view_handle_raw_drop (NAUTILUS_FILES_VIEW (view),
+                                         raw_data, length, target_uri, direct_save_uri, action, x, y);
 }
 
 static void
 canvas_view_handle_hover (NautilusCanvasContainer *container,
-			  const char *target_uri,
-			  NautilusCanvasView *view)
+                          const char              *target_uri,
+                          NautilusCanvasView      *view)
 {
-	nautilus_files_view_handle_hover (NAUTILUS_FILES_VIEW (view), target_uri);
+    nautilus_files_view_handle_hover (NAUTILUS_FILES_VIEW (view), target_uri);
 }
 
 static char *
 canvas_view_get_first_visible_file (NautilusFilesView *view)
 {
-	NautilusFile *file;
-	NautilusCanvasView *canvas_view;
+    NautilusFile *file;
+    NautilusCanvasView *canvas_view;
+
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
+    file = NAUTILUS_FILE (nautilus_canvas_container_get_first_visible_icon (get_canvas_container (canvas_view)));
 
-	file = NAUTILUS_FILE (nautilus_canvas_container_get_first_visible_icon (get_canvas_container (canvas_view)));
+    if (file)
+    {
+        return nautilus_file_get_uri (file);
+    }
 
-	if (file) {
-		return nautilus_file_get_uri (file);
-	}
-	
-	return NULL;
+    return NULL;
 }
 
 static void
 canvas_view_scroll_to_file (NautilusFilesView *view,
-			  const char *uri)
+                            const char        *uri)
 {
-	NautilusFile *file;
-	NautilusCanvasView *canvas_view;
+    NautilusFile *file;
+    NautilusCanvasView *canvas_view;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (view);
-	
-	if (uri != NULL) {
-		/* Only if existing, since we don't want to add the file to
-		   the directory if it has been removed since then */
-		file = nautilus_file_get_existing_by_uri (uri);
-		if (file != NULL) {
-			nautilus_canvas_container_scroll_to_canvas (get_canvas_container (canvas_view),
-								NAUTILUS_CANVAS_ICON_DATA (file));
-			nautilus_file_unref (file);
-		}
-	}
+    canvas_view = NAUTILUS_CANVAS_VIEW (view);
+
+    if (uri != NULL)
+    {
+        /* Only if existing, since we don't want to add the file to
+         *  the directory if it has been removed since then */
+        file = nautilus_file_get_existing_by_uri (uri);
+        if (file != NULL)
+        {
+            nautilus_canvas_container_scroll_to_canvas (get_canvas_container (canvas_view),
+                                                        NAUTILUS_CANVAS_ICON_DATA (file));
+            nautilus_file_unref (file);
+        }
+    }
 }
 
 static guint
 nautilus_canvas_view_get_id (NautilusFilesView *view)
 {
-	return NAUTILUS_VIEW_GRID_ID;
+    return NAUTILUS_VIEW_GRID_ID;
 }
 
 static void
-nautilus_canvas_view_set_property (GObject         *object,
-			   guint            prop_id,
-			   const GValue    *value,
-			   GParamSpec      *pspec)
-{
-	NautilusCanvasView *canvas_view;
-  
-	canvas_view = NAUTILUS_CANVAS_VIEW (object);
-
-	switch (prop_id)  {
-	case PROP_SUPPORTS_AUTO_LAYOUT:
-		canvas_view->details->supports_auto_layout = g_value_get_boolean (value);
-		break;
-	case PROP_SUPPORTS_MANUAL_LAYOUT:
-		canvas_view->details->supports_manual_layout = g_value_get_boolean (value);
-		break;
-	case PROP_SUPPORTS_SCALING:
-		canvas_view->details->supports_scaling = g_value_get_boolean (value);
-		break;
-	case PROP_SUPPORTS_KEEP_ALIGNED:
-		canvas_view->details->supports_keep_aligned = g_value_get_boolean (value);
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
+nautilus_canvas_view_set_property (GObject      *object,
+                                   guint         prop_id,
+                                   const GValue *value,
+                                   GParamSpec   *pspec)
+{
+    NautilusCanvasView *canvas_view;
+
+    canvas_view = NAUTILUS_CANVAS_VIEW (object);
+
+    switch (prop_id)
+    {
+        case PROP_SUPPORTS_AUTO_LAYOUT:
+            {
+                canvas_view->details->supports_auto_layout = g_value_get_boolean (value);
+            }
+            break;
+
+        case PROP_SUPPORTS_MANUAL_LAYOUT:
+            {
+                canvas_view->details->supports_manual_layout = g_value_get_boolean (value);
+            }
+            break;
+
+        case PROP_SUPPORTS_SCALING:
+            {
+                canvas_view->details->supports_scaling = g_value_get_boolean (value);
+            }
+            break;
+
+        case PROP_SUPPORTS_KEEP_ALIGNED:
+            {
+                canvas_view->details->supports_keep_aligned = g_value_get_boolean (value);
+            }
+            break;
+
+        default:
+            {
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            }
+            break;
+    }
 }
 
 static void
 nautilus_canvas_view_finalize (GObject *object)
 {
-	NautilusCanvasView *canvas_view;
+    NautilusCanvasView *canvas_view;
 
-	canvas_view = NAUTILUS_CANVAS_VIEW (object);
+    canvas_view = NAUTILUS_CANVAS_VIEW (object);
 
-        g_clear_object (&canvas_view->details->icon);
+    g_clear_object (&canvas_view->details->icon);
 
-	g_free (canvas_view->details);
+    g_free (canvas_view->details);
 
-	g_signal_handlers_disconnect_by_func (nautilus_preferences,
-					      default_sort_order_changed_callback,
-					      canvas_view);
-	g_signal_handlers_disconnect_by_func (nautilus_preferences,
-					      image_display_policy_changed_callback,
-					      canvas_view);
+    g_signal_handlers_disconnect_by_func (nautilus_preferences,
+                                          default_sort_order_changed_callback,
+                                          canvas_view);
+    g_signal_handlers_disconnect_by_func (nautilus_preferences,
+                                          image_display_policy_changed_callback,
+                                          canvas_view);
 
-	g_signal_handlers_disconnect_by_func (nautilus_icon_view_preferences,
-					      text_attribute_names_changed_callback,
-					      canvas_view);
+    g_signal_handlers_disconnect_by_func (nautilus_icon_view_preferences,
+                                          text_attribute_names_changed_callback,
+                                          canvas_view);
 
-	G_OBJECT_CLASS (nautilus_canvas_view_parent_class)->finalize (object);
+    G_OBJECT_CLASS (nautilus_canvas_view_parent_class)->finalize (object);
 }
 
-static GIcon*
+static GIcon *
 nautilus_canvas_view_get_icon (NautilusFilesView *view)
 {
-        g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL);
+    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), NULL);
 
-        return NAUTILUS_CANVAS_VIEW (view)->details->icon;
+    return NAUTILUS_CANVAS_VIEW (view)->details->icon;
 }
 
 static void
 nautilus_canvas_view_class_init (NautilusCanvasViewClass *klass)
 {
-	NautilusFilesViewClass *nautilus_files_view_class;
-	GObjectClass *oclass;
-
-	nautilus_files_view_class = NAUTILUS_FILES_VIEW_CLASS (klass);
-	oclass = G_OBJECT_CLASS (klass);
-
-	oclass->set_property = nautilus_canvas_view_set_property;
-	oclass->finalize = nautilus_canvas_view_finalize;
-
-	GTK_WIDGET_CLASS (klass)->destroy = nautilus_canvas_view_destroy;
-
-        klass->create_canvas_container = real_create_canvas_container;
-	
-	nautilus_files_view_class->add_file = nautilus_canvas_view_add_file;
-	nautilus_files_view_class->begin_loading = nautilus_canvas_view_begin_loading;
-	nautilus_files_view_class->bump_zoom_level = nautilus_canvas_view_bump_zoom_level;
-	nautilus_files_view_class->can_zoom_in = nautilus_canvas_view_can_zoom_in;
-	nautilus_files_view_class->can_zoom_out = nautilus_canvas_view_can_zoom_out;
-        nautilus_files_view_class->get_zoom_level_percentage = nautilus_canvas_view_get_zoom_level_percentage;
-	nautilus_files_view_class->clear = nautilus_canvas_view_clear;
-	nautilus_files_view_class->end_loading = nautilus_canvas_view_end_loading;
-	nautilus_files_view_class->file_changed = nautilus_canvas_view_file_changed;
-	nautilus_files_view_class->compute_rename_popover_pointing_to = nautilus_canvas_view_compute_rename_popover_pointing_to;
-	nautilus_files_view_class->get_selection = nautilus_canvas_view_get_selection;
-	nautilus_files_view_class->get_selection_for_file_transfer = nautilus_canvas_view_get_selection;
-	nautilus_files_view_class->is_empty = nautilus_canvas_view_is_empty;
-	nautilus_files_view_class->remove_file = nautilus_canvas_view_remove_file;
-        nautilus_files_view_class->restore_standard_zoom_level = nautilus_canvas_view_restore_standard_zoom_level;
-	nautilus_files_view_class->reveal_selection = nautilus_canvas_view_reveal_selection;
-	nautilus_files_view_class->select_all = nautilus_canvas_view_select_all;
-	nautilus_files_view_class->select_first = nautilus_canvas_view_select_first;
-	nautilus_files_view_class->set_selection = nautilus_canvas_view_set_selection;
-	nautilus_files_view_class->invert_selection = nautilus_canvas_view_invert_selection;
-	nautilus_files_view_class->compare_files = compare_files;
-        nautilus_files_view_class->click_policy_changed = nautilus_canvas_view_click_policy_changed;
-	nautilus_files_view_class->update_actions_state = nautilus_canvas_view_update_actions_state;
-        nautilus_files_view_class->sort_directories_first_changed = nautilus_canvas_view_sort_directories_first_changed;
-	nautilus_files_view_class->using_manual_layout = nautilus_canvas_view_using_manual_layout;
-	nautilus_files_view_class->widget_to_file_operation_position = nautilus_canvas_view_widget_to_file_operation_position;
-	nautilus_files_view_class->get_view_id = nautilus_canvas_view_get_id;
-	nautilus_files_view_class->get_first_visible_file = canvas_view_get_first_visible_file;
-	nautilus_files_view_class->scroll_to_file = canvas_view_scroll_to_file;
-        nautilus_files_view_class->get_icon = nautilus_canvas_view_get_icon;
-
-	properties[PROP_SUPPORTS_AUTO_LAYOUT] =
-		g_param_spec_boolean ("supports-auto-layout",
-				      "Supports auto layout",
-				      "Whether this view supports auto layout",
-				      TRUE,
-				      G_PARAM_WRITABLE |
-				      G_PARAM_CONSTRUCT_ONLY);
-	properties[PROP_SUPPORTS_MANUAL_LAYOUT] =
-		g_param_spec_boolean ("supports-manual-layout",
-				      "Supports manual layout",
-				      "Whether this view supports manual layout",
-				      FALSE,
-				      G_PARAM_WRITABLE |
-				      G_PARAM_CONSTRUCT_ONLY);
-	properties[PROP_SUPPORTS_SCALING] =
-		g_param_spec_boolean ("supports-scaling",
-				      "Supports scaling",
-				      "Whether this view supports scaling",
-				      FALSE,
-				      G_PARAM_WRITABLE |
-				      G_PARAM_CONSTRUCT_ONLY);
-	properties[PROP_SUPPORTS_KEEP_ALIGNED] =
-		g_param_spec_boolean ("supports-keep-aligned",
-				      "Supports keep aligned",
-				      "Whether this view supports keep aligned",
-				      FALSE,
-				      G_PARAM_WRITABLE |
-				      G_PARAM_CONSTRUCT_ONLY);
-
-	g_object_class_install_properties (oclass, NUM_PROPERTIES, properties);
+    NautilusFilesViewClass *nautilus_files_view_class;
+    GObjectClass *oclass;
+
+    nautilus_files_view_class = NAUTILUS_FILES_VIEW_CLASS (klass);
+    oclass = G_OBJECT_CLASS (klass);
+
+    oclass->set_property = nautilus_canvas_view_set_property;
+    oclass->finalize = nautilus_canvas_view_finalize;
+
+    GTK_WIDGET_CLASS (klass)->destroy = nautilus_canvas_view_destroy;
+
+    klass->create_canvas_container = real_create_canvas_container;
+
+    nautilus_files_view_class->add_file = nautilus_canvas_view_add_file;
+    nautilus_files_view_class->begin_loading = nautilus_canvas_view_begin_loading;
+    nautilus_files_view_class->bump_zoom_level = nautilus_canvas_view_bump_zoom_level;
+    nautilus_files_view_class->can_zoom_in = nautilus_canvas_view_can_zoom_in;
+    nautilus_files_view_class->can_zoom_out = nautilus_canvas_view_can_zoom_out;
+    nautilus_files_view_class->get_zoom_level_percentage = nautilus_canvas_view_get_zoom_level_percentage;
+    nautilus_files_view_class->clear = nautilus_canvas_view_clear;
+    nautilus_files_view_class->end_loading = nautilus_canvas_view_end_loading;
+    nautilus_files_view_class->file_changed = nautilus_canvas_view_file_changed;
+    nautilus_files_view_class->compute_rename_popover_pointing_to = nautilus_canvas_view_compute_rename_popover_pointing_to;
+    nautilus_files_view_class->get_selection = nautilus_canvas_view_get_selection;
+    nautilus_files_view_class->get_selection_for_file_transfer = nautilus_canvas_view_get_selection;
+    nautilus_files_view_class->is_empty = nautilus_canvas_view_is_empty;
+    nautilus_files_view_class->remove_file = nautilus_canvas_view_remove_file;
+    nautilus_files_view_class->restore_standard_zoom_level = nautilus_canvas_view_restore_standard_zoom_level;
+    nautilus_files_view_class->reveal_selection = nautilus_canvas_view_reveal_selection;
+    nautilus_files_view_class->select_all = nautilus_canvas_view_select_all;
+    nautilus_files_view_class->select_first = nautilus_canvas_view_select_first;
+    nautilus_files_view_class->set_selection = nautilus_canvas_view_set_selection;
+    nautilus_files_view_class->invert_selection = nautilus_canvas_view_invert_selection;
+    nautilus_files_view_class->compare_files = compare_files;
+    nautilus_files_view_class->click_policy_changed = nautilus_canvas_view_click_policy_changed;
+    nautilus_files_view_class->update_actions_state = nautilus_canvas_view_update_actions_state;
+    nautilus_files_view_class->sort_directories_first_changed = nautilus_canvas_view_sort_directories_first_changed;
+    nautilus_files_view_class->using_manual_layout = nautilus_canvas_view_using_manual_layout;
+    nautilus_files_view_class->widget_to_file_operation_position = nautilus_canvas_view_widget_to_file_operation_position;
+    nautilus_files_view_class->get_view_id = nautilus_canvas_view_get_id;
+    nautilus_files_view_class->get_first_visible_file = canvas_view_get_first_visible_file;
+    nautilus_files_view_class->scroll_to_file = canvas_view_scroll_to_file;
+    nautilus_files_view_class->get_icon = nautilus_canvas_view_get_icon;
+
+    properties[PROP_SUPPORTS_AUTO_LAYOUT] =
+        g_param_spec_boolean ("supports-auto-layout",
+                              "Supports auto layout",
+                              "Whether this view supports auto layout",
+                              TRUE,
+                              G_PARAM_WRITABLE |
+                              G_PARAM_CONSTRUCT_ONLY);
+    properties[PROP_SUPPORTS_MANUAL_LAYOUT] =
+        g_param_spec_boolean ("supports-manual-layout",
+                              "Supports manual layout",
+                              "Whether this view supports manual layout",
+                              FALSE,
+                              G_PARAM_WRITABLE |
+                              G_PARAM_CONSTRUCT_ONLY);
+    properties[PROP_SUPPORTS_SCALING] =
+        g_param_spec_boolean ("supports-scaling",
+                              "Supports scaling",
+                              "Whether this view supports scaling",
+                              FALSE,
+                              G_PARAM_WRITABLE |
+                              G_PARAM_CONSTRUCT_ONLY);
+    properties[PROP_SUPPORTS_KEEP_ALIGNED] =
+        g_param_spec_boolean ("supports-keep-aligned",
+                              "Supports keep aligned",
+                              "Whether this view supports keep aligned",
+                              FALSE,
+                              G_PARAM_WRITABLE |
+                              G_PARAM_CONSTRUCT_ONLY);
+
+    g_object_class_install_properties (oclass, NUM_PROPERTIES, properties);
 }
 
 static void
 nautilus_canvas_view_init (NautilusCanvasView *canvas_view)
 {
-	NautilusCanvasContainer *canvas_container;
-  	GActionGroup *view_action_group;
-
-	canvas_view->details = g_new0 (NautilusCanvasViewDetails, 1);
-	canvas_view->details->sort = &sort_criteria[0];
-        canvas_view->details->icon = g_themed_icon_new ("view-grid-symbolic");
-
-	canvas_container = create_canvas_container (canvas_view);
-        initialize_canvas_container (canvas_view, canvas_container);
-
-	g_signal_connect_swapped (nautilus_preferences,
-				  "changed::" NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER,
-				  G_CALLBACK (default_sort_order_changed_callback),
-				  canvas_view);
-	g_signal_connect_swapped (nautilus_preferences,
-				  "changed::" NAUTILUS_PREFERENCES_DEFAULT_SORT_IN_REVERSE_ORDER,
-				  G_CALLBACK (default_sort_order_changed_callback),
-				  canvas_view);
-	g_signal_connect_swapped (nautilus_preferences,
-				  "changed::" NAUTILUS_PREFERENCES_SHOW_FILE_THUMBNAILS,
-				  G_CALLBACK (image_display_policy_changed_callback),
-				  canvas_view);
-
-	g_signal_connect_swapped (nautilus_icon_view_preferences,
-				  "changed::" NAUTILUS_PREFERENCES_ICON_VIEW_CAPTIONS,
-				  G_CALLBACK (text_attribute_names_changed_callback),
-				  canvas_view);
-
-	g_signal_connect_object (canvas_container, "handle-netscape-url",
-				 G_CALLBACK (canvas_view_handle_netscape_url), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "handle-uri-list",
-				 G_CALLBACK (canvas_view_handle_uri_list), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "handle-text",
-				 G_CALLBACK (canvas_view_handle_text), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "handle-raw",
-				 G_CALLBACK (canvas_view_handle_raw), canvas_view, 0);
-	g_signal_connect_object (canvas_container, "handle-hover",
-				 G_CALLBACK (canvas_view_handle_hover), canvas_view, 0);
-
-	canvas_view->details->clipboard_handler_id =
-		g_signal_connect (nautilus_clipboard_monitor_get (),
-		                  "clipboard-info",
-		                  G_CALLBACK (canvas_view_notify_clipboard_info), canvas_view);
-
-	view_action_group = nautilus_files_view_get_action_group (NAUTILUS_FILES_VIEW (canvas_view));
-	g_action_map_add_action_entries (G_ACTION_MAP (view_action_group),
-					 canvas_view_entries,
-					 G_N_ELEMENTS (canvas_view_entries),
-					 canvas_view);
-	/* Keep the action synced with the actual value, so the toolbar can poll it */
-	g_action_group_change_action_state (nautilus_files_view_get_action_group (NAUTILUS_FILES_VIEW (canvas_view)),
-					    "zoom-to-level", g_variant_new_int32 (get_default_zoom_level (canvas_view)));
+    NautilusCanvasContainer *canvas_container;
+    GActionGroup *view_action_group;
+
+    canvas_view->details = g_new0 (NautilusCanvasViewDetails, 1);
+    canvas_view->details->sort = &sort_criteria[0];
+    canvas_view->details->icon = g_themed_icon_new ("view-grid-symbolic");
+
+    canvas_container = create_canvas_container (canvas_view);
+    initialize_canvas_container (canvas_view, canvas_container);
+
+    g_signal_connect_swapped (nautilus_preferences,
+                              "changed::" NAUTILUS_PREFERENCES_DEFAULT_SORT_ORDER,
+                              G_CALLBACK (default_sort_order_changed_callback),
+                              canvas_view);
+    g_signal_connect_swapped (nautilus_preferences,
+                              "changed::" NAUTILUS_PREFERENCES_DEFAULT_SORT_IN_REVERSE_ORDER,
+                              G_CALLBACK (default_sort_order_changed_callback),
+                              canvas_view);
+    g_signal_connect_swapped (nautilus_preferences,
+                              "changed::" NAUTILUS_PREFERENCES_SHOW_FILE_THUMBNAILS,
+                              G_CALLBACK (image_display_policy_changed_callback),
+                              canvas_view);
+
+    g_signal_connect_swapped (nautilus_icon_view_preferences,
+                              "changed::" NAUTILUS_PREFERENCES_ICON_VIEW_CAPTIONS,
+                              G_CALLBACK (text_attribute_names_changed_callback),
+                              canvas_view);
+
+    g_signal_connect_object (canvas_container, "handle-netscape-url",
+                             G_CALLBACK (canvas_view_handle_netscape_url), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "handle-uri-list",
+                             G_CALLBACK (canvas_view_handle_uri_list), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "handle-text",
+                             G_CALLBACK (canvas_view_handle_text), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "handle-raw",
+                             G_CALLBACK (canvas_view_handle_raw), canvas_view, 0);
+    g_signal_connect_object (canvas_container, "handle-hover",
+                             G_CALLBACK (canvas_view_handle_hover), canvas_view, 0);
+
+    canvas_view->details->clipboard_handler_id =
+        g_signal_connect (nautilus_clipboard_monitor_get (),
+                          "clipboard-info",
+                          G_CALLBACK (canvas_view_notify_clipboard_info), canvas_view);
+
+    view_action_group = nautilus_files_view_get_action_group (NAUTILUS_FILES_VIEW (canvas_view));
+    g_action_map_add_action_entries (G_ACTION_MAP (view_action_group),
+                                     canvas_view_entries,
+                                     G_N_ELEMENTS (canvas_view_entries),
+                                     canvas_view);
+    /* Keep the action synced with the actual value, so the toolbar can poll it */
+    g_action_group_change_action_state (nautilus_files_view_get_action_group (NAUTILUS_FILES_VIEW (canvas_view)),
+                                        "zoom-to-level", g_variant_new_int32 (get_default_zoom_level (canvas_view)));
 }
 
 NautilusFilesView *
 nautilus_canvas_view_new (NautilusWindowSlot *slot)
 {
-	return g_object_new (NAUTILUS_TYPE_CANVAS_VIEW,
-			     "window-slot", slot,
-			     NULL);
+    return g_object_new (NAUTILUS_TYPE_CANVAS_VIEW,
+                         "window-slot", slot,
+                         NULL);
 }