moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 2152 insertions, 0 deletions

diff --git a/src/file-manager/fm-tree-model.c b/src/file-manager/fm-tree-model.c
new file mode 100644
index 00000000..6356db90
--- /dev/null
+++ b/src/file-manager/fm-tree-model.c
@@ -0,0 +1,2152 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/*
+ * Copyright C) 2000, 2001 Eazel, Inc
+ * Copyright (C) 2002 Anders Carlsson
+ * Copyright (C) 2002 Bent Spoon Software
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Authors: Anders Carlsson <[email protected]>
+ *          Darin Adler <[email protected]>
+ */
+
+/* fm-tree-model.c - model for the tree view */
+
+#include <config.h>
+#include "fm-tree-model.h"
+
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-gdk-pixbuf-extensions.h>
+#include <glib/gi18n.h>
+#include <libcaja-private/caja-directory.h>
+#include <libcaja-private/caja-file-attributes.h>
+#include <libcaja-private/caja-file.h>
+#include <gtk/gtk.h>
+#include <string.h>
+
+enum
+{
+    ROW_LOADED,
+    LAST_SIGNAL
+};
+
+static guint tree_model_signals[LAST_SIGNAL] = { 0 };
+
+typedef gboolean (* FilePredicate) (CajaFile *);
+
+/* The user_data of the GtkTreeIter is the TreeNode pointer.
+ * It's NULL for the dummy node. If it's NULL, then user_data2
+ * is the TreeNode pointer to the parent.
+ */
+
+typedef struct TreeNode TreeNode;
+typedef struct FMTreeModelRoot FMTreeModelRoot;
+
+struct TreeNode
+{
+    /* part of this node for the file itself */
+    int ref_count;
+
+    CajaFile *file;
+    char *display_name;
+    GIcon *icon;
+    GMount *mount;
+    GdkPixbuf *closed_pixbuf;
+    GdkPixbuf *open_pixbuf;
+    GdkPixbuf *emblem_pixbuf;
+
+    FMTreeModelRoot *root;
+
+    TreeNode *parent;
+    TreeNode *next;
+    TreeNode *prev;
+
+    /* part of the node used only for directories */
+    int dummy_child_ref_count;
+    int all_children_ref_count;
+
+    CajaDirectory *directory;
+    guint done_loading_id;
+    guint files_added_id;
+    guint files_changed_id;
+
+    TreeNode *first_child;
+
+    /* misc. flags */
+    guint done_loading : 1;
+    guint force_has_dummy : 1;
+    guint inserted : 1;
+};
+
+struct FMTreeModelDetails
+{
+    int stamp;
+
+    TreeNode *root_node;
+
+    guint monitoring_update_idle_id;
+
+    gboolean show_hidden_files;
+    gboolean show_backup_files;
+    gboolean show_only_directories;
+
+    GList *highlighted_files;
+};
+
+struct FMTreeModelRoot
+{
+    FMTreeModel *model;
+
+    /* separate hash table for each root node needed */
+    GHashTable *file_to_node_map;
+
+    TreeNode *root_node;
+};
+
+typedef struct
+{
+    CajaDirectory *directory;
+    FMTreeModel *model;
+} DoneLoadingParameters;
+
+static void fm_tree_model_tree_model_init (GtkTreeModelIface *iface);
+static void schedule_monitoring_update     (FMTreeModel *model);
+static void destroy_node_without_reporting (FMTreeModel *model,
+        TreeNode          *node);
+static void report_node_contents_changed   (FMTreeModel *model,
+        TreeNode          *node);
+
+G_DEFINE_TYPE_WITH_CODE (FMTreeModel, fm_tree_model, G_TYPE_OBJECT,
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
+                                 fm_tree_model_tree_model_init));
+
+static GtkTreeModelFlags
+fm_tree_model_get_flags (GtkTreeModel *tree_model)
+{
+    return GTK_TREE_MODEL_ITERS_PERSIST;
+}
+
+static void
+object_unref_if_not_NULL (gpointer object)
+{
+    if (object == NULL)
+    {
+        return;
+    }
+    g_object_unref (object);
+}
+
+static FMTreeModelRoot *
+tree_model_root_new (FMTreeModel *model)
+{
+    FMTreeModelRoot *root;
+
+    root = g_new0 (FMTreeModelRoot, 1);
+    root->model = model;
+    root->file_to_node_map = g_hash_table_new (NULL, NULL);
+
+    return root;
+}
+
+static TreeNode *
+tree_node_new (CajaFile *file, FMTreeModelRoot *root)
+{
+    TreeNode *node;
+
+    node = g_new0 (TreeNode, 1);
+    node->file = caja_file_ref (file);
+    node->root = root;
+    return node;
+}
+
+static void
+tree_node_unparent (FMTreeModel *model, TreeNode *node)
+{
+    TreeNode *parent, *next, *prev;
+
+    parent = node->parent;
+    next = node->next;
+    prev = node->prev;
+
+    if (parent == NULL &&
+            node == model->details->root_node)
+    {
+        /* it's the first root node -> if there is a next then let it be the first root node */
+        model->details->root_node = next;
+    }
+
+    if (next != NULL)
+    {
+        next->prev = prev;
+    }
+    if (prev == NULL && parent != NULL)
+    {
+        g_assert (parent->first_child == node);
+        parent->first_child = next;
+    }
+    else if (prev != NULL)
+    {
+        prev->next = next;
+    }
+
+    node->parent = NULL;
+    node->next = NULL;
+    node->prev = NULL;
+    node->root = NULL;
+}
+
+static void
+tree_node_destroy (FMTreeModel *model, TreeNode *node)
+{
+    g_assert (node->first_child == NULL);
+    g_assert (node->ref_count == 0);
+
+    tree_node_unparent (model, node);
+
+    g_object_unref (node->file);
+    g_free (node->display_name);
+    object_unref_if_not_NULL (node->icon);
+    object_unref_if_not_NULL (node->closed_pixbuf);
+    object_unref_if_not_NULL (node->open_pixbuf);
+    object_unref_if_not_NULL (node->emblem_pixbuf);
+
+    g_assert (node->done_loading_id == 0);
+    g_assert (node->files_added_id == 0);
+    g_assert (node->files_changed_id == 0);
+    caja_directory_unref (node->directory);
+
+    g_free (node);
+}
+
+static void
+tree_node_parent (TreeNode *node, TreeNode *parent)
+{
+    TreeNode *first_child;
+
+    g_assert (parent != NULL);
+    g_assert (node->parent == NULL);
+    g_assert (node->prev == NULL);
+    g_assert (node->next == NULL);
+
+    first_child = parent->first_child;
+
+    node->parent = parent;
+    node->root = parent->root;
+    node->next = first_child;
+
+    if (first_child != NULL)
+    {
+        g_assert (first_child->prev == NULL);
+        first_child->prev = node;
+    }
+
+    parent->first_child = node;
+}
+
+static GdkPixbuf *
+get_menu_icon (GIcon *icon)
+{
+    CajaIconInfo *info;
+    GdkPixbuf *pixbuf;
+    int size;
+
+    size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU);
+
+    info = caja_icon_info_lookup (icon, size);
+    pixbuf = caja_icon_info_get_pixbuf_nodefault_at_size (info, size);
+    g_object_unref (info);
+
+    return pixbuf;
+}
+
+static GdkPixbuf *
+get_menu_icon_for_file (TreeNode *node,
+                        CajaFile *file,
+                        CajaFileIconFlags flags)
+{
+    CajaIconInfo *info;
+    GdkPixbuf *pixbuf, *retval;
+    gboolean highlight;
+    int size;
+    FMTreeModel *model;
+
+    size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU);
+
+    info = caja_file_get_icon (file, size, flags);
+    retval = caja_icon_info_get_pixbuf_nodefault_at_size (info, size);
+    model = node->root->model;
+
+    highlight = (g_list_find_custom (model->details->highlighted_files,
+                                     file, (GCompareFunc) caja_file_compare_location) != NULL);
+
+    if (highlight)
+    {
+        pixbuf = eel_gdk_pixbuf_render (retval, 1, 255, 255, 0, 0);
+
+        if (pixbuf != NULL)
+        {
+            g_object_unref (retval);
+            retval = pixbuf;
+        }
+    }
+
+    g_object_unref (info);
+
+    return retval;
+}
+
+static GdkPixbuf *
+tree_node_get_pixbuf (TreeNode *node,
+                      CajaFileIconFlags flags)
+{
+    if (node->parent == NULL)
+    {
+        return get_menu_icon (node->icon);
+    }
+    return get_menu_icon_for_file (node, node->file, flags);
+}
+
+static gboolean
+tree_node_update_pixbuf (TreeNode *node,
+                         GdkPixbuf **pixbuf_storage,
+                         CajaFileIconFlags flags)
+{
+    GdkPixbuf *pixbuf;
+
+    if (*pixbuf_storage == NULL)
+    {
+        return FALSE;
+    }
+    pixbuf = tree_node_get_pixbuf (node, flags);
+    if (pixbuf == *pixbuf_storage)
+    {
+        g_object_unref (pixbuf);
+        return FALSE;
+    }
+    g_object_unref (*pixbuf_storage);
+    *pixbuf_storage = pixbuf;
+    return TRUE;
+}
+
+static gboolean
+tree_node_update_closed_pixbuf (TreeNode *node)
+{
+    return tree_node_update_pixbuf (node, &node->closed_pixbuf, 0);
+}
+
+static gboolean
+tree_node_update_open_pixbuf (TreeNode *node)
+{
+    return tree_node_update_pixbuf (node, &node->open_pixbuf, CAJA_FILE_ICON_FLAGS_FOR_OPEN_FOLDER);
+}
+
+static GdkPixbuf *
+tree_node_get_emblem_pixbuf_internal (TreeNode *node)
+{
+    GdkPixbuf *pixbuf;
+    GList *emblem_pixbufs;
+    char *emblems_to_ignore[3];
+    int i;
+
+    i = 0;
+    emblems_to_ignore[i++] = CAJA_FILE_EMBLEM_NAME_TRASH;
+
+    if (node->parent && node->parent->file)
+    {
+        if (!caja_file_can_write (node->parent->file))
+        {
+            emblems_to_ignore[i++] = CAJA_FILE_EMBLEM_NAME_CANT_WRITE;
+        }
+    }
+
+    emblems_to_ignore[i++] = NULL;
+
+    emblem_pixbufs = caja_file_get_emblem_pixbufs (node->file,
+                     caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU),
+                     TRUE,
+                     emblems_to_ignore);
+
+
+    if (emblem_pixbufs != NULL)
+    {
+        pixbuf = g_object_ref (emblem_pixbufs->data);
+    }
+    else
+    {
+        pixbuf = NULL;
+    }
+
+    eel_gdk_pixbuf_list_free (emblem_pixbufs);
+
+    return pixbuf;
+}
+
+static gboolean
+tree_node_update_emblem_pixbuf (TreeNode *node)
+{
+    GdkPixbuf *pixbuf;
+
+    if (node->emblem_pixbuf == NULL)
+    {
+        return FALSE;
+    }
+    pixbuf = tree_node_get_emblem_pixbuf_internal (node);
+    if (pixbuf == node->emblem_pixbuf)
+    {
+        g_object_unref (pixbuf);
+        return FALSE;
+    }
+    g_object_unref (node->emblem_pixbuf);
+    node->emblem_pixbuf = pixbuf;
+    return TRUE;
+}
+
+static gboolean
+tree_node_update_display_name (TreeNode *node)
+{
+    char *display_name;
+
+    if (node->display_name == NULL)
+    {
+        return FALSE;
+    }
+    /* don't update root node display names */
+    if (node->parent == NULL)
+    {
+        return FALSE;
+    }
+    display_name = caja_file_get_display_name (node->file);
+    if (strcmp (display_name, node->display_name) == 0)
+    {
+        g_free (display_name);
+        return FALSE;
+    }
+    g_free (node->display_name);
+    node->display_name = NULL;
+    return TRUE;
+}
+
+static GdkPixbuf *
+tree_node_get_closed_pixbuf (TreeNode *node)
+{
+    if (node->closed_pixbuf == NULL)
+    {
+        node->closed_pixbuf = tree_node_get_pixbuf (node, 0);
+    }
+    return node->closed_pixbuf;
+}
+
+static GdkPixbuf *
+tree_node_get_open_pixbuf (TreeNode *node)
+{
+    if (node->open_pixbuf == NULL)
+    {
+        node->open_pixbuf = tree_node_get_pixbuf (node, CAJA_FILE_ICON_FLAGS_FOR_OPEN_FOLDER);
+    }
+    return node->open_pixbuf;
+}
+
+static GdkPixbuf *
+tree_node_get_emblem_pixbuf (TreeNode *node)
+{
+    if (node->emblem_pixbuf == NULL)
+    {
+        node->emblem_pixbuf = tree_node_get_emblem_pixbuf_internal (node);
+    }
+    return node->emblem_pixbuf;
+}
+
+static const char *
+tree_node_get_display_name (TreeNode *node)
+{
+    if (node->display_name == NULL)
+    {
+        node->display_name = caja_file_get_display_name (node->file);
+    }
+    return node->display_name;
+}
+
+static gboolean
+tree_node_has_dummy_child (TreeNode *node)
+{
+    return (node->directory != NULL
+            && (!node->done_loading
+                || node->first_child == NULL
+                || node->force_has_dummy)) ||
+           /* Roots always have dummy nodes if directory isn't loaded yet */
+           (node->directory == NULL && node->parent == NULL);
+}
+
+static int
+tree_node_get_child_index (TreeNode *parent, TreeNode *child)
+{
+    int i;
+    TreeNode *node;
+
+    if (child == NULL)
+    {
+        g_assert (tree_node_has_dummy_child (parent));
+        return 0;
+    }
+
+    i = tree_node_has_dummy_child (parent) ? 1 : 0;
+    for (node = parent->first_child; node != NULL; node = node->next, i++)
+    {
+        if (child == node)
+        {
+            return i;
+        }
+    }
+
+    g_assert_not_reached ();
+    return 0;
+}
+
+static gboolean
+make_iter_invalid (GtkTreeIter *iter)
+{
+    iter->stamp = 0;
+    iter->user_data = NULL;
+    iter->user_data2 = NULL;
+    iter->user_data3 = NULL;
+    return FALSE;
+}
+
+static gboolean
+make_iter_for_node (TreeNode *node, GtkTreeIter *iter, int stamp)
+{
+    if (node == NULL)
+    {
+        return make_iter_invalid (iter);
+    }
+    iter->stamp = stamp;
+    iter->user_data = node;
+    iter->user_data2 = NULL;
+    iter->user_data3 = NULL;
+    return TRUE;
+}
+
+static gboolean
+make_iter_for_dummy_row (TreeNode *parent, GtkTreeIter *iter, int stamp)
+{
+    g_assert (tree_node_has_dummy_child (parent));
+    g_assert (parent != NULL);
+    iter->stamp = stamp;
+    iter->user_data = NULL;
+    iter->user_data2 = parent;
+    iter->user_data3 = NULL;
+    return TRUE;
+}
+
+static TreeNode *
+get_node_from_file (FMTreeModelRoot *root, CajaFile *file)
+{
+    return g_hash_table_lookup (root->file_to_node_map, file);
+}
+
+static TreeNode *
+get_parent_node_from_file (FMTreeModelRoot *root, CajaFile *file)
+{
+    CajaFile *parent_file;
+    TreeNode *parent_node;
+
+    parent_file = caja_file_get_parent (file);
+    parent_node = get_node_from_file (root, parent_file);
+    caja_file_unref (parent_file);
+    return parent_node;
+}
+
+static TreeNode *
+create_node_for_file (FMTreeModelRoot *root, CajaFile *file)
+{
+    TreeNode *node;
+
+    g_assert (get_node_from_file (root, file) == NULL);
+    node = tree_node_new (file, root);
+    g_hash_table_insert (root->file_to_node_map, node->file, node);
+    return node;
+}
+
+#ifdef LOG_REF_COUNTS
+
+static char *
+get_node_uri (GtkTreeIter *iter)
+{
+    TreeNode *node, *parent;
+    char *parent_uri, *node_uri;
+
+    node = iter->user_data;
+    if (node != NULL)
+    {
+        return caja_file_get_uri (node->file);
+    }
+
+    parent = iter->user_data2;
+    parent_uri = caja_file_get_uri (parent->file);
+    node_uri = g_strconcat (parent_uri, " -- DUMMY", NULL);
+    g_free (parent_uri);
+    return node_uri;
+}
+
+#endif
+
+static void
+decrement_ref_count (FMTreeModel *model, TreeNode *node, int count)
+{
+    node->all_children_ref_count -= count;
+    if (node->all_children_ref_count == 0)
+    {
+        schedule_monitoring_update (model);
+    }
+}
+
+static void
+abandon_node_ref_count (FMTreeModel *model, TreeNode *node)
+{
+    if (node->parent != NULL)
+    {
+        decrement_ref_count (model, node->parent, node->ref_count);
+#ifdef LOG_REF_COUNTS
+        if (node->ref_count != 0)
+        {
+            char *uri;
+
+            uri = caja_file_get_uri (node->file);
+            g_message ("abandoning %d ref of %s, count is now %d",
+                       node->ref_count, uri, node->parent->all_children_ref_count);
+            g_free (uri);
+        }
+#endif
+    }
+    node->ref_count = 0;
+}
+
+static void
+abandon_dummy_row_ref_count (FMTreeModel *model, TreeNode *node)
+{
+    decrement_ref_count (model, node, node->dummy_child_ref_count);
+    if (node->dummy_child_ref_count != 0)
+    {
+#ifdef LOG_REF_COUNTS
+        char *uri;
+
+        uri = caja_file_get_uri (node->file);
+        g_message ("abandoning %d ref of %s -- DUMMY, count is now %d",
+                   node->dummy_child_ref_count, uri, node->all_children_ref_count);
+        g_free (uri);
+#endif
+    }
+    node->dummy_child_ref_count = 0;
+}
+
+static void
+report_row_inserted (FMTreeModel *model, GtkTreeIter *iter)
+{
+    GtkTreePath *path;
+
+    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);
+}
+
+static void
+report_row_contents_changed (FMTreeModel *model, GtkTreeIter *iter)
+{
+    GtkTreePath *path;
+
+    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
+report_row_has_child_toggled (FMTreeModel *model, GtkTreeIter *iter)
+{
+    GtkTreePath *path;
+
+    path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter);
+    gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (model), path, iter);
+    gtk_tree_path_free (path);
+}
+
+static GtkTreePath *
+get_node_path (FMTreeModel *model, TreeNode *node)
+{
+    GtkTreeIter iter;
+
+    make_iter_for_node (node, &iter, model->details->stamp);
+    return gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+}
+
+static void
+report_dummy_row_inserted (FMTreeModel *model, TreeNode *parent)
+{
+    GtkTreeIter iter;
+
+    if (!parent->inserted)
+    {
+        return;
+    }
+    make_iter_for_dummy_row (parent, &iter, model->details->stamp);
+    report_row_inserted (model, &iter);
+}
+
+static void
+report_dummy_row_deleted (FMTreeModel *model, TreeNode *parent)
+{
+    GtkTreeIter iter;
+    GtkTreePath *path;
+
+    if (parent->inserted)
+    {
+        make_iter_for_node (parent, &iter, model->details->stamp);
+        path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
+        gtk_tree_path_append_index (path, 0);
+        gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+        gtk_tree_path_free (path);
+    }
+    abandon_dummy_row_ref_count (model, parent);
+}
+
+static void
+report_node_inserted (FMTreeModel *model, TreeNode *node)
+{
+    GtkTreeIter iter;
+
+    make_iter_for_node (node, &iter, model->details->stamp);
+    report_row_inserted (model, &iter);
+    node->inserted = TRUE;
+
+    if (tree_node_has_dummy_child (node))
+    {
+        report_dummy_row_inserted (model, node);
+    }
+
+    if (node->directory != NULL ||
+            node->parent == NULL)
+    {
+        report_row_has_child_toggled (model, &iter);
+    }
+}
+
+static void
+report_node_contents_changed (FMTreeModel *model, TreeNode *node)
+{
+    GtkTreeIter iter;
+
+    if (!node->inserted)
+    {
+        return;
+    }
+    make_iter_for_node (node, &iter, model->details->stamp);
+    report_row_contents_changed (model, &iter);
+}
+
+static void
+report_node_has_child_toggled (FMTreeModel *model, TreeNode *node)
+{
+    GtkTreeIter iter;
+
+    if (!node->inserted)
+    {
+        return;
+    }
+    make_iter_for_node (node, &iter, model->details->stamp);
+    report_row_has_child_toggled (model, &iter);
+}
+
+static void
+report_dummy_row_contents_changed (FMTreeModel *model, TreeNode *parent)
+{
+    GtkTreeIter iter;
+
+    if (!parent->inserted)
+    {
+        return;
+    }
+    make_iter_for_dummy_row (parent, &iter, model->details->stamp);
+    report_row_contents_changed (model, &iter);
+}
+
+static void
+stop_monitoring_directory (FMTreeModel *model, TreeNode *node)
+{
+    CajaDirectory *directory;
+
+    if (node->done_loading_id == 0)
+    {
+        g_assert (node->files_added_id == 0);
+        g_assert (node->files_changed_id == 0);
+        return;
+    }
+
+    directory = node->directory;
+
+    g_signal_handler_disconnect (node->directory, node->done_loading_id);
+    g_signal_handler_disconnect (node->directory, node->files_added_id);
+    g_signal_handler_disconnect (node->directory, node->files_changed_id);
+
+    node->done_loading_id = 0;
+    node->files_added_id = 0;
+    node->files_changed_id = 0;
+
+    caja_directory_file_monitor_remove (node->directory, model);
+}
+
+static void
+destroy_children_without_reporting (FMTreeModel *model, TreeNode *parent)
+{
+    while (parent->first_child != NULL)
+    {
+        destroy_node_without_reporting (model, parent->first_child);
+    }
+}
+
+static void
+destroy_node_without_reporting (FMTreeModel *model, TreeNode *node)
+{
+    abandon_node_ref_count (model, node);
+    stop_monitoring_directory (model, node);
+    node->inserted = FALSE;
+    destroy_children_without_reporting (model, node);
+    g_hash_table_remove (node->root->file_to_node_map, node->file);
+    tree_node_destroy (model, node);
+}
+
+static void
+destroy_node (FMTreeModel *model, TreeNode *node)
+{
+    TreeNode *parent;
+    gboolean parent_had_dummy_child;
+    GtkTreePath *path;
+
+    parent = node->parent;
+    parent_had_dummy_child = tree_node_has_dummy_child (parent);
+
+    path = get_node_path (model, node);
+
+    /* Report row_deleted before actually deleting */
+    gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+    gtk_tree_path_free (path);
+
+    destroy_node_without_reporting (model, node);
+
+    if (tree_node_has_dummy_child (parent))
+    {
+        if (!parent_had_dummy_child)
+        {
+            report_dummy_row_inserted (model, parent);
+        }
+    }
+    else
+    {
+        g_assert (!parent_had_dummy_child);
+    }
+}
+
+static void
+destroy_children (FMTreeModel *model, TreeNode *parent)
+{
+    while (parent->first_child != NULL)
+    {
+        destroy_node (model, parent->first_child);
+    }
+}
+
+static void
+destroy_children_by_function (FMTreeModel *model, TreeNode *parent, FilePredicate f)
+{
+    TreeNode *child, *next;
+
+    for (child = parent->first_child; child != NULL; child = next)
+    {
+        next = child->next;
+        if (f (child->file))
+        {
+            destroy_node (model, child);
+        }
+        else
+        {
+            destroy_children_by_function (model, child, f);
+        }
+    }
+}
+
+static void
+destroy_by_function (FMTreeModel *model, FilePredicate f)
+{
+    TreeNode *node;
+    for (node = model->details->root_node; node != NULL; node = node->next)
+    {
+        destroy_children_by_function (model, node, f);
+    }
+}
+
+static gboolean
+update_node_without_reporting (FMTreeModel *model, TreeNode *node)
+{
+    gboolean changed;
+
+    changed = FALSE;
+
+    if (node->directory == NULL &&
+            (caja_file_is_directory (node->file) || node->parent == NULL))
+    {
+        node->directory = caja_directory_get_for_file (node->file);
+    }
+    else if (node->directory != NULL &&
+             !(caja_file_is_directory (node->file) || node->parent == NULL))
+    {
+        stop_monitoring_directory (model, node);
+        destroy_children (model, node);
+        caja_directory_unref (node->directory);
+        node->directory = NULL;
+    }
+
+    changed |= tree_node_update_display_name (node);
+    changed |= tree_node_update_closed_pixbuf (node);
+    changed |= tree_node_update_open_pixbuf (node);
+    changed |= tree_node_update_emblem_pixbuf (node);
+
+    return changed;
+}
+
+static void
+insert_node (FMTreeModel *model, TreeNode *parent, TreeNode *node)
+{
+    gboolean parent_empty;
+
+    parent_empty = parent->first_child == NULL;
+    if (parent_empty)
+    {
+        /* Make sure the dummy lives as we insert the new row */
+        parent->force_has_dummy = TRUE;
+    }
+
+    tree_node_parent (node, parent);
+
+    update_node_without_reporting (model, node);
+    report_node_inserted (model, node);
+
+    if (parent_empty)
+    {
+        parent->force_has_dummy = FALSE;
+        if (!tree_node_has_dummy_child (parent))
+        {
+            /* Temporarily set this back so that row_deleted is
+             * sent before actually removing the dummy child */
+            parent->force_has_dummy = TRUE;
+            report_dummy_row_deleted (model, parent);
+            parent->force_has_dummy = FALSE;
+        }
+    }
+}
+
+static void
+reparent_node (FMTreeModel *model, TreeNode *node)
+{
+    GtkTreePath *path;
+    TreeNode *new_parent;
+
+    new_parent = get_parent_node_from_file (node->root, node->file);
+    if (new_parent == NULL || new_parent->directory == NULL)
+    {
+        destroy_node (model, node);
+        return;
+    }
+
+    path = get_node_path (model, node);
+
+    /* Report row_deleted before actually deleting */
+    gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+    gtk_tree_path_free (path);
+
+    abandon_node_ref_count (model, node);
+    tree_node_unparent (model, node);
+
+    insert_node (model, new_parent, node);
+}
+
+static gboolean
+should_show_file (FMTreeModel *model, CajaFile *file)
+{
+    gboolean should;
+    TreeNode *node;
+
+    should = caja_file_should_show (file,
+                                    model->details->show_hidden_files,
+                                    model->details->show_backup_files,
+                                    TRUE);
+
+    if (should
+            && model->details->show_only_directories
+            &&! caja_file_is_directory (file))
+    {
+        should = FALSE;
+    }
+
+    if (should && caja_file_is_gone (file))
+    {
+        should = FALSE;
+    }
+
+    for (node = model->details->root_node; node != NULL; node = node->next)
+    {
+        if (!should && node != NULL && file == node->file)
+        {
+            should = TRUE;
+        }
+    }
+
+    return should;
+}
+
+static void
+update_node (FMTreeModel *model, TreeNode *node)
+{
+    gboolean had_dummy_child, has_dummy_child;
+    gboolean had_directory, has_directory;
+    gboolean changed;
+
+    if (!should_show_file (model, node->file))
+    {
+        destroy_node (model, node);
+        return;
+    }
+
+    if (node->parent != NULL && node->parent->directory != NULL
+            && !caja_directory_contains_file (node->parent->directory, node->file))
+    {
+        reparent_node (model, node);
+        return;
+    }
+
+    had_dummy_child = tree_node_has_dummy_child (node);
+    had_directory = node->directory != NULL;
+
+    changed = update_node_without_reporting (model, node);
+
+    has_dummy_child = tree_node_has_dummy_child (node);
+    has_directory = node->directory != NULL;
+
+    if (had_dummy_child != has_dummy_child)
+    {
+        if (has_dummy_child)
+        {
+            report_dummy_row_inserted (model, node);
+        }
+        else
+        {
+            /* Temporarily set this back so that row_deleted is
+             * sent before actually removing the dummy child */
+            node->force_has_dummy = TRUE;
+            report_dummy_row_deleted (model, node);
+            node->force_has_dummy = FALSE;
+        }
+    }
+    if (had_directory != has_directory)
+    {
+        report_node_has_child_toggled (model, node);
+    }
+
+    if (changed)
+    {
+        report_node_contents_changed (model, node);
+    }
+}
+
+static void
+process_file_change (FMTreeModelRoot *root,
+                     CajaFile *file)
+{
+    TreeNode *node, *parent;
+
+    node = get_node_from_file (root, file);
+    if (node != NULL)
+    {
+        update_node (root->model, node);
+        return;
+    }
+
+    if (!should_show_file (root->model, file))
+    {
+        return;
+    }
+
+    parent = get_parent_node_from_file (root, file);
+    if (parent == NULL)
+    {
+        return;
+    }
+
+    insert_node (root->model, parent, create_node_for_file (root, file));
+}
+
+static void
+files_changed_callback (CajaDirectory *directory,
+                        GList *changed_files,
+                        gpointer callback_data)
+{
+    FMTreeModelRoot *root;
+    GList *node;
+
+    root = (FMTreeModelRoot *) (callback_data);
+
+    for (node = changed_files; node != NULL; node = node->next)
+    {
+        process_file_change (root, CAJA_FILE (node->data));
+    }
+}
+
+static void
+set_done_loading (FMTreeModel *model, TreeNode *node, gboolean done_loading)
+{
+    gboolean had_dummy;
+
+    if (node == NULL || node->done_loading == done_loading)
+    {
+        return;
+    }
+
+    had_dummy = tree_node_has_dummy_child (node);
+
+    node->done_loading = done_loading;
+
+    if (tree_node_has_dummy_child (node))
+    {
+        if (had_dummy)
+        {
+            report_dummy_row_contents_changed (model, node);
+        }
+        else
+        {
+            report_dummy_row_inserted (model, node);
+        }
+    }
+    else
+    {
+        if (had_dummy)
+        {
+            /* Temporarily set this back so that row_deleted is
+             * sent before actually removing the dummy child */
+            node->force_has_dummy = TRUE;
+            report_dummy_row_deleted (model, node);
+            node->force_has_dummy = FALSE;
+        }
+        else
+        {
+            g_assert_not_reached ();
+        }
+    }
+}
+
+static void
+done_loading_callback (CajaDirectory *directory,
+                       FMTreeModelRoot *root)
+{
+    CajaFile *file;
+    TreeNode *node;
+    GtkTreeIter iter;
+
+    file = caja_directory_get_corresponding_file (directory);
+    node = get_node_from_file (root, file);
+    if (node == NULL)
+    {
+        /* This can happen for non-existing files as tree roots,
+         * since the directory <-> file object relation gets
+         * broken due to caja_directory_remove_file()
+         * getting called when i/o fails.
+         */
+        return;
+    }
+    set_done_loading (root->model, node, TRUE);
+    caja_file_unref (file);
+
+    make_iter_for_node (node, &iter, root->model->details->stamp);
+    g_signal_emit (root->model,
+                   tree_model_signals[ROW_LOADED], 0,
+                   &iter);
+}
+
+static CajaFileAttributes
+get_tree_monitor_attributes (void)
+{
+    CajaFileAttributes attributes;
+
+    attributes =
+        CAJA_FILE_ATTRIBUTES_FOR_ICON |
+        CAJA_FILE_ATTRIBUTE_INFO |
+        CAJA_FILE_ATTRIBUTE_LINK_INFO;
+
+    return attributes;
+}
+
+static void
+start_monitoring_directory (FMTreeModel *model, TreeNode *node)
+{
+    CajaDirectory *directory;
+    CajaFileAttributes attributes;
+
+    if (node->done_loading_id != 0)
+    {
+        return;
+    }
+
+    g_assert (node->files_added_id == 0);
+    g_assert (node->files_changed_id == 0);
+
+    directory = node->directory;
+
+    node->done_loading_id = g_signal_connect
+                            (directory, "done_loading",
+                             G_CALLBACK (done_loading_callback), node->root);
+    node->files_added_id = g_signal_connect
+                           (directory, "files_added",
+                            G_CALLBACK (files_changed_callback), node->root);
+    node->files_changed_id = g_signal_connect
+                             (directory, "files_changed",
+                              G_CALLBACK (files_changed_callback), node->root);
+
+    set_done_loading (model, node, caja_directory_are_all_files_seen (directory));
+
+    attributes = get_tree_monitor_attributes ();
+    caja_directory_file_monitor_add (directory, model,
+                                     model->details->show_hidden_files,
+                                     model->details->show_backup_files,
+                                     attributes, files_changed_callback, node->root);
+}
+
+static int
+fm_tree_model_get_n_columns (GtkTreeModel *model)
+{
+    return FM_TREE_MODEL_NUM_COLUMNS;
+}
+
+static GType
+fm_tree_model_get_column_type (GtkTreeModel *model, int index)
+{
+    switch (index)
+    {
+    case FM_TREE_MODEL_DISPLAY_NAME_COLUMN:
+        return G_TYPE_STRING;
+    case FM_TREE_MODEL_CLOSED_PIXBUF_COLUMN:
+        return GDK_TYPE_PIXBUF;
+    case FM_TREE_MODEL_OPEN_PIXBUF_COLUMN:
+        return GDK_TYPE_PIXBUF;
+    case FM_TREE_MODEL_EMBLEM_PIXBUF_COLUMN:
+        return GDK_TYPE_PIXBUF;
+    case FM_TREE_MODEL_FONT_STYLE_COLUMN:
+        return PANGO_TYPE_STYLE;
+    default:
+        g_assert_not_reached ();
+    }
+
+    return G_TYPE_INVALID;
+}
+
+static gboolean
+iter_is_valid (FMTreeModel *model, const GtkTreeIter *iter)
+{
+    TreeNode *node, *parent;
+
+    if (iter->stamp != model->details->stamp)
+    {
+        return FALSE;
+    }
+
+    node = iter->user_data;
+    parent = iter->user_data2;
+    if (node == NULL)
+    {
+        if (parent != NULL)
+        {
+            if (!CAJA_IS_FILE (parent->file))
+            {
+                return FALSE;
+            }
+            if (!tree_node_has_dummy_child (parent))
+            {
+                return FALSE;
+            }
+        }
+    }
+    else
+    {
+        if (!CAJA_IS_FILE (node->file))
+        {
+            return FALSE;
+        }
+        if (parent != NULL)
+        {
+            return FALSE;
+        }
+    }
+    if (iter->user_data3 != NULL)
+    {
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static gboolean
+fm_tree_model_get_iter (GtkTreeModel *model, GtkTreeIter *iter, GtkTreePath *path)
+{
+    int *indices;
+    GtkTreeIter parent;
+    int depth, i;
+
+    indices = gtk_tree_path_get_indices (path);
+    depth = gtk_tree_path_get_depth (path);
+
+    if (! gtk_tree_model_iter_nth_child (model, iter, NULL, indices[0]))
+    {
+        return FALSE;
+    }
+
+    for (i = 1; i < depth; i++)
+    {
+        parent = *iter;
+
+        if (! gtk_tree_model_iter_nth_child (model, iter, &parent, indices[i]))
+        {
+            return FALSE;
+        }
+    }
+
+    return TRUE;
+}
+
+static GtkTreePath *
+fm_tree_model_get_path (GtkTreeModel *model, GtkTreeIter *iter)
+{
+    FMTreeModel *tree_model;
+    TreeNode *node, *parent, *cnode;
+    GtkTreePath *path;
+    GtkTreeIter parent_iter;
+    int i;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), NULL);
+    tree_model = FM_TREE_MODEL (model);
+    g_return_val_if_fail (iter_is_valid (tree_model, iter), NULL);
+
+    node = iter->user_data;
+    if (node == NULL)
+    {
+        parent = iter->user_data2;
+        if (parent == NULL)
+        {
+            return gtk_tree_path_new ();
+        }
+    }
+    else
+    {
+        parent = node->parent;
+        if (parent == NULL)
+        {
+            i = 0;
+            for (cnode = tree_model->details->root_node; cnode != node; cnode = cnode->next)
+            {
+                i++;
+            }
+            path = gtk_tree_path_new ();
+            gtk_tree_path_append_index (path, i);
+            return path;
+        }
+    }
+
+    parent_iter.stamp = iter->stamp;
+    parent_iter.user_data = parent;
+    parent_iter.user_data2 = NULL;
+    parent_iter.user_data3 = NULL;
+
+    path = fm_tree_model_get_path (model, &parent_iter);
+
+    gtk_tree_path_append_index (path, tree_node_get_child_index (parent, node));
+
+    return path;
+}
+
+static void
+fm_tree_model_get_value (GtkTreeModel *model, GtkTreeIter *iter, int column, GValue *value)
+{
+    TreeNode *node, *parent;
+    FMTreeModel *fm_model;
+
+    g_return_if_fail (FM_IS_TREE_MODEL (model));
+    g_return_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter));
+
+    fm_model = FM_TREE_MODEL (model);
+    node = iter->user_data;
+
+    switch (column)
+    {
+    case FM_TREE_MODEL_DISPLAY_NAME_COLUMN:
+        g_value_init (value, G_TYPE_STRING);
+        if (node == NULL)
+        {
+            parent = iter->user_data2;
+            g_value_set_static_string (value, parent->done_loading
+                                       ? _("(Empty)") : _("Loading..."));
+        }
+        else
+        {
+            g_value_set_string (value, tree_node_get_display_name (node));
+        }
+        break;
+    case FM_TREE_MODEL_CLOSED_PIXBUF_COLUMN:
+        g_value_init (value, GDK_TYPE_PIXBUF);
+        g_value_set_object (value, node == NULL ? NULL : tree_node_get_closed_pixbuf (node));
+        break;
+    case FM_TREE_MODEL_OPEN_PIXBUF_COLUMN:
+        g_value_init (value, GDK_TYPE_PIXBUF);
+        g_value_set_object (value, node == NULL ? NULL : tree_node_get_open_pixbuf (node));
+        break;
+    case FM_TREE_MODEL_EMBLEM_PIXBUF_COLUMN:
+        g_value_init (value, GDK_TYPE_PIXBUF);
+        g_value_set_object (value, node == NULL ? NULL : tree_node_get_emblem_pixbuf (node));
+        break;
+    case FM_TREE_MODEL_FONT_STYLE_COLUMN:
+        g_value_init (value, PANGO_TYPE_STYLE);
+        if (node == NULL)
+        {
+            g_value_set_enum (value, PANGO_STYLE_ITALIC);
+        }
+        else
+        {
+            g_value_set_enum (value, PANGO_STYLE_NORMAL);
+        }
+        break;
+    default:
+        g_assert_not_reached ();
+    }
+}
+
+static gboolean
+fm_tree_model_iter_next (GtkTreeModel *model, GtkTreeIter *iter)
+{
+    TreeNode *node, *parent, *next;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), FALSE);
+    g_return_val_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter), FALSE);
+
+    node = iter->user_data;
+
+    if (node == NULL)
+    {
+        parent = iter->user_data2;
+        next = parent->first_child;
+    }
+    else
+    {
+        next = node->next;
+    }
+
+    return make_iter_for_node (next, iter, iter->stamp);
+}
+
+static gboolean
+fm_tree_model_iter_children (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *parent_iter)
+{
+    TreeNode *parent;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), FALSE);
+    g_return_val_if_fail (iter_is_valid (FM_TREE_MODEL (model), parent_iter), FALSE);
+
+    parent = parent_iter->user_data;
+    if (parent == NULL)
+    {
+        return make_iter_invalid (iter);
+    }
+
+    if (tree_node_has_dummy_child (parent))
+    {
+        return make_iter_for_dummy_row (parent, iter, parent_iter->stamp);
+    }
+    return make_iter_for_node (parent->first_child, iter, parent_iter->stamp);
+}
+
+static gboolean
+fm_tree_model_iter_parent (GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *child_iter)
+{
+    TreeNode *child, *parent;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), FALSE);
+    g_return_val_if_fail (iter_is_valid (FM_TREE_MODEL (model), child_iter), FALSE);
+
+    child = child_iter->user_data;
+
+    if (child == NULL)
+    {
+        parent = child_iter->user_data2;
+    }
+    else
+    {
+        parent = child->parent;
+    }
+
+    return make_iter_for_node (parent, iter, child_iter->stamp);
+}
+
+static gboolean
+fm_tree_model_iter_has_child (GtkTreeModel *model, GtkTreeIter *iter)
+{
+    gboolean has_child;
+    TreeNode *node;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), FALSE);
+    g_return_val_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter), FALSE);
+
+    node = iter->user_data;
+
+    has_child = node != NULL && (node->directory != NULL || node->parent == NULL);
+
+#if 0
+    g_warning ("Node '%s' %s",
+               node && node->file ? caja_file_get_uri (node->file) : "no name",
+               has_child ? "has child" : "no child");
+#endif
+
+    return has_child;
+}
+
+static int
+fm_tree_model_iter_n_children (GtkTreeModel *model, GtkTreeIter *iter)
+{
+    FMTreeModel *tree_model;
+    TreeNode *parent, *node;
+    int n;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), FALSE);
+    g_return_val_if_fail (iter == NULL || iter_is_valid (FM_TREE_MODEL (model), iter), FALSE);
+
+    tree_model = FM_TREE_MODEL (model);
+
+    if (iter == NULL)
+    {
+        return 1;
+    }
+
+    parent = iter->user_data;
+    if (parent == NULL)
+    {
+        return 0;
+    }
+
+    n = tree_node_has_dummy_child (parent) ? 1 : 0;
+    for (node = parent->first_child; node != NULL; node = node->next)
+    {
+        n++;
+    }
+
+    return n;
+}
+
+static gboolean
+fm_tree_model_iter_nth_child (GtkTreeModel *model, GtkTreeIter *iter,
+                              GtkTreeIter *parent_iter, int n)
+{
+    FMTreeModel *tree_model;
+    TreeNode *parent, *node;
+    int i;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), FALSE);
+    g_return_val_if_fail (parent_iter == NULL
+                          || iter_is_valid (FM_TREE_MODEL (model), parent_iter), FALSE);
+
+    tree_model = FM_TREE_MODEL (model);
+
+    if (parent_iter == NULL)
+    {
+        node = tree_model->details->root_node;
+        for (i = 0; i < n && node != NULL; i++, node = node->next);
+        return make_iter_for_node (node, iter,
+                                   tree_model->details->stamp);
+    }
+
+    parent = parent_iter->user_data;
+    if (parent == NULL)
+    {
+        return make_iter_invalid (iter);
+    }
+
+    i = tree_node_has_dummy_child (parent) ? 1 : 0;
+    if (n == 0 && i == 1)
+    {
+        return make_iter_for_dummy_row (parent, iter, parent_iter->stamp);
+    }
+    for (node = parent->first_child; i != n; i++, node = node->next)
+    {
+        if (node == NULL)
+        {
+            return make_iter_invalid (iter);
+        }
+    }
+
+    return make_iter_for_node (node, iter, parent_iter->stamp);
+}
+
+static void
+update_monitoring (FMTreeModel *model, TreeNode *node)
+{
+    TreeNode *child;
+
+    if (node->all_children_ref_count == 0)
+    {
+        stop_monitoring_directory (model, node);
+        destroy_children (model, node);
+    }
+    else
+    {
+        for (child = node->first_child; child != NULL; child = child->next)
+        {
+            update_monitoring (model, child);
+        }
+        start_monitoring_directory (model, node);
+    }
+}
+
+static gboolean
+update_monitoring_idle_callback (gpointer callback_data)
+{
+    FMTreeModel *model;
+    TreeNode *node;
+
+    model = FM_TREE_MODEL (callback_data);
+    model->details->monitoring_update_idle_id = 0;
+    for (node = model->details->root_node; node != NULL; node = node->next)
+    {
+        update_monitoring (model, node);
+    }
+    return FALSE;
+}
+
+static void
+schedule_monitoring_update (FMTreeModel *model)
+{
+    if (model->details->monitoring_update_idle_id == 0)
+    {
+        model->details->monitoring_update_idle_id =
+            g_idle_add (update_monitoring_idle_callback, model);
+    }
+}
+
+static void
+stop_monitoring_directory_and_children (FMTreeModel *model, TreeNode *node)
+{
+    TreeNode *child;
+
+    stop_monitoring_directory (model, node);
+    for (child = node->first_child; child != NULL; child = child->next)
+    {
+        stop_monitoring_directory_and_children (model, child);
+    }
+}
+
+static void
+stop_monitoring (FMTreeModel *model)
+{
+    TreeNode *node;
+
+    for (node = model->details->root_node; node != NULL; node = node->next)
+    {
+        stop_monitoring_directory_and_children (model, node);
+    }
+}
+
+static void
+fm_tree_model_ref_node (GtkTreeModel *model, GtkTreeIter *iter)
+{
+    TreeNode *node, *parent;
+#ifdef LOG_REF_COUNTS
+    char *uri;
+#endif
+
+    g_return_if_fail (FM_IS_TREE_MODEL (model));
+    g_return_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter));
+
+    node = iter->user_data;
+    if (node == NULL)
+    {
+        parent = iter->user_data2;
+        g_assert (parent->dummy_child_ref_count >= 0);
+        ++parent->dummy_child_ref_count;
+    }
+    else
+    {
+        parent = node->parent;
+        g_assert (node->ref_count >= 0);
+        ++node->ref_count;
+    }
+
+    if (parent != NULL)
+    {
+        g_assert (parent->all_children_ref_count >= 0);
+        if (++parent->all_children_ref_count == 1)
+        {
+            if (parent->first_child == NULL)
+            {
+                parent->done_loading = FALSE;
+            }
+            schedule_monitoring_update (FM_TREE_MODEL (model));
+        }
+#ifdef LOG_REF_COUNTS
+        uri = get_node_uri (iter);
+        g_message ("ref of %s, count is now %d",
+                   uri, parent->all_children_ref_count);
+        g_free (uri);
+#endif
+    }
+}
+
+static void
+fm_tree_model_unref_node (GtkTreeModel *model, GtkTreeIter *iter)
+{
+    TreeNode *node, *parent;
+#ifdef LOG_REF_COUNTS
+    char *uri;
+#endif
+
+    g_return_if_fail (FM_IS_TREE_MODEL (model));
+    g_return_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter));
+
+    node = iter->user_data;
+    if (node == NULL)
+    {
+        parent = iter->user_data2;
+        g_assert (parent->dummy_child_ref_count > 0);
+        --parent->dummy_child_ref_count;
+    }
+    else
+    {
+        parent = node->parent;
+        g_assert (node->ref_count > 0);
+        --node->ref_count;
+    }
+
+    if (parent != NULL)
+    {
+        g_assert (parent->all_children_ref_count > 0);
+#ifdef LOG_REF_COUNTS
+        uri = get_node_uri (iter);
+        g_message ("unref of %s, count is now %d",
+                   uri, parent->all_children_ref_count - 1);
+        g_free (uri);
+#endif
+        if (--parent->all_children_ref_count == 0)
+        {
+            schedule_monitoring_update (FM_TREE_MODEL (model));
+        }
+    }
+}
+
+void
+fm_tree_model_add_root_uri (FMTreeModel *model, const char *root_uri, const char *display_name, GIcon *icon, GMount *mount)
+{
+    CajaFile *file;
+    TreeNode *node, *cnode;
+    FMTreeModelRoot *newroot;
+
+    file = caja_file_get_by_uri (root_uri);
+
+    newroot = tree_model_root_new (model);
+    node = create_node_for_file (newroot, file);
+    node->display_name = g_strdup (display_name);
+    node->icon = g_object_ref (icon);
+    if (mount)
+    {
+        node->mount = g_object_ref (mount);
+    }
+    newroot->root_node = node;
+    node->parent = NULL;
+    if (model->details->root_node == NULL)
+    {
+        model->details->root_node = node;
+    }
+    else
+    {
+        /* append it */
+        for (cnode = model->details->root_node; cnode->next != NULL; cnode = cnode->next);
+        cnode->next = node;
+        node->prev = cnode;
+    }
+
+    caja_file_unref (file);
+
+    update_node_without_reporting (model, node);
+    report_node_inserted (model, node);
+}
+
+GMount *
+fm_tree_model_get_mount_for_root_node_file (FMTreeModel *model, CajaFile *file)
+{
+    TreeNode *node;
+
+    for (node = model->details->root_node; node != NULL; node = node->next)
+    {
+        if (file == node->file)
+        {
+            break;
+        }
+    }
+
+    if (node)
+    {
+        return node->mount;
+    }
+
+    return NULL;
+}
+
+void
+fm_tree_model_remove_root_uri (FMTreeModel *model, const char *uri)
+{
+    TreeNode *node;
+    GtkTreePath *path;
+    FMTreeModelRoot *root;
+    CajaFile *file;
+
+    file = caja_file_get_by_uri (uri);
+    for (node = model->details->root_node; node != NULL; node = node->next)
+    {
+        if (file == node->file)
+        {
+            break;
+        }
+    }
+    caja_file_unref (file);
+
+    if (node)
+    {
+        /* remove the node */
+
+        if (node->mount)
+        {
+            g_object_unref (node->mount);
+            node->mount = NULL;
+        }
+
+        caja_file_monitor_remove (node->file, model);
+        path = get_node_path (model, node);
+
+        /* Report row_deleted before actually deleting */
+        gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+        gtk_tree_path_free (path);
+
+        if (node->prev)
+        {
+            node->prev->next = node->next;
+        }
+        if (node->next)
+        {
+            node->next->prev = node->prev;
+        }
+        if (node == model->details->root_node)
+        {
+            model->details->root_node = node->next;
+        }
+
+        /* destroy the root identifier */
+        root = node->root;
+        destroy_node_without_reporting (model, node);
+        g_hash_table_destroy (root->file_to_node_map);
+        g_free (root);
+    }
+}
+
+FMTreeModel *
+fm_tree_model_new (void)
+{
+    FMTreeModel *model;
+
+    model = g_object_new (FM_TYPE_TREE_MODEL, NULL);
+
+    return model;
+}
+
+void
+fm_tree_model_set_show_hidden_files (FMTreeModel *model,
+                                     gboolean show_hidden_files)
+{
+    g_return_if_fail (FM_IS_TREE_MODEL (model));
+    g_return_if_fail (show_hidden_files == FALSE || show_hidden_files == TRUE);
+
+    show_hidden_files = show_hidden_files != FALSE;
+    if (model->details->show_hidden_files == show_hidden_files)
+    {
+        return;
+    }
+    model->details->show_hidden_files = show_hidden_files;
+    model->details->show_backup_files = show_hidden_files;
+    stop_monitoring (model);
+    if (!show_hidden_files)
+    {
+        destroy_by_function (model, caja_file_is_hidden_file);
+    }
+    schedule_monitoring_update (model);
+}
+
+static gboolean
+file_is_not_directory (CajaFile *file)
+{
+    return !caja_file_is_directory (file);
+}
+
+void
+fm_tree_model_set_show_only_directories (FMTreeModel *model,
+        gboolean show_only_directories)
+{
+    g_return_if_fail (FM_IS_TREE_MODEL (model));
+    g_return_if_fail (show_only_directories == FALSE || show_only_directories == TRUE);
+
+    show_only_directories = show_only_directories != FALSE;
+    if (model->details->show_only_directories == show_only_directories)
+    {
+        return;
+    }
+    model->details->show_only_directories = show_only_directories;
+    stop_monitoring (model);
+    if (show_only_directories)
+    {
+        destroy_by_function (model, file_is_not_directory);
+    }
+    schedule_monitoring_update (model);
+}
+
+CajaFile *
+fm_tree_model_iter_get_file (FMTreeModel *model, GtkTreeIter *iter)
+{
+    TreeNode *node;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), NULL);
+    g_return_val_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter), NULL);
+
+    node = iter->user_data;
+    return node == NULL ? NULL : caja_file_ref (node->file);
+}
+
+/* This is used to work around some sort order stability problems
+   with gtktreemodelsort */
+int
+fm_tree_model_iter_compare_roots (FMTreeModel *model,
+                                  GtkTreeIter *iter_a,
+                                  GtkTreeIter *iter_b)
+{
+    TreeNode *a, *b, *n;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), 0);
+    g_return_val_if_fail (iter_is_valid (model, iter_a), 0);
+    g_return_val_if_fail (iter_is_valid (model, iter_b), 0);
+
+    a = iter_a->user_data;
+    b = iter_b->user_data;
+
+    g_assert (a != NULL && a->parent == NULL);
+    g_assert (b != NULL && b->parent == NULL);
+
+    if (a == b)
+    {
+        return 0;
+    }
+
+    for (n = model->details->root_node; n != NULL; n = n->next)
+    {
+        if (n == a)
+        {
+            return -1;
+        }
+        if (n == b)
+        {
+            return 1;
+        }
+    }
+    g_assert_not_reached ();
+}
+
+gboolean
+fm_tree_model_iter_is_root (FMTreeModel *model, GtkTreeIter *iter)
+{
+    TreeNode *node;
+
+    g_return_val_if_fail (FM_IS_TREE_MODEL (model), 0);
+    g_return_val_if_fail (iter_is_valid (model, iter), 0);
+    node = iter->user_data;
+    if (node == NULL)
+    {
+        return FALSE;
+    }
+    else
+    {
+        return (node->parent == NULL);
+    }
+}
+
+gboolean
+fm_tree_model_file_get_iter (FMTreeModel *model,
+                             GtkTreeIter *iter,
+                             CajaFile *file,
+                             GtkTreeIter *current_iter)
+{
+    TreeNode *node, *root_node;
+
+    if (current_iter != NULL && current_iter->user_data != NULL)
+    {
+        node = get_node_from_file (((TreeNode *) current_iter->user_data)->root, file);
+        return make_iter_for_node (node, iter, model->details->stamp);
+    }
+
+    for (root_node = model->details->root_node; root_node != NULL; root_node = root_node->next)
+    {
+        node = get_node_from_file (root_node->root, file);
+        if (node != NULL)
+        {
+            return make_iter_for_node (node, iter, model->details->stamp);
+        }
+    }
+    return FALSE;
+}
+
+static void
+do_update_node (CajaFile *file,
+                FMTreeModel *model)
+{
+    TreeNode *root, *node = NULL;
+
+    for (root = model->details->root_node; root != NULL; root = root->next)
+    {
+        node = get_node_from_file (root->root, file);
+
+        if (node != NULL)
+        {
+            break;
+        }
+    }
+
+    if (node == NULL)
+    {
+        return;
+    }
+
+    update_node (model, node);
+}
+
+void
+fm_tree_model_set_highlight_for_files (FMTreeModel *model,
+                                       GList *files)
+{
+    GList *old_files;
+
+    if (model->details->highlighted_files != NULL)
+    {
+        old_files = model->details->highlighted_files;
+        model->details->highlighted_files = NULL;
+
+        g_list_foreach (old_files,
+                        (GFunc) do_update_node, model);
+
+        caja_file_list_free (old_files);
+    }
+
+    if (files != NULL)
+    {
+        model->details->highlighted_files =
+            caja_file_list_copy (files);
+        g_list_foreach (model->details->highlighted_files,
+                        (GFunc) do_update_node, model);
+    }
+}
+
+static void
+fm_tree_model_init (FMTreeModel *model)
+{
+    model->details = g_new0 (FMTreeModelDetails, 1);
+
+    do
+    {
+        model->details->stamp = g_random_int ();
+    }
+    while (model->details->stamp == 0);
+}
+
+static void
+fm_tree_model_finalize (GObject *object)
+{
+    FMTreeModel *model;
+    TreeNode *root_node, *next_root;
+    FMTreeModelRoot *root;
+
+    model = FM_TREE_MODEL (object);
+
+    for (root_node = model->details->root_node; root_node != NULL; root_node = next_root)
+    {
+        next_root = root_node->next;
+        root = root_node->root;
+        destroy_node_without_reporting (model, root_node);
+        g_hash_table_destroy (root->file_to_node_map);
+        g_free (root);
+    }
+
+    if (model->details->monitoring_update_idle_id != 0)
+    {
+        g_source_remove (model->details->monitoring_update_idle_id);
+    }
+
+    if (model->details->highlighted_files != NULL)
+    {
+        caja_file_list_free (model->details->highlighted_files);
+    }
+
+    g_free (model->details);
+
+    G_OBJECT_CLASS (fm_tree_model_parent_class)->finalize (object);
+}
+
+static void
+fm_tree_model_class_init (FMTreeModelClass *class)
+{
+    G_OBJECT_CLASS (class)->finalize = fm_tree_model_finalize;
+
+    tree_model_signals[ROW_LOADED] =
+        g_signal_new ("row_loaded",
+                      FM_TYPE_TREE_MODEL,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET (FMTreeModelClass, row_loaded),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__BOXED,
+                      G_TYPE_NONE, 1,
+                      GTK_TYPE_TREE_ITER);
+}
+
+static void
+fm_tree_model_tree_model_init (GtkTreeModelIface *iface)
+{
+    iface->get_flags = fm_tree_model_get_flags;
+    iface->get_n_columns = fm_tree_model_get_n_columns;
+    iface->get_column_type = fm_tree_model_get_column_type;
+    iface->get_iter = fm_tree_model_get_iter;
+    iface->get_path = fm_tree_model_get_path;
+    iface->get_value = fm_tree_model_get_value;
+    iface->iter_next = fm_tree_model_iter_next;
+    iface->iter_children = fm_tree_model_iter_children;
+    iface->iter_has_child = fm_tree_model_iter_has_child;
+    iface->iter_n_children = fm_tree_model_iter_n_children;
+    iface->iter_nth_child = fm_tree_model_iter_nth_child;
+    iface->iter_parent = fm_tree_model_iter_parent;
+    iface->ref_node = fm_tree_model_ref_node;
+    iface->unref_node = fm_tree_model_unref_node;
+}
+
+