Pileus Git - ~andy/gtk/blob - gtk/gtkfilesystemmodel.c

   1 /* GTK - The GIMP Toolkit
   2  * gtkfilesystemmodel.c: GtkTreeModel wrapping a GtkFileSystem
   3  * Copyright (C) 2003, Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22 #include <string.h>
  23
  24 #include "gtkfilechooserprivate.h"
  25 #include "gtkfilesystemmodel.h"
  26 #include "gtkfilesystem.h"
  27 #include "gtkintl.h"
  28 #include "gtkmarshalers.h"
  29 #include "gtktreednd.h"
  30 #include "gtktreemodel.h"
  31 #include "gtkalias.h"
  32
  33 typedef struct _GtkFileSystemModelClass GtkFileSystemModelClass;
  34
  35 #define GTK_FILE_SYSTEM_MODEL_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModelClass))
  36 #define GTK_IS_FILE_SYSTEM_MODEL_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_SYSTEM_MODEL))
  37 #define GTK_FILE_SYSTEM_MODEL_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModelClass))
  38
  39 struct _GtkFileSystemModelClass
  40 {
  41   GObjectClass parent_class;
  42
  43   /* Signals */
  44
  45   void (*finished_loading) (GtkFileSystemModel *model);
  46 };
  47
  48
  49 static void gtk_file_system_model_iface_init   (GtkTreeModelIface       *iface);
  50 static void gtk_file_system_model_finalize     (GObject                 *object);
  51 static void gtk_file_system_model_dispose      (GObject                 *object);
  52
  53 static void drag_source_iface_init (GtkTreeDragSourceIface *iface);
  54
  55 static GtkTreeModelFlags gtk_file_system_model_get_flags       (GtkTreeModel *tree_model);
  56 static gint              gtk_file_system_model_get_n_columns   (GtkTreeModel *tree_model);
  57 static GType             gtk_file_system_model_get_column_type (GtkTreeModel *tree_model,
  58                                                                 gint          index);
  59 static gboolean          gtk_file_system_model_get_iter        (GtkTreeModel *tree_model,
  60                                                                 GtkTreeIter  *iter,
  61                                                                 GtkTreePath  *path);
  62 static GtkTreePath *     gtk_file_system_model_get_path        (GtkTreeModel *tree_model,
  63                                                                 GtkTreeIter  *iter);
  64 static void              gtk_file_system_model_get_value       (GtkTreeModel *tree_model,
  65                                                                 GtkTreeIter  *iter,
  66                                                                 gint          column,
  67                                                                 GValue       *value);
  68 static gboolean          gtk_file_system_model_iter_next       (GtkTreeModel *tree_model,
  69                                                                 GtkTreeIter  *iter);
  70 static gboolean          gtk_file_system_model_iter_children   (GtkTreeModel *tree_model,
  71                                                                 GtkTreeIter  *iter,
  72                                                                 GtkTreeIter  *parent);
  73 static gboolean          gtk_file_system_model_iter_has_child  (GtkTreeModel *tree_model,
  74                                                                 GtkTreeIter  *iter);
  75 static gint              gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model,
  76                                                                 GtkTreeIter  *iter);
  77 static gboolean          gtk_file_system_model_iter_nth_child  (GtkTreeModel *tree_model,
  78                                                                 GtkTreeIter  *iter,
  79                                                                 GtkTreeIter  *parent,
  80                                                                 gint          n);
  81 static gboolean          gtk_file_system_model_iter_parent     (GtkTreeModel *tree_model,
  82                                                                 GtkTreeIter  *iter,
  83                                                                 GtkTreeIter  *child);
  84 static void              gtk_file_system_model_ref_node        (GtkTreeModel *tree_model,
  85                                                                 GtkTreeIter  *iter);
  86 static void              gtk_file_system_model_unref_node      (GtkTreeModel *tree_model,
  87                                                                 GtkTreeIter  *iter);
  88
  89 static gboolean drag_source_row_draggable (GtkTreeDragSource   *drag_source,
  90                                            GtkTreePath         *path);
  91 static gboolean drag_source_drag_data_get (GtkTreeDragSource   *drag_source,
  92                                            GtkTreePath         *path,
  93                                            GtkSelectionData    *selection_data);
  94
  95 static FileModelNode *file_model_node_new        (GtkFileSystemModel *model,
  96                                                   GFile              *file);
  97 static void           file_model_node_free       (FileModelNode      *node);
  98 static void           file_model_node_ref        (FileModelNode      *node);
  99 static void           file_model_node_unref      (GtkFileSystemModel *model,
 100                                                   FileModelNode      *node);
 101
 102 static void file_model_node_idle_clear        (FileModelNode *node);
 103 static void file_model_node_idle_clear_cancel (FileModelNode *node);
 104 static void file_model_node_child_unref       (FileModelNode *parent);
 105
 106 static GFileInfo *        file_model_node_get_info     (GtkFileSystemModel *model,
 107                                                         FileModelNode      *node);
 108 static gboolean           file_model_node_is_visible   (GtkFileSystemModel *model,
 109                                                         FileModelNode      *node);
 110 static void               file_model_node_clear        (GtkFileSystemModel *model,
 111                                                         FileModelNode      *node);
 112 static FileModelNode *    file_model_node_get_children (GtkFileSystemModel *model,
 113                                                         FileModelNode      *node);
 114
 115 static void deleted_callback       (GFile         *folder,
 116                                     FileModelNode *node);
 117 static void files_added_callback   (GFile         *folder,
 118                                     GSList        *paths,
 119                                     FileModelNode *node);
 120 static void files_changed_callback (GFile         *folder,
 121                                     GSList        *paths,
 122                                     FileModelNode *node);
 123 static void files_removed_callback (GFile         *folder,
 124                                     GSList        *paths,
 125                                     FileModelNode *node);
 126
 127 static void root_deleted_callback       (GFile              *folder,
 128                                          GtkFileSystemModel *model);
 129 static void root_files_added_callback   (GFile              *folder,
 130                                          GSList             *paths,
 131                                          GtkFileSystemModel *model);
 132 static void root_files_changed_callback (GFile              *folder,
 133                                          GSList             *paths,
 134                                          GtkFileSystemModel *model);
 135 static void root_files_removed_callback (GFile              *folder,
 136                                          GSList             *paths,
 137                                          GtkFileSystemModel *model);
 138
 139 /* Signal IDs */
 140 enum {
 141   FINISHED_LOADING,
 142   LAST_SIGNAL
 143 };
 144
 145 static guint file_system_model_signals[LAST_SIGNAL] = { 0 };
 146
 147 \f
 148
 149 G_DEFINE_TYPE_WITH_CODE (GtkFileSystemModel, _gtk_file_system_model, G_TYPE_OBJECT,
 150                          G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
 151                                                 gtk_file_system_model_iface_init)
 152                          G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
 153                                                 drag_source_iface_init))
 154
 155 static void
 156 _gtk_file_system_model_class_init (GtkFileSystemModelClass *class)
 157 {
 158   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 159
 160   gobject_class->finalize = gtk_file_system_model_finalize;
 161   gobject_class->dispose = gtk_file_system_model_dispose;
 162
 163   file_system_model_signals[FINISHED_LOADING] =
 164     g_signal_new (I_("finished-loading"),
 165                   G_OBJECT_CLASS_TYPE (gobject_class),
 166                   G_SIGNAL_RUN_LAST,
 167                   G_STRUCT_OFFSET (GtkFileSystemModelClass, finished_loading),
 168                   NULL, NULL,
 169                   _gtk_marshal_VOID__VOID,
 170                   G_TYPE_NONE, 0);
 171 }
 172
 173 static void
 174 gtk_file_system_model_iface_init (GtkTreeModelIface *iface)
 175 {
 176   iface->get_flags =       gtk_file_system_model_get_flags;
 177   iface->get_n_columns =   gtk_file_system_model_get_n_columns;
 178   iface->get_column_type = gtk_file_system_model_get_column_type;
 179   iface->get_iter =        gtk_file_system_model_get_iter;
 180   iface->get_path =        gtk_file_system_model_get_path;
 181   iface->get_value =       gtk_file_system_model_get_value;
 182   iface->iter_next =       gtk_file_system_model_iter_next;
 183   iface->iter_children =   gtk_file_system_model_iter_children;
 184   iface->iter_has_child =  gtk_file_system_model_iter_has_child;
 185   iface->iter_n_children = gtk_file_system_model_iter_n_children;
 186   iface->iter_nth_child =  gtk_file_system_model_iter_nth_child;
 187   iface->iter_parent =     gtk_file_system_model_iter_parent;
 188   iface->ref_node =        gtk_file_system_model_ref_node;
 189   iface->unref_node =      gtk_file_system_model_unref_node;
 190 }
 191
 192 static void
 193 _gtk_file_system_model_init (GtkFileSystemModel *model)
 194 {
 195   model->show_files = TRUE;
 196   model->show_folders = TRUE;
 197   model->show_hidden = FALSE;
 198 }
 199
 200 static void
 201 gtk_file_system_model_finalize (GObject *object)
 202 {
 203   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
 204   FileModelNode *children, *next;
 205
 206   if (model->root_folder)
 207     g_object_unref (model->root_folder);
 208
 209   if (model->root_file)
 210     g_object_unref (model->root_file);
 211
 212   if (model->file_system)
 213     g_object_unref (model->file_system);
 214
 215   children = model->roots;
 216   while (children)
 217     {
 218       next = children->next;
 219       file_model_node_free (children);
 220       children = next;
 221     }
 222
 223   g_free (model->attributes);
 224
 225   G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object);
 226 }
 227
 228
 229 static void
 230 gtk_file_system_model_dispose (GObject *object)
 231 {
 232   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
 233
 234   if (model->pending_cancellables)
 235     {
 236       GSList *l;
 237
 238       for (l = model->pending_cancellables; l; l = l->next)
 239         g_cancellable_cancel (l->data);
 240       g_slist_free (model->pending_cancellables);
 241       model->pending_cancellables = NULL;
 242     }
 243
 244   G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object);
 245 }
 246
 247 static void
 248 drag_source_iface_init (GtkTreeDragSourceIface *iface)
 249 {
 250   iface->row_draggable = drag_source_row_draggable;
 251   iface->drag_data_get = drag_source_drag_data_get;
 252   iface->drag_data_delete = NULL;
 253 }
 254
 255 /*
 256  * ******************** GtkTreeModel methods ********************
 257  */
 258
 259 static GtkTreeModelFlags
 260 gtk_file_system_model_get_flags (GtkTreeModel *tree_model)
 261 {
 262   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 263   GtkTreeModelFlags flags = GTK_TREE_MODEL_ITERS_PERSIST;
 264
 265   if (model->max_depth == 0)
 266     flags |= GTK_TREE_MODEL_LIST_ONLY;
 267
 268   return flags;
 269 }
 270
 271 static gint
 272 gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model)
 273 {
 274   return GTK_FILE_SYSTEM_MODEL_N_COLUMNS;
 275 }
 276
 277 static GType
 278 gtk_file_system_model_get_column_type (GtkTreeModel *tree_model,
 279                                        gint          index)
 280 {
 281   switch (index)
 282     {
 283     case GTK_FILE_SYSTEM_MODEL_INFO:
 284       return G_TYPE_FILE_INFO;
 285     case GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME:
 286       return G_TYPE_STRING;
 287    default:
 288       g_assert_not_reached ();
 289       return G_TYPE_NONE;
 290     }
 291 }
 292
 293 static gboolean
 294 gtk_file_system_model_get_iter (GtkTreeModel *tree_model,
 295                                 GtkTreeIter  *iter,
 296                                 GtkTreePath  *path)
 297 {
 298   GtkTreeIter parent;
 299   gint *indices;
 300   gint depth, i;
 301
 302   indices = gtk_tree_path_get_indices (path);
 303   depth = gtk_tree_path_get_depth (path);
 304
 305   g_return_val_if_fail (depth > 0, FALSE);
 306
 307   if (!gtk_tree_model_iter_nth_child (tree_model, iter, NULL, indices[0]))
 308     return FALSE;
 309
 310   for (i = 1; i < depth; i++)
 311     {
 312       parent = *iter;
 313       if (!gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[i]))
 314         return FALSE;
 315     }
 316
 317   return TRUE;
 318 }
 319
 320 static GtkTreePath *
 321 gtk_file_system_model_get_path (GtkTreeModel *tree_model,
 322                                 GtkTreeIter  *iter)
 323 {
 324   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 325   FileModelNode *node = iter->user_data;
 326
 327   GtkTreePath *result = gtk_tree_path_new ();
 328
 329   while (node)
 330     {
 331       FileModelNode *parent = node->parent;
 332       FileModelNode *children;
 333       int n = 0;
 334
 335       if (parent)
 336         children = parent->children;
 337       else
 338         children = model->roots;
 339
 340       while (children != node)
 341         {
 342           if (children->is_visible)
 343             n++;
 344           children = children->next;
 345         }
 346
 347       gtk_tree_path_prepend_index (result, n);
 348
 349       node = parent;
 350     }
 351
 352   return result;
 353 }
 354
 355 static void
 356 gtk_file_system_model_get_value (GtkTreeModel *tree_model,
 357                                  GtkTreeIter  *iter,
 358                                  gint          column,
 359                                  GValue       *value)
 360 {
 361   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 362   FileModelNode *node = iter->user_data;
 363   GFileInfo *info;
 364
 365   switch (column)
 366     {
 367     case GTK_FILE_SYSTEM_MODEL_INFO:
 368       if (model->has_editable && node == model->roots)
 369         info = NULL;
 370       else
 371         info = file_model_node_get_info (model, node);
 372
 373       g_value_set_object (value, info);
 374       break;
 375     case GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME:
 376       {
 377         g_value_init (value, G_TYPE_STRING);
 378
 379         if (model->has_editable && node == model->roots)
 380           g_value_set_static_string (value, "");
 381         else
 382           {
 383             GFileInfo *info = file_model_node_get_info (model, node);
 384
 385             g_value_set_string (value, g_file_info_get_display_name (info));
 386           }
 387       }
 388       break;
 389     default:
 390       g_assert_not_reached ();
 391     }
 392 }
 393
 394 static gboolean
 395 gtk_file_system_model_iter_next (GtkTreeModel *tree_model,
 396                                  GtkTreeIter  *iter)
 397 {
 398   FileModelNode *node = iter->user_data;
 399
 400   node = node->next;
 401   while (node && !node->is_visible)
 402     node = node->next;
 403
 404   iter->user_data = node;
 405
 406   return node != NULL;
 407 }
 408
 409 static gboolean
 410 gtk_file_system_model_iter_children (GtkTreeModel *tree_model,
 411                                      GtkTreeIter  *iter,
 412                                      GtkTreeIter  *parent)
 413 {
 414   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 415   FileModelNode *children;
 416
 417   if (parent)
 418     {
 419       FileModelNode *parent_node = parent->user_data;
 420       children = file_model_node_get_children (model, parent_node);
 421     }
 422   else
 423     {
 424       children = model->roots;
 425     }
 426
 427   while (children && !children->is_visible)
 428     children = children->next;
 429
 430   iter->user_data = children;
 431
 432   return children != NULL;
 433 }
 434
 435 static gboolean
 436 gtk_file_system_model_iter_has_child (GtkTreeModel *tree_model,
 437                                       GtkTreeIter  *iter)
 438 {
 439   FileModelNode *node = iter->user_data;
 440   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 441
 442   if (node->depth == model->max_depth)
 443     return FALSE;
 444   else
 445     {
 446       GFileInfo *info = file_model_node_get_info (model, node);
 447       return (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
 448     }
 449 }
 450
 451 static gint
 452 gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model,
 453                                        GtkTreeIter  *iter)
 454 {
 455   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 456   FileModelNode *children;
 457   gint n = 0;
 458
 459   if (iter)
 460     {
 461       FileModelNode *node = iter->user_data;
 462       children = file_model_node_get_children (model, node);
 463     }
 464   else
 465     {
 466       children = model->roots;
 467     }
 468
 469   while (children)
 470     {
 471       if (children->is_visible)
 472         n++;
 473       children = children->next;
 474     }
 475
 476   return n;
 477 }
 478
 479 static gboolean
 480 gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model,
 481                                       GtkTreeIter  *iter,
 482                                       GtkTreeIter  *parent,
 483                                       gint          n)
 484 {
 485   GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
 486   FileModelNode *children;
 487
 488   if (parent)
 489     {
 490       FileModelNode *parent_node = parent->user_data;
 491       children = file_model_node_get_children (model, parent_node);
 492     }
 493   else
 494     {
 495       children = model->roots;
 496     }
 497
 498   while (children && !children->is_visible)
 499     children = children->next;
 500
 501   while (n && children)
 502     {
 503       n--;
 504       children = children->next;
 505       while (children && !children->is_visible)
 506         children = children->next;
 507     }
 508
 509   iter->user_data = children;
 510
 511   return children != NULL;
 512 }
 513
 514 static gboolean
 515 gtk_file_system_model_iter_parent (GtkTreeModel *tree_model,
 516                                    GtkTreeIter  *iter,
 517                                    GtkTreeIter  *child)
 518 {
 519   FileModelNode *node = child->user_data;
 520
 521   node = node->parent;
 522   iter->user_data = node;
 523
 524   return node != NULL;
 525 }
 526
 527 static void
 528 gtk_file_system_model_ref_node (GtkTreeModel *tree_model,
 529                                 GtkTreeIter  *iter)
 530 {
 531   file_model_node_ref (iter->user_data);
 532 }
 533
 534 static void
 535 gtk_file_system_model_unref_node (GtkTreeModel *tree_model,
 536                                   GtkTreeIter  *iter)
 537 {
 538   file_model_node_unref (GTK_FILE_SYSTEM_MODEL (tree_model),
 539                          iter->user_data);
 540 }
 541
 542 static gboolean
 543 drag_source_row_draggable (GtkTreeDragSource *drag_source,
 544                            GtkTreePath       *path)
 545 {
 546   GtkFileSystemModel *model;
 547   GtkTreeIter iter;
 548   FileModelNode *node;
 549
 550   model = GTK_FILE_SYSTEM_MODEL (drag_source);
 551
 552   if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
 553     return FALSE;
 554
 555   if (!model->has_editable)
 556     return TRUE;
 557
 558   node = iter.user_data;
 559   return (node != model->roots);
 560 }
 561
 562 static gboolean
 563 drag_source_drag_data_get (GtkTreeDragSource *drag_source,
 564                            GtkTreePath       *path,
 565                            GtkSelectionData  *selection_data)
 566 {
 567   GtkFileSystemModel *model;
 568   GtkTreeIter iter;
 569   GFile *file;
 570   char *uris[2];
 571
 572   model = GTK_FILE_SYSTEM_MODEL (drag_source);
 573
 574   if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
 575     return FALSE;
 576
 577   file = _gtk_file_system_model_get_file (model, &iter);
 578   g_assert (file != NULL);
 579
 580   uris[0] = g_file_get_uri (file);
 581   uris[1] = NULL;
 582
 583   gtk_selection_data_set_uris (selection_data, uris);
 584
 585   g_free (uris[0]);
 586
 587   return TRUE;
 588 }
 589
 590 /* Callback used when the root folder finished loading */
 591 static void
 592 root_folder_finished_loading_cb (GFile              *folder,
 593                                  GtkFileSystemModel *model)
 594 {
 595   g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0);
 596 }
 597
 598 static void
 599 got_root_folder_cb (GCancellable *cancellable,
 600                     GtkFolder    *folder,
 601                     const GError *error,
 602                     gpointer      data)
 603 {
 604   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
 605   GtkFileSystemModel *model = data;
 606   GSList *tmp_list;
 607
 608   tmp_list = g_slist_find (model->pending_cancellables, cancellable);
 609   if (!tmp_list)
 610     goto out;
 611
 612   model->pending_cancellables = g_slist_delete_link (model->pending_cancellables,
 613                                                      tmp_list);
 614
 615   if (cancelled || !folder)
 616     goto out;
 617
 618   model->root_folder = g_object_ref (folder);
 619
 620   g_signal_connect_object (model->root_folder, "finished-loading",
 621                            G_CALLBACK (root_folder_finished_loading_cb), model, 0);
 622   g_signal_connect_object (model->root_folder, "deleted",
 623                            G_CALLBACK (root_deleted_callback), model, 0);
 624   g_signal_connect_object (model->root_folder, "files-added",
 625                            G_CALLBACK (root_files_added_callback), model, 0);
 626   g_signal_connect_object (model->root_folder, "files-changed",
 627                            G_CALLBACK (root_files_changed_callback), model, 0);
 628   g_signal_connect_object (model->root_folder, "files-removed",
 629                            G_CALLBACK (root_files_removed_callback), model, 0);
 630
 631 out:
 632   g_object_unref (model);
 633   g_object_unref (cancellable);
 634 }
 635
 636 /**
 637  * _gtk_file_system_model_new:
 638  * @file_system: an object implementing #GtkFileSystem
 639  * @root_file: the root file path to show.
 640  * @max_depth: the maximum depth from the children of @root_file
 641  *             or the roots of the file system to display in
 642  *             the file selector). A depth of 0 displays
 643  *             only the immediate children of @root_file,
 644  *             or the roots of the filesystem. -1 for no
 645  *             maximum depth.
 646  * @error: location to store error, or %NULL.
 647  *
 648  * Creates a new #GtkFileSystemModel object. The #GtkFileSystemModel
 649  * object wraps a #GtkFileSystem interface as a #GtkTreeModel.
 650  * Using the @root_file and @max_depth parameters, the tree model
 651  * can be restricted to a subportion of the entire file system.
 652  *
 653  * Return value: the newly created #GtkFileSystemModel object, or NULL if there
 654  * was an error.
 655  **/
 656 GtkFileSystemModel *
 657 _gtk_file_system_model_new (GtkFileSystem     *file_system,
 658                             GFile             *root_file,
 659                             gint               max_depth,
 660                             const gchar       *attributes,
 661                             GError           **error)
 662 {
 663   GtkFileSystemModel *model;
 664   GCancellable *cancellable;
 665
 666   g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL);
 667   g_return_val_if_fail (G_IS_FILE (root_file), NULL);
 668   g_return_val_if_fail (error == NULL || *error == NULL, NULL);
 669
 670   /* Then, actually create the model and the root nodes */
 671
 672   model = g_object_new (GTK_TYPE_FILE_SYSTEM_MODEL, NULL);
 673   model->file_system = g_object_ref (file_system);
 674   if (max_depth < 0)
 675     model->max_depth = G_MAXUSHORT;
 676   else
 677     model->max_depth = MIN (max_depth, G_MAXUSHORT);
 678
 679   model->attributes = g_strdup (attributes);
 680   model->root_folder = NULL;
 681   model->root_file = g_object_ref (root_file);
 682
 683   model->roots = NULL;
 684
 685   cancellable = _gtk_file_system_get_folder (file_system, root_file,
 686                                              attributes,
 687                                              got_root_folder_cb,
 688                                              g_object_ref (model));
 689   if (!cancellable)
 690     {
 691       /* In this case got_root_folder_cb() will never be called, so we
 692        * need to unref model twice.
 693        */
 694       g_object_unref (model);
 695       g_object_unref (model);
 696
 697       g_set_error_literal (error,
 698                            GTK_FILE_CHOOSER_ERROR,
 699                            GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
 700                            _("Could not obtain root folder"));
 701
 702       return NULL;
 703     }
 704
 705   model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable);
 706
 707   return model;
 708 }
 709
 710 static void
 711 model_refilter_recurse (GtkFileSystemModel *model,
 712                         FileModelNode      *parent,
 713                         GtkTreePath        *path)
 714 {
 715   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
 716   int i = 0;
 717   FileModelNode *nodes;
 718   gboolean has_children = FALSE;
 719
 720   if (parent && !parent->loaded)
 721     return;
 722
 723   if (parent)
 724     nodes = parent->children;
 725   else
 726     nodes = model->roots;
 727
 728   while (nodes)
 729     {
 730       FileModelNode *next = nodes->next;
 731       gboolean is_visible;
 732
 733       gtk_tree_path_append_index (path, i);
 734
 735       is_visible = file_model_node_is_visible (model, nodes);
 736
 737       if (!is_visible && nodes->is_visible)
 738         {
 739           file_model_node_clear (model, nodes);
 740           gtk_tree_model_row_deleted (tree_model, path);
 741
 742           nodes->is_visible = FALSE;
 743         }
 744       else if (is_visible && !nodes->is_visible)
 745         {
 746           GtkTreeIter iter;
 747
 748           iter.user_data = nodes;
 749           nodes->is_visible = TRUE;
 750           gtk_tree_model_row_inserted (tree_model, path, &iter);
 751         }
 752       else
 753         model_refilter_recurse (model, nodes, path);
 754
 755       if (is_visible)
 756         {
 757           has_children = TRUE;
 758           i++;
 759         }
 760
 761       gtk_tree_path_up (path);
 762
 763       nodes = next;
 764     }
 765
 766   if (parent && !has_children)
 767     {
 768       /* Fixme - need to insert dummy node here */
 769     }
 770 }
 771
 772 static void
 773 model_refilter_all (GtkFileSystemModel *model)
 774 {
 775   GtkTreePath *path;
 776
 777   path = gtk_tree_path_new ();
 778   model_refilter_recurse (model, NULL, path);
 779   gtk_tree_path_free (path);
 780 }
 781
 782 /**
 783  * _gtk_file_system_model_set_show_hidden:
 784  * @model: a #GtkFileSystemModel
 785  * @show_hidden: whether hidden files should be displayed
 786  *
 787  * Sets whether hidden files should be included in the #GtkTreeModel
 788  * for display.
 789  **/
 790 void
 791 _gtk_file_system_model_set_show_hidden (GtkFileSystemModel *model,
 792                                         gboolean            show_hidden)
 793 {
 794   show_hidden = show_hidden != FALSE;
 795
 796   if (show_hidden != model->show_hidden)
 797     {
 798       model->show_hidden = show_hidden;
 799       model_refilter_all (model);
 800     }
 801 }
 802
 803 /**
 804  * _gtk_file_system_model_set_show_folders:
 805  * @model: a #GtkFileSystemModel
 806  * @show_folders: whether folders should be displayed
 807  *
 808  * Sets whether folders should be included in the #GtkTreeModel for
 809  * display.
 810  **/
 811 void
 812 _gtk_file_system_model_set_show_folders (GtkFileSystemModel *model,
 813                                          gboolean            show_folders)
 814 {
 815   show_folders = show_folders != FALSE;
 816
 817   if (show_folders != model->show_folders)
 818     {
 819       model->show_folders = show_folders;
 820       model_refilter_all (model);
 821     }
 822 }
 823
 824 /**
 825  * _gtk_file_system_model_set_show_files:
 826  * @model: a #GtkFileSystemModel
 827  * @show_files: whether files (as opposed to folders) should
 828  *              be displayed.
 829  *
 830  * Sets whether files (as opposed to folders) should be included
 831  * in the #GtkTreeModel for display.
 832  **/
 833 void
 834 _gtk_file_system_model_set_show_files (GtkFileSystemModel *model,
 835                                        gboolean            show_files)
 836 {
 837   show_files = show_files != FALSE;
 838
 839   if (show_files != model->show_files)
 840     {
 841       model->show_files = show_files;
 842       model_refilter_all (model);
 843     }
 844 }
 845
 846 /**
 847  * _gtk_file_system_model_get_info:
 848  * @model: a #GtkFileSystemModel
 849  * @iter: a #GtkTreeIter pointing to a row of @model
 850  *
 851  * Gets the #GFileInfo structure for a particular row
 852  * of @model. The information included in this structure
 853  * is determined by the @types parameter to
 854  * _gtk_file_system_model_new().
 855  *
 856  * Return value: a #GFileInfo structure. This structure
 857  *   is owned by @model and must not be modified or freed.
 858  *   If you want to save the information for later use,
 859  *   you must make a copy, since the structure may be
 860  *   freed on later changes to the file system.  If you have
 861  *   called _gtk_file_system_model_add_editable() and the @iter
 862  *   corresponds to the row that this function returned, the
 863  *   return value will be NULL.
 864  **/
 865 GFileInfo *
 866 _gtk_file_system_model_get_info (GtkFileSystemModel *model,
 867                                  GtkTreeIter        *iter)
 868 {
 869   FileModelNode *node;
 870
 871   node = iter->user_data;
 872   if (model->has_editable && node == model->roots)
 873     return NULL;
 874   else
 875     return file_model_node_get_info (model, node);
 876 }
 877
 878 /**
 879  * _gtk_file_system_model_get_file:
 880  * @model: a #GtkFileSystemModel
 881  * @iter: a #GtkTreeIter pointing to a row of @model
 882  *
 883  * Gets the path for a particular row in @model.
 884  *
 885  * Return value: the file. This object is owned by @model and
 886  *   or freed. If you want to save the path for later use,
 887  *   you must take a ref, since the object may be freed
 888  *   on later changes to the file system.
 889  **/
 890 GFile *
 891 _gtk_file_system_model_get_file (GtkFileSystemModel *model,
 892                                  GtkTreeIter        *iter)
 893 {
 894   FileModelNode *node = iter->user_data;
 895
 896   if (model->has_editable && node == model->roots)
 897     return NULL;
 898
 899   if (node->is_dummy)
 900     return node->parent->file;
 901   else
 902     return node->file;
 903 }
 904
 905 static void
 906 unref_node_and_parents (GtkFileSystemModel *model,
 907                         FileModelNode      *node)
 908 {
 909   file_model_node_unref (model, node);
 910   if (node->parent)
 911     file_model_node_unref (model, node->parent);
 912 }
 913
 914 static FileModelNode *
 915 find_child_node (GtkFileSystemModel *model,
 916                  FileModelNode      *parent_node,
 917                  GFile              *file)
 918 {
 919   FileModelNode *children;
 920
 921   if (parent_node)
 922     children = file_model_node_get_children (model, parent_node);
 923   else
 924     children = model->roots;
 925
 926   while (children)
 927     {
 928       if (children->is_visible &&
 929           children->file &&
 930           g_file_equal (children->file, file))
 931         return children;
 932
 933       children = children->next;
 934     }
 935
 936   return NULL;
 937 }
 938
 939 /**
 940  * _gtk_file_system_model_set_filter:
 941  * @mode: a #GtkFileSystemModel
 942  * @filter: function to be called for each file
 943  * @user_data: data to pass to @filter
 944  *
 945  * Sets a callback called for each file/directory to see whether
 946  * it should be included in model. If this function was made
 947  * public, we'd want to include a GDestroyNotify as well.
 948  **/
 949 void
 950 _gtk_file_system_model_set_filter (GtkFileSystemModel      *model,
 951                                    GtkFileSystemModelFilter filter,
 952                                    gpointer                 user_data)
 953 {
 954   g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
 955
 956   model->filter_func = filter;
 957   model->filter_data = user_data;
 958
 959   model_refilter_all (model);
 960 }
 961
 962
 963 struct RefPathData
 964 {
 965   GtkFileSystemModel *model;
 966   FileModelNode *node;
 967   FileModelNode *parent_node;
 968   GSList *files;
 969   GSList *cleanups;
 970   GtkFileSystemModelPathFunc func;
 971   gpointer user_data;
 972 };
 973
 974 /* FIXME: maybe we have to wait on finished-loading? */
 975 static void
 976 ref_path_cb (GCancellable *cancellable,
 977              GtkFolder    *folder,
 978              const GError *error,
 979              gpointer      data)
 980 {
 981   struct RefPathData *info = data;
 982   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
 983
 984   if (!g_slist_find (info->model->pending_cancellables, cancellable))
 985     goto out;
 986
 987   info->model->pending_cancellables = g_slist_remove (info->model->pending_cancellables, cancellable);
 988
 989   /* Note that !folder means that the child node was already
 990    * found, without using get_folder.
 991    */
 992   if (cancelled || error)
 993     goto out;
 994
 995   if (folder)
 996     info->cleanups = g_slist_prepend (info->cleanups, folder);
 997   else if (g_slist_length (info->files) == 1
 998            && g_file_equal (info->node->file, info->files->data))
 999     {
1000       /* Done, now call the function */
1001       if (info->node)
1002         {
1003           GtkTreeIter iter;
1004           GtkTreePath *path;
1005
1006           iter.user_data = info->node;
1007           path = gtk_tree_model_get_path (GTK_TREE_MODEL (info->model), &iter);
1008
1009           (* info->func) (info->model, path, &iter, info->user_data);
1010
1011           gtk_tree_path_free (path);
1012         }
1013
1014       goto out;
1015     }
1016
1017   info->node = find_child_node (info->model, info->parent_node, info->files->data);
1018   if (info->node)
1019     file_model_node_ref (info->node);
1020   else
1021     {
1022       goto out;
1023     }
1024
1025   g_object_unref (info->files);
1026   info->files = g_slist_remove (info->files, info->files->data);
1027
1028   if (g_slist_length (info->files) < 1)
1029     {
1030       /* Done, now call the function */
1031       if (info->node)
1032         {
1033           GtkTreeIter iter;
1034           GtkTreePath *path;
1035
1036           iter.user_data = info->node;
1037           path = gtk_tree_model_get_path (GTK_TREE_MODEL (info->model), &iter);
1038
1039           (* info->func) (info->model, path, &iter, info->user_data);
1040
1041           gtk_tree_path_free (path);
1042         }
1043
1044       goto out;
1045     }
1046   else
1047     {
1048       info->parent_node = info->node;
1049
1050       if (info->parent_node->loaded)
1051         {
1052           info->node = find_child_node (info->model, info->parent_node, info->files->data);
1053           ref_path_cb (NULL, NULL, NULL, info);
1054         }
1055       else
1056         {
1057           GCancellable *cancellable;
1058
1059           cancellable = _gtk_file_system_get_folder (info->model->file_system,
1060                                                      info->files->data,
1061                                                      info->model->attributes,
1062                                                      ref_path_cb, data);
1063           info->model->pending_cancellables =
1064             g_slist_append (info->model->pending_cancellables, cancellable);
1065         }
1066
1067       return;
1068     }
1069
1070 out:
1071   if (info->node)
1072     unref_node_and_parents (info->model, info->node);
1073   g_object_unref (info->files);
1074   g_slist_foreach (info->cleanups, (GFunc)g_object_unref, NULL);
1075   g_slist_free (info->cleanups);
1076   g_object_unref (info->model);
1077   g_free (info);
1078
1079   g_object_unref (cancellable);
1080 }
1081
1082 /**
1083  * _gtk_file_system_model_path_do:
1084  * @model: a #GtkFileSystemModel
1085  * @path: a path pointing to a file in the filesystem
1086  *       for @model.
1087  * @func: Function to call with the path and iter corresponding
1088  *        to @path.
1089  * @user_data: data to pass to @func
1090  *
1091  * Locates @path within @model, referencing
1092  * (gtk_tree_model_ref_node()) all parent nodes,
1093  * calls @func passing in the path and iter for @path,
1094  * then unrefs all the parent nodes.
1095  *
1096  * The reason for doing this operation as a callback
1097  * is so that if the operation performed with the
1098  * path and iter results in referencing the node
1099  * and/or parent nodes, we don't load all the information
1100  * about the nodes.
1101  *
1102  * This function is particularly useful for expanding
1103  * a #GtkTreeView to a particular point in the file system.
1104  */
1105 void
1106 _gtk_file_system_model_path_do (GtkFileSystemModel        *model,
1107                                 GFile                     *file,
1108                                 GtkFileSystemModelPathFunc func,
1109                                 gpointer                   user_data)
1110 {
1111   GFile *parent_file;
1112   GSList *files = NULL;
1113   FileModelNode *node;
1114   struct RefPathData *info;
1115
1116   if (g_file_equal (file, model->root_file))
1117     return;
1118
1119   parent_file = g_file_get_parent (file);
1120
1121   if (!parent_file)
1122     return;
1123
1124   files = g_slist_prepend (files, g_object_ref (file));
1125   while (!g_file_equal (parent_file, model->root_file))
1126     {
1127       files = g_slist_prepend (files, parent_file);
1128       parent_file = g_file_get_parent (parent_file);
1129       if (!parent_file)
1130         {
1131           g_slist_foreach (files, (GFunc) g_object_unref, NULL);
1132           g_slist_free (files);
1133           return;
1134         }
1135     }
1136
1137   if (g_slist_length (files) < 1)
1138     return;
1139
1140   /* Now we have all paths, except the root path */
1141   node = find_child_node (model, NULL, files->data);
1142   if (!node)
1143     {
1144       g_slist_foreach (files, (GFunc) g_object_unref, NULL);
1145       g_slist_free (files);
1146       return;
1147     }
1148
1149   file_model_node_ref (node);
1150
1151   g_object_unref (files->data);
1152   files = g_slist_remove (files, files->data);
1153
1154   if (g_slist_length (files) < 1)
1155     {
1156       /* Done, now call the function */
1157       if (node)
1158         {
1159           GtkTreeIter iter;
1160           GtkTreePath *path;
1161
1162           iter.user_data = node;
1163           path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
1164
1165           (* func) (model, path, &iter, user_data);
1166
1167           gtk_tree_path_free (path);
1168           unref_node_and_parents (model, node);
1169         }
1170     }
1171   else
1172     {
1173       info = g_new0 (struct RefPathData, 1);
1174       info->files = files;
1175       info->model = g_object_ref (model);
1176       info->func = func;
1177       info->user_data = user_data;
1178       info->node = node;
1179
1180       if (info->node->loaded)
1181         {
1182           info->parent_node = info->node;
1183           info->node = find_child_node (model, info->parent_node, info->files->data);
1184           ref_path_cb (NULL, NULL, NULL, info);
1185         }
1186       else
1187         {
1188           GCancellable *cancellable;
1189
1190           cancellable = _gtk_file_system_get_folder (model->file_system,
1191                                                      files->data,
1192                                                      model->attributes,
1193                                                      ref_path_cb, info);
1194           model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable);
1195         }
1196     }
1197 }
1198
1199 /**
1200  * _gtk_file_system_model_add_editable:
1201  * @model: a #GtkFileSystemModel
1202  * @iter: Location to return the iter corresponding to the editable row
1203  *
1204  * Adds an "empty" row at the beginning of the model.  This does not refer to
1205  * any file, but is a temporary placeholder for a file name that the user will
1206  * type when a corresponding cell is made editable.  When your code is done
1207  * using this temporary row, call _gtk_file_system_model_remove_editable().
1208  **/
1209 void
1210 _gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *iter)
1211 {
1212   FileModelNode *node;
1213   GtkTreePath *path;
1214
1215   g_return_if_fail (!model->has_editable);
1216
1217   model->has_editable = TRUE;
1218
1219   node = file_model_node_new (model, NULL);
1220   node->is_visible = TRUE;
1221
1222   node->next = model->roots;
1223   model->roots = node;
1224
1225   path = gtk_tree_path_new ();
1226   gtk_tree_path_append_index (path, 0);
1227   iter->user_data = node;
1228
1229   gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, iter);
1230
1231   gtk_tree_path_free (path);
1232 }
1233
1234 /**
1235  * _gtk_file_system_model_remove_editable:
1236  * @model: a #GtkFileSystemModel
1237  *
1238  * Removes the "empty" row at the beginning of the model that was
1239  * created with _gtk_file_system_model_add_editable().  You should call
1240  * this function when your code is finished editing this temporary row.
1241  **/
1242 void
1243 _gtk_file_system_model_remove_editable (GtkFileSystemModel *model)
1244 {
1245   GtkTreePath *path;
1246   FileModelNode *node;
1247
1248   g_return_if_fail (model->has_editable);
1249
1250   model->has_editable = FALSE;
1251
1252   node = model->roots;
1253   model->roots = model->roots->next;
1254   file_model_node_free (node);
1255
1256   path = gtk_tree_path_new ();
1257   gtk_tree_path_append_index (path, 0);
1258
1259   gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
1260
1261   gtk_tree_path_free (path);
1262 }
1263
1264 static FileModelNode *
1265 file_model_node_new (GtkFileSystemModel *model,
1266                      GFile              *file)
1267 {
1268   FileModelNode *node = g_new0 (FileModelNode, 1);
1269
1270   node->model = model;
1271   node->file = file ? g_object_ref (file) : NULL;
1272
1273   return node;
1274 }
1275
1276 static void
1277 file_model_node_free (FileModelNode *node)
1278 {
1279   file_model_node_clear (node->model, node);
1280
1281   if (node->file)
1282     g_object_unref (node->file);
1283
1284   if (node->info)
1285     g_object_unref (node->info);
1286
1287   g_free (node);
1288 }
1289
1290 static GFileInfo *
1291 file_model_node_get_info (GtkFileSystemModel *model,
1292                           FileModelNode      *node)
1293 {
1294   if (!node->info)
1295     {
1296       if (node->is_dummy)
1297         {
1298           node->info = g_file_info_new ();
1299           g_file_info_set_display_name (node->info, _("(Empty)"));
1300         }
1301       else if (node->parent || model->root_folder)
1302         {
1303           node->info = _gtk_folder_get_info ((node->parent != NULL) ? node->parent->folder : model->root_folder,
1304                                              node->file);
1305         }
1306       else
1307         g_assert_not_reached ();
1308     }
1309
1310   return node->info;
1311 }
1312
1313 static gboolean
1314 file_model_node_is_visible (GtkFileSystemModel *model,
1315                             FileModelNode      *node)
1316 {
1317   if (model->show_folders != model->show_files ||
1318       !model->show_hidden ||
1319       model->filter_func)
1320     {
1321       GFileInfo *info = file_model_node_get_info (model, node);
1322       gboolean is_folder;
1323
1324       if (!info)
1325         {
1326           /* File probably disappeared underneath us or resides in a
1327              directory where we have only partial access rights.  */
1328           return FALSE;
1329         }
1330
1331       is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
1332
1333       if (model->show_folders != model->show_files &&
1334           model->show_folders != is_folder)
1335         return FALSE;
1336
1337       if (!model->show_hidden && g_file_info_get_is_hidden (info))
1338         return FALSE;
1339
1340       if (model->filter_func &&
1341           !model->filter_func (model, node->file, info, model->filter_data))
1342         return FALSE;
1343     }
1344
1345   return TRUE;
1346 }
1347
1348 static void
1349 file_model_node_clear (GtkFileSystemModel *model,
1350                        FileModelNode      *node)
1351 {
1352   FileModelNode *children;
1353
1354   file_model_node_idle_clear_cancel (node);
1355
1356   children = node->children;
1357   node->children = NULL;
1358   node->loaded = FALSE;
1359
1360   while (children)
1361     {
1362       FileModelNode *next = children->next;
1363
1364       file_model_node_free (children);
1365
1366       children = next;
1367     }
1368
1369   if (node->folder)
1370     {
1371       /* Unreffing node->folder may cause roots_changed,
1372        * so we need to be careful about ordering.
1373        */
1374       GtkFolder *folder = node->folder;
1375       node->folder = NULL;
1376
1377       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (deleted_callback), node);
1378       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_added_callback), node);
1379       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_changed_callback), node);
1380       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_removed_callback), node);
1381
1382       g_object_unref (folder);
1383     }
1384 }
1385
1386 static void
1387 file_model_node_ref (FileModelNode *node)
1388 {
1389   node->ref_count++;
1390   if (node->ref_count == 1 && node->parent)
1391     node->parent->n_referenced_children++;
1392 }
1393
1394 static gboolean
1395 idle_clear_callback (GtkFileSystemModel *model)
1396 {
1397   while (model->idle_clears)
1398     {
1399       FileModelNode *node = model->idle_clears->data;
1400       model->idle_clears = g_slist_delete_link (model->idle_clears, model->idle_clears);
1401
1402       node->idle_clear = FALSE;
1403       file_model_node_clear (node->model, node);
1404     }
1405
1406   return FALSE;
1407 }
1408
1409 static void
1410 file_model_node_idle_clear (FileModelNode *node)
1411 {
1412   if (!node->idle_clear)
1413     {
1414       GtkFileSystemModel *model = node->model;
1415
1416       node->idle_clear = TRUE;
1417       if (!model->idle_clears)
1418         {
1419           model->idle_clear_source = g_idle_source_new ();
1420           g_source_set_priority (model->idle_clear_source, G_PRIORITY_HIGH);
1421           g_source_set_closure (model->idle_clear_source,
1422                                 g_cclosure_new_object (G_CALLBACK (idle_clear_callback),
1423                                                        G_OBJECT (model)));
1424           g_source_attach (model->idle_clear_source, NULL);
1425         }
1426
1427       model->idle_clears = g_slist_prepend (model->idle_clears, node);
1428       node->idle_clear = TRUE;
1429     }
1430 }
1431
1432 static void
1433 file_model_node_idle_clear_cancel (FileModelNode *node)
1434 {
1435   if (node->idle_clear)
1436     {
1437       GtkFileSystemModel *model = node->model;
1438
1439       model->idle_clears = g_slist_remove (model->idle_clears, node);
1440       if (!model->idle_clears)
1441         {
1442           g_source_destroy (model->idle_clear_source);
1443           model->idle_clear_source = NULL;
1444         }
1445
1446       node->idle_clear = FALSE;
1447     }
1448 }
1449
1450 static void
1451 file_model_node_unref (GtkFileSystemModel *model,
1452                        FileModelNode       *node)
1453 {
1454   node->ref_count--;
1455   if (node->ref_count == 0)
1456     {
1457       file_model_node_clear (model, node);
1458       if (node->parent)
1459         file_model_node_child_unref (node->parent);
1460     }
1461 }
1462
1463 static void
1464 file_model_node_child_unref (FileModelNode *parent)
1465 {
1466   parent->n_referenced_children--;
1467   if (parent->n_referenced_children == 0)
1468     file_model_node_idle_clear (parent);
1469 }
1470
1471 struct GetChildrenData
1472 {
1473   GtkFileSystemModel *model;
1474   FileModelNode *node;
1475 };
1476
1477 static void
1478 get_children_get_folder_cb (GCancellable *cancellable,
1479                             GtkFolder    *folder,
1480                             const GError *error,
1481                             gpointer      callback_data)
1482 {
1483   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1484   struct GetChildrenData *data = callback_data;
1485   FileModelNode *child_node;
1486   GSList *tmp_list;
1487
1488   tmp_list = g_slist_find (data->model->pending_cancellables, cancellable);
1489
1490   if (!tmp_list)
1491     goto out;
1492
1493   data->model->pending_cancellables = g_slist_delete_link (data->model->pending_cancellables, tmp_list);
1494
1495   if (cancelled || !folder)
1496     {
1497       /* error, no folder, remove dummy child */
1498       if (data->node->parent && data->node->parent->has_dummy)
1499         {
1500           data->node->parent->children = NULL;
1501           data->node->parent->has_dummy = FALSE;
1502         }
1503
1504       file_model_node_free (data->node);
1505
1506       goto out;
1507     }
1508
1509   data->node->folder = folder;
1510   data->node->load_pending = FALSE;
1511
1512   g_signal_connect (data->node->folder, "deleted",
1513                     G_CALLBACK (deleted_callback), data->node);
1514   g_signal_connect (data->node->folder, "files-added",
1515                     G_CALLBACK (files_added_callback), data->node);
1516   g_signal_connect (data->node->folder, "files-changed",
1517                     G_CALLBACK (files_changed_callback), data->node);
1518   g_signal_connect (data->node->folder, "files-removed",
1519                     G_CALLBACK (files_removed_callback), data->node);
1520
1521   data->node->loaded = TRUE;
1522
1523   /* We claimed this folder had children, so we
1524    * have to add a dummy child, possibly to remove later.
1525    */
1526   child_node = file_model_node_new (data->model, NULL);
1527   child_node->is_visible = TRUE;
1528   child_node->parent = data->node;
1529   child_node->is_dummy = TRUE;
1530
1531   data->node->children = child_node;
1532   data->node->has_dummy = TRUE;
1533
1534   g_object_set_data (G_OBJECT (data->node->folder), I_("model-node"), data->node);
1535
1536 out:
1537   g_object_unref (data->model);
1538   g_free (data);
1539
1540   g_object_unref (cancellable);
1541 }
1542
1543 static FileModelNode *
1544 file_model_node_get_children (GtkFileSystemModel *model,
1545                               FileModelNode      *node)
1546 {
1547   if (node->ref_count == 0)
1548     return NULL;
1549
1550   if (!node->loaded && !node->load_pending)
1551     {
1552       GFileInfo *info = file_model_node_get_info (model, node);
1553       gboolean has_children = FALSE;
1554       gboolean is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
1555
1556       file_model_node_idle_clear_cancel (node);
1557
1558       if (node->depth < model->max_depth && is_folder)
1559         {
1560           struct GetChildrenData *data;
1561           GCancellable *cancellable;
1562
1563           data = g_new (struct GetChildrenData, 1);
1564           data->model = g_object_ref (model);
1565           data->node = node;
1566
1567           cancellable =
1568             _gtk_file_system_get_folder (model->file_system,
1569                                          node->file,
1570                                          model->attributes,
1571                                          get_children_get_folder_cb,
1572                                          data);
1573
1574           model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable);
1575           node->load_pending = TRUE;
1576
1577           if (!has_children)
1578             {
1579               /* The hard case ... we claimed this folder had children, but actually
1580                * it didn't. We have to add a dummy child, possibly to remove later.
1581                */
1582               FileModelNode *child_node = file_model_node_new (model, NULL);
1583               child_node->is_visible = TRUE;
1584               child_node->parent = node;
1585               child_node->is_dummy = TRUE;
1586
1587               node->children = child_node;
1588               node->has_dummy = TRUE;
1589             }
1590         }
1591     }
1592
1593   return node->children;
1594 }
1595
1596 static gint
1597 file_compare_func (GFile *file1,
1598                    GFile *file2)
1599 {
1600   gchar *uri1, *uri2;
1601   gint result;
1602
1603   uri1 = g_file_get_uri (file1);
1604   uri2 = g_file_get_uri (file2);
1605
1606   result = g_strcmp0 (uri1, uri2);
1607
1608   g_free (uri1);
1609   g_free (uri2);
1610
1611   return result;
1612 }
1613
1614 static GSList *
1615 sort_file_list (GSList *list)
1616 {
1617   GSList *copy;
1618
1619   copy = g_slist_copy (list);
1620   return g_slist_sort (copy, (GCompareFunc) file_compare_func);
1621 }
1622
1623 static void
1624 do_files_added (GtkFileSystemModel *model,
1625                 FileModelNode      *parent_node,
1626                 GSList             *files)
1627 {
1628   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
1629   FileModelNode *children;
1630   FileModelNode *prev = NULL;
1631   GtkTreeIter iter;
1632   GtkTreePath *path;
1633   GSList *sorted_files, *tmp_list;
1634
1635   sorted_files = sort_file_list (files);
1636
1637   if (parent_node)
1638     {
1639       iter.user_data = parent_node;
1640       path = gtk_tree_model_get_path (tree_model, &iter);
1641       children = parent_node->children;
1642     }
1643   else
1644     {
1645       path = gtk_tree_path_new ();
1646       children = model->roots;
1647     }
1648
1649   gtk_tree_path_down (path);
1650
1651   if (parent_node && parent_node->has_dummy)
1652     {
1653       prev = children;
1654       children = children->next;
1655       gtk_tree_path_next (path);
1656     }
1657
1658   for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next)
1659     {
1660       GFile *file = tmp_list->data;
1661
1662       while (children &&
1663              (!children->file || !g_file_equal (children->file, file)))
1664         {
1665           prev = children;
1666           if (children->is_visible)
1667             gtk_tree_path_next (path);
1668
1669           children = children->next;
1670         }
1671
1672       if (children &&
1673           children->file && g_file_equal (children->file, file))
1674         {
1675           /* Shouldn't happen */
1676         }
1677       else
1678         {
1679           FileModelNode *new;
1680
1681           new = file_model_node_new (model, file);
1682
1683           if (children)
1684             new->next = children;
1685           if (prev)
1686             prev->next = new;
1687           else if (parent_node)
1688             parent_node->children = new;
1689           else
1690             model->roots = new;
1691
1692           prev = new;
1693
1694           if (parent_node)
1695             {
1696               new->parent = parent_node;
1697               new->depth = parent_node->depth + 1;
1698             }
1699
1700           new->is_visible = file_model_node_is_visible (model, new);
1701
1702           if (new->is_visible)
1703             {
1704               iter.user_data = new;
1705               gtk_tree_path_free (path);
1706               path = gtk_tree_model_get_path (tree_model, &iter);
1707               gtk_tree_model_row_inserted (tree_model, path, &iter);
1708
1709               if (gtk_file_system_model_iter_has_child (tree_model, &iter))
1710                 gtk_tree_model_row_has_child_toggled (tree_model, path, &iter);
1711
1712               if (parent_node && parent_node->has_dummy)
1713                 {
1714                   FileModelNode *dummy = parent_node->children;
1715                   GtkTreePath *dummy_path;
1716
1717                   parent_node->children = parent_node->children->next;
1718                   parent_node->has_dummy = FALSE;
1719
1720                   dummy_path = gtk_tree_path_copy (path);
1721                   gtk_tree_path_up (dummy_path);
1722                   gtk_tree_path_down (dummy_path);
1723
1724                   gtk_tree_model_row_deleted (tree_model, dummy_path);
1725                   gtk_tree_path_free (dummy_path);
1726
1727                   if (dummy->ref_count)
1728                     file_model_node_child_unref (parent_node);
1729                   file_model_node_free (dummy);
1730                 }
1731
1732               gtk_tree_path_next (path);
1733             }
1734         }
1735     }
1736
1737   gtk_tree_path_free (path);
1738   g_slist_free (sorted_files);
1739 }
1740
1741 static void
1742 do_files_changed (GtkFileSystemModel *model,
1743                   FileModelNode      *parent_node,
1744                   GSList             *files)
1745 {
1746   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
1747   FileModelNode *children;
1748   GtkTreeIter iter;
1749   GtkTreePath *path;
1750   GSList *sorted_files;
1751   GSList *tmp_list;
1752
1753   sorted_files = sort_file_list (files);
1754
1755   if (parent_node)
1756     {
1757       iter.user_data = parent_node;
1758       path = gtk_tree_model_get_path (tree_model, &iter);
1759       children = parent_node->children;
1760     }
1761   else
1762     {
1763       path = gtk_tree_path_new ();
1764       children = model->roots;
1765     }
1766
1767   gtk_tree_path_down (path);
1768
1769   if (parent_node && parent_node->has_dummy)
1770     {
1771       children = children->next;
1772       gtk_tree_path_next (path);
1773     }
1774
1775   for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next)
1776     {
1777       GFile *file = tmp_list->data;
1778
1779       while (children &&
1780              (!children->file || !g_file_equal (children->file, file)))
1781         {
1782           if (children->is_visible)
1783             gtk_tree_path_next (path);
1784
1785           children = children->next;
1786         }
1787
1788       if (children &&
1789           children->file && g_file_equal (children->file, file))
1790         {
1791           gtk_tree_model_row_changed (tree_model, path, &iter);
1792         }
1793       else
1794         {
1795           /* Shouldn't happen */
1796         }
1797     }
1798
1799   gtk_tree_path_free (path);
1800   g_slist_free (sorted_files);
1801 }
1802
1803 static void
1804 do_files_removed (GtkFileSystemModel *model,
1805                   FileModelNode      *parent_node,
1806                   GSList             *files)
1807 {
1808   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
1809   FileModelNode *children;
1810   FileModelNode *prev = NULL;
1811   GtkTreeIter iter;
1812   GtkTreePath *path;
1813   GSList *sorted_files;
1814   GSList *tmp_list;
1815   FileModelNode *tmp_child;
1816   gint n_visible;
1817
1818   sorted_files = sort_file_list (files);
1819
1820   if (parent_node)
1821     {
1822       iter.user_data = parent_node;
1823       path = gtk_tree_model_get_path (tree_model, &iter);
1824       children = parent_node->children;
1825     }
1826   else
1827     {
1828       path = gtk_tree_path_new ();
1829       children = model->roots;
1830     }
1831
1832   /* Count the number of currently visible children, so that
1833    * can catch when we need to insert a dummy node.
1834    */
1835   n_visible = 0;
1836   for (tmp_child = children; tmp_child; tmp_child = tmp_child->next)
1837     {
1838       if (tmp_child->is_visible)
1839         n_visible++;
1840     }
1841
1842   gtk_tree_path_down (path);
1843
1844   if (parent_node && parent_node->has_dummy)
1845     {
1846       prev = children;
1847       children = children->next;
1848       gtk_tree_path_next (path);
1849     }
1850
1851   for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next)
1852     {
1853       GFile *file = tmp_list->data;
1854
1855       while (children &&
1856              (!children->file || !g_file_equal (children->file, file)))
1857         {
1858           prev = children;
1859           if (children->is_visible)
1860             gtk_tree_path_next (path);
1861
1862           children = children->next;
1863         }
1864
1865       if (children &&
1866           children->file && g_file_equal (children->file, file))
1867         {
1868           FileModelNode *next = children->next;
1869
1870           if (children->is_visible)
1871             n_visible--;
1872
1873           if (parent_node && n_visible == 0)
1874             {
1875               FileModelNode *dummy = file_model_node_new (model, NULL);
1876               dummy->is_visible = TRUE;
1877               dummy->parent = parent_node;
1878               dummy->is_dummy = TRUE;
1879
1880               parent_node->children = dummy;
1881               parent_node->has_dummy = TRUE;
1882
1883               iter.user_data = dummy;
1884               gtk_tree_model_row_inserted (tree_model, path, &iter);
1885               gtk_tree_path_next (path);
1886
1887               prev = dummy;
1888             }
1889
1890           if (prev)
1891             prev->next = next;
1892           else if (parent_node)
1893             parent_node->children = next;
1894           else
1895             model->roots = next;
1896
1897           if (parent_node && children->ref_count)
1898             file_model_node_child_unref (parent_node);
1899
1900           if (children->is_visible)
1901             gtk_tree_model_row_deleted (tree_model, path);
1902
1903           file_model_node_free (children);
1904
1905           children = next;
1906         }
1907       else
1908         {
1909           /* Shouldn't happen */
1910         }
1911     }
1912
1913   gtk_tree_path_free (path);
1914   g_slist_free (sorted_files);
1915 }
1916
1917 static void
1918 deleted_callback (GFile         *folder,
1919                   FileModelNode *node)
1920 {
1921 }
1922
1923 static void
1924 files_added_callback (GFile         *folder,
1925                       GSList        *files,
1926                       FileModelNode *node)
1927 {
1928   do_files_added (node->model, node, files);
1929 }
1930
1931 static void
1932 files_changed_callback (GFile         *folder,
1933                         GSList        *files,
1934                         FileModelNode *node)
1935 {
1936   do_files_changed (node->model, node, files);
1937 }
1938
1939 static void
1940 files_removed_callback (GFile         *folder,
1941                         GSList        *files,
1942                         FileModelNode *node)
1943 {
1944   do_files_removed (node->model, node, files);
1945 }
1946
1947 static void
1948 root_deleted_callback (GFile              *folder,
1949                        GtkFileSystemModel *model)
1950 {
1951 }
1952
1953 static void
1954 root_files_added_callback (GFile              *folder,
1955                            GSList             *files,
1956                            GtkFileSystemModel *model)
1957 {
1958   do_files_added (model, NULL, files);
1959 }
1960
1961 static void
1962 root_files_changed_callback (GFile              *folder,
1963                              GSList             *files,
1964                              GtkFileSystemModel *model)
1965 {
1966   do_files_changed (model, NULL, files);
1967 }
1968
1969 static void
1970 root_files_removed_callback (GFile              *folder,
1971                              GSList             *files,
1972                              GtkFileSystemModel *model)
1973 {
1974   do_files_removed (model, NULL, files);
1975 }