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

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