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