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 _gtk_file_info_consider_as_directory (info);
 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 ((info->files != NULL && info->files->next == NULL) /* g_slist_length == 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->data);
1026   info->files = g_slist_remove (info->files, info->files->data);
1027
1028   if (info->files == NULL)
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_slist_foreach (info->files, (GFunc)g_object_unref, NULL);
1074   g_slist_free (info->files);
1075   g_slist_foreach (info->cleanups, (GFunc)g_object_unref, NULL);
1076   g_slist_free (info->cleanups);
1077   g_object_unref (info->model);
1078   g_free (info);
1079
1080   g_object_unref (cancellable);
1081 }
1082
1083 /**
1084  * _gtk_file_system_model_path_do:
1085  * @model: a #GtkFileSystemModel
1086  * @path: a path pointing to a file in the filesystem
1087  *       for @model.
1088  * @func: Function to call with the path and iter corresponding
1089  *        to @path.
1090  * @user_data: data to pass to @func
1091  *
1092  * Locates @path within @model, referencing
1093  * (gtk_tree_model_ref_node()) all parent nodes,
1094  * calls @func passing in the path and iter for @path,
1095  * then unrefs all the parent nodes.
1096  *
1097  * The reason for doing this operation as a callback
1098  * is so that if the operation performed with the
1099  * path and iter results in referencing the node
1100  * and/or parent nodes, we don't load all the information
1101  * about the nodes.
1102  *
1103  * This function is particularly useful for expanding
1104  * a #GtkTreeView to a particular point in the file system.
1105  */
1106 void
1107 _gtk_file_system_model_path_do (GtkFileSystemModel        *model,
1108                                 GFile                     *file,
1109                                 GtkFileSystemModelPathFunc func,
1110                                 gpointer                   user_data)
1111 {
1112   GFile *parent_file;
1113   GSList *files = NULL;
1114   FileModelNode *node;
1115   struct RefPathData *info;
1116
1117   if (g_file_equal (file, model->root_file))
1118     return;
1119
1120   parent_file = g_file_get_parent (file);
1121
1122   if (!parent_file)
1123     return;
1124
1125   files = g_slist_prepend (files, g_object_ref (file));
1126   while (!g_file_equal (parent_file, model->root_file))
1127     {
1128       files = g_slist_prepend (files, parent_file);
1129       parent_file = g_file_get_parent (parent_file);
1130       if (!parent_file)
1131         {
1132           g_slist_foreach (files, (GFunc) g_object_unref, NULL);
1133           g_slist_free (files);
1134           return;
1135         }
1136     }
1137   g_object_unref (parent_file);
1138
1139   if (files == NULL)
1140     return;
1141
1142   /* Now we have all paths, except the root path */
1143   node = find_child_node (model, NULL, files->data);
1144   if (!node)
1145     {
1146       g_slist_foreach (files, (GFunc) g_object_unref, NULL);
1147       g_slist_free (files);
1148       return;
1149     }
1150
1151   file_model_node_ref (node);
1152
1153   g_object_unref (files->data);
1154   files = g_slist_remove (files, files->data);
1155
1156   if (files == NULL)
1157     {
1158       /* Done, now call the function */
1159       if (node)
1160         {
1161           GtkTreeIter iter;
1162           GtkTreePath *path;
1163
1164           iter.user_data = node;
1165           path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
1166
1167           (* func) (model, path, &iter, user_data);
1168
1169           gtk_tree_path_free (path);
1170           unref_node_and_parents (model, node);
1171         }
1172     }
1173   else
1174     {
1175       info = g_new0 (struct RefPathData, 1);
1176       info->files = files;
1177       info->model = g_object_ref (model);
1178       info->func = func;
1179       info->user_data = user_data;
1180       info->node = node;
1181
1182       if (info->node->loaded)
1183         {
1184           info->parent_node = info->node;
1185           info->node = find_child_node (model, info->parent_node, info->files->data);
1186           ref_path_cb (NULL, NULL, NULL, info);
1187         }
1188       else
1189         {
1190           GCancellable *cancellable;
1191
1192           cancellable = _gtk_file_system_get_folder (model->file_system,
1193                                                      files->data,
1194                                                      model->attributes,
1195                                                      ref_path_cb, info);
1196           model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable);
1197         }
1198     }
1199 }
1200
1201 /**
1202  * _gtk_file_system_model_add_editable:
1203  * @model: a #GtkFileSystemModel
1204  * @iter: Location to return the iter corresponding to the editable row
1205  *
1206  * Adds an "empty" row at the beginning of the model.  This does not refer to
1207  * any file, but is a temporary placeholder for a file name that the user will
1208  * type when a corresponding cell is made editable.  When your code is done
1209  * using this temporary row, call _gtk_file_system_model_remove_editable().
1210  **/
1211 void
1212 _gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *iter)
1213 {
1214   FileModelNode *node;
1215   GtkTreePath *path;
1216
1217   g_return_if_fail (!model->has_editable);
1218
1219   model->has_editable = TRUE;
1220
1221   node = file_model_node_new (model, NULL);
1222   node->is_visible = TRUE;
1223
1224   node->next = model->roots;
1225   model->roots = node;
1226
1227   path = gtk_tree_path_new ();
1228   gtk_tree_path_append_index (path, 0);
1229   iter->user_data = node;
1230
1231   gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, iter);
1232
1233   gtk_tree_path_free (path);
1234 }
1235
1236 /**
1237  * _gtk_file_system_model_remove_editable:
1238  * @model: a #GtkFileSystemModel
1239  *
1240  * Removes the "empty" row at the beginning of the model that was
1241  * created with _gtk_file_system_model_add_editable().  You should call
1242  * this function when your code is finished editing this temporary row.
1243  **/
1244 void
1245 _gtk_file_system_model_remove_editable (GtkFileSystemModel *model)
1246 {
1247   GtkTreePath *path;
1248   FileModelNode *node;
1249
1250   g_return_if_fail (model->has_editable);
1251
1252   model->has_editable = FALSE;
1253
1254   node = model->roots;
1255   model->roots = model->roots->next;
1256   file_model_node_free (node);
1257
1258   path = gtk_tree_path_new ();
1259   gtk_tree_path_append_index (path, 0);
1260
1261   gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
1262
1263   gtk_tree_path_free (path);
1264 }
1265
1266 static FileModelNode *
1267 file_model_node_new (GtkFileSystemModel *model,
1268                      GFile              *file)
1269 {
1270   FileModelNode *node = g_new0 (FileModelNode, 1);
1271
1272   node->model = model;
1273   node->file = file ? g_object_ref (file) : NULL;
1274
1275   return node;
1276 }
1277
1278 static void
1279 file_model_node_free (FileModelNode *node)
1280 {
1281   file_model_node_clear (node->model, node);
1282
1283   if (node->file)
1284     g_object_unref (node->file);
1285
1286   if (node->info)
1287     g_object_unref (node->info);
1288
1289   g_free (node);
1290 }
1291
1292 static GFileInfo *
1293 file_model_node_get_info (GtkFileSystemModel *model,
1294                           FileModelNode      *node)
1295 {
1296   if (!node->info)
1297     {
1298       if (node->is_dummy)
1299         {
1300           node->info = g_file_info_new ();
1301           g_file_info_set_display_name (node->info, _("(Empty)"));
1302         }
1303       else if (node->parent || model->root_folder)
1304         {
1305           node->info = _gtk_folder_get_info ((node->parent != NULL) ? node->parent->folder : model->root_folder,
1306                                              node->file);
1307         }
1308       else
1309         g_assert_not_reached ();
1310     }
1311
1312   return node->info;
1313 }
1314
1315 static gboolean
1316 file_model_node_is_visible (GtkFileSystemModel *model,
1317                             FileModelNode      *node)
1318 {
1319   if (model->show_folders != model->show_files ||
1320       !model->show_hidden ||
1321       model->filter_func)
1322     {
1323       GFileInfo *info = file_model_node_get_info (model, node);
1324       gboolean is_folder;
1325
1326       if (!info)
1327         {
1328           /* File probably disappeared underneath us or resides in a
1329              directory where we have only partial access rights.  */
1330           return FALSE;
1331         }
1332
1333       is_folder = _gtk_file_info_consider_as_directory (info);
1334
1335       if (model->show_folders != model->show_files &&
1336           model->show_folders != is_folder)
1337         return FALSE;
1338
1339       if (!model->show_hidden &&
1340           (g_file_info_get_is_hidden (info) || g_file_info_get_is_backup (info)))
1341         return FALSE;
1342
1343       if (model->filter_func &&
1344           !model->filter_func (model, node->file, info, model->filter_data))
1345         return FALSE;
1346     }
1347
1348   return TRUE;
1349 }
1350
1351 static void
1352 file_model_node_clear (GtkFileSystemModel *model,
1353                        FileModelNode      *node)
1354 {
1355   FileModelNode *children;
1356
1357   file_model_node_idle_clear_cancel (node);
1358
1359   children = node->children;
1360   node->children = NULL;
1361   node->loaded = FALSE;
1362
1363   while (children)
1364     {
1365       FileModelNode *next = children->next;
1366
1367       file_model_node_free (children);
1368
1369       children = next;
1370     }
1371
1372   if (node->folder)
1373     {
1374       /* Unreffing node->folder may cause roots_changed,
1375        * so we need to be careful about ordering.
1376        */
1377       GtkFolder *folder = node->folder;
1378       node->folder = NULL;
1379
1380       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (deleted_callback), node);
1381       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_added_callback), node);
1382       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_changed_callback), node);
1383       g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_removed_callback), node);
1384
1385       g_object_unref (folder);
1386     }
1387 }
1388
1389 static void
1390 file_model_node_ref (FileModelNode *node)
1391 {
1392   node->ref_count++;
1393   if (node->ref_count == 1 && node->parent)
1394     node->parent->n_referenced_children++;
1395 }
1396
1397 static gboolean
1398 idle_clear_callback (GtkFileSystemModel *model)
1399 {
1400   while (model->idle_clears)
1401     {
1402       FileModelNode *node = model->idle_clears->data;
1403       model->idle_clears = g_slist_delete_link (model->idle_clears, model->idle_clears);
1404
1405       node->idle_clear = FALSE;
1406       file_model_node_clear (node->model, node);
1407     }
1408
1409   return FALSE;
1410 }
1411
1412 static void
1413 file_model_node_idle_clear (FileModelNode *node)
1414 {
1415   if (!node->idle_clear)
1416     {
1417       GtkFileSystemModel *model = node->model;
1418
1419       node->idle_clear = TRUE;
1420       if (!model->idle_clears)
1421         {
1422           model->idle_clear_source = g_idle_source_new ();
1423           g_source_set_priority (model->idle_clear_source, G_PRIORITY_HIGH);
1424           g_source_set_closure (model->idle_clear_source,
1425                                 g_cclosure_new_object (G_CALLBACK (idle_clear_callback),
1426                                                        G_OBJECT (model)));
1427           g_source_attach (model->idle_clear_source, NULL);
1428         }
1429
1430       model->idle_clears = g_slist_prepend (model->idle_clears, node);
1431       node->idle_clear = TRUE;
1432     }
1433 }
1434
1435 static void
1436 file_model_node_idle_clear_cancel (FileModelNode *node)
1437 {
1438   if (node->idle_clear)
1439     {
1440       GtkFileSystemModel *model = node->model;
1441
1442       model->idle_clears = g_slist_remove (model->idle_clears, node);
1443       if (!model->idle_clears)
1444         {
1445           g_source_destroy (model->idle_clear_source);
1446           model->idle_clear_source = NULL;
1447         }
1448
1449       node->idle_clear = FALSE;
1450     }
1451 }
1452
1453 static void
1454 file_model_node_unref (GtkFileSystemModel *model,
1455                        FileModelNode       *node)
1456 {
1457   node->ref_count--;
1458   if (node->ref_count == 0)
1459     {
1460       file_model_node_clear (model, node);
1461       if (node->parent)
1462         file_model_node_child_unref (node->parent);
1463     }
1464 }
1465
1466 static void
1467 file_model_node_child_unref (FileModelNode *parent)
1468 {
1469   parent->n_referenced_children--;
1470   if (parent->n_referenced_children == 0)
1471     file_model_node_idle_clear (parent);
1472 }
1473
1474 struct GetChildrenData
1475 {
1476   GtkFileSystemModel *model;
1477   FileModelNode *node;
1478 };
1479
1480 static void
1481 get_children_get_folder_cb (GCancellable *cancellable,
1482                             GtkFolder    *folder,
1483                             const GError *error,
1484                             gpointer      callback_data)
1485 {
1486   gboolean cancelled = g_cancellable_is_cancelled (cancellable);
1487   struct GetChildrenData *data = callback_data;
1488   FileModelNode *child_node;
1489   GSList *tmp_list;
1490
1491   tmp_list = g_slist_find (data->model->pending_cancellables, cancellable);
1492
1493   if (!tmp_list)
1494     goto out;
1495
1496   data->model->pending_cancellables = g_slist_delete_link (data->model->pending_cancellables, tmp_list);
1497
1498   if (cancelled || !folder)
1499     {
1500       /* error, no folder, remove dummy child */
1501       if (data->node->parent && data->node->parent->has_dummy)
1502         {
1503           data->node->parent->children = NULL;
1504           data->node->parent->has_dummy = FALSE;
1505         }
1506
1507       file_model_node_free (data->node);
1508
1509       goto out;
1510     }
1511
1512   data->node->folder = folder;
1513   data->node->load_pending = FALSE;
1514
1515   g_signal_connect (data->node->folder, "deleted",
1516                     G_CALLBACK (deleted_callback), data->node);
1517   g_signal_connect (data->node->folder, "files-added",
1518                     G_CALLBACK (files_added_callback), data->node);
1519   g_signal_connect (data->node->folder, "files-changed",
1520                     G_CALLBACK (files_changed_callback), data->node);
1521   g_signal_connect (data->node->folder, "files-removed",
1522                     G_CALLBACK (files_removed_callback), data->node);
1523
1524   data->node->loaded = TRUE;
1525
1526   /* We claimed this folder had children, so we
1527    * have to add a dummy child, possibly to remove later.
1528    */
1529   child_node = file_model_node_new (data->model, NULL);
1530   child_node->is_visible = TRUE;
1531   child_node->parent = data->node;
1532   child_node->is_dummy = TRUE;
1533
1534   data->node->children = child_node;
1535   data->node->has_dummy = TRUE;
1536
1537   g_object_set_data (G_OBJECT (data->node->folder), I_("model-node"), data->node);
1538
1539 out:
1540   g_object_unref (data->model);
1541   g_free (data);
1542
1543   g_object_unref (cancellable);
1544 }
1545
1546 static FileModelNode *
1547 file_model_node_get_children (GtkFileSystemModel *model,
1548                               FileModelNode      *node)
1549 {
1550   if (node->ref_count == 0)
1551     return NULL;
1552
1553   if (!node->loaded && !node->load_pending)
1554     {
1555       GFileInfo *info = file_model_node_get_info (model, node);
1556       gboolean has_children = FALSE;
1557       gboolean is_folder = _gtk_file_info_consider_as_directory (info);
1558
1559       file_model_node_idle_clear_cancel (node);
1560
1561       if (node->depth < model->max_depth && is_folder)
1562         {
1563           struct GetChildrenData *data;
1564           GCancellable *cancellable;
1565
1566           data = g_new (struct GetChildrenData, 1);
1567           data->model = g_object_ref (model);
1568           data->node = node;
1569
1570           cancellable =
1571             _gtk_file_system_get_folder (model->file_system,
1572                                          node->file,
1573                                          model->attributes,
1574                                          get_children_get_folder_cb,
1575                                          data);
1576
1577           model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable);
1578           node->load_pending = TRUE;
1579
1580           if (!has_children)
1581             {
1582               /* The hard case ... we claimed this folder had children, but actually
1583                * it didn't. We have to add a dummy child, possibly to remove later.
1584                */
1585               FileModelNode *child_node = file_model_node_new (model, NULL);
1586               child_node->is_visible = TRUE;
1587               child_node->parent = node;
1588               child_node->is_dummy = TRUE;
1589
1590               node->children = child_node;
1591               node->has_dummy = TRUE;
1592             }
1593         }
1594     }
1595
1596   return node->children;
1597 }
1598
1599 static gint
1600 file_compare_func (GFile *file1,
1601                    GFile *file2)
1602 {
1603   gchar *uri1, *uri2;
1604   gint result;
1605
1606   uri1 = g_file_get_uri (file1);
1607   uri2 = g_file_get_uri (file2);
1608
1609   result = g_strcmp0 (uri1, uri2);
1610
1611   g_free (uri1);
1612   g_free (uri2);
1613
1614   return result;
1615 }
1616
1617 static GSList *
1618 sort_file_list (GSList *list)
1619 {
1620   GSList *copy;
1621
1622   copy = g_slist_copy (list);
1623   return g_slist_sort (copy, (GCompareFunc) file_compare_func);
1624 }
1625
1626 static void
1627 do_files_added (GtkFileSystemModel *model,
1628                 FileModelNode      *parent_node,
1629                 GSList             *files)
1630 {
1631   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
1632   FileModelNode *children;
1633   FileModelNode *prev = NULL;
1634   GtkTreeIter iter;
1635   GtkTreePath *path;
1636   GSList *sorted_files, *tmp_list;
1637
1638   sorted_files = sort_file_list (files);
1639
1640   if (parent_node)
1641     {
1642       iter.user_data = parent_node;
1643       path = gtk_tree_model_get_path (tree_model, &iter);
1644       children = parent_node->children;
1645     }
1646   else
1647     {
1648       path = gtk_tree_path_new ();
1649       children = model->roots;
1650     }
1651
1652   gtk_tree_path_down (path);
1653
1654   if (parent_node && parent_node->has_dummy)
1655     {
1656       prev = children;
1657       children = children->next;
1658       gtk_tree_path_next (path);
1659     }
1660
1661   for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next)
1662     {
1663       GFile *file = tmp_list->data;
1664
1665       while (children &&
1666              (!children->file || !g_file_equal (children->file, file)))
1667         {
1668           prev = children;
1669           if (children->is_visible)
1670             gtk_tree_path_next (path);
1671
1672           children = children->next;
1673         }
1674
1675       if (children &&
1676           children->file && g_file_equal (children->file, file))
1677         {
1678           /* Shouldn't happen */
1679         }
1680       else
1681         {
1682           FileModelNode *new;
1683
1684           new = file_model_node_new (model, file);
1685
1686           if (children)
1687             new->next = children;
1688           if (prev)
1689             prev->next = new;
1690           else if (parent_node)
1691             parent_node->children = new;
1692           else
1693             model->roots = new;
1694
1695           prev = new;
1696
1697           if (parent_node)
1698             {
1699               new->parent = parent_node;
1700               new->depth = parent_node->depth + 1;
1701             }
1702
1703           new->is_visible = file_model_node_is_visible (model, new);
1704
1705           if (new->is_visible)
1706             {
1707               iter.user_data = new;
1708               gtk_tree_path_free (path);
1709               path = gtk_tree_model_get_path (tree_model, &iter);
1710               gtk_tree_model_row_inserted (tree_model, path, &iter);
1711
1712               if (gtk_file_system_model_iter_has_child (tree_model, &iter))
1713                 gtk_tree_model_row_has_child_toggled (tree_model, path, &iter);
1714
1715               if (parent_node && parent_node->has_dummy)
1716                 {
1717                   FileModelNode *dummy = parent_node->children;
1718                   GtkTreePath *dummy_path;
1719
1720                   parent_node->children = parent_node->children->next;
1721                   parent_node->has_dummy = FALSE;
1722
1723                   dummy_path = gtk_tree_path_copy (path);
1724                   gtk_tree_path_up (dummy_path);
1725                   gtk_tree_path_down (dummy_path);
1726
1727                   gtk_tree_model_row_deleted (tree_model, dummy_path);
1728                   gtk_tree_path_free (dummy_path);
1729
1730                   if (dummy->ref_count)
1731                     file_model_node_child_unref (parent_node);
1732                   file_model_node_free (dummy);
1733                 }
1734
1735               gtk_tree_path_next (path);
1736             }
1737         }
1738     }
1739
1740   gtk_tree_path_free (path);
1741   g_slist_free (sorted_files);
1742 }
1743
1744 static void
1745 do_files_changed (GtkFileSystemModel *model,
1746                   FileModelNode      *parent_node,
1747                   GSList             *files)
1748 {
1749   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
1750   FileModelNode *children;
1751   GtkTreeIter iter;
1752   GtkTreePath *path;
1753   GSList *sorted_files;
1754   GSList *tmp_list;
1755
1756   sorted_files = sort_file_list (files);
1757
1758   if (parent_node)
1759     {
1760       iter.user_data = parent_node;
1761       path = gtk_tree_model_get_path (tree_model, &iter);
1762       children = parent_node->children;
1763     }
1764   else
1765     {
1766       path = gtk_tree_path_new ();
1767       children = model->roots;
1768     }
1769
1770   gtk_tree_path_down (path);
1771
1772   if (parent_node && parent_node->has_dummy)
1773     {
1774       children = children->next;
1775       gtk_tree_path_next (path);
1776     }
1777
1778   for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next)
1779     {
1780       GFile *file = tmp_list->data;
1781
1782       while (children &&
1783              (!children->file || !g_file_equal (children->file, file)))
1784         {
1785           if (children->is_visible)
1786             gtk_tree_path_next (path);
1787
1788           children = children->next;
1789         }
1790
1791       if (children &&
1792           children->file && g_file_equal (children->file, file))
1793         {
1794           gtk_tree_model_row_changed (tree_model, path, &iter);
1795         }
1796       else
1797         {
1798           /* Shouldn't happen */
1799         }
1800     }
1801
1802   gtk_tree_path_free (path);
1803   g_slist_free (sorted_files);
1804 }
1805
1806 static void
1807 do_files_removed (GtkFileSystemModel *model,
1808                   FileModelNode      *parent_node,
1809                   GSList             *files)
1810 {
1811   GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
1812   FileModelNode *children;
1813   FileModelNode *prev = NULL;
1814   GtkTreeIter iter;
1815   GtkTreePath *path;
1816   GSList *sorted_files;
1817   GSList *tmp_list;
1818   FileModelNode *tmp_child;
1819   gint n_visible;
1820
1821   sorted_files = sort_file_list (files);
1822
1823   if (parent_node)
1824     {
1825       iter.user_data = parent_node;
1826       path = gtk_tree_model_get_path (tree_model, &iter);
1827       children = parent_node->children;
1828     }
1829   else
1830     {
1831       path = gtk_tree_path_new ();
1832       children = model->roots;
1833     }
1834
1835   /* Count the number of currently visible children, so that
1836    * can catch when we need to insert a dummy node.
1837    */
1838   n_visible = 0;
1839   for (tmp_child = children; tmp_child; tmp_child = tmp_child->next)
1840     {
1841       if (tmp_child->is_visible)
1842         n_visible++;
1843     }
1844
1845   gtk_tree_path_down (path);
1846
1847   if (parent_node && parent_node->has_dummy)
1848     {
1849       prev = children;
1850       children = children->next;
1851       gtk_tree_path_next (path);
1852     }
1853
1854   for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next)
1855     {
1856       GFile *file = tmp_list->data;
1857
1858       while (children &&
1859              (!children->file || !g_file_equal (children->file, file)))
1860         {
1861           prev = children;
1862           if (children->is_visible)
1863             gtk_tree_path_next (path);
1864
1865           children = children->next;
1866         }
1867
1868       if (children &&
1869           children->file && g_file_equal (children->file, file))
1870         {
1871           FileModelNode *next = children->next;
1872
1873           if (children->is_visible)
1874             n_visible--;
1875
1876           if (parent_node && n_visible == 0)
1877             {
1878               FileModelNode *dummy = file_model_node_new (model, NULL);
1879               dummy->is_visible = TRUE;
1880               dummy->parent = parent_node;
1881               dummy->is_dummy = TRUE;
1882
1883               parent_node->children = dummy;
1884               parent_node->has_dummy = TRUE;
1885
1886               iter.user_data = dummy;
1887               gtk_tree_model_row_inserted (tree_model, path, &iter);
1888               gtk_tree_path_next (path);
1889
1890               prev = dummy;
1891             }
1892
1893           if (prev)
1894             prev->next = next;
1895           else if (parent_node)
1896             parent_node->children = next;
1897           else
1898             model->roots = next;
1899
1900           if (parent_node && children->ref_count)
1901             file_model_node_child_unref (parent_node);
1902
1903           if (children->is_visible)
1904             gtk_tree_model_row_deleted (tree_model, path);
1905
1906           file_model_node_free (children);
1907
1908           children = next;
1909         }
1910       else
1911         {
1912           /* Shouldn't happen */
1913         }
1914     }
1915
1916   gtk_tree_path_free (path);
1917   g_slist_free (sorted_files);
1918 }
1919
1920 static void
1921 deleted_callback (GFile         *folder,
1922                   FileModelNode *node)
1923 {
1924 }
1925
1926 static void
1927 files_added_callback (GFile         *folder,
1928                       GSList        *files,
1929                       FileModelNode *node)
1930 {
1931   do_files_added (node->model, node, files);
1932 }
1933
1934 static void
1935 files_changed_callback (GFile         *folder,
1936                         GSList        *files,
1937                         FileModelNode *node)
1938 {
1939   do_files_changed (node->model, node, files);
1940 }
1941
1942 static void
1943 files_removed_callback (GFile         *folder,
1944                         GSList        *files,
1945                         FileModelNode *node)
1946 {
1947   do_files_removed (node->model, node, files);
1948 }
1949
1950 static void
1951 root_deleted_callback (GFile              *folder,
1952                        GtkFileSystemModel *model)
1953 {
1954 }
1955
1956 static void
1957 root_files_added_callback (GFile              *folder,
1958                            GSList             *files,
1959                            GtkFileSystemModel *model)
1960 {
1961   do_files_added (model, NULL, files);
1962 }
1963
1964 static void
1965 root_files_changed_callback (GFile              *folder,
1966                              GSList             *files,
1967                              GtkFileSystemModel *model)
1968 {
1969   do_files_changed (model, NULL, files);
1970 }
1971
1972 static void
1973 root_files_removed_callback (GFile              *folder,
1974                              GSList             *files,
1975                              GtkFileSystemModel *model)
1976 {
1977   do_files_removed (model, NULL, files);
1978 }