1 /* GTK - The GIMP Toolkit
2 * gtkfilesystemmodel.c: GtkTreeModel wrapping a GtkFileSystem
3 * Copyright (C) 2003, Red Hat, Inc.
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.
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.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
21 #include "gtkfilesystemmodel.h"
26 #include "gtkfilesystem.h"
28 #include "gtkmarshalers.h"
29 #include "gtktreedatalist.h"
30 #include "gtktreednd.h"
31 #include "gtktreemodel.h"
33 /*** Structure: how GtkFileSystemModel works
35 * This is a custom GtkTreeModel used to hold a collection of files for GtkFileChooser. There are two use cases:
37 * 1. The model populates itself from a folder, using the GIO file enumerator API. This happens if you use
38 * _gtk_file_system_model_new_for_directory(). This is the normal usage for showing the contents of a folder.
40 * 2. The caller populates the model by hand, with files not necessarily in the same folder. This happens
41 * if you use _gtk_file_system_model_new() and then _gtk_file_system_model_add_and_query_file(). This is
42 * the special kind of usage for "search" and "recent-files", where the file chooser gives the model the
43 * files to be displayed.
45 * Internal data structure
46 * -----------------------
48 * Each file is kept in a FileModelNode structure. Each FileModelNode holds a GFile* and other data. All the
49 * node structures have the same size, determined at runtime, depending on the number of columns that were passed
50 * to _gtk_file_system_model_new() or _gtk_file_system_model_new_for_directory() (that is, the size of a node is
51 * not sizeof (FileModelNode), but rather model->node_size). The last field in the FileModelNode structure,
52 * node->values[], is an array of GValue, used to hold the data for those columns.
54 * The model stores an array of FileModelNode structures in model->files. This is a GArray where each element is
55 * model->node_size bytes in size (the model computes that node size when initializing itself). There are
56 * convenience macros, get_node() and node_index(), to access that array based on an array index or a pointer to
57 * a node inside the array.
59 * The model accesses files through two of its fields:
61 * model->files - GArray of FileModelNode structures.
63 * model->file_lookup - hash table that maps a GFile* to an index inside the model->files array.
65 * The model->file_lookup hash table is populated lazily. It is both accessed and populated with the
66 * node_get_for_file() function. The invariant is that the files in model->files[n] for n < g_hash_table_size
67 * (model->file_lookup) are already added to the hash table. The hash table will get cleared when we re-sort the
68 * files, as the array will be in a different order and the indexes need to be rebuilt.
70 * Each FileModelNode has a node->visible field, which indicates whether the node is visible in the GtkTreeView.
71 * A node may be invisible if, for example, it corresponds to a hidden file and the file chooser is not showing
72 * hidden files. Also, a file filter may be explicitly set onto the model, for example, to only show files that
73 * match "*.jpg". In this case, node->filtered_out says whether the node failed the filter. The ultimate
74 * decision on whether a node is visible or not in the treeview is distilled into the node->visible field.
75 * The reason for having a separate node->filtered_out field is so that the file chooser can query whether
76 * a (filtered-out) folder should be made sensitive in the GUI.
78 * Visible rows vs. possibly-invisible nodes
79 * -----------------------------------------
81 * Since not all nodes in the model->files array may be visible, we need a way to map visible row indexes from
82 * the treeview to array indexes in our array of files. And thus we introduce a bit of terminology:
84 * index - An index in the model->files array. All variables/fields that represent indexes are either called
85 * "index" or "i_*", or simply "i" for things like loop counters.
87 * row - An index in the GtkTreeView, i.e. the index of a row within the outward-facing API of the
88 * GtkFileSystemModel. However, note that our rows are 1-based, not 0-based, for the reason explained in the
89 * following paragraph. Variables/fields that represent visible rows are called "row", or "r_*", or simply
92 * Each FileModelNode has a node->row field which is the number of visible rows in the treeview, *before and
93 * including* that node. This means that node->row is 1-based, instead of 0-based --- this makes some code
94 * simpler, believe it or not :) This also means that when the calling GtkTreeView gives us a GtkTreePath, we
95 * turn the 0-based treepath into a 1-based row for our purposes. If a node is not visible, it will have the
96 * same row number as its closest preceding visible node.
98 * We try to compute the node->row fields lazily. A node is said to be "valid" if its node->row is accurate.
99 * For this, the model keeps a model->n_nodes_valid field which is the count of valid nodes starting from the
100 * beginning of the model->files array. When a node changes its information, or when a node gets deleted, that
101 * node and the following ones get invalidated by simply setting model->n_nodes_valid to the array index of the
102 * node. If the model happens to need a node's row number and that node is in the model->files array after
103 * model->n_nodes_valid, then the nodes get re-validated up to the sought node. See node_validate_rows() for
106 * You never access a node->row directly. Instead, call node_get_tree_row(). That function will validate the nodes
107 * up to the sought one if the node is not valid yet, and it will return a proper 0-based row.
112 * The model implements the GtkTreeSortable interface. To avoid re-sorting
113 * every time a node gets added (which would lead to O(n^2) performance during
114 * the initial population of the model), the model can freeze itself (with
115 * freeze_updates()) during the intial population process. When the model is
116 * frozen, sorting will not happen. The model will sort itself when the freeze
117 * count goes back to zero, via corresponding calls to thaw_updates().
122 /* priority used for all async callbacks in the main loop
123 * This should be higher than redraw priorities so multiple callbacks
124 * firing can be handled without intermediate redraws */
125 #define IO_PRIORITY G_PRIORITY_DEFAULT
127 /* random number that everyone else seems to use, too */
128 #define FILES_PER_QUERY 100
130 typedef struct _FileModelNode FileModelNode;
131 typedef struct _GtkFileSystemModelClass GtkFileSystemModelClass;
133 struct _FileModelNode
135 GFile * file; /* file represented by this node or NULL for editable */
136 GFileInfo * info; /* info for this file or NULL if unknown */
138 guint row; /* if valid (see model->n_valid_indexes), visible nodes before and including
139 * this one - see the "Structure" comment above.
142 guint visible :1; /* if the file is currently visible */
143 guint filtered_out :1;/* if the file is currently filtered out (i.e. it didn't pass the filters) */
144 guint frozen_add :1; /* true if the model was frozen and the entry has not been added yet */
146 GValue values[1]; /* actually n_columns values */
149 struct _GtkFileSystemModel
151 GObject parent_instance;
153 GFile * dir; /* directory that's displayed */
154 guint dir_thaw_source;/* GSource id for unfreezing the model */
155 char * attributes; /* attributes the file info must contain, or NULL for all attributes */
156 GFileMonitor * dir_monitor; /* directory that is monitored, or NULL if monitoring was not supported */
158 GCancellable * cancellable; /* cancellable in use for all operations - cancelled on dispose */
159 GArray * files; /* array of FileModelNode containing all our files */
160 gsize node_size; /* Size of a FileModelNode structure once its ->values field has n_columns */
161 guint n_nodes_valid; /* count of valid nodes (i.e. those whose node->row is accurate) */
162 GHashTable * file_lookup; /* mapping of GFile => array index in model->files
163 * This hash table doesn't always have the same number of entries as the files array;
164 * it can get cleared completely when we resort.
165 * The hash table gets re-populated in node_get_for_file() if this mismatch is
169 guint n_columns; /* number of columns */
170 GType * column_types; /* types of each column */
171 GtkFileSystemModelGetValue get_func; /* function to call to fill in values in columns */
172 gpointer get_data; /* data to pass to get_func */
174 GtkFileFilter * filter; /* filter to use for deciding which nodes are visible */
176 int sort_column_id; /* current sorting column */
177 GtkSortType sort_order; /* current sorting order */
178 GList * sort_list; /* list of sorting functions */
179 GtkTreeIterCompareFunc default_sort_func; /* default sort function */
180 gpointer default_sort_data; /* data to pass to default sort func */
181 GDestroyNotify default_sort_destroy; /* function to call to destroy default_sort_data */
183 guint frozen; /* number of times we're frozen */
185 gboolean filter_on_thaw :1;/* set when filtering needs to happen upon thawing */
186 gboolean sort_on_thaw :1;/* set when sorting needs to happen upon thawing */
188 guint show_hidden :1; /* whether to show hidden files */
189 guint show_folders :1;/* whether to show folders */
190 guint show_files :1; /* whether to show files */
191 guint filter_folders :1;/* whether filter applies to folders */
194 #define GTK_FILE_SYSTEM_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModelClass))
195 #define GTK_IS_FILE_SYSTEM_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_SYSTEM_MODEL))
196 #define GTK_FILE_SYSTEM_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModelClass))
198 struct _GtkFileSystemModelClass
200 GObjectClass parent_class;
204 void (*finished_loading) (GtkFileSystemModel *model, GError *error);
207 static void freeze_updates (GtkFileSystemModel *model);
208 static void thaw_updates (GtkFileSystemModel *model);
210 static guint node_get_for_file (GtkFileSystemModel *model,
213 static void add_file (GtkFileSystemModel *model,
216 static void remove_file (GtkFileSystemModel *model,
220 * @user_data: the model
221 * @user_data2: GUINT_TO_POINTER of array index of current entry
223 * All other fields are unused. Note that the array index does not corrspond
224 * 1:1 with the path index as entries might not be visible.
226 #define ITER_INDEX(iter) GPOINTER_TO_UINT((iter)->user_data2)
227 #define ITER_IS_VALID(model, iter) ((model) == (iter)->user_data)
228 #define ITER_INIT_FROM_INDEX(model, _iter, _index) G_STMT_START {\
229 g_assert (_index < (model)->files->len); \
230 (_iter)->user_data = (model); \
231 (_iter)->user_data2 = GUINT_TO_POINTER (_index); \
234 /*** FileModelNode ***/
236 /* Get a FileModelNode structure given an index in the model->files array of nodes */
237 #define get_node(_model, _index) ((FileModelNode *) ((_model)->files->data + (_index) * (_model)->node_size))
239 /* Get an index within the model->files array of nodes, given a FileModelNode* */
240 #define node_index(_model, _node) (((gchar *) (_node) - (_model)->files->data) / (_model)->node_size)
242 /* @up_to_index: smallest model->files array index that will be valid after this call
243 * @up_to_row: smallest node->row that will be valid after this call
245 * If you want to validate up to an index or up to a row, specify the index or
246 * the row you want and specify G_MAXUINT for the other argument. Pass
247 * G_MAXUINT for both arguments for "validate everything".
250 node_validate_rows (GtkFileSystemModel *model, guint up_to_index, guint up_to_row)
254 if (model->files->len == 0)
257 up_to_index = MIN (up_to_index, model->files->len - 1);
259 i = model->n_nodes_valid;
261 row = get_node (model, i - 1)->row;
265 while (i <= up_to_index && row <= up_to_row)
267 FileModelNode *node = get_node (model, i);
273 model->n_nodes_valid = i;
277 node_get_tree_row (GtkFileSystemModel *model, guint index)
279 if (model->n_nodes_valid <= index)
280 node_validate_rows (model, index, G_MAXUINT);
282 return get_node (model, index)->row - 1;
286 node_invalidate_index (GtkFileSystemModel *model, guint id)
288 model->n_nodes_valid = MIN (model->n_nodes_valid, id);
292 tree_path_new_from_node (GtkFileSystemModel *model, guint id)
294 guint r = node_get_tree_row (model, id);
296 g_assert (r < model->files->len);
298 return gtk_tree_path_new_from_indices (r, -1);
302 emit_row_inserted_for_node (GtkFileSystemModel *model, guint id)
307 path = tree_path_new_from_node (model, id);
308 ITER_INIT_FROM_INDEX (model, &iter, id);
309 gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter);
310 gtk_tree_path_free (path);
314 emit_row_changed_for_node (GtkFileSystemModel *model, guint id)
319 path = tree_path_new_from_node (model, id);
320 ITER_INIT_FROM_INDEX (model, &iter, id);
321 gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
322 gtk_tree_path_free (path);
326 emit_row_deleted_for_row (GtkFileSystemModel *model, guint row)
330 path = gtk_tree_path_new_from_indices (row, -1);
331 gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
332 gtk_tree_path_free (path);
336 node_set_visible_and_filtered_out (GtkFileSystemModel *model, guint id, gboolean visible, gboolean filtered_out)
338 FileModelNode *node = get_node (model, id);
342 if (node->filtered_out != filtered_out)
344 node->filtered_out = filtered_out;
345 if (node->visible && visible)
346 emit_row_changed_for_node (model, id);
351 if (node->visible == visible ||
357 node->visible = TRUE;
358 node_invalidate_index (model, id);
359 emit_row_inserted_for_node (model, id);
365 row = node_get_tree_row (model, id);
366 g_assert (row < model->files->len);
368 node->visible = FALSE;
369 node_invalidate_index (model, id);
370 emit_row_deleted_for_row (model, row);
375 node_should_be_filtered_out (GtkFileSystemModel *model, guint id)
377 FileModelNode *node = get_node (model, id);
378 GtkFileFilterInfo filter_info = { 0, };
379 GtkFileFilterFlags required;
381 char *mime_type = NULL;
382 char *filename = NULL;
385 if (node->info == NULL)
388 if (model->filter == NULL)
392 required = gtk_file_filter_get_needed (model->filter);
394 filter_info.contains = GTK_FILE_FILTER_DISPLAY_NAME;
395 filter_info.display_name = g_file_info_get_display_name (node->info);
397 if (required & GTK_FILE_FILTER_MIME_TYPE)
399 const char *s = g_file_info_get_content_type (node->info);
402 mime_type = g_content_type_get_mime_type (s);
405 filter_info.mime_type = mime_type;
406 filter_info.contains |= GTK_FILE_FILTER_MIME_TYPE;
411 if (required & GTK_FILE_FILTER_FILENAME)
413 filename = g_file_get_path (node->file);
416 filter_info.filename = filename;
417 filter_info.contains |= GTK_FILE_FILTER_FILENAME;
421 if (required & GTK_FILE_FILTER_URI)
423 uri = g_file_get_uri (node->file);
426 filter_info.uri = uri;
427 filter_info.contains |= GTK_FILE_FILTER_URI;
431 result = !gtk_file_filter_filter (model->filter, &filter_info);
441 node_should_be_visible (GtkFileSystemModel *model, guint id, gboolean filtered_out)
443 FileModelNode *node = get_node (model, id);
446 if (node->info == NULL)
449 if (!model->show_hidden &&
450 (g_file_info_get_is_hidden (node->info) || g_file_info_get_is_backup (node->info)))
453 if (_gtk_file_info_consider_as_directory (node->info))
455 if (!model->show_folders)
458 if (!model->filter_folders)
463 if (!model->show_files)
467 result = !filtered_out;
473 node_compute_visibility_and_filters (GtkFileSystemModel *model, guint id)
475 gboolean filtered_out;
478 filtered_out = node_should_be_filtered_out (model, id);
479 visible = node_should_be_visible (model, id, filtered_out);
481 node_set_visible_and_filtered_out (model, id, visible, filtered_out);
484 /*** GtkTreeModel ***/
486 static GtkTreeModelFlags
487 gtk_file_system_model_get_flags (GtkTreeModel *tree_model)
489 /* GTK_TREE_MODEL_ITERS_PERSIST doesn't work with arrays :( */
490 return GTK_TREE_MODEL_LIST_ONLY;
494 gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model)
496 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
498 return model->n_columns;
502 gtk_file_system_model_get_column_type (GtkTreeModel *tree_model,
505 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
507 g_return_val_if_fail (i >= 0 && (guint) i < model->n_columns, G_TYPE_NONE);
509 return model->column_types[i];
513 compare_indices (gconstpointer key, gconstpointer _node)
515 const FileModelNode *node = _node;
517 return GPOINTER_TO_UINT (key) - node->row;
521 gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model,
526 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
531 g_return_val_if_fail (n >= 0, FALSE);
536 row_to_find = n + 1; /* plus one as our node->row numbers are 1-based; see the "Structure" comment at the beginning */
538 if (model->n_nodes_valid > 0 &&
539 get_node (model, model->n_nodes_valid - 1)->row >= row_to_find)
541 /* Fast path - the nodes are valid up to the sought one.
543 * First, find a node with the sought row number...*/
545 node = bsearch (GUINT_TO_POINTER (row_to_find),
547 model->n_nodes_valid,
553 /* ... Second, back up until we find the first visible node with that row number */
555 id = node_index (model, node);
556 while (!get_node (model, id)->visible)
559 g_assert (get_node (model, id)->row == row_to_find);
563 /* Slow path - the nodes need to be validated up to the sought one */
565 node_validate_rows (model, G_MAXUINT, n); /* note that this is really "n", not row_to_find - see node_validate_rows() */
566 id = model->n_nodes_valid - 1;
567 if (model->n_nodes_valid == 0 || get_node (model, id)->row != row_to_find)
571 ITER_INIT_FROM_INDEX (model, iter, id);
576 gtk_file_system_model_get_iter (GtkTreeModel *tree_model,
580 g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
582 if (gtk_tree_path_get_depth (path) > 1)
585 return gtk_file_system_model_iter_nth_child (tree_model,
588 gtk_tree_path_get_indices (path)[0]);
592 gtk_file_system_model_get_path (GtkTreeModel *tree_model,
595 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
597 g_return_val_if_fail (ITER_IS_VALID (model, iter), NULL);
599 return tree_path_new_from_node (model, ITER_INDEX (iter));
603 gtk_file_system_model_get_value (GtkTreeModel *tree_model,
608 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
609 const GValue *original;
611 g_return_if_fail ((guint) column < model->n_columns);
612 g_return_if_fail (ITER_IS_VALID (model, iter));
614 original = _gtk_file_system_model_get_value (model, iter, column);
617 g_value_init (value, G_VALUE_TYPE (original));
618 g_value_copy (original, value);
621 g_value_init (value, model->column_types[column]);
625 gtk_file_system_model_iter_next (GtkTreeModel *tree_model,
628 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
631 g_return_val_if_fail (ITER_IS_VALID (model, iter), FALSE);
633 for (i = ITER_INDEX (iter) + 1; i < model->files->len; i++)
635 FileModelNode *node = get_node (model, i);
639 ITER_INIT_FROM_INDEX (model, iter, i);
648 gtk_file_system_model_iter_children (GtkTreeModel *tree_model,
656 gtk_file_system_model_iter_has_child (GtkTreeModel *tree_model,
663 gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model,
666 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
671 return node_get_tree_row (model, model->files->len - 1) + 1;
675 gtk_file_system_model_iter_parent (GtkTreeModel *tree_model,
683 gtk_file_system_model_ref_node (GtkTreeModel *tree_model,
690 gtk_file_system_model_unref_node (GtkTreeModel *tree_model,
697 gtk_file_system_model_iface_init (GtkTreeModelIface *iface)
699 iface->get_flags = gtk_file_system_model_get_flags;
700 iface->get_n_columns = gtk_file_system_model_get_n_columns;
701 iface->get_column_type = gtk_file_system_model_get_column_type;
702 iface->get_iter = gtk_file_system_model_get_iter;
703 iface->get_path = gtk_file_system_model_get_path;
704 iface->get_value = gtk_file_system_model_get_value;
705 iface->iter_next = gtk_file_system_model_iter_next;
706 iface->iter_children = gtk_file_system_model_iter_children;
707 iface->iter_has_child = gtk_file_system_model_iter_has_child;
708 iface->iter_n_children = gtk_file_system_model_iter_n_children;
709 iface->iter_nth_child = gtk_file_system_model_iter_nth_child;
710 iface->iter_parent = gtk_file_system_model_iter_parent;
711 iface->ref_node = gtk_file_system_model_ref_node;
712 iface->unref_node = gtk_file_system_model_unref_node;
715 /*** GtkTreeSortable ***/
717 typedef struct _SortData SortData;
719 GtkFileSystemModel * model;
720 GtkTreeIterCompareFunc func;
722 int order; /* -1 to invert sort order or 1 to keep it */
725 /* returns FALSE if no sort necessary */
727 sort_data_init (SortData *data, GtkFileSystemModel *model)
729 GtkTreeDataSortHeader *header;
731 if (model->files->len <= 2)
734 switch (model->sort_column_id)
736 case GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID:
737 if (!model->default_sort_func)
739 data->func = model->default_sort_func;
740 data->data = model->default_sort_data;
742 case GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID:
745 header = _gtk_tree_data_list_get_header (model->sort_list, model->sort_column_id);
748 data->func = header->func;
749 data->data = header->data;
753 data->order = model->sort_order == GTK_SORT_DESCENDING ? -1 : 1;
759 compare_array_element (gconstpointer a, gconstpointer b, gpointer user_data)
761 SortData *data = user_data;
762 GtkTreeIter itera, iterb;
764 ITER_INIT_FROM_INDEX (data->model, &itera, node_index (data->model, a));
765 ITER_INIT_FROM_INDEX (data->model, &iterb, node_index (data->model, b));
766 return data->func (GTK_TREE_MODEL (data->model), &itera, &iterb, data->data) * data->order;
770 gtk_file_system_model_sort (GtkFileSystemModel *model)
776 model->sort_on_thaw = TRUE;
780 if (sort_data_init (&data, model))
784 guint r, n_visible_rows;
786 node_validate_rows (model, G_MAXUINT, G_MAXUINT);
787 n_visible_rows = node_get_tree_row (model, model->files->len - 1) + 1;
788 model->n_nodes_valid = 0;
789 g_hash_table_remove_all (model->file_lookup);
790 g_qsort_with_data (get_node (model, 1), /* start at index 1; don't sort the editable row */
791 model->files->len - 1,
793 compare_array_element,
795 g_assert (model->n_nodes_valid == 0);
796 g_assert (g_hash_table_size (model->file_lookup) == 0);
799 int *new_order = g_new (int, n_visible_rows);
802 for (i = 0; i < model->files->len; i++)
804 FileModelNode *node = get_node (model, i);
811 new_order[r] = node->row - 1;
815 g_assert (r == n_visible_rows);
816 path = gtk_tree_path_new ();
817 gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
821 gtk_tree_path_free (path);
826 model->sort_on_thaw = FALSE;
830 gtk_file_system_model_sort_node (GtkFileSystemModel *model, guint node)
833 gtk_file_system_model_sort (model);
837 gtk_file_system_model_get_sort_column_id (GtkTreeSortable *sortable,
838 gint *sort_column_id,
841 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
844 *sort_column_id = model->sort_column_id;
846 *order = model->sort_order;
848 if (model->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID ||
849 model->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
856 gtk_file_system_model_set_sort_column_id (GtkTreeSortable *sortable,
860 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
862 if ((model->sort_column_id == sort_column_id) &&
863 (model->sort_order == order))
866 if (sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
868 if (sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)
870 GtkTreeDataSortHeader *header = NULL;
872 header = _gtk_tree_data_list_get_header (model->sort_list,
875 /* We want to make sure that we have a function */
876 g_return_if_fail (header != NULL);
877 g_return_if_fail (header->func != NULL);
881 g_return_if_fail (model->default_sort_func != NULL);
886 model->sort_column_id = sort_column_id;
887 model->sort_order = order;
889 gtk_tree_sortable_sort_column_changed (sortable);
891 gtk_file_system_model_sort (model);
895 gtk_file_system_model_set_sort_func (GtkTreeSortable *sortable,
897 GtkTreeIterCompareFunc func,
899 GDestroyNotify destroy)
901 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
903 model->sort_list = _gtk_tree_data_list_set_header (model->sort_list,
905 func, data, destroy);
907 if (model->sort_column_id == sort_column_id)
908 gtk_file_system_model_sort (model);
912 gtk_file_system_model_set_default_sort_func (GtkTreeSortable *sortable,
913 GtkTreeIterCompareFunc func,
915 GDestroyNotify destroy)
917 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
919 if (model->default_sort_destroy)
921 GDestroyNotify d = model->default_sort_destroy;
923 model->default_sort_destroy = NULL;
924 d (model->default_sort_data);
927 model->default_sort_func = func;
928 model->default_sort_data = data;
929 model->default_sort_destroy = destroy;
931 if (model->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)
932 gtk_file_system_model_sort (model);
936 gtk_file_system_model_has_default_sort_func (GtkTreeSortable *sortable)
938 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
940 return (model->default_sort_func != NULL);
944 gtk_file_system_model_sortable_init (GtkTreeSortableIface *iface)
946 iface->get_sort_column_id = gtk_file_system_model_get_sort_column_id;
947 iface->set_sort_column_id = gtk_file_system_model_set_sort_column_id;
948 iface->set_sort_func = gtk_file_system_model_set_sort_func;
949 iface->set_default_sort_func = gtk_file_system_model_set_default_sort_func;
950 iface->has_default_sort_func = gtk_file_system_model_has_default_sort_func;
953 /*** GtkTreeDragSource ***/
956 drag_source_row_draggable (GtkTreeDragSource *drag_source,
959 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (drag_source);
962 if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
965 return ITER_INDEX (&iter) != 0;
969 drag_source_drag_data_get (GtkTreeDragSource *drag_source,
971 GtkSelectionData *selection_data)
973 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (drag_source);
978 if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
981 node = get_node (model, ITER_INDEX (&iter));
982 if (node->file == NULL)
985 uris[0] = g_file_get_uri (node->file);
987 gtk_selection_data_set_uris (selection_data, uris);
994 drag_source_iface_init (GtkTreeDragSourceIface *iface)
996 iface->row_draggable = drag_source_row_draggable;
997 iface->drag_data_get = drag_source_drag_data_get;
998 iface->drag_data_delete = NULL;
1001 /*** GtkFileSystemModel ***/
1009 static guint file_system_model_signals[LAST_SIGNAL] = { 0 };
1013 G_DEFINE_TYPE_WITH_CODE (GtkFileSystemModel, _gtk_file_system_model, G_TYPE_OBJECT,
1014 G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL,
1015 gtk_file_system_model_iface_init)
1016 G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_SORTABLE,
1017 gtk_file_system_model_sortable_init)
1018 G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
1019 drag_source_iface_init))
1022 gtk_file_system_model_dispose (GObject *object)
1024 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
1026 if (model->dir_thaw_source)
1028 g_source_remove (model->dir_thaw_source);
1029 model->dir_thaw_source = 0;
1032 g_cancellable_cancel (model->cancellable);
1033 if (model->dir_monitor)
1034 g_file_monitor_cancel (model->dir_monitor);
1036 G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object);
1041 gtk_file_system_model_finalize (GObject *object)
1043 GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
1046 for (i = 0; i < model->files->len; i++)
1050 FileModelNode *node = get_node (model, i);
1052 g_object_unref (node->file);
1054 g_object_unref (node->info);
1056 for (v = 0; v < model->n_columns; v++)
1057 if (G_VALUE_TYPE (&node->values[v]) != G_TYPE_INVALID)
1058 g_value_unset (&node->values[v]);
1060 g_array_free (model->files, TRUE);
1062 g_object_unref (model->cancellable);
1063 g_free (model->attributes);
1065 g_object_unref (model->dir);
1066 if (model->dir_monitor)
1067 g_object_unref (model->dir_monitor);
1068 g_hash_table_destroy (model->file_lookup);
1070 g_object_unref (model->filter);
1072 g_slice_free1 (sizeof (GType) * model->n_columns, model->column_types);
1074 _gtk_tree_data_list_header_free (model->sort_list);
1075 if (model->default_sort_destroy)
1076 model->default_sort_destroy (model->default_sort_data);
1078 G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object);
1082 _gtk_file_system_model_class_init (GtkFileSystemModelClass *class)
1084 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
1086 gobject_class->finalize = gtk_file_system_model_finalize;
1087 gobject_class->dispose = gtk_file_system_model_dispose;
1089 file_system_model_signals[FINISHED_LOADING] =
1090 g_signal_new (I_("finished-loading"),
1091 G_OBJECT_CLASS_TYPE (gobject_class),
1093 G_STRUCT_OFFSET (GtkFileSystemModelClass, finished_loading),
1095 _gtk_marshal_VOID__POINTER,
1096 G_TYPE_NONE, 1, G_TYPE_POINTER);
1100 _gtk_file_system_model_init (GtkFileSystemModel *model)
1102 model->show_files = TRUE;
1103 model->show_folders = TRUE;
1104 model->show_hidden = FALSE;
1105 model->filter_folders = FALSE;
1107 model->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
1109 model->file_lookup = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal);
1110 model->cancellable = g_cancellable_new ();
1116 gtk_file_system_model_closed_enumerator (GObject *object, GAsyncResult *res, gpointer data)
1118 g_file_enumerator_close_finish (G_FILE_ENUMERATOR (object), res, NULL);
1122 thaw_func (gpointer data)
1124 GtkFileSystemModel *model = data;
1126 thaw_updates (model);
1127 model->dir_thaw_source = 0;
1133 gtk_file_system_model_got_files (GObject *object, GAsyncResult *res, gpointer data)
1135 GFileEnumerator *enumerator = G_FILE_ENUMERATOR (object);
1136 GtkFileSystemModel *model = data;
1137 GList *walk, *files;
1138 GError *error = NULL;
1140 gdk_threads_enter ();
1142 files = g_file_enumerator_next_files_finish (enumerator, res, &error);
1146 if (model->dir_thaw_source == 0)
1148 freeze_updates (model);
1149 model->dir_thaw_source = gdk_threads_add_timeout_full (IO_PRIORITY + 1,
1156 for (walk = files; walk; walk = walk->next)
1163 name = g_file_info_get_name (info);
1166 /* Shouldn't happen, but the APIs allow it */
1167 g_object_unref (info);
1170 file = g_file_get_child (model->dir, name);
1171 add_file (model, file, info);
1172 g_object_unref (file);
1173 g_object_unref (info);
1175 g_list_free (files);
1177 g_file_enumerator_next_files_async (enumerator,
1178 g_file_is_native (model->dir) ? 50 * FILES_PER_QUERY : FILES_PER_QUERY,
1181 gtk_file_system_model_got_files,
1186 if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
1188 g_file_enumerator_close_async (enumerator,
1191 gtk_file_system_model_closed_enumerator,
1193 if (model->dir_thaw_source != 0)
1195 g_source_remove (model->dir_thaw_source);
1196 model->dir_thaw_source = 0;
1197 thaw_updates (model);
1200 g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, error);
1204 g_error_free (error);
1207 gdk_threads_leave ();
1211 gtk_file_system_model_query_done (GObject * object,
1215 GtkFileSystemModel *model = data; /* only a valid pointer if not cancelled */
1216 GFile *file = G_FILE (object);
1220 info = g_file_query_info_finish (file, res, NULL);
1224 gdk_threads_enter ();
1226 _gtk_file_system_model_update_file (model, file, info);
1228 id = node_get_for_file (model, file);
1229 gtk_file_system_model_sort_node (model, id);
1231 gdk_threads_leave ();
1235 gtk_file_system_model_monitor_change (GFileMonitor * monitor,
1238 GFileMonitorEvent type,
1239 GtkFileSystemModel *model)
1243 case G_FILE_MONITOR_EVENT_CREATED:
1244 case G_FILE_MONITOR_EVENT_CHANGED:
1245 case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
1246 /* We can treat all of these the same way */
1247 g_file_query_info_async (file,
1249 G_FILE_QUERY_INFO_NONE,
1252 gtk_file_system_model_query_done,
1255 case G_FILE_MONITOR_EVENT_DELETED:
1256 gdk_threads_enter ();
1257 remove_file (model, file);
1258 gdk_threads_leave ();
1260 case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
1261 /* FIXME: use freeze/thaw with this somehow? */
1262 case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
1263 case G_FILE_MONITOR_EVENT_UNMOUNTED:
1271 gtk_file_system_model_got_enumerator (GObject *dir, GAsyncResult *res, gpointer data)
1273 GtkFileSystemModel *model = data;
1274 GFileEnumerator *enumerator;
1275 GError *error = NULL;
1277 gdk_threads_enter ();
1279 enumerator = g_file_enumerate_children_finish (G_FILE (dir), res, &error);
1280 if (enumerator == NULL)
1282 if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
1284 g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, error);
1285 g_error_free (error);
1290 g_file_enumerator_next_files_async (enumerator,
1291 g_file_is_native (model->dir) ? 50 * FILES_PER_QUERY : FILES_PER_QUERY,
1294 gtk_file_system_model_got_files,
1296 g_object_unref (enumerator);
1297 model->dir_monitor = g_file_monitor_directory (model->dir,
1298 G_FILE_MONITOR_NONE,
1300 NULL); /* we don't mind if directory monitoring isn't supported, so the GError is NULL here */
1301 if (model->dir_monitor)
1302 g_signal_connect (model->dir_monitor,
1304 G_CALLBACK (gtk_file_system_model_monitor_change),
1308 gdk_threads_leave ();
1312 gtk_file_system_model_set_n_columns (GtkFileSystemModel *model,
1318 g_assert (model->files == NULL);
1319 g_assert (n_columns > 0);
1321 model->n_columns = n_columns;
1322 model->column_types = g_slice_alloc (sizeof (GType) * n_columns);
1324 model->node_size = sizeof (FileModelNode) + sizeof (GValue) * (n_columns - 1); /* minus 1 because FileModelNode.values[] has a default size of 1 */
1326 for (i = 0; i < (guint) n_columns; i++)
1328 GType type = va_arg (args, GType);
1329 if (! _gtk_tree_data_list_check_type (type))
1331 g_error ("%s: type %s cannot be a column type for GtkFileSystemModel\n", G_STRLOC, g_type_name (type));
1332 return; /* not reached */
1335 model->column_types[i] = type;
1338 model->sort_list = _gtk_tree_data_list_header_new (n_columns, model->column_types);
1340 model->files = g_array_sized_new (FALSE, FALSE, model->node_size, FILES_PER_QUERY);
1341 /* add editable node at start */
1342 g_array_set_size (model->files, 1);
1343 memset (get_node (model, 0), 0, model->node_size);
1347 gtk_file_system_model_set_directory (GtkFileSystemModel *model,
1349 const gchar * attributes)
1351 g_assert (G_IS_FILE (dir));
1353 model->dir = g_object_ref (dir);
1354 model->attributes = g_strdup (attributes);
1356 g_file_enumerate_children_async (model->dir,
1358 G_FILE_QUERY_INFO_NONE,
1361 gtk_file_system_model_got_enumerator,
1366 static GtkFileSystemModel *
1367 _gtk_file_system_model_new_valist (GtkFileSystemModelGetValue get_func,
1372 GtkFileSystemModel *model;
1374 model = g_object_new (GTK_TYPE_FILE_SYSTEM_MODEL, NULL);
1375 model->get_func = get_func;
1376 model->get_data = get_data;
1378 gtk_file_system_model_set_n_columns (model, n_columns, args);
1384 * _gtk_file_system_model_new:
1385 * @get_func: function to call for getting a value
1386 * @get_data: user data argument passed to @get_func
1387 * @n_columns: number of columns
1388 * @...: @n_columns #GType types for the columns
1390 * Creates a new #GtkFileSystemModel object. You need to add files
1391 * to the list using _gtk_file_system_model_add_and_query_file()
1392 * or _gtk_file_system_model_update_file().
1394 * Return value: the newly created #GtkFileSystemModel
1396 GtkFileSystemModel *
1397 _gtk_file_system_model_new (GtkFileSystemModelGetValue get_func,
1402 GtkFileSystemModel *model;
1405 g_return_val_if_fail (get_func != NULL, NULL);
1406 g_return_val_if_fail (n_columns > 0, NULL);
1408 va_start (args, n_columns);
1409 model = _gtk_file_system_model_new_valist (get_func, get_data, n_columns, args);
1416 * _gtk_file_system_model_new_for_directory:
1417 * @directory: the directory to show.
1418 * @attributes: (allow-none): attributes to immediately load or %NULL for all
1419 * @get_func: function that the model should call to query data about a file
1420 * @get_data: user data to pass to the @get_func
1421 * @n_columns: number of columns
1422 * @...: @n_columns #GType types for the columns
1424 * Creates a new #GtkFileSystemModel object. The #GtkFileSystemModel
1425 * object wraps the given @directory as a #GtkTreeModel.
1426 * The model will query the given directory with the given @attributes
1427 * and add all files inside the directory automatically. If supported,
1428 * it will also monitor the drectory and update the model's
1429 * contents to reflect changes, if the @directory supports monitoring.
1431 * Return value: the newly created #GtkFileSystemModel
1433 GtkFileSystemModel *
1434 _gtk_file_system_model_new_for_directory (GFile * dir,
1435 const gchar * attributes,
1436 GtkFileSystemModelGetValue get_func,
1441 GtkFileSystemModel *model;
1444 g_return_val_if_fail (G_IS_FILE (dir), NULL);
1445 g_return_val_if_fail (get_func != NULL, NULL);
1446 g_return_val_if_fail (n_columns > 0, NULL);
1448 va_start (args, n_columns);
1449 model = _gtk_file_system_model_new_valist (get_func, get_data, n_columns, args);
1452 gtk_file_system_model_set_directory (model, dir, attributes);
1458 gtk_file_system_model_refilter_all (GtkFileSystemModel *model)
1464 model->filter_on_thaw = TRUE;
1468 freeze_updates (model);
1470 /* start at index 1, don't change the editable */
1471 for (i = 1; i < model->files->len; i++)
1472 node_compute_visibility_and_filters (model, i);
1474 model->filter_on_thaw = FALSE;
1475 thaw_updates (model);
1479 * _gtk_file_system_model_set_show_hidden:
1480 * @model: a #GtkFileSystemModel
1481 * @show_hidden: whether hidden files should be displayed
1483 * Sets whether hidden files should be included in the #GtkTreeModel
1487 _gtk_file_system_model_set_show_hidden (GtkFileSystemModel *model,
1488 gboolean show_hidden)
1490 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1492 show_hidden = show_hidden != FALSE;
1494 if (show_hidden != model->show_hidden)
1496 model->show_hidden = show_hidden;
1497 gtk_file_system_model_refilter_all (model);
1502 * _gtk_file_system_model_set_show_folders:
1503 * @model: a #GtkFileSystemModel
1504 * @show_folders: whether folders should be displayed
1506 * Sets whether folders should be included in the #GtkTreeModel for
1510 _gtk_file_system_model_set_show_folders (GtkFileSystemModel *model,
1511 gboolean show_folders)
1513 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1515 show_folders = show_folders != FALSE;
1517 if (show_folders != model->show_folders)
1519 model->show_folders = show_folders;
1520 gtk_file_system_model_refilter_all (model);
1525 * _gtk_file_system_model_set_show_files:
1526 * @model: a #GtkFileSystemModel
1527 * @show_files: whether files (as opposed to folders) should
1530 * Sets whether files (as opposed to folders) should be included
1531 * in the #GtkTreeModel for display.
1534 _gtk_file_system_model_set_show_files (GtkFileSystemModel *model,
1535 gboolean show_files)
1537 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1539 show_files = show_files != FALSE;
1541 if (show_files != model->show_files)
1543 model->show_files = show_files;
1544 gtk_file_system_model_refilter_all (model);
1549 * _gtk_file_system_model_set_filter_folders:
1550 * @model: a #GtkFileSystemModel
1551 * @filter_folders: whether the filter applies to folders
1553 * Sets whether the filter set by _gtk_file_system_model_set_filter()
1554 * applies to folders. By default, it does not and folders are always
1558 _gtk_file_system_model_set_filter_folders (GtkFileSystemModel *model,
1559 gboolean filter_folders)
1561 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1563 filter_folders = filter_folders != FALSE;
1565 if (filter_folders != model->filter_folders)
1567 model->filter_folders = filter_folders;
1568 gtk_file_system_model_refilter_all (model);
1573 * _gtk_file_system_model_get_cancellable:
1576 * Gets the cancellable used by the @model. This is the cancellable used
1577 * internally by the @model that will be cancelled when @model is
1578 * disposed. So you can use it for operations that should be cancelled
1579 * when the model goes away.
1581 * Returns: The cancellable used by @model
1584 _gtk_file_system_model_get_cancellable (GtkFileSystemModel *model)
1586 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
1588 return model->cancellable;
1592 * _gtk_file_system_model_iter_is_visible:
1594 * @iter: a valid iterator
1596 * Checks if the iterator is visible. A visible iterator references
1597 * a row that is currently exposed using the #GtkTreeModel API. If
1598 * the iterator is invisible, it references a file that is not shown
1599 * for some reason, such as being filtered out by the current filter or
1600 * being a hidden file.
1602 * Returns: %TRUE if the iterator is visible
1605 _gtk_file_system_model_iter_is_visible (GtkFileSystemModel *model,
1608 FileModelNode *node;
1610 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), FALSE);
1611 g_return_val_if_fail (iter != NULL, FALSE);
1613 node = get_node (model, ITER_INDEX (iter));
1614 return node->visible;
1618 * _gtk_file_system_model_iter_is_filtered_out:
1620 * @iter: a valid iterator
1622 * Checks if the iterator is filtered out. This is only useful for rows
1623 * that refer to folders, as those are always visible regardless
1624 * of what the current filter says. This function lets you see
1625 * the results of the filter.
1627 * Returns: %TRUE if the iterator passed the current filter; %FALSE if the
1628 * filter would not have let the row pass.
1631 _gtk_file_system_model_iter_is_filtered_out (GtkFileSystemModel *model,
1634 FileModelNode *node;
1636 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), FALSE);
1637 g_return_val_if_fail (iter != NULL, FALSE);
1639 node = get_node (model, ITER_INDEX (iter));
1640 return node->filtered_out;
1644 * _gtk_file_system_model_get_info:
1645 * @model: a #GtkFileSystemModel
1646 * @iter: a #GtkTreeIter pointing to a row of @model
1648 * Gets the #GFileInfo structure for a particular row
1651 * Return value: a #GFileInfo structure. This structure
1652 * is owned by @model and must not be modified or freed.
1653 * If you want to keep the information for later use,
1654 * you must take a reference, since the structure may be
1655 * freed on later changes to the file system. If you have
1656 * called _gtk_file_system_model_add_editable() and the @iter
1657 * corresponds to the row that this function returned, the
1658 * return value will be NULL.
1661 _gtk_file_system_model_get_info (GtkFileSystemModel *model,
1664 FileModelNode *node;
1666 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
1667 g_return_val_if_fail (iter != NULL, NULL);
1669 node = get_node (model, ITER_INDEX (iter));
1670 g_assert (node->info == NULL || G_IS_FILE_INFO (node->info));
1675 * _gtk_file_system_model_get_file:
1676 * @model: a #GtkFileSystemModel
1677 * @iter: a #GtkTreeIter pointing to a row of @model
1679 * Gets the file for a particular row in @model.
1681 * Return value: the file. This object is owned by @model and
1682 * or freed. If you want to save the path for later use,
1683 * you must take a ref, since the object may be freed
1684 * on later changes to the file system.
1687 _gtk_file_system_model_get_file (GtkFileSystemModel *model,
1690 FileModelNode *node;
1692 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
1694 node = get_node (model, ITER_INDEX (iter));
1699 * _gtk_file_system_model_get_value:
1700 * @model: a #GtkFileSystemModel
1701 * @iter: a #GtkTreeIter pointing to a row of @model
1702 * @column: the column to get the value for
1704 * Gets the value associated with the given row @iter and @column.
1705 * If no value is available yet and the default value should be used,
1706 * %NULL is returned.
1707 * This is a performance optimization for the calls
1708 * gtk_tree_model_get() or gtk_tree_model_get_value(), which copy
1709 * the value and spend a considerable amount of time in iterator
1710 * lookups. Both of which are slow.
1712 * Returns: a pointer to the actual value as stored in @model or %NULL
1713 * if no value available yet.
1716 _gtk_file_system_model_get_value (GtkFileSystemModel *model,
1720 FileModelNode *node;
1722 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
1723 g_return_val_if_fail (column >= 0 && (guint) column < model->n_columns, NULL);
1725 node = get_node (model, ITER_INDEX (iter));
1727 if (!G_VALUE_TYPE (&node->values[column]))
1729 g_value_init (&node->values[column], model->column_types[column]);
1730 if (!model->get_func (model,
1734 &node->values[column],
1737 g_value_unset (&node->values[column]);
1742 return &node->values[column];
1746 node_get_for_file (GtkFileSystemModel *model,
1751 i = GPOINTER_TO_UINT (g_hash_table_lookup (model->file_lookup, file));
1755 /* Node 0 is the editable row and has no associated file or entry in the table, so we start counting from 1.
1757 * The invariant here is that the files in model->files[n] for n < g_hash_table_size (model->file_lookup)
1758 * are already added to the hash table. The table can get cleared when we re-sort; this loop merely rebuilds
1759 * our (file -> index) mapping on demand.
1761 * If we exit the loop, the next pending batch of mappings will be resolved when this function gets called again
1762 * with another file that is not yet in the mapping.
1764 for (i = g_hash_table_size (model->file_lookup) + 1; i < model->files->len; i++)
1766 FileModelNode *node = get_node (model, i);
1768 g_hash_table_insert (model->file_lookup, node->file, GUINT_TO_POINTER (i));
1769 if (g_file_equal (node->file, file))
1777 * _gtk_file_system_model_get_iter_for_file:
1779 * @iter: the iterator to be initialized
1780 * @file: the file to look up
1782 * Initializes @iter to point to the row used for @file, if @file is part
1783 * of the model. Note that upon successful return, @iter may point to an
1784 * invisible row in the @model. Use
1785 * _gtk_file_system_model_iter_is_visible() to make sure it is visible to
1788 * Returns: %TRUE if file is part of the model and @iter was initialized
1791 _gtk_file_system_model_get_iter_for_file (GtkFileSystemModel *model,
1797 g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), FALSE);
1798 g_return_val_if_fail (iter != NULL, FALSE);
1799 g_return_val_if_fail (G_IS_FILE (file), FALSE);
1801 i = node_get_for_file (model, file);
1806 ITER_INIT_FROM_INDEX (model, iter, i);
1810 /* When an element is added or removed to the model->files array, we need to
1811 * update the model->file_lookup mappings of (node, index), as the indexes
1812 * change. This function adds the specified increment to the index in that pair
1813 * if the index is equal or after the specified id. We use this to slide the
1814 * mappings up or down when a node is added or removed, respectively.
1817 adjust_file_lookup (GtkFileSystemModel *model, guint id, int increment)
1819 GHashTableIter iter;
1823 g_hash_table_iter_init (&iter, model->file_lookup);
1825 while (g_hash_table_iter_next (&iter, &key, &value))
1827 guint index = GPOINTER_TO_UINT (value);
1832 g_hash_table_iter_replace (&iter, GUINT_TO_POINTER (index));
1840 * @file: the file to add
1841 * @info: the information to associate with the file
1843 * Adds the given @file with its associated @info to the @model.
1844 * If the model is frozen, the file will only show up after it is thawn.
1847 add_file (GtkFileSystemModel *model,
1851 FileModelNode *node;
1853 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1854 g_return_if_fail (G_IS_FILE (file));
1855 g_return_if_fail (G_IS_FILE_INFO (info));
1857 node = g_slice_alloc0 (model->node_size);
1858 node->file = g_object_ref (file);
1860 node->info = g_object_ref (info);
1861 node->frozen_add = model->frozen ? TRUE : FALSE;
1863 g_array_append_vals (model->files, node, 1);
1864 g_slice_free1 (model->node_size, node);
1867 node_compute_visibility_and_filters (model, model->files->len -1);
1869 gtk_file_system_model_sort_node (model, model->files->len -1);
1875 * @file: file to remove from the model. The file must have been
1876 * added to the model previously
1878 * Removes the given file from the model. If the file is not part of
1879 * @model, this function does nothing.
1882 remove_file (GtkFileSystemModel *model,
1885 FileModelNode *node;
1889 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1890 g_return_if_fail (G_IS_FILE (file));
1892 id = node_get_for_file (model, file);
1896 node = get_node (model, id);
1897 row = node_get_tree_row (model, id);
1899 node_invalidate_index (model, id);
1901 g_hash_table_remove (model->file_lookup, file);
1902 g_object_unref (node->file);
1903 adjust_file_lookup (model, id, -1);
1906 g_object_unref (node->info);
1908 g_array_remove_index (model->files, id);
1910 /* We don't need to resort, as removing a row doesn't change the sorting order of the other rows */
1912 emit_row_deleted_for_row (model, row);
1916 * _gtk_file_system_model_update_file:
1919 * @info: the new file info
1921 * Tells the file system model that the file changed and that the
1922 * new @info should be used for it now. If the file is not part of
1923 * @model, it will get added automatically.
1926 _gtk_file_system_model_update_file (GtkFileSystemModel *model,
1930 FileModelNode *node;
1932 GFileInfo *old_info;
1934 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1935 g_return_if_fail (G_IS_FILE (file));
1936 g_return_if_fail (G_IS_FILE_INFO (info));
1938 id = node_get_for_file (model, file);
1941 add_file (model, file, info);
1942 id = node_get_for_file (model, file);
1945 node = get_node (model, id);
1947 old_info = node->info;
1948 node->info = g_object_ref (info);
1950 g_object_unref (old_info);
1952 for (i = 0; i < model->n_columns; i++)
1954 if (G_VALUE_TYPE (&node->values[i]))
1955 g_value_unset (&node->values[i]);
1959 emit_row_changed_for_node (model, id);
1963 * _gtk_file_system_model_set_filter:
1964 * @mode: a #GtkFileSystemModel
1965 * @filter: (allow-none): %NULL or filter to use
1967 * Sets a filter to be used for deciding if a row should be visible or not.
1968 * Whether this filter applies to directories can be toggled with
1969 * _gtk_file_system_model_set_filter_folders().
1972 _gtk_file_system_model_set_filter (GtkFileSystemModel *model,
1973 GtkFileFilter * filter)
1975 GtkFileFilter *old_filter;
1977 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
1978 g_return_if_fail (filter == NULL || GTK_IS_FILE_FILTER (filter));
1981 g_object_ref (filter);
1983 old_filter = model->filter;
1984 model->filter = filter;
1987 g_object_unref (old_filter);
1989 gtk_file_system_model_refilter_all (model);
1993 * _gtk_file_system_model_add_editable:
1994 * @model: a #GtkFileSystemModel
1995 * @iter: Location to return the iter corresponding to the editable row
1997 * Adds an "empty" row at the beginning of the model. This does not refer to
1998 * any file, but is a temporary placeholder for a file name that the user will
1999 * type when a corresponding cell is made editable. When your code is done
2000 * using this temporary row, call _gtk_file_system_model_remove_editable().
2003 _gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *iter)
2005 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
2006 g_return_if_fail (!get_node (model, 0)->visible);
2008 node_set_visible_and_filtered_out (model, 0, TRUE, FALSE);
2009 ITER_INIT_FROM_INDEX (model, iter, 0);
2013 * _gtk_file_system_model_remove_editable:
2014 * @model: a #GtkFileSystemModel
2016 * Removes the "empty" row at the beginning of the model that was
2017 * created with _gtk_file_system_model_add_editable(). You should call
2018 * this function when your code is finished editing this temporary row.
2021 _gtk_file_system_model_remove_editable (GtkFileSystemModel *model)
2023 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
2024 g_return_if_fail (get_node (model, 0)->visible);
2026 node_set_visible_and_filtered_out (model, 0, FALSE, FALSE);
2031 * @model: a #GtkFileSystemModel
2033 * Freezes most updates on the model, so that performing multiple operations on
2034 * the files in the model do not cause any events. Use thaw_updates() to resume
2035 * proper operations. It is fine to call this function multiple times as long as
2036 * freeze and thaw calls are balanced.
2039 freeze_updates (GtkFileSystemModel *model)
2041 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
2048 * @model: a #GtkFileSystemModel
2050 * Undoes the effect of a previous call to freeze_updates()
2053 thaw_updates (GtkFileSystemModel *model)
2055 gboolean stuff_added;
2057 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
2058 g_return_if_fail (model->frozen > 0);
2061 if (model->frozen > 0)
2064 stuff_added = get_node (model, model->files->len - 1)->frozen_add;
2066 if (model->filter_on_thaw)
2067 gtk_file_system_model_refilter_all (model);
2068 if (model->sort_on_thaw)
2069 gtk_file_system_model_sort (model);
2074 for (i = 0; i < model->files->len; i++)
2076 FileModelNode *node = get_node (model, i);
2078 if (!node->frozen_add)
2080 node->frozen_add = FALSE;
2081 node_compute_visibility_and_filters (model, i);
2087 * _gtk_file_system_model_clear_cache:
2088 * @model: a #GtkFileSystemModel
2089 * @column: the column to clear or -1 for all columns
2091 * Clears the cached values in the model for the given @column. Use
2092 * this function whenever your get_value function would return different
2093 * values for a column.
2094 * The file chooser uses this for example when the icon theme changes to
2095 * invalidate the cached pixbufs.
2098 _gtk_file_system_model_clear_cache (GtkFileSystemModel *model,
2105 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
2106 g_return_if_fail (column >= -1 && (guint) column < model->n_columns);
2116 end = model->n_columns;
2119 for (i = 0; i < model->files->len; i++)
2121 FileModelNode *node = get_node (model, i);
2123 for (column = start; column < end; column++)
2125 if (!G_VALUE_TYPE (&node->values[column]))
2128 g_value_unset (&node->values[column]);
2132 if (changed && node->visible)
2133 emit_row_changed_for_node (model, i);
2136 /* FIXME: resort? */
2140 * _gtk_file_system_model_add_and_query_file:
2141 * @model: a #GtkFileSystemModel
2142 * @file: the file to add
2143 * @attributes: attributes to query before adding the file
2145 * This is a conenience function that calls g_file_query_info_async() on
2146 * the given file, and when successful, adds it to the model.
2147 * Upon failure, the @file is discarded.
2150 _gtk_file_system_model_add_and_query_file (GtkFileSystemModel *model,
2152 const char * attributes)
2154 g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
2155 g_return_if_fail (G_IS_FILE (file));
2156 g_return_if_fail (attributes != NULL);
2158 g_file_query_info_async (file,
2160 G_FILE_QUERY_INFO_NONE,
2163 gtk_file_system_model_query_done,