general: remove desktop support

1 files changed, 59 insertions, 627 deletions

diff --git a/src/nautilus-canvas-view.c b/src/nautilus-canvas-view.c
index 5b2683b44..71187cfc3 100644
--- a/src/nautilus-canvas-view.c
+++ b/src/nautilus-canvas-view.c
@@ -56,17 +56,6 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
-enum
-{
-    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 struct
@@ -86,8 +75,10 @@ typedef enum
     MENU_ITEM_TYPE_TREE
 } MenuItemType;
 
-typedef struct
+struct _NautilusCanvasView
 {
+    NautilusFilesView parent_instance;
+
     GList *icons_not_positioned;
 
     guint react_to_canvas_change_idle_id;
@@ -96,18 +87,13 @@ typedef struct
 
     GtkWidget *canvas_container;
 
-    gboolean supports_auto_layout;
-    gboolean supports_manual_layout;
-    gboolean supports_scaling;
-    gboolean supports_keep_aligned;
-
     /* FIXME: Needed for async operations. Suposedly we would use cancellable and gtask,
      * sadly gtkclipboard doesn't support that.
      * We follow this pattern for checking validity of the object in the views.
      * Ideally we would connect to a weak reference and do a cancellable.
      */
     gboolean destroyed;
-} NautilusCanvasViewPrivate;
+};
 
 /* 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
@@ -186,19 +172,17 @@ static const SortCriterion sort_criteria[] =
     }
 };
 
-G_DEFINE_TYPE_WITH_PRIVATE (NautilusCanvasView, nautilus_canvas_view, NAUTILUS_TYPE_FILES_VIEW);
+G_DEFINE_TYPE (NautilusCanvasView, nautilus_canvas_view, NAUTILUS_TYPE_FILES_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);
 static void on_clipboard_owner_changed (GtkClipboard *clipboard,
@@ -209,18 +193,16 @@ static void
 nautilus_canvas_view_destroy (GtkWidget *object)
 {
     NautilusCanvasView *canvas_view;
-    NautilusCanvasViewPrivate *priv;
     GtkClipboard *clipboard;
 
     canvas_view = NAUTILUS_CANVAS_VIEW (object);
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
 
     nautilus_canvas_view_clear (NAUTILUS_FILES_VIEW (object));
 
-    if (priv->react_to_canvas_change_idle_id != 0)
+    if (canvas_view->react_to_canvas_change_idle_id != 0)
     {
-        g_source_remove (priv->react_to_canvas_change_idle_id);
-        priv->react_to_canvas_change_idle_id = 0;
+        g_source_remove (canvas_view->react_to_canvas_change_idle_id);
+        canvas_view->react_to_canvas_change_idle_id = 0;
     }
 
     clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
@@ -228,10 +210,10 @@ nautilus_canvas_view_destroy (GtkWidget *object)
                                           on_clipboard_owner_changed,
                                           canvas_view);
 
-    if (priv->icons_not_positioned)
+    if (canvas_view->icons_not_positioned)
     {
-        nautilus_file_list_free (priv->icons_not_positioned);
-        priv->icons_not_positioned = NULL;
+        nautilus_file_list_free (canvas_view->icons_not_positioned);
+        canvas_view->icons_not_positioned = NULL;
     }
 
     GTK_WIDGET_CLASS (nautilus_canvas_view_parent_class)->destroy (object);
@@ -240,11 +222,7 @@ nautilus_canvas_view_destroy (GtkWidget *object)
 static NautilusCanvasContainer *
 get_canvas_container (NautilusCanvasView *canvas_view)
 {
-    NautilusCanvasViewPrivate *priv;
-
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
-
-    return NAUTILUS_CANVAS_CONTAINER (priv->canvas_container);
+    return NAUTILUS_CANVAS_CONTAINER (canvas_view->canvas_container);
 }
 
 NautilusCanvasContainer *
@@ -253,81 +231,15 @@ nautilus_canvas_view_get_canvas_container (NautilusCanvasView *canvas_view)
     return get_canvas_container (canvas_view);
 }
 
-static gboolean
-nautilus_canvas_view_supports_manual_layout (NautilusCanvasView *view)
-{
-    NautilusCanvasViewPrivate *priv;
-
-    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
-
-    priv = nautilus_canvas_view_get_instance_private (view);
-
-    return priv->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;
-}
-
 static void
 update_sort_criterion (NautilusCanvasView  *canvas_view,
                        const SortCriterion *sort,
                        gboolean             set_metadata)
 {
     NautilusFile *file;
-    NautilusCanvasViewPrivate *priv;
     const SortCriterion *overrided_sort_criterion;
 
     file = nautilus_files_view_get_directory_as_file (NAUTILUS_FILES_VIEW (canvas_view));
-    priv = nautilus_canvas_view_get_instance_private (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
@@ -336,7 +248,7 @@ update_sort_criterion (NautilusCanvasView  *canvas_view,
     {
         overrided_sort_criterion = get_default_sort_order (file);
     }
-    else if (sort != NULL && priv->sort != sort)
+    else if (sort != NULL && canvas_view->sort != sort)
     {
         overrided_sort_criterion = sort;
         if (set_metadata)
@@ -352,27 +264,7 @@ update_sort_criterion (NautilusCanvasView  *canvas_view,
         return;
     }
 
-    priv->sort = overrided_sort_criterion;
-}
-
-void
-nautilus_canvas_view_clean_up_by_name (NautilusCanvasView *canvas_view)
-{
-    NautilusCanvasContainer *canvas_container;
-
-    canvas_container = get_canvas_container (canvas_view);
-
-    update_sort_criterion (canvas_view, &sort_criteria[0], FALSE);
-
-    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));
+    canvas_view->sort = overrided_sort_criterion;
 }
 
 static void
@@ -497,42 +389,6 @@ nautilus_canvas_view_file_changed (NautilusFilesView *view,
         NAUTILUS_CANVAS_ICON_DATA (file));
 }
 
-static gboolean
-nautilus_canvas_view_supports_auto_layout (NautilusCanvasView *view)
-{
-    NautilusCanvasViewPrivate *priv;
-
-    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
-
-    priv = nautilus_canvas_view_get_instance_private (view);
-
-    return priv->supports_auto_layout;
-}
-
-static gboolean
-nautilus_canvas_view_supports_scaling (NautilusCanvasView *view)
-{
-    NautilusCanvasViewPrivate *priv;
-
-    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
-
-    priv = nautilus_canvas_view_get_instance_private (view);
-
-    return priv->supports_scaling;
-}
-
-static gboolean
-nautilus_canvas_view_supports_keep_aligned (NautilusCanvasView *view)
-{
-    NautilusCanvasViewPrivate *priv;
-
-    g_return_val_if_fail (NAUTILUS_IS_CANVAS_VIEW (view), FALSE);
-
-    priv = nautilus_canvas_view_get_instance_private (view);
-
-    return priv->supports_keep_aligned;
-}
-
 static const SortCriterion *
 nautilus_canvas_view_get_directory_sort_by (NautilusCanvasView *canvas_view,
                                             NautilusFile       *file)
@@ -541,11 +397,6 @@ nautilus_canvas_view_get_directory_sort_by (NautilusCanvasView *canvas_view,
     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);
-    }
-
     default_sort = get_default_sort_order (file);
     g_return_val_if_fail (default_sort != NULL, NULL);
 
@@ -592,11 +443,6 @@ nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView  *canvas_view,
 {
     const SortCriterion *default_sort_criterion;
 
-    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);
 
@@ -610,78 +456,6 @@ nautilus_canvas_view_set_directory_sort_by (NautilusCanvasView  *canvas_view,
                                         sort->reverse_order);
 }
 
-static gboolean
-get_default_directory_keep_aligned (void)
-{
-    return TRUE;
-}
-
-static gboolean
-nautilus_canvas_view_get_directory_keep_aligned (NautilusCanvasView *canvas_view,
-                                                 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 ());
-}
-
-static void
-nautilus_canvas_view_set_directory_keep_aligned (NautilusCanvasView *canvas_view,
-                                                 NautilusFile       *file,
-                                                 gboolean            keep_aligned)
-{
-    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);
-}
-
-static gboolean
-nautilus_canvas_view_get_directory_auto_layout (NautilusCanvasView *canvas_view,
-                                                NautilusFile       *file)
-{
-    if (!nautilus_canvas_view_supports_auto_layout (canvas_view))
-    {
-        return FALSE;
-    }
-
-    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);
-}
-
-static void
-nautilus_canvas_view_set_directory_auto_layout (NautilusCanvasView *canvas_view,
-                                                NautilusFile       *file,
-                                                gboolean            auto_layout)
-{
-    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);
-}
-
 static const SortCriterion *
 get_sort_criterion_by_metadata_text (const char *metadata_text,
                                      gboolean    reversed)
@@ -761,8 +535,6 @@ nautilus_canvas_view_begin_loading (NautilusFilesView *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));
-
     g_free (uri);
 
     /* Set the sort mode.
@@ -772,18 +544,6 @@ nautilus_canvas_view_begin_loading (NautilusFilesView *view)
     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));
-
-    /* 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);
@@ -795,15 +555,14 @@ on_clipboard_contents_received (GtkClipboard     *clipboard,
                                 GtkSelectionData *selection_data,
                                 gpointer          user_data)
 {
-    NautilusCanvasViewPrivate *priv;
-    NautilusCanvasView *view = NAUTILUS_CANVAS_VIEW (user_data);
+    NautilusCanvasView *canvas_view;
 
-    priv = nautilus_canvas_view_get_instance_private (view);
+    canvas_view = NAUTILUS_CANVAS_VIEW (user_data);
 
-    if (priv->destroyed)
+    if (canvas_view->destroyed)
     {
         /* We've been destroyed since call */
-        g_object_unref (view);
+        g_object_unref (canvas_view);
         return;
     }
 
@@ -814,7 +573,7 @@ on_clipboard_contents_received (GtkClipboard     *clipboard,
 
         uris = nautilus_clipboard_get_uri_list_from_selection_data (selection_data);
         files = nautilus_file_list_from_uri_list (uris);
-        nautilus_canvas_container_set_highlighted_for_clipboard (get_canvas_container (view),
+        nautilus_canvas_container_set_highlighted_for_clipboard (get_canvas_container (canvas_view),
                                                                  files);
 
         nautilus_file_list_free (files);
@@ -822,11 +581,11 @@ on_clipboard_contents_received (GtkClipboard     *clipboard,
     }
     else
     {
-        nautilus_canvas_container_set_highlighted_for_clipboard (get_canvas_container (view),
+        nautilus_canvas_container_set_highlighted_for_clipboard (get_canvas_container (canvas_view),
                                                                  NULL);
     }
 
-    g_object_unref (view);
+    g_object_unref (canvas_view);
 }
 
 static void
@@ -854,8 +613,6 @@ nautilus_canvas_view_end_loading (NautilusFilesView *view,
     NautilusCanvasView *canvas_view;
 
     canvas_view = NAUTILUS_CANVAS_VIEW (view);
-    nautilus_canvas_container_end_loading (nautilus_canvas_view_get_canvas_container (canvas_view),
-                                           all_files_seen);
     update_clipboard_status (canvas_view);
 }
 
@@ -984,28 +741,6 @@ nautilus_canvas_view_get_selection (NautilusFilesView *view)
 }
 
 static void
-action_keep_aligned (GSimpleAction *action,
-                     GVariant      *state,
-                     gpointer       user_data)
-{
-    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);
-
-    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);
-}
-
-static void
 action_sort_order_changed (GSimpleAction *action,
                            GVariant      *value,
                            gpointer       user_data)
@@ -1019,20 +754,11 @@ action_sort_order_changed (GSimpleAction *action,
     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);
 
-        nautilus_canvas_container_sort (get_canvas_container (user_data));
-        nautilus_canvas_view_reveal_selection (NAUTILUS_FILES_VIEW (user_data));
-    }
+    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));
 
     g_simple_action_set_state (action, value);
 }
@@ -1061,48 +787,8 @@ action_zoom_to_level (GSimpleAction *action,
     }
 }
 
-static void
-switch_to_manual_layout (NautilusCanvasView *canvas_view)
-{
-    NautilusCanvasViewPrivate *priv;
-
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
-
-    if (!nautilus_canvas_view_using_auto_layout (canvas_view) ||
-        !nautilus_files_view_is_editable (NAUTILUS_FILES_VIEW (canvas_view)))
-    {
-        return;
-    }
-
-    priv->sort = &sort_criteria[0];
-
-    nautilus_canvas_container_set_auto_layout
-        (get_canvas_container (canvas_view), FALSE);
-}
-
-static void
-layout_changed_callback (NautilusCanvasContainer *container,
-                         NautilusCanvasView      *canvas_view)
-{
-    NautilusFile *file;
-
-    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));
-
-    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 }
 };
@@ -1168,56 +854,42 @@ static void
 nautilus_canvas_view_update_actions_state (NautilusFilesView *view)
 {
     GActionGroup *view_action_group;
+    GVariant *sort_state;
     GAction *action;
-    gboolean keep_aligned;
     NautilusCanvasView *canvas_view;
-    NautilusCanvasViewPrivate *priv;
 
     canvas_view = NAUTILUS_CANVAS_VIEW (view);
-    priv = nautilus_canvas_view_get_instance_private (canvas_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),
-                       priv->sort->action_target_name) != 0)
-        {
-            g_action_group_change_action_state (view_action_group,
-                                                "sort",
-                                                g_variant_new_string (priv->sort->action_target_name));
-        }
 
-        g_variant_unref (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),
+                   canvas_view->sort->action_target_name) != 0)
+    {
+        g_action_group_change_action_state (view_action_group,
+                                            "sort",
+                                            g_variant_new_string (canvas_view->sort->action_target_name));
     }
 
     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),
-                                 priv->supports_keep_aligned);
-    if (priv->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);
+
+    g_variant_unref (sort_state);
 }
 
 static void
@@ -1308,14 +980,6 @@ nautilus_canvas_view_invert_selection (NautilusFilesView *view)
         (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);
-
-    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)
@@ -1445,15 +1109,11 @@ nautilus_canvas_view_compare_files (NautilusCanvasView *canvas_view,
                                     NautilusFile       *a,
                                     NautilusFile       *b)
 {
-    NautilusCanvasViewPrivate *priv;
-
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
-
     return nautilus_file_compare_for_sort
-               (a, b, priv->sort->sort_type,
+               (a, b, canvas_view->sort->sort_type,
                /* Use type-unsafe cast for performance */
                nautilus_files_view_should_sort_directories_first ((NautilusFilesView *) canvas_view),
-               priv->sort->reverse_order);
+               canvas_view->sort->reverse_order);
 }
 
 static int
@@ -1496,37 +1156,6 @@ canvas_container_context_click_background_callback (NautilusCanvasContainer *con
     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)
-{
-    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));
-
-    /* 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);
-}
-
 static char *
 get_icon_uri_callback (NautilusCanvasContainer *container,
                        NautilusFile            *file,
@@ -1621,11 +1250,7 @@ nautilus_canvas_view_sort_directories_first_changed (NautilusFilesView *director
 
     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));
-    }
+    nautilus_canvas_container_sort (get_canvas_container (canvas_view));
 }
 
 static gboolean
@@ -1647,17 +1272,14 @@ canvas_view_get_container_uri (NautilusCanvasContainer *container,
 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)
 {
     nautilus_clipboard_clear_if_colliding_uris (GTK_WIDGET (view),
                                                 item_uris);
-    nautilus_files_view_move_copy_items (view, item_uris, relative_item_points, target_dir,
-                                         copy_action, x, y);
+    nautilus_files_view_move_copy_items (view, item_uris, target_dir,
+                                         copy_action);
 }
 
 static void
@@ -1675,95 +1297,16 @@ nautilus_canvas_view_update_click_mode (NautilusCanvasView *canvas_view)
                                                      click_mode == NAUTILUS_CLICK_POLICY_SINGLE);
 }
 
-static gboolean
-get_stored_layout_timestamp (NautilusCanvasContainer *container,
-                             NautilusCanvasIconData  *icon_data,
-                             time_t                  *timestamp,
-                             NautilusCanvasView      *view)
-{
-    NautilusFile *file;
-    NautilusDirectory *directory;
-
-    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);
-    }
-
-    return TRUE;
-}
-
-static gboolean
-store_layout_timestamp (NautilusCanvasContainer *container,
-                        NautilusCanvasIconData  *icon_data,
-                        const time_t            *timestamp,
-                        NautilusCanvasView      *view)
-{
-    NautilusFile *file;
-    NautilusDirectory *directory;
-
-    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);
-    }
-
-    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);
-}
-
-static NautilusCanvasContainer *
-real_create_canvas_container (NautilusCanvasView *canvas_view)
-{
-    return nautilus_canvas_view_container_new (canvas_view);
-}
-
 static void
 initialize_canvas_container (NautilusCanvasView      *canvas_view,
                              NautilusCanvasContainer *canvas_container)
 {
     GtkWidget *content_widget;
-    NautilusCanvasViewPrivate *priv;
-
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
 
     content_widget = nautilus_files_view_get_content_widget (NAUTILUS_FILES_VIEW (canvas_view));
-    priv->canvas_container = GTK_WIDGET (canvas_container);
+    canvas_view->canvas_container = GTK_WIDGET (canvas_container);
     g_object_add_weak_pointer (G_OBJECT (canvas_container),
-                               (gpointer *) &priv->canvas_container);
+                               (gpointer *) &canvas_view->canvas_container);
 
     gtk_widget_set_can_focus (GTK_WIDGET (canvas_container), TRUE);
 
@@ -1781,8 +1324,6 @@ initialize_canvas_container (NautilusCanvasView      *canvas_view,
                              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 */
@@ -1798,21 +1339,6 @@ initialize_canvas_container (NautilusCanvasView      *canvas_view,
                              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));
@@ -1830,12 +1356,10 @@ 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);
+                                                  encoded_url, target_uri, action);
 }
 
 static void
@@ -1843,12 +1367,10 @@ 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);
+                                              item_uris, target_uri, action);
 }
 
 static void
@@ -1856,12 +1378,10 @@ 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);
+                                          text, target_uri, action);
 }
 
 static void
@@ -1871,12 +1391,10 @@ canvas_view_handle_raw (NautilusCanvasContainer *container,
                         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);
+                                         raw_data, length, target_uri, direct_save_uri, action);
 }
 
 static void
@@ -1935,60 +1453,12 @@ nautilus_canvas_view_get_id (NautilusFilesView *view)
 }
 
 static void
-nautilus_canvas_view_set_property (GObject      *object,
-                                   guint         prop_id,
-                                   const GValue *value,
-                                   GParamSpec   *pspec)
-{
-    NautilusCanvasView *canvas_view;
-    NautilusCanvasViewPrivate *priv;
-
-    canvas_view = NAUTILUS_CANVAS_VIEW (object);
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
-
-    switch (prop_id)
-    {
-        case PROP_SUPPORTS_AUTO_LAYOUT:
-        {
-            priv->supports_auto_layout = g_value_get_boolean (value);
-        }
-        break;
-
-        case PROP_SUPPORTS_MANUAL_LAYOUT:
-        {
-            priv->supports_manual_layout = g_value_get_boolean (value);
-        }
-        break;
-
-        case PROP_SUPPORTS_SCALING:
-        {
-            priv->supports_scaling = g_value_get_boolean (value);
-        }
-        break;
-
-        case PROP_SUPPORTS_KEEP_ALIGNED:
-        {
-            priv->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_dispose (GObject *object)
 {
     NautilusCanvasView *canvas_view;
-    NautilusCanvasViewPrivate *priv;
 
     canvas_view = NAUTILUS_CANVAS_VIEW (object);
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
-    priv->destroyed = TRUE;
+    canvas_view->destroyed = TRUE;
 
     g_signal_handlers_disconnect_by_func (nautilus_preferences,
                                           default_sort_order_changed_callback,
@@ -2014,13 +1484,10 @@ nautilus_canvas_view_class_init (NautilusCanvasViewClass *klass)
     nautilus_files_view_class = NAUTILUS_FILES_VIEW_CLASS (klass);
     oclass = G_OBJECT_CLASS (klass);
 
-    oclass->set_property = nautilus_canvas_view_set_property;
     oclass->dispose = nautilus_canvas_view_dispose;
 
     GTK_WIDGET_CLASS (klass)->destroy = nautilus_canvas_view_destroy;
 
-    klass->create_canvas_container = real_create_canvas_container;
-
     nautilus_files_view_class->add_files = nautilus_canvas_view_add_files;
     nautilus_files_view_class->begin_loading = nautilus_canvas_view_begin_loading;
     nautilus_files_view_class->bump_zoom_level = nautilus_canvas_view_bump_zoom_level;
@@ -2046,58 +1513,23 @@ nautilus_canvas_view_class_init (NautilusCanvasViewClass *klass)
     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;
-
-    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)
 {
-    NautilusCanvasViewPrivate *priv;
     NautilusCanvasContainer *canvas_container;
     GActionGroup *view_action_group;
     GtkClipboard *clipboard;
 
-    priv = nautilus_canvas_view_get_instance_private (canvas_view);
-
-    priv->sort = &sort_criteria[0];
-    priv->destroyed = FALSE;
+    canvas_view->sort = &sort_criteria[0];
+    canvas_view->destroyed = FALSE;
 
-    canvas_container = create_canvas_container (canvas_view);
+    canvas_container = nautilus_canvas_view_container_new (canvas_view);
     initialize_canvas_container (canvas_view, canvas_container);
 
     g_signal_connect_swapped (nautilus_preferences,