Adding upstream version 3.38.2.upstream/3.38.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1866 insertions, 0 deletions

diff --git a/src/nautilus-list-model.c b/src/nautilus-list-model.c
new file mode 100644
index 0000000..e700669
--- /dev/null
+++ b/src/nautilus-list-model.c
@@ -0,0 +1,1866 @@
+/* fm-list-model.h - a GtkTreeModel for file lists.
+ *
+ *  Copyright (C) 2001, 2002 Anders Carlsson
+ *  Copyright (C) 2003, Soeren Sandmann
+ *  Copyright (C) 2004, Novell, 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: Anders Carlsson <andersca@gnu.org>, Soeren Sandmann (sandmann@daimi.au.dk), Dave Camp <dave@ximian.com>
+ */
+
+#include <config.h>
+
+#include "nautilus-list-model.h"
+
+#include <string.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <cairo-gobject.h>
+
+#include <eel/eel-graphic-effects.h>
+#include "nautilus-dnd.h"
+
+enum
+{
+    SUBDIRECTORY_UNLOADED,
+    GET_ICON_SCALE,
+    LAST_SIGNAL
+};
+
+static GQuark attribute_name_q,
+              attribute_modification_date_q,
+              attribute_date_modified_q;
+
+/* msec delay after Loading... dummy row turns into (empty) */
+#define LOADING_TO_EMPTY_DELAY 100
+
+static guint list_model_signals[LAST_SIGNAL] = { 0 };
+
+static int nautilus_list_model_file_entry_compare_func (gconstpointer a,
+                                                        gconstpointer b,
+                                                        gpointer      user_data);
+static void nautilus_list_model_tree_model_init (GtkTreeModelIface *iface);
+static void nautilus_list_model_sortable_init (GtkTreeSortableIface *iface);
+
+typedef struct
+{
+    GSequence *files;
+    GHashTable *directory_reverse_map;     /* map from directory to GSequenceIter's */
+    GHashTable *top_reverse_map;           /* map from files in top dir to GSequenceIter's */
+
+    int stamp;
+
+    GQuark sort_attribute;
+    GtkSortType order;
+
+    gboolean sort_directories_first;
+
+    GtkTreeView *drag_view;
+    int drag_begin_x;
+    int drag_begin_y;
+
+    GPtrArray *columns;
+
+    GList *highlight_files;
+} NautilusListModelPrivate;
+
+typedef struct
+{
+    NautilusListModel *model;
+
+    GList *path_list;
+} DragDataGetInfo;
+
+typedef struct FileEntry FileEntry;
+
+struct FileEntry
+{
+    NautilusFile *file;
+    GHashTable *reverse_map;            /* map from files to GSequenceIter's */
+    NautilusDirectory *subdirectory;
+    FileEntry *parent;
+    GSequence *files;
+    GSequenceIter *ptr;
+    guint loaded : 1;
+};
+
+G_DEFINE_TYPE_WITH_CODE (NautilusListModel, nautilus_list_model, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
+                                                nautilus_list_model_tree_model_init)
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_SORTABLE,
+                                                nautilus_list_model_sortable_init)
+                         G_ADD_PRIVATE (NautilusListModel));
+
+static const GtkTargetEntry drag_types [] =
+{
+    { NAUTILUS_ICON_DND_GNOME_ICON_LIST_TYPE, 0, NAUTILUS_ICON_DND_GNOME_ICON_LIST },
+    { NAUTILUS_ICON_DND_URI_LIST_TYPE, 0, NAUTILUS_ICON_DND_URI_LIST },
+};
+
+static void
+file_entry_free (FileEntry *file_entry)
+{
+    nautilus_file_unref (file_entry->file);
+    if (file_entry->reverse_map)
+    {
+        g_hash_table_destroy (file_entry->reverse_map);
+        file_entry->reverse_map = NULL;
+    }
+    if (file_entry->subdirectory != NULL)
+    {
+        nautilus_directory_unref (file_entry->subdirectory);
+    }
+    if (file_entry->files != NULL)
+    {
+        g_sequence_free (file_entry->files);
+    }
+    g_free (file_entry);
+}
+
+static GtkTreeModelFlags
+nautilus_list_model_get_flags (GtkTreeModel *tree_model)
+{
+    return GTK_TREE_MODEL_ITERS_PERSIST;
+}
+
+static int
+nautilus_list_model_get_n_columns (GtkTreeModel *tree_model)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (NAUTILUS_LIST_MODEL (tree_model));
+
+    return NAUTILUS_LIST_MODEL_NUM_COLUMNS + priv->columns->len;
+}
+
+static GType
+nautilus_list_model_get_column_type (GtkTreeModel *tree_model,
+                                     int           index)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    switch (index)
+    {
+        case NAUTILUS_LIST_MODEL_FILE_COLUMN:
+        {
+            return NAUTILUS_TYPE_FILE;
+        }
+
+        case NAUTILUS_LIST_MODEL_SUBDIRECTORY_COLUMN:
+        {
+            return NAUTILUS_TYPE_DIRECTORY;
+        }
+
+        case NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN:
+        case NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN:
+        case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN:
+        case NAUTILUS_LIST_MODEL_LARGER_ICON_COLUMN:
+        {
+            return CAIRO_GOBJECT_TYPE_SURFACE;
+        }
+
+        case NAUTILUS_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN:
+        {
+            return G_TYPE_BOOLEAN;
+        }
+
+        default:
+            if (index < NAUTILUS_LIST_MODEL_NUM_COLUMNS + priv->columns->len)
+            {
+                return G_TYPE_STRING;
+            }
+            else
+            {
+                return G_TYPE_INVALID;
+            }
+    }
+}
+
+static void
+nautilus_list_model_ptr_to_iter (NautilusListModel *model,
+                                 GSequenceIter     *ptr,
+                                 GtkTreeIter       *iter)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    g_assert (!g_sequence_iter_is_end (ptr));
+
+    if (iter != NULL)
+    {
+        iter->stamp = priv->stamp;
+        iter->user_data = ptr;
+    }
+}
+
+static gboolean
+nautilus_list_model_get_iter (GtkTreeModel *tree_model,
+                              GtkTreeIter  *iter,
+                              GtkTreePath  *path)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    GSequence *files;
+    GSequenceIter *ptr;
+    FileEntry *file_entry;
+    int i, d;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+    ptr = NULL;
+
+    files = priv->files;
+    for (d = 0; d < gtk_tree_path_get_depth (path); d++)
+    {
+        i = gtk_tree_path_get_indices (path)[d];
+
+        if (files == NULL || i >= g_sequence_get_length (files))
+        {
+            return FALSE;
+        }
+
+        ptr = g_sequence_get_iter_at_pos (files, i);
+        file_entry = g_sequence_get (ptr);
+        files = file_entry->files;
+    }
+
+    nautilus_list_model_ptr_to_iter (model, ptr, iter);
+
+    return TRUE;
+}
+
+static GtkTreePath *
+nautilus_list_model_get_path (GtkTreeModel *tree_model,
+                              GtkTreeIter  *iter)
+{
+    GtkTreePath *path;
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    GSequenceIter *ptr;
+    FileEntry *file_entry;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    g_return_val_if_fail (iter->stamp == priv->stamp, NULL);
+
+    if (g_sequence_iter_is_end (iter->user_data))
+    {
+        /* FIXME is this right? */
+        return NULL;
+    }
+
+    path = gtk_tree_path_new ();
+    ptr = iter->user_data;
+    while (ptr != NULL)
+    {
+        gtk_tree_path_prepend_index (path, g_sequence_iter_get_position (ptr));
+        file_entry = g_sequence_get (ptr);
+        if (file_entry->parent != NULL)
+        {
+            ptr = file_entry->parent->ptr;
+        }
+        else
+        {
+            ptr = NULL;
+        }
+    }
+
+    return path;
+}
+
+static gint
+nautilus_list_model_get_icon_scale (NautilusListModel *model)
+{
+    gint retval = -1;
+
+    g_signal_emit (model, list_model_signals[GET_ICON_SCALE], 0,
+                   &retval);
+
+    if (retval == -1)
+    {
+        retval = gdk_monitor_get_scale_factor (gdk_display_get_monitor (gdk_display_get_default (), 0));
+    }
+
+    return retval;
+}
+
+guint
+nautilus_list_model_get_icon_size_for_zoom_level (NautilusListZoomLevel zoom_level)
+{
+    switch (zoom_level)
+    {
+        case NAUTILUS_LIST_ZOOM_LEVEL_SMALL:
+        {
+            return NAUTILUS_LIST_ICON_SIZE_SMALL;
+        }
+
+        case NAUTILUS_LIST_ZOOM_LEVEL_STANDARD:
+        {
+            return NAUTILUS_LIST_ICON_SIZE_STANDARD;
+        }
+
+        case NAUTILUS_LIST_ZOOM_LEVEL_LARGE:
+        {
+            return NAUTILUS_LIST_ICON_SIZE_LARGE;
+        }
+
+        case NAUTILUS_LIST_ZOOM_LEVEL_LARGER:
+            return NAUTILUS_LIST_ICON_SIZE_LARGER;
+    }
+    g_return_val_if_reached (NAUTILUS_LIST_ICON_SIZE_STANDARD);
+}
+
+static void
+nautilus_list_model_get_value (GtkTreeModel *tree_model,
+                               GtkTreeIter  *iter,
+                               int           column,
+                               GValue       *value)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    FileEntry *file_entry;
+    NautilusFile *file;
+    char *str;
+    GdkPixbuf *icon, *rendered_icon;
+    int icon_size, icon_scale;
+    NautilusListZoomLevel zoom_level;
+    NautilusFileIconFlags flags;
+    cairo_surface_t *surface;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    g_return_if_fail (priv->stamp == iter->stamp);
+    g_return_if_fail (!g_sequence_iter_is_end (iter->user_data));
+
+    file_entry = g_sequence_get (iter->user_data);
+    file = file_entry->file;
+
+    switch (column)
+    {
+        case NAUTILUS_LIST_MODEL_FILE_COLUMN:
+        {
+            g_value_init (value, NAUTILUS_TYPE_FILE);
+
+            g_value_set_object (value, file);
+        }
+        break;
+
+        case NAUTILUS_LIST_MODEL_SUBDIRECTORY_COLUMN:
+        {
+            g_value_init (value, NAUTILUS_TYPE_DIRECTORY);
+
+            g_value_set_object (value, file_entry->subdirectory);
+        }
+        break;
+
+        case NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN:
+        case NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN:
+        case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN:
+        case NAUTILUS_LIST_MODEL_LARGER_ICON_COLUMN:
+        {
+            g_value_init (value, CAIRO_GOBJECT_TYPE_SURFACE);
+
+            if (file != NULL)
+            {
+                zoom_level = nautilus_list_model_get_zoom_level_from_column_id (column);
+                icon_size = nautilus_list_model_get_icon_size_for_zoom_level (zoom_level);
+                icon_scale = nautilus_list_model_get_icon_scale (model);
+
+                flags = NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS |
+                        NAUTILUS_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE |
+                        NAUTILUS_FILE_ICON_FLAGS_USE_EMBLEMS |
+                        NAUTILUS_FILE_ICON_FLAGS_USE_ONE_EMBLEM;
+
+                if (priv->drag_view != NULL)
+                {
+                    GtkTreePath *path_a, *path_b;
+
+                    gtk_tree_view_get_drag_dest_row (priv->drag_view,
+                                                     &path_a,
+                                                     NULL);
+                    if (path_a != NULL)
+                    {
+                        path_b = gtk_tree_model_get_path (tree_model, iter);
+
+                        if (gtk_tree_path_compare (path_a, path_b) == 0)
+                        {
+                            flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT;
+                        }
+
+                        gtk_tree_path_free (path_a);
+                        gtk_tree_path_free (path_b);
+                    }
+                }
+
+                icon = nautilus_file_get_icon_pixbuf (file, icon_size, TRUE, icon_scale, flags);
+
+                if (priv->highlight_files != NULL &&
+                    g_list_find_custom (priv->highlight_files,
+                                        file, (GCompareFunc) nautilus_file_compare_location))
+                {
+                    rendered_icon = eel_create_spotlight_pixbuf (icon);
+
+                    if (rendered_icon != NULL)
+                    {
+                        g_object_unref (icon);
+                        icon = rendered_icon;
+                    }
+                }
+
+                surface = gdk_cairo_surface_create_from_pixbuf (icon, icon_scale, NULL);
+                g_value_take_boxed (value, surface);
+                g_object_unref (icon);
+            }
+        }
+        break;
+
+        case NAUTILUS_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN:
+        {
+            g_value_init (value, G_TYPE_BOOLEAN);
+
+            g_value_set_boolean (value, file != NULL && nautilus_file_can_rename (file));
+        }
+        break;
+
+        default:
+            if (column >= NAUTILUS_LIST_MODEL_NUM_COLUMNS && column < NAUTILUS_LIST_MODEL_NUM_COLUMNS + priv->columns->len)
+            {
+                NautilusColumn *nautilus_column;
+                GQuark attribute;
+                nautilus_column = priv->columns->pdata[column - NAUTILUS_LIST_MODEL_NUM_COLUMNS];
+
+                g_value_init (value, G_TYPE_STRING);
+                g_object_get (nautilus_column,
+                              "attribute_q", &attribute,
+                              NULL);
+                if (file != NULL)
+                {
+                    str = nautilus_file_get_string_attribute_with_default_q (file,
+                                                                             attribute);
+                    g_value_take_string (value, str);
+                }
+                else if (attribute == attribute_name_q)
+                {
+                    if (file_entry->parent->loaded)
+                    {
+                        g_value_set_string (value, _("(Empty)"));
+                    }
+                    else
+                    {
+                        g_value_set_string (value, _("Loading…"));
+                    }
+                }
+            }
+            else
+            {
+                g_assert_not_reached ();
+            }
+    }
+}
+
+static gboolean
+nautilus_list_model_iter_next (GtkTreeModel *tree_model,
+                               GtkTreeIter  *iter)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    g_return_val_if_fail (priv->stamp == iter->stamp, FALSE);
+
+    iter->user_data = g_sequence_iter_next (iter->user_data);
+
+    return !g_sequence_iter_is_end (iter->user_data);
+}
+
+static gboolean
+nautilus_list_model_iter_children (GtkTreeModel *tree_model,
+                                   GtkTreeIter  *iter,
+                                   GtkTreeIter  *parent)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    GSequence *files;
+    FileEntry *file_entry;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (parent == NULL)
+    {
+        files = priv->files;
+    }
+    else
+    {
+        file_entry = g_sequence_get (parent->user_data);
+        files = file_entry->files;
+    }
+
+    if (files == NULL || g_sequence_get_length (files) == 0)
+    {
+        return FALSE;
+    }
+
+    iter->stamp = priv->stamp;
+    iter->user_data = g_sequence_get_begin_iter (files);
+
+    return TRUE;
+}
+
+static gboolean
+nautilus_list_model_iter_has_child (GtkTreeModel *tree_model,
+                                    GtkTreeIter  *iter)
+{
+    FileEntry *file_entry;
+
+    if (iter == NULL)
+    {
+        return !nautilus_list_model_is_empty (NAUTILUS_LIST_MODEL (tree_model));
+    }
+
+    file_entry = g_sequence_get (iter->user_data);
+
+    return (file_entry->files != NULL && g_sequence_get_length (file_entry->files) > 0);
+}
+
+static int
+nautilus_list_model_iter_n_children (GtkTreeModel *tree_model,
+                                     GtkTreeIter  *iter)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    GSequence *files;
+    FileEntry *file_entry;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (iter == NULL)
+    {
+        files = priv->files;
+    }
+    else
+    {
+        file_entry = g_sequence_get (iter->user_data);
+        files = file_entry->files;
+    }
+
+    return g_sequence_get_length (files);
+}
+
+static gboolean
+nautilus_list_model_iter_nth_child (GtkTreeModel *tree_model,
+                                    GtkTreeIter  *iter,
+                                    GtkTreeIter  *parent,
+                                    int           n)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    GSequenceIter *child;
+    GSequence *files;
+    FileEntry *file_entry;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (parent != NULL)
+    {
+        file_entry = g_sequence_get (parent->user_data);
+        files = file_entry->files;
+    }
+    else
+    {
+        files = priv->files;
+    }
+
+    child = g_sequence_get_iter_at_pos (files, n);
+
+    if (g_sequence_iter_is_end (child))
+    {
+        return FALSE;
+    }
+
+    iter->stamp = priv->stamp;
+    iter->user_data = child;
+
+    return TRUE;
+}
+
+static gboolean
+nautilus_list_model_iter_parent (GtkTreeModel *tree_model,
+                                 GtkTreeIter  *iter,
+                                 GtkTreeIter  *child)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    FileEntry *file_entry;
+
+    model = NAUTILUS_LIST_MODEL (tree_model);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    file_entry = g_sequence_get (child->user_data);
+
+    if (file_entry->parent == NULL)
+    {
+        return FALSE;
+    }
+
+    iter->stamp = priv->stamp;
+    iter->user_data = file_entry->parent->ptr;
+
+    return TRUE;
+}
+
+static GSequenceIter *
+lookup_file (NautilusListModel *model,
+             NautilusFile      *file,
+             NautilusDirectory *directory)
+{
+    NautilusListModelPrivate *priv;
+    FileEntry *file_entry;
+    GSequenceIter *ptr, *parent_ptr;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    parent_ptr = NULL;
+    if (directory)
+    {
+        parent_ptr = g_hash_table_lookup (priv->directory_reverse_map,
+                                          directory);
+    }
+
+    if (parent_ptr)
+    {
+        file_entry = g_sequence_get (parent_ptr);
+        ptr = g_hash_table_lookup (file_entry->reverse_map, file);
+    }
+    else
+    {
+        ptr = g_hash_table_lookup (priv->top_reverse_map, file);
+    }
+
+    if (ptr)
+    {
+        g_assert (((FileEntry *) g_sequence_get (ptr))->file == file);
+    }
+
+    return ptr;
+}
+
+
+struct GetIters
+{
+    NautilusListModel *model;
+    NautilusFile *file;
+    GList *iters;
+};
+
+static void
+dir_to_iters (struct GetIters *data,
+              GHashTable      *reverse_map)
+{
+    GSequenceIter *ptr;
+
+    ptr = g_hash_table_lookup (reverse_map, data->file);
+    if (ptr)
+    {
+        GtkTreeIter *iter;
+        iter = g_new0 (GtkTreeIter, 1);
+        nautilus_list_model_ptr_to_iter (data->model, ptr, iter);
+        data->iters = g_list_prepend (data->iters, iter);
+    }
+}
+
+static void
+file_to_iter_cb (gpointer key,
+                 gpointer value,
+                 gpointer user_data)
+{
+    struct GetIters *data;
+    FileEntry *dir_file_entry;
+
+    data = user_data;
+    dir_file_entry = g_sequence_get ((GSequenceIter *) value);
+    dir_to_iters (data, dir_file_entry->reverse_map);
+}
+
+GList *
+nautilus_list_model_get_all_iters_for_file (NautilusListModel *model,
+                                            NautilusFile      *file)
+{
+    struct GetIters data;
+    NautilusListModelPrivate *priv;
+    data.file = file;
+    data.model = model;
+    data.iters = NULL;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    dir_to_iters (&data, priv->top_reverse_map);
+    g_hash_table_foreach (priv->directory_reverse_map,
+                          file_to_iter_cb, &data);
+
+    return g_list_reverse (data.iters);
+}
+
+gboolean
+nautilus_list_model_get_first_iter_for_file (NautilusListModel *model,
+                                             NautilusFile      *file,
+                                             GtkTreeIter       *iter)
+{
+    GList *list;
+    gboolean res;
+
+    res = FALSE;
+
+    list = nautilus_list_model_get_all_iters_for_file (model, file);
+    if (list != NULL)
+    {
+        res = TRUE;
+        *iter = *(GtkTreeIter *) list->data;
+    }
+    g_list_free_full (list, g_free);
+
+    return res;
+}
+
+
+gboolean
+nautilus_list_model_get_tree_iter_from_file (NautilusListModel *model,
+                                             NautilusFile      *file,
+                                             NautilusDirectory *directory,
+                                             GtkTreeIter       *iter)
+{
+    GSequenceIter *ptr;
+
+    ptr = lookup_file (model, file, directory);
+    if (!ptr)
+    {
+        return FALSE;
+    }
+
+    nautilus_list_model_ptr_to_iter (model, ptr, iter);
+
+    return TRUE;
+}
+
+static int
+nautilus_list_model_file_entry_compare_func (gconstpointer a,
+                                             gconstpointer b,
+                                             gpointer      user_data)
+{
+    FileEntry *file_entry1;
+    FileEntry *file_entry2;
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    int result;
+
+    model = NAUTILUS_LIST_MODEL (user_data);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    file_entry1 = (FileEntry *) a;
+    file_entry2 = (FileEntry *) b;
+
+    if (file_entry1->file != NULL && file_entry2->file != NULL)
+    {
+        result = nautilus_file_compare_for_sort_by_attribute_q (file_entry1->file, file_entry2->file,
+                                                                priv->sort_attribute,
+                                                                priv->sort_directories_first,
+                                                                (priv->order == GTK_SORT_DESCENDING));
+    }
+    else if (file_entry1->file == NULL)
+    {
+        return -1;
+    }
+    else
+    {
+        return 1;
+    }
+
+    return result;
+}
+
+int
+nautilus_list_model_compare_func (NautilusListModel *model,
+                                  NautilusFile      *file1,
+                                  NautilusFile      *file2)
+{
+    NautilusListModelPrivate *priv;
+    int result;
+
+    priv = nautilus_list_model_get_instance_private (model);
+    result = nautilus_file_compare_for_sort_by_attribute_q (file1, file2,
+                                                            priv->sort_attribute,
+                                                            priv->sort_directories_first,
+                                                            (priv->order == GTK_SORT_DESCENDING));
+
+    return result;
+}
+
+static void
+nautilus_list_model_sort_file_entries (NautilusListModel *model,
+                                       GSequence         *files,
+                                       GtkTreePath       *path)
+{
+    GSequenceIter **old_order;
+    GtkTreeIter iter;
+    int *new_order;
+    int length;
+    int i;
+    FileEntry *file_entry;
+    gboolean has_iter;
+
+    length = g_sequence_get_length (files);
+
+    if (length <= 1)
+    {
+        return;
+    }
+
+    /* generate old order of GSequenceIter's */
+    old_order = g_new (GSequenceIter *, length);
+    for (i = 0; i < length; ++i)
+    {
+        GSequenceIter *ptr = g_sequence_get_iter_at_pos (files, i);
+
+        file_entry = g_sequence_get (ptr);
+        if (file_entry->files != NULL)
+        {
+            gtk_tree_path_append_index (path, i);
+            nautilus_list_model_sort_file_entries (model, file_entry->files, path);
+            gtk_tree_path_up (path);
+        }
+
+        old_order[i] = ptr;
+    }
+
+    /* sort */
+    g_sequence_sort (files, nautilus_list_model_file_entry_compare_func, model);
+
+    /* generate new order */
+    new_order = g_new (int, length);
+    /* Note: new_order[newpos] = oldpos */
+    for (i = 0; i < length; ++i)
+    {
+        new_order[g_sequence_iter_get_position (old_order[i])] = i;
+    }
+
+    /* Let the world know about our new order */
+
+    g_assert (new_order != NULL);
+
+    has_iter = FALSE;
+    if (gtk_tree_path_get_depth (path) != 0)
+    {
+        gboolean get_iter_result;
+        has_iter = TRUE;
+        get_iter_result = gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path);
+        g_assert (get_iter_result);
+    }
+
+    gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
+                                   path, has_iter ? &iter : NULL, new_order);
+
+    g_free (old_order);
+    g_free (new_order);
+}
+
+static void
+nautilus_list_model_sort (NautilusListModel *model)
+{
+    GtkTreePath *path;
+    NautilusListModelPrivate *priv;
+
+    path = gtk_tree_path_new ();
+    priv = nautilus_list_model_get_instance_private (model);
+
+    nautilus_list_model_sort_file_entries (model, priv->files, path);
+
+    gtk_tree_path_free (path);
+}
+
+static gboolean
+nautilus_list_model_get_sort_column_id (GtkTreeSortable *sortable,
+                                        gint            *sort_column_id,
+                                        GtkSortType     *order)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    int id;
+
+    model = NAUTILUS_LIST_MODEL (sortable);
+    priv = nautilus_list_model_get_instance_private (model);
+    id = nautilus_list_model_get_sort_column_id_from_attribute (model, priv->sort_attribute);
+
+    if (id == -1)
+    {
+        return FALSE;
+    }
+
+    if (sort_column_id != NULL)
+    {
+        *sort_column_id = id;
+    }
+
+    if (order != NULL)
+    {
+        *order = priv->order;
+    }
+
+    return TRUE;
+}
+
+static void
+nautilus_list_model_set_sort_column_id (GtkTreeSortable *sortable,
+                                        gint             sort_column_id,
+                                        GtkSortType      order)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+
+    model = NAUTILUS_LIST_MODEL (sortable);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    priv->sort_attribute = nautilus_list_model_get_attribute_from_sort_column_id (model, sort_column_id);
+
+    priv->order = order;
+
+    nautilus_list_model_sort (model);
+    gtk_tree_sortable_sort_column_changed (sortable);
+}
+
+static gboolean
+nautilus_list_model_has_default_sort_func (GtkTreeSortable *sortable)
+{
+    return FALSE;
+}
+
+static void
+add_dummy_row (NautilusListModel *model,
+               FileEntry         *parent_entry)
+{
+    NautilusListModelPrivate *priv;
+    FileEntry *dummy_file_entry;
+    GtkTreeIter iter;
+    GtkTreePath *path;
+
+    priv = nautilus_list_model_get_instance_private (model);
+    dummy_file_entry = g_new0 (FileEntry, 1);
+    dummy_file_entry->parent = parent_entry;
+    dummy_file_entry->ptr = g_sequence_insert_sorted (parent_entry->files, dummy_file_entry,
+                                                      nautilus_list_model_file_entry_compare_func, model);
+    iter.stamp = priv->stamp;
+    iter.user_data = dummy_file_entry->ptr;
+
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+    gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
+    gtk_tree_path_free (path);
+}
+
+gboolean
+nautilus_list_model_add_file (NautilusListModel *model,
+                              NautilusFile      *file,
+                              NautilusDirectory *directory)
+{
+    NautilusListModelPrivate *priv;
+    GtkTreeIter iter;
+    GtkTreePath *path;
+    FileEntry *file_entry;
+    GSequenceIter *ptr, *parent_ptr;
+    GSequence *files;
+    gboolean replace_dummy;
+    GHashTable *parent_hash;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    parent_ptr = g_hash_table_lookup (priv->directory_reverse_map,
+                                      directory);
+    if (parent_ptr)
+    {
+        file_entry = g_sequence_get (parent_ptr);
+        ptr = g_hash_table_lookup (file_entry->reverse_map, file);
+    }
+    else
+    {
+        file_entry = NULL;
+        ptr = g_hash_table_lookup (priv->top_reverse_map, file);
+    }
+
+    if (ptr != NULL)
+    {
+        g_warning ("file already in tree (parent_ptr: %p)!!!\n", parent_ptr);
+        return FALSE;
+    }
+
+    file_entry = g_new0 (FileEntry, 1);
+    file_entry->file = nautilus_file_ref (file);
+    file_entry->parent = NULL;
+    file_entry->subdirectory = NULL;
+    file_entry->files = NULL;
+
+    files = priv->files;
+    parent_hash = priv->top_reverse_map;
+
+    replace_dummy = FALSE;
+
+    if (parent_ptr != NULL)
+    {
+        file_entry->parent = g_sequence_get (parent_ptr);
+        /* At this point we set loaded. Either we saw
+         * "done" and ignored it waiting for this, or we do this
+         * earlier, but then we replace the dummy row anyway,
+         * so it doesn't matter */
+        file_entry->parent->loaded = 1;
+        parent_hash = file_entry->parent->reverse_map;
+        files = file_entry->parent->files;
+        if (g_sequence_get_length (files) == 1)
+        {
+            GSequenceIter *dummy_ptr = g_sequence_get_iter_at_pos (files, 0);
+            FileEntry *dummy_entry = g_sequence_get (dummy_ptr);
+            if (dummy_entry->file == NULL)
+            {
+                /* replace the dummy loading entry */
+                priv->stamp++;
+                g_sequence_remove (dummy_ptr);
+
+                replace_dummy = TRUE;
+            }
+        }
+    }
+
+
+    file_entry->ptr = g_sequence_insert_sorted (files, file_entry,
+                                                nautilus_list_model_file_entry_compare_func, model);
+
+    g_hash_table_insert (parent_hash, file, file_entry->ptr);
+
+    iter.stamp = priv->stamp;
+    iter.user_data = file_entry->ptr;
+
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+    if (replace_dummy)
+    {
+        gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
+    }
+    else
+    {
+        gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
+    }
+
+    if (nautilus_file_is_directory (file))
+    {
+        file_entry->files = g_sequence_new ((GDestroyNotify) file_entry_free);
+
+        add_dummy_row (model, file_entry);
+
+        gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (model),
+                                              path, &iter);
+    }
+    gtk_tree_path_free (path);
+
+    return TRUE;
+}
+
+void
+nautilus_list_model_file_changed (NautilusListModel *model,
+                                  NautilusFile      *file,
+                                  NautilusDirectory *directory)
+{
+    NautilusListModelPrivate *priv;
+    FileEntry *parent_file_entry;
+    GtkTreeIter iter;
+    GtkTreePath *path, *parent_path;
+    GSequenceIter *ptr;
+    int pos_before, pos_after, length, i, old;
+    int *new_order;
+    gboolean has_iter;
+    GSequence *files;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    ptr = lookup_file (model, file, directory);
+    if (!ptr)
+    {
+        return;
+    }
+
+
+    pos_before = g_sequence_iter_get_position (ptr);
+
+    g_sequence_sort_changed (ptr, nautilus_list_model_file_entry_compare_func, model);
+
+    pos_after = g_sequence_iter_get_position (ptr);
+
+    if (pos_before != pos_after)
+    {
+        /* The file moved, we need to send rows_reordered */
+
+        parent_file_entry = ((FileEntry *) g_sequence_get (ptr))->parent;
+
+        if (parent_file_entry == NULL)
+        {
+            has_iter = FALSE;
+            parent_path = gtk_tree_path_new ();
+            files = priv->files;
+        }
+        else
+        {
+            has_iter = TRUE;
+            nautilus_list_model_ptr_to_iter (model, parent_file_entry->ptr, &iter);
+            parent_path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+            files = parent_file_entry->files;
+        }
+
+        length = g_sequence_get_length (files);
+        new_order = g_new (int, length);
+        /* Note: new_order[newpos] = oldpos */
+        for (i = 0, old = 0; i < length; ++i)
+        {
+            if (i == pos_after)
+            {
+                new_order[i] = pos_before;
+            }
+            else
+            {
+                if (old == pos_before)
+                {
+                    old++;
+                }
+                new_order[i] = old++;
+            }
+        }
+
+        gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
+                                       parent_path, has_iter ? &iter : NULL, new_order);
+
+        gtk_tree_path_free (parent_path);
+        g_free (new_order);
+    }
+
+    nautilus_list_model_ptr_to_iter (model, ptr, &iter);
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+    gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
+    gtk_tree_path_free (path);
+}
+
+gboolean
+nautilus_list_model_is_empty (NautilusListModel *model)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    return (g_sequence_get_length (priv->files) == 0);
+}
+
+static void
+nautilus_list_model_remove (NautilusListModel *model,
+                            GtkTreeIter       *iter)
+{
+    NautilusListModelPrivate *priv;
+    GSequenceIter *ptr, *child_ptr;
+    FileEntry *file_entry, *child_file_entry, *parent_file_entry;
+    GtkTreePath *path;
+    GtkTreeIter parent_iter;
+
+    priv = nautilus_list_model_get_instance_private (model);
+    ptr = iter->user_data;
+    file_entry = g_sequence_get (ptr);
+
+    if (file_entry->files != NULL)
+    {
+        while (g_sequence_get_length (file_entry->files) > 0)
+        {
+            child_ptr = g_sequence_get_begin_iter (file_entry->files);
+            child_file_entry = g_sequence_get (child_ptr);
+            if (child_file_entry->file != NULL)
+            {
+                nautilus_list_model_remove_file (model,
+                                                 child_file_entry->file,
+                                                 file_entry->subdirectory);
+            }
+            else
+            {
+                path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter);
+                gtk_tree_path_append_index (path, 0);
+                priv->stamp++;
+                g_sequence_remove (child_ptr);
+                gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+                gtk_tree_path_free (path);
+            }
+
+            /* the parent iter didn't actually change */
+            iter->stamp = priv->stamp;
+        }
+    }
+
+    if (file_entry->file != NULL)       /* Don't try to remove dummy row */
+    {
+        if (file_entry->parent != NULL)
+        {
+            g_hash_table_remove (file_entry->parent->reverse_map, file_entry->file);
+        }
+        else
+        {
+            g_hash_table_remove (priv->top_reverse_map, file_entry->file);
+        }
+    }
+
+    parent_file_entry = file_entry->parent;
+    if (parent_file_entry && g_sequence_get_length (parent_file_entry->files) == 1 &&
+        file_entry->file != NULL)
+    {
+        /* this is the last non-dummy child, add a dummy node */
+        /* We need to do this before removing the last file to avoid
+         * collapsing the row.
+         */
+        add_dummy_row (model, parent_file_entry);
+    }
+
+    if (file_entry->subdirectory != NULL)
+    {
+        g_signal_emit (model,
+                       list_model_signals[SUBDIRECTORY_UNLOADED], 0,
+                       file_entry->subdirectory);
+        g_hash_table_remove (priv->directory_reverse_map,
+                             file_entry->subdirectory);
+    }
+
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter);
+
+    g_sequence_remove (ptr);
+    priv->stamp++;
+    gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+
+    gtk_tree_path_free (path);
+
+    if (parent_file_entry && g_sequence_get_length (parent_file_entry->files) == 0)
+    {
+        parent_iter.stamp = priv->stamp;
+        parent_iter.user_data = parent_file_entry->ptr;
+        path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &parent_iter);
+        gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (model),
+                                              path, &parent_iter);
+        gtk_tree_path_free (path);
+    }
+}
+
+void
+nautilus_list_model_remove_file (NautilusListModel *model,
+                                 NautilusFile      *file,
+                                 NautilusDirectory *directory)
+{
+    GtkTreeIter iter;
+
+    if (nautilus_list_model_get_tree_iter_from_file (model, file, directory, &iter))
+    {
+        nautilus_list_model_remove (model, &iter);
+    }
+}
+
+static void
+nautilus_list_model_clear_directory (NautilusListModel *model,
+                                     GSequence         *files)
+{
+    NautilusListModelPrivate *priv;
+    GtkTreeIter iter;
+    FileEntry *file_entry;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    while (g_sequence_get_length (files) > 0)
+    {
+        iter.user_data = g_sequence_get_begin_iter (files);
+
+        file_entry = g_sequence_get (iter.user_data);
+        if (file_entry->files != NULL)
+        {
+            nautilus_list_model_clear_directory (model, file_entry->files);
+        }
+
+        iter.stamp = priv->stamp;
+        nautilus_list_model_remove (model, &iter);
+    }
+}
+
+void
+nautilus_list_model_clear (NautilusListModel *model)
+{
+    NautilusListModelPrivate *priv;
+
+    g_return_if_fail (model != NULL);
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    nautilus_list_model_clear_directory (model, priv->files);
+}
+
+NautilusFile *
+nautilus_list_model_file_for_path (NautilusListModel *model,
+                                   GtkTreePath       *path)
+{
+    NautilusFile *file;
+    GtkTreeIter iter;
+
+    file = NULL;
+    if (gtk_tree_model_get_iter (GTK_TREE_MODEL (model),
+                                 &iter, path))
+    {
+        gtk_tree_model_get (GTK_TREE_MODEL (model),
+                            &iter,
+                            NAUTILUS_LIST_MODEL_FILE_COLUMN, &file,
+                            -1);
+    }
+    return file;
+}
+
+gboolean
+nautilus_list_model_load_subdirectory (NautilusListModel  *model,
+                                       GtkTreePath        *path,
+                                       NautilusDirectory **directory)
+{
+    NautilusListModelPrivate *priv;
+    GtkTreeIter iter;
+    FileEntry *file_entry;
+    NautilusDirectory *subdirectory;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
+    {
+        return FALSE;
+    }
+
+    file_entry = g_sequence_get (iter.user_data);
+    if (file_entry->file == NULL ||
+        file_entry->subdirectory != NULL)
+    {
+        return FALSE;
+    }
+
+    subdirectory = nautilus_directory_get_for_file (file_entry->file);
+
+    if (g_hash_table_lookup (priv->directory_reverse_map, subdirectory) != NULL)
+    {
+        nautilus_directory_unref (subdirectory);
+        g_warning ("Already in directory_reverse_map, failing\n");
+        return FALSE;
+    }
+
+    file_entry->subdirectory = subdirectory,
+    g_hash_table_insert (priv->directory_reverse_map,
+                         subdirectory, file_entry->ptr);
+    file_entry->reverse_map = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+    /* Return a ref too */
+    nautilus_directory_ref (subdirectory);
+    *directory = subdirectory;
+
+    return TRUE;
+}
+
+/* removes all children of the subfolder and unloads the subdirectory */
+void
+nautilus_list_model_unload_subdirectory (NautilusListModel *model,
+                                         GtkTreeIter       *iter)
+{
+    NautilusListModelPrivate *priv;
+    GSequenceIter *child_ptr;
+    FileEntry *file_entry, *child_file_entry;
+    GtkTreeIter child_iter;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    file_entry = g_sequence_get (iter->user_data);
+    if (file_entry->file == NULL ||
+        file_entry->subdirectory == NULL)
+    {
+        return;
+    }
+
+    file_entry->loaded = 0;
+
+    /* Remove all children */
+    while (g_sequence_get_length (file_entry->files) > 0)
+    {
+        child_ptr = g_sequence_get_begin_iter (file_entry->files);
+        child_file_entry = g_sequence_get (child_ptr);
+        if (child_file_entry->file == NULL)
+        {
+            /* Don't delete the dummy node */
+            break;
+        }
+        else
+        {
+            nautilus_list_model_ptr_to_iter (model, child_ptr, &child_iter);
+            nautilus_list_model_remove (model, &child_iter);
+        }
+    }
+
+    /* Emit unload signal */
+    g_signal_emit (model,
+                   list_model_signals[SUBDIRECTORY_UNLOADED], 0,
+                   file_entry->subdirectory);
+
+    /* actually unload */
+    g_hash_table_remove (priv->directory_reverse_map,
+                         file_entry->subdirectory);
+    nautilus_directory_unref (file_entry->subdirectory);
+    file_entry->subdirectory = NULL;
+
+    g_assert (g_hash_table_size (file_entry->reverse_map) == 0);
+    g_hash_table_destroy (file_entry->reverse_map);
+    file_entry->reverse_map = NULL;
+}
+
+
+
+void
+nautilus_list_model_set_should_sort_directories_first (NautilusListModel *model,
+                                                       gboolean           sort_directories_first)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (priv->sort_directories_first == sort_directories_first)
+    {
+        return;
+    }
+
+    priv->sort_directories_first = sort_directories_first;
+    nautilus_list_model_sort (model);
+}
+
+int
+nautilus_list_model_get_sort_column_id_from_attribute (NautilusListModel *model,
+                                                       GQuark             attribute)
+{
+    NautilusListModelPrivate *priv;
+    guint i;
+
+    if (attribute == 0)
+    {
+        return -1;
+    }
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    /* Hack - the preferences dialog sets modification_date for some
+     * rather than date_modified for some reason.  Make sure that
+     * works. */
+    if (attribute == attribute_modification_date_q)
+    {
+        attribute = attribute_date_modified_q;
+    }
+
+    for (i = 0; i < priv->columns->len; i++)
+    {
+        NautilusColumn *column;
+        GQuark column_attribute;
+
+        column = NAUTILUS_COLUMN (priv->columns->pdata[i]);
+        g_object_get (G_OBJECT (column),
+                      "attribute_q", &column_attribute,
+                      NULL);
+        if (column_attribute == attribute)
+        {
+            return NAUTILUS_LIST_MODEL_NUM_COLUMNS + i;
+        }
+    }
+
+    return -1;
+}
+
+GQuark
+nautilus_list_model_get_attribute_from_sort_column_id (NautilusListModel *model,
+                                                       int                sort_column_id)
+{
+    NautilusListModelPrivate *priv;
+    NautilusColumn *column;
+    int index;
+    GQuark attribute;
+
+    priv = nautilus_list_model_get_instance_private (model);
+    index = sort_column_id - NAUTILUS_LIST_MODEL_NUM_COLUMNS;
+
+    if (index < 0 || index >= priv->columns->len)
+    {
+        g_warning ("unknown sort column id: %d", sort_column_id);
+        return 0;
+    }
+
+    column = NAUTILUS_COLUMN (priv->columns->pdata[index]);
+    g_object_get (G_OBJECT (column), "attribute_q", &attribute, NULL);
+
+    return attribute;
+}
+
+NautilusListZoomLevel
+nautilus_list_model_get_zoom_level_from_column_id (int column)
+{
+    switch (column)
+    {
+        case NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN:
+        {
+            return NAUTILUS_LIST_ZOOM_LEVEL_SMALL;
+        }
+
+        case NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN:
+        {
+            return NAUTILUS_LIST_ZOOM_LEVEL_STANDARD;
+        }
+
+        case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN:
+        {
+            return NAUTILUS_LIST_ZOOM_LEVEL_LARGE;
+        }
+
+        case NAUTILUS_LIST_MODEL_LARGER_ICON_COLUMN:
+            return NAUTILUS_LIST_ZOOM_LEVEL_LARGER;
+    }
+
+    g_return_val_if_reached (NAUTILUS_LIST_ZOOM_LEVEL_STANDARD);
+}
+
+int
+nautilus_list_model_get_column_id_from_zoom_level (NautilusListZoomLevel zoom_level)
+{
+    switch (zoom_level)
+    {
+        case NAUTILUS_LIST_ZOOM_LEVEL_SMALL:
+        {
+            return NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN;
+        }
+
+        case NAUTILUS_LIST_ZOOM_LEVEL_STANDARD:
+        {
+            return NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN;
+        }
+
+        case NAUTILUS_LIST_ZOOM_LEVEL_LARGE:
+        {
+            return NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN;
+        }
+
+        case NAUTILUS_LIST_ZOOM_LEVEL_LARGER:
+            return NAUTILUS_LIST_MODEL_LARGER_ICON_COLUMN;
+    }
+
+    g_return_val_if_reached (NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN);
+}
+
+void
+nautilus_list_model_set_drag_view (NautilusListModel *model,
+                                   GtkTreeView       *view,
+                                   int                drag_begin_x,
+                                   int                drag_begin_y)
+{
+    NautilusListModelPrivate *priv;
+
+    g_return_if_fail (model != NULL);
+    g_return_if_fail (NAUTILUS_IS_LIST_MODEL (model));
+    g_return_if_fail (!view || GTK_IS_TREE_VIEW (view));
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    priv->drag_view = view;
+    priv->drag_begin_x = drag_begin_x;
+    priv->drag_begin_y = drag_begin_y;
+}
+
+GtkTreeView *
+nautilus_list_model_get_drag_view (NautilusListModel *model,
+                                   int               *drag_begin_x,
+                                   int               *drag_begin_y)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (drag_begin_x != NULL)
+    {
+        *drag_begin_x = priv->drag_begin_x;
+    }
+
+    if (drag_begin_y != NULL)
+    {
+        *drag_begin_y = priv->drag_begin_y;
+    }
+
+    return priv->drag_view;
+}
+
+GtkTargetList *
+nautilus_list_model_get_drag_target_list ()
+{
+    GtkTargetList *target_list;
+
+    target_list = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types));
+    gtk_target_list_add_text_targets (target_list, NAUTILUS_ICON_DND_TEXT);
+
+    return target_list;
+}
+
+int
+nautilus_list_model_add_column (NautilusListModel *model,
+                                NautilusColumn    *column)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    g_ptr_array_add (priv->columns, column);
+    g_object_ref (column);
+
+    return NAUTILUS_LIST_MODEL_NUM_COLUMNS + (priv->columns->len - 1);
+}
+
+static void
+nautilus_list_model_dispose (GObject *object)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+    int i;
+
+    model = NAUTILUS_LIST_MODEL (object);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (priv->columns)
+    {
+        for (i = 0; i < priv->columns->len; i++)
+        {
+            g_object_unref (priv->columns->pdata[i]);
+        }
+        g_ptr_array_free (priv->columns, TRUE);
+        priv->columns = NULL;
+    }
+
+    if (priv->files)
+    {
+        g_sequence_free (priv->files);
+        priv->files = NULL;
+    }
+
+    if (priv->top_reverse_map)
+    {
+        g_hash_table_destroy (priv->top_reverse_map);
+        priv->top_reverse_map = NULL;
+    }
+    if (priv->directory_reverse_map)
+    {
+        g_hash_table_destroy (priv->directory_reverse_map);
+        priv->directory_reverse_map = NULL;
+    }
+
+    G_OBJECT_CLASS (nautilus_list_model_parent_class)->dispose (object);
+}
+
+static void
+nautilus_list_model_finalize (GObject *object)
+{
+    NautilusListModel *model;
+    NautilusListModelPrivate *priv;
+
+    model = NAUTILUS_LIST_MODEL (object);
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (priv->highlight_files != NULL)
+    {
+        nautilus_file_list_free (priv->highlight_files);
+        priv->highlight_files = NULL;
+    }
+
+    G_OBJECT_CLASS (nautilus_list_model_parent_class)->finalize (object);
+}
+
+static void
+nautilus_list_model_init (NautilusListModel *model)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    priv->files = g_sequence_new ((GDestroyNotify) file_entry_free);
+    priv->top_reverse_map = g_hash_table_new (g_direct_hash, g_direct_equal);
+    priv->directory_reverse_map = g_hash_table_new (g_direct_hash, g_direct_equal);
+    priv->stamp = g_random_int ();
+    priv->sort_attribute = 0;
+    priv->columns = g_ptr_array_new ();
+}
+
+static void
+nautilus_list_model_class_init (NautilusListModelClass *klass)
+{
+    GObjectClass *object_class;
+
+    attribute_name_q = g_quark_from_static_string ("name");
+    attribute_modification_date_q = g_quark_from_static_string ("modification_date");
+    attribute_date_modified_q = g_quark_from_static_string ("date_modified");
+
+    object_class = (GObjectClass *) klass;
+    object_class->finalize = nautilus_list_model_finalize;
+    object_class->dispose = nautilus_list_model_dispose;
+
+    list_model_signals[SUBDIRECTORY_UNLOADED] =
+        g_signal_new ("subdirectory-unloaded",
+                      NAUTILUS_TYPE_LIST_MODEL,
+                      G_SIGNAL_RUN_FIRST,
+                      G_STRUCT_OFFSET (NautilusListModelClass, subdirectory_unloaded),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__OBJECT,
+                      G_TYPE_NONE, 1,
+                      NAUTILUS_TYPE_DIRECTORY);
+
+    list_model_signals[GET_ICON_SCALE] =
+        g_signal_new ("get-icon-scale",
+                      NAUTILUS_TYPE_LIST_MODEL,
+                      G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST,
+                      0, NULL, NULL,
+                      NULL,
+                      G_TYPE_INT, 0);
+}
+
+static void
+nautilus_list_model_tree_model_init (GtkTreeModelIface *iface)
+{
+    iface->get_flags = nautilus_list_model_get_flags;
+    iface->get_n_columns = nautilus_list_model_get_n_columns;
+    iface->get_column_type = nautilus_list_model_get_column_type;
+    iface->get_iter = nautilus_list_model_get_iter;
+    iface->get_path = nautilus_list_model_get_path;
+    iface->get_value = nautilus_list_model_get_value;
+    iface->iter_next = nautilus_list_model_iter_next;
+    iface->iter_children = nautilus_list_model_iter_children;
+    iface->iter_has_child = nautilus_list_model_iter_has_child;
+    iface->iter_n_children = nautilus_list_model_iter_n_children;
+    iface->iter_nth_child = nautilus_list_model_iter_nth_child;
+    iface->iter_parent = nautilus_list_model_iter_parent;
+}
+
+static void
+nautilus_list_model_sortable_init (GtkTreeSortableIface *iface)
+{
+    iface->get_sort_column_id = nautilus_list_model_get_sort_column_id;
+    iface->set_sort_column_id = nautilus_list_model_set_sort_column_id;
+    iface->has_default_sort_func = nautilus_list_model_has_default_sort_func;
+}
+
+void
+nautilus_list_model_subdirectory_done_loading (NautilusListModel *model,
+                                               NautilusDirectory *directory)
+{
+    NautilusListModelPrivate *priv;
+    GtkTreeIter iter;
+    GtkTreePath *path;
+    FileEntry *file_entry, *dummy_entry;
+    GSequenceIter *parent_ptr, *dummy_ptr;
+    GSequence *files;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (model == NULL || priv->directory_reverse_map == NULL)
+    {
+        return;
+    }
+    parent_ptr = g_hash_table_lookup (priv->directory_reverse_map,
+                                      directory);
+    if (parent_ptr == NULL)
+    {
+        return;
+    }
+
+    file_entry = g_sequence_get (parent_ptr);
+    files = file_entry->files;
+
+    /* Only swap loading -> empty if we saw no files yet at "done",
+     * otherwise, toggle loading at first added file to the model.
+     */
+    if (!nautilus_directory_is_not_empty (directory) &&
+        g_sequence_get_length (files) == 1)
+    {
+        dummy_ptr = g_sequence_get_iter_at_pos (file_entry->files, 0);
+        dummy_entry = g_sequence_get (dummy_ptr);
+        if (dummy_entry->file == NULL)
+        {
+            /* was the dummy file */
+            file_entry->loaded = 1;
+
+            iter.stamp = priv->stamp;
+            iter.user_data = dummy_ptr;
+
+            path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+            gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
+            gtk_tree_path_free (path);
+        }
+    }
+}
+
+static void
+refresh_row (gpointer data,
+             gpointer user_data)
+{
+    NautilusFile *file;
+    NautilusListModel *model;
+    GList *iters, *l;
+    GtkTreePath *path;
+
+    model = user_data;
+    file = data;
+
+    iters = nautilus_list_model_get_all_iters_for_file (model, file);
+    for (l = iters; l != NULL; l = l->next)
+    {
+        path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), l->data);
+        gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, l->data);
+
+        gtk_tree_path_free (path);
+    }
+
+    g_list_free_full (iters, g_free);
+}
+
+void
+nautilus_list_model_set_highlight_for_files (NautilusListModel *model,
+                                             GList             *files)
+{
+    NautilusListModelPrivate *priv;
+
+    priv = nautilus_list_model_get_instance_private (model);
+
+    if (priv->highlight_files != NULL)
+    {
+        g_list_foreach (priv->highlight_files, refresh_row, model);
+        nautilus_file_list_free (priv->highlight_files);
+        priv->highlight_files = NULL;
+    }
+
+    if (files != NULL)
+    {
+        priv->highlight_files = nautilus_file_list_copy (files);
+        g_list_foreach (priv->highlight_files, refresh_row, model);
+    }
+}