X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkfilesystemmodel.c;h=132902b31788851b2fecc1b75ac822a8f26b2085;hb=f5217289ca6feee9d482763d9c1fcf412d2dd610;hp=e316a1b7a92467f9a328effd30f82fe41034e1e3;hpb=446f41757b425441976e5a2b32c233f64036e6ff;p=~andy%2Fgtk diff --git a/gtk/gtkfilesystemmodel.c b/gtk/gtkfilesystemmodel.c index e316a1b7a..132902b31 100644 --- a/gtk/gtkfilesystemmodel.c +++ b/gtk/gtkfilesystemmodel.c @@ -13,25 +13,184 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . */ -#include -#include +#include "config.h" -#include "gtkfilechooserprivate.h" #include "gtkfilesystemmodel.h" + +#include +#include + #include "gtkfilesystem.h" #include "gtkintl.h" #include "gtkmarshalers.h" +#include "gtktreedatalist.h" #include "gtktreednd.h" #include "gtktreemodel.h" -#include "gtkalias.h" +/*** Structure: how GtkFileSystemModel works + * + * This is a custom GtkTreeModel used to hold a collection of files for GtkFileChooser. There are two use cases: + * + * 1. The model populates itself from a folder, using the GIO file enumerator API. This happens if you use + * _gtk_file_system_model_new_for_directory(). This is the normal usage for showing the contents of a folder. + * + * 2. The caller populates the model by hand, with files not necessarily in the same folder. This happens + * if you use _gtk_file_system_model_new() and then _gtk_file_system_model_add_and_query_file(). This is + * the special kind of usage for "search" and "recent-files", where the file chooser gives the model the + * files to be displayed. + * + * Internal data structure + * ----------------------- + * + * Each file is kept in a FileModelNode structure. Each FileModelNode holds a GFile* and other data. All the + * node structures have the same size, determined at runtime, depending on the number of columns that were passed + * to _gtk_file_system_model_new() or _gtk_file_system_model_new_for_directory() (that is, the size of a node is + * not sizeof (FileModelNode), but rather model->node_size). The last field in the FileModelNode structure, + * node->values[], is an array of GValue, used to hold the data for those columns. + * + * The model stores an array of FileModelNode structures in model->files. This is a GArray where each element is + * model->node_size bytes in size (the model computes that node size when initializing itself). There are + * convenience macros, get_node() and node_index(), to access that array based on an array index or a pointer to + * a node inside the array. + * + * The model accesses files through two of its fields: + * + * model->files - GArray of FileModelNode structures. + * + * model->file_lookup - hash table that maps a GFile* to an index inside the model->files array. + * + * The model->file_lookup hash table is populated lazily. It is both accessed and populated with the + * node_get_for_file() function. The invariant is that the files in model->files[n] for n < g_hash_table_size + * (model->file_lookup) are already added to the hash table. The hash table will get cleared when we re-sort the + * files, as the array will be in a different order and the indexes need to be rebuilt. + * + * Each FileModelNode has a node->visible field, which indicates whether the node is visible in the GtkTreeView. + * A node may be invisible if, for example, it corresponds to a hidden file and the file chooser is not showing + * hidden files. Also, a file filter may be explicitly set onto the model, for example, to only show files that + * match "*.jpg". In this case, node->filtered_out says whether the node failed the filter. The ultimate + * decision on whether a node is visible or not in the treeview is distilled into the node->visible field. + * The reason for having a separate node->filtered_out field is so that the file chooser can query whether + * a (filtered-out) folder should be made sensitive in the GUI. + * + * Visible rows vs. possibly-invisible nodes + * ----------------------------------------- + * + * Since not all nodes in the model->files array may be visible, we need a way to map visible row indexes from + * the treeview to array indexes in our array of files. And thus we introduce a bit of terminology: + * + * index - An index in the model->files array. All variables/fields that represent indexes are either called + * "index" or "i_*", or simply "i" for things like loop counters. + * + * row - An index in the GtkTreeView, i.e. the index of a row within the outward-facing API of the + * GtkFileSystemModel. However, note that our rows are 1-based, not 0-based, for the reason explained in the + * following paragraph. Variables/fields that represent visible rows are called "row", or "r_*", or simply + * "r". + * + * Each FileModelNode has a node->row field which is the number of visible rows in the treeview, *before and + * including* that node. This means that node->row is 1-based, instead of 0-based --- this makes some code + * simpler, believe it or not :) This also means that when the calling GtkTreeView gives us a GtkTreePath, we + * turn the 0-based treepath into a 1-based row for our purposes. If a node is not visible, it will have the + * same row number as its closest preceding visible node. + * + * We try to compute the node->row fields lazily. A node is said to be "valid" if its node->row is accurate. + * For this, the model keeps a model->n_nodes_valid field which is the count of valid nodes starting from the + * beginning of the model->files array. When a node changes its information, or when a node gets deleted, that + * node and the following ones get invalidated by simply setting model->n_nodes_valid to the array index of the + * node. If the model happens to need a node's row number and that node is in the model->files array after + * model->n_nodes_valid, then the nodes get re-validated up to the sought node. See node_validate_rows() for + * this logic. + * + * You never access a node->row directly. Instead, call node_get_tree_row(). That function will validate the nodes + * up to the sought one if the node is not valid yet, and it will return a proper 0-based row. + * + * Sorting + * ------- + * + * The model implements the GtkTreeSortable interface. To avoid re-sorting + * every time a node gets added (which would lead to O(n^2) performance during + * the initial population of the model), the model can freeze itself (with + * freeze_updates()) during the intial population process. When the model is + * frozen, sorting will not happen. The model will sort itself when the freeze + * count goes back to zero, via corresponding calls to thaw_updates(). + */ + +/*** DEFINES ***/ + +/* priority used for all async callbacks in the main loop + * This should be higher than redraw priorities so multiple callbacks + * firing can be handled without intermediate redraws */ +#define IO_PRIORITY G_PRIORITY_DEFAULT + +/* random number that everyone else seems to use, too */ +#define FILES_PER_QUERY 100 + +typedef struct _FileModelNode FileModelNode; typedef struct _GtkFileSystemModelClass GtkFileSystemModelClass; +struct _FileModelNode +{ + GFile * file; /* file represented by this node or NULL for editable */ + GFileInfo * info; /* info for this file or NULL if unknown */ + + guint row; /* if valid (see model->n_valid_indexes), visible nodes before and including + * this one - see the "Structure" comment above. + */ + + guint visible :1; /* if the file is currently visible */ + guint filtered_out :1;/* if the file is currently filtered out (i.e. it didn't pass the filters) */ + guint frozen_add :1; /* true if the model was frozen and the entry has not been added yet */ + + GValue values[1]; /* actually n_columns values */ +}; + +struct _GtkFileSystemModel +{ + GObject parent_instance; + + GFile * dir; /* directory that's displayed */ + guint dir_thaw_source;/* GSource id for unfreezing the model */ + char * attributes; /* attributes the file info must contain, or NULL for all attributes */ + GFileMonitor * dir_monitor; /* directory that is monitored, or NULL if monitoring was not supported */ + + GCancellable * cancellable; /* cancellable in use for all operations - cancelled on dispose */ + GArray * files; /* array of FileModelNode containing all our files */ + gsize node_size; /* Size of a FileModelNode structure once its ->values field has n_columns */ + guint n_nodes_valid; /* count of valid nodes (i.e. those whose node->row is accurate) */ + GHashTable * file_lookup; /* mapping of GFile => array index in model->files + * This hash table doesn't always have the same number of entries as the files array; + * it can get cleared completely when we resort. + * The hash table gets re-populated in node_get_for_file() if this mismatch is + * detected. + */ + + guint n_columns; /* number of columns */ + GType * column_types; /* types of each column */ + GtkFileSystemModelGetValue get_func; /* function to call to fill in values in columns */ + gpointer get_data; /* data to pass to get_func */ + + GtkFileFilter * filter; /* filter to use for deciding which nodes are visible */ + + int sort_column_id; /* current sorting column */ + GtkSortType sort_order; /* current sorting order */ + GList * sort_list; /* list of sorting functions */ + GtkTreeIterCompareFunc default_sort_func; /* default sort function */ + gpointer default_sort_data; /* data to pass to default sort func */ + GDestroyNotify default_sort_destroy; /* function to call to destroy default_sort_data */ + + guint frozen; /* number of times we're frozen */ + + gboolean filter_on_thaw :1;/* set when filtering needs to happen upon thawing */ + gboolean sort_on_thaw :1;/* set when sorting needs to happen upon thawing */ + + guint show_hidden :1; /* whether to show hidden files */ + guint show_folders :1;/* whether to show folders */ + guint show_files :1; /* whether to show files */ + guint filter_folders :1;/* whether filter applies to folders */ +}; + #define GTK_FILE_SYSTEM_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModelClass)) #define GTK_IS_FILE_SYSTEM_MODEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_SYSTEM_MODEL)) #define GTK_FILE_SYSTEM_MODEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModelClass)) @@ -42,314 +201,402 @@ struct _GtkFileSystemModelClass /* Signals */ - void (*finished_loading) (GtkFileSystemModel *model); + void (*finished_loading) (GtkFileSystemModel *model, GError *error); }; +static void freeze_updates (GtkFileSystemModel *model); +static void thaw_updates (GtkFileSystemModel *model); -static void gtk_file_system_model_iface_init (GtkTreeModelIface *iface); -static void gtk_file_system_model_finalize (GObject *object); -static void gtk_file_system_model_dispose (GObject *object); - -static void drag_source_iface_init (GtkTreeDragSourceIface *iface); - -static GtkTreeModelFlags gtk_file_system_model_get_flags (GtkTreeModel *tree_model); -static gint gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model); -static GType gtk_file_system_model_get_column_type (GtkTreeModel *tree_model, - gint index); -static gboolean gtk_file_system_model_get_iter (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreePath *path); -static GtkTreePath * gtk_file_system_model_get_path (GtkTreeModel *tree_model, - GtkTreeIter *iter); -static void gtk_file_system_model_get_value (GtkTreeModel *tree_model, - GtkTreeIter *iter, - gint column, - GValue *value); -static gboolean gtk_file_system_model_iter_next (GtkTreeModel *tree_model, - GtkTreeIter *iter); -static gboolean gtk_file_system_model_iter_children (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreeIter *parent); -static gboolean gtk_file_system_model_iter_has_child (GtkTreeModel *tree_model, - GtkTreeIter *iter); -static gint gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model, - GtkTreeIter *iter); -static gboolean gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreeIter *parent, - gint n); -static gboolean gtk_file_system_model_iter_parent (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreeIter *child); -static void gtk_file_system_model_ref_node (GtkTreeModel *tree_model, - GtkTreeIter *iter); -static void gtk_file_system_model_unref_node (GtkTreeModel *tree_model, - GtkTreeIter *iter); - -static gboolean drag_source_row_draggable (GtkTreeDragSource *drag_source, - GtkTreePath *path); -static gboolean drag_source_drag_data_get (GtkTreeDragSource *drag_source, - GtkTreePath *path, - GtkSelectionData *selection_data); - -static FileModelNode *file_model_node_new (GtkFileSystemModel *model, - GFile *file); -static void file_model_node_free (FileModelNode *node); -static void file_model_node_ref (FileModelNode *node); -static void file_model_node_unref (GtkFileSystemModel *model, - FileModelNode *node); - -static void file_model_node_idle_clear (FileModelNode *node); -static void file_model_node_idle_clear_cancel (FileModelNode *node); -static void file_model_node_child_unref (FileModelNode *parent); - -static GFileInfo * file_model_node_get_info (GtkFileSystemModel *model, - FileModelNode *node); -static gboolean file_model_node_is_visible (GtkFileSystemModel *model, - FileModelNode *node); -static void file_model_node_clear (GtkFileSystemModel *model, - FileModelNode *node); -static FileModelNode * file_model_node_get_children (GtkFileSystemModel *model, - FileModelNode *node); - -static void deleted_callback (GFile *folder, - FileModelNode *node); -static void files_added_callback (GFile *folder, - GSList *paths, - FileModelNode *node); -static void files_changed_callback (GFile *folder, - GSList *paths, - FileModelNode *node); -static void files_removed_callback (GFile *folder, - GSList *paths, - FileModelNode *node); - -static void root_deleted_callback (GFile *folder, - GtkFileSystemModel *model); -static void root_files_added_callback (GFile *folder, - GSList *paths, - GtkFileSystemModel *model); -static void root_files_changed_callback (GFile *folder, - GSList *paths, - GtkFileSystemModel *model); -static void root_files_removed_callback (GFile *folder, - GSList *paths, - GtkFileSystemModel *model); +static guint node_get_for_file (GtkFileSystemModel *model, + GFile *file); -/* Signal IDs */ -enum { - FINISHED_LOADING, - LAST_SIGNAL -}; +static void add_file (GtkFileSystemModel *model, + GFile *file, + GFileInfo *info); +static void remove_file (GtkFileSystemModel *model, + GFile *file); -static guint file_system_model_signals[LAST_SIGNAL] = { 0 }; +/* iter setup: + * @user_data: the model + * @user_data2: GUINT_TO_POINTER of array index of current entry + * + * All other fields are unused. Note that the array index does not corrspond + * 1:1 with the path index as entries might not be visible. + */ +#define ITER_INDEX(iter) GPOINTER_TO_UINT((iter)->user_data2) +#define ITER_IS_VALID(model, iter) ((model) == (iter)->user_data) +#define ITER_INIT_FROM_INDEX(model, _iter, _index) G_STMT_START {\ + g_assert (_index < (model)->files->len); \ + (_iter)->user_data = (model); \ + (_iter)->user_data2 = GUINT_TO_POINTER (_index); \ +}G_STMT_END - +/*** FileModelNode ***/ -G_DEFINE_TYPE_WITH_CODE (GtkFileSystemModel, _gtk_file_system_model, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL, - gtk_file_system_model_iface_init) - G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE, - drag_source_iface_init)) +/* Get a FileModelNode structure given an index in the model->files array of nodes */ +#define get_node(_model, _index) ((FileModelNode *) ((_model)->files->data + (_index) * (_model)->node_size)) + +/* Get an index within the model->files array of nodes, given a FileModelNode* */ +#define node_index(_model, _node) (((gchar *) (_node) - (_model)->files->data) / (_model)->node_size) +/* @up_to_index: smallest model->files array index that will be valid after this call + * @up_to_row: smallest node->row that will be valid after this call + * + * If you want to validate up to an index or up to a row, specify the index or + * the row you want and specify G_MAXUINT for the other argument. Pass + * G_MAXUINT for both arguments for "validate everything". + */ static void -_gtk_file_system_model_class_init (GtkFileSystemModelClass *class) +node_validate_rows (GtkFileSystemModel *model, guint up_to_index, guint up_to_row) { - GObjectClass *gobject_class = G_OBJECT_CLASS (class); + guint i, row; - gobject_class->finalize = gtk_file_system_model_finalize; - gobject_class->dispose = gtk_file_system_model_dispose; + if (model->files->len == 0) + return; - file_system_model_signals[FINISHED_LOADING] = - g_signal_new (I_("finished-loading"), - G_OBJECT_CLASS_TYPE (gobject_class), - G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET (GtkFileSystemModelClass, finished_loading), - NULL, NULL, - _gtk_marshal_VOID__VOID, - G_TYPE_NONE, 0); + up_to_index = MIN (up_to_index, model->files->len - 1); + + i = model->n_nodes_valid; + if (i != 0) + row = get_node (model, i - 1)->row; + else + row = 0; + + while (i <= up_to_index && row <= up_to_row) + { + FileModelNode *node = get_node (model, i); + if (node->visible) + row++; + node->row = row; + i++; + } + model->n_nodes_valid = i; +} + +static guint +node_get_tree_row (GtkFileSystemModel *model, guint index) +{ + if (model->n_nodes_valid <= index) + node_validate_rows (model, index, G_MAXUINT); + + return get_node (model, index)->row - 1; +} + +static void +node_invalidate_index (GtkFileSystemModel *model, guint id) +{ + model->n_nodes_valid = MIN (model->n_nodes_valid, id); +} + +static GtkTreePath * +tree_path_new_from_node (GtkFileSystemModel *model, guint id) +{ + guint r = node_get_tree_row (model, id); + + g_assert (r < model->files->len); + + return gtk_tree_path_new_from_indices (r, -1); } static void -gtk_file_system_model_iface_init (GtkTreeModelIface *iface) +emit_row_inserted_for_node (GtkFileSystemModel *model, guint id) { - iface->get_flags = gtk_file_system_model_get_flags; - iface->get_n_columns = gtk_file_system_model_get_n_columns; - iface->get_column_type = gtk_file_system_model_get_column_type; - iface->get_iter = gtk_file_system_model_get_iter; - iface->get_path = gtk_file_system_model_get_path; - iface->get_value = gtk_file_system_model_get_value; - iface->iter_next = gtk_file_system_model_iter_next; - iface->iter_children = gtk_file_system_model_iter_children; - iface->iter_has_child = gtk_file_system_model_iter_has_child; - iface->iter_n_children = gtk_file_system_model_iter_n_children; - iface->iter_nth_child = gtk_file_system_model_iter_nth_child; - iface->iter_parent = gtk_file_system_model_iter_parent; - iface->ref_node = gtk_file_system_model_ref_node; - iface->unref_node = gtk_file_system_model_unref_node; + GtkTreePath *path; + GtkTreeIter iter; + + path = tree_path_new_from_node (model, id); + ITER_INIT_FROM_INDEX (model, &iter, id); + gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); + gtk_tree_path_free (path); } static void -_gtk_file_system_model_init (GtkFileSystemModel *model) +emit_row_changed_for_node (GtkFileSystemModel *model, guint id) { - model->show_files = TRUE; - model->show_folders = TRUE; - model->show_hidden = FALSE; + GtkTreePath *path; + GtkTreeIter iter; + + path = tree_path_new_from_node (model, id); + ITER_INIT_FROM_INDEX (model, &iter, id); + gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); + gtk_tree_path_free (path); } static void -gtk_file_system_model_finalize (GObject *object) +emit_row_deleted_for_row (GtkFileSystemModel *model, guint row) { - GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object); - FileModelNode *children, *next; + GtkTreePath *path; - if (model->root_folder) - g_object_unref (model->root_folder); + path = gtk_tree_path_new_from_indices (row, -1); + gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); + gtk_tree_path_free (path); +} - if (model->root_file) - g_object_unref (model->root_file); +static void +node_set_visible_and_filtered_out (GtkFileSystemModel *model, guint id, gboolean visible, gboolean filtered_out) +{ + FileModelNode *node = get_node (model, id); - if (model->file_system) - g_object_unref (model->file_system); + /* Filteredness */ - children = model->roots; - while (children) + if (node->filtered_out != filtered_out) { - next = children->next; - file_model_node_free (children); - children = next; + node->filtered_out = filtered_out; + if (node->visible && visible) + emit_row_changed_for_node (model, id); } - g_free (model->attributes); + /* Visibility */ + + if (node->visible == visible || + node->frozen_add) + return; - G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object); + if (visible) + { + node->visible = TRUE; + node_invalidate_index (model, id); + emit_row_inserted_for_node (model, id); + } + else + { + guint row; + + row = node_get_tree_row (model, id); + g_assert (row < model->files->len); + + node->visible = FALSE; + node_invalidate_index (model, id); + emit_row_deleted_for_row (model, row); + } } +static gboolean +node_should_be_filtered_out (GtkFileSystemModel *model, guint id) +{ + FileModelNode *node = get_node (model, id); + GtkFileFilterInfo filter_info = { 0, }; + GtkFileFilterFlags required; + gboolean result; + char *mime_type = NULL; + char *filename = NULL; + char *uri = NULL; -static void -gtk_file_system_model_dispose (GObject *object) + if (node->info == NULL) + return TRUE; + + if (model->filter == NULL) + return FALSE; + + /* fill info */ + required = gtk_file_filter_get_needed (model->filter); + + filter_info.contains = GTK_FILE_FILTER_DISPLAY_NAME; + filter_info.display_name = g_file_info_get_display_name (node->info); + + if (required & GTK_FILE_FILTER_MIME_TYPE) + { + const char *s = g_file_info_get_content_type (node->info); + if (s) + { + mime_type = g_content_type_get_mime_type (s); + if (mime_type) + { + filter_info.mime_type = mime_type; + filter_info.contains |= GTK_FILE_FILTER_MIME_TYPE; + } + } + } + + if (required & GTK_FILE_FILTER_FILENAME) + { + filename = g_file_get_path (node->file); + if (filename) + { + filter_info.filename = filename; + filter_info.contains |= GTK_FILE_FILTER_FILENAME; + } + } + + if (required & GTK_FILE_FILTER_URI) + { + uri = g_file_get_uri (node->file); + if (uri) + { + filter_info.uri = uri; + filter_info.contains |= GTK_FILE_FILTER_URI; + } + } + + result = !gtk_file_filter_filter (model->filter, &filter_info); + + g_free (mime_type); + g_free (filename); + g_free (uri); + + return result; +} + +static gboolean +node_should_be_visible (GtkFileSystemModel *model, guint id, gboolean filtered_out) { - GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object); + FileModelNode *node = get_node (model, id); + gboolean result; + + if (node->info == NULL) + return FALSE; + + if (!model->show_hidden && + (g_file_info_get_is_hidden (node->info) || g_file_info_get_is_backup (node->info))) + return FALSE; - if (model->pending_cancellables) + if (_gtk_file_info_consider_as_directory (node->info)) { - GSList *l; + if (!model->show_folders) + return FALSE; - for (l = model->pending_cancellables; l; l = l->next) - g_cancellable_cancel (l->data); - g_slist_free (model->pending_cancellables); - model->pending_cancellables = NULL; + if (!model->filter_folders) + return TRUE; + } + else + { + if (!model->show_files) + return FALSE; } - G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object); + result = !filtered_out; + + return result; } static void -drag_source_iface_init (GtkTreeDragSourceIface *iface) +node_compute_visibility_and_filters (GtkFileSystemModel *model, guint id) { - iface->row_draggable = drag_source_row_draggable; - iface->drag_data_get = drag_source_drag_data_get; - iface->drag_data_delete = NULL; + gboolean filtered_out; + gboolean visible; + + filtered_out = node_should_be_filtered_out (model, id); + visible = node_should_be_visible (model, id, filtered_out); + + node_set_visible_and_filtered_out (model, id, visible, filtered_out); } -/* - * ******************** GtkTreeModel methods ******************** - */ +/*** GtkTreeModel ***/ static GtkTreeModelFlags gtk_file_system_model_get_flags (GtkTreeModel *tree_model) { - GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - GtkTreeModelFlags flags = GTK_TREE_MODEL_ITERS_PERSIST; - - if (model->max_depth == 0) - flags |= GTK_TREE_MODEL_LIST_ONLY; - - return flags; + /* GTK_TREE_MODEL_ITERS_PERSIST doesn't work with arrays :( */ + return GTK_TREE_MODEL_LIST_ONLY; } static gint gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model) { - return GTK_FILE_SYSTEM_MODEL_N_COLUMNS; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); + + return model->n_columns; } static GType gtk_file_system_model_get_column_type (GtkTreeModel *tree_model, - gint index) + gint i) { - switch (index) - { - case GTK_FILE_SYSTEM_MODEL_INFO: - return G_TYPE_FILE_INFO; - case GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME: - return G_TYPE_STRING; - default: - g_assert_not_reached (); - return G_TYPE_NONE; - } + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); + + g_return_val_if_fail (i >= 0 && (guint) i < model->n_columns, G_TYPE_NONE); + + return model->column_types[i]; } -static gboolean -gtk_file_system_model_get_iter (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreePath *path) +static int +compare_indices (gconstpointer key, gconstpointer _node) { - GtkTreeIter parent; - gint *indices; - gint depth, i; + const FileModelNode *node = _node; + + return GPOINTER_TO_UINT (key) - node->row; +} - indices = gtk_tree_path_get_indices (path); - depth = gtk_tree_path_get_depth (path); +static gboolean +gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + gint n) +{ + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); + char *node; + guint id; + guint row_to_find; - g_return_val_if_fail (depth > 0, FALSE); + g_return_val_if_fail (n >= 0, FALSE); - if (!gtk_tree_model_iter_nth_child (tree_model, iter, NULL, indices[0])) + if (parent != NULL) return FALSE; - for (i = 1; i < depth; i++) + row_to_find = n + 1; /* plus one as our node->row numbers are 1-based; see the "Structure" comment at the beginning */ + + if (model->n_nodes_valid > 0 && + get_node (model, model->n_nodes_valid - 1)->row >= row_to_find) + { + /* Fast path - the nodes are valid up to the sought one. + * + * First, find a node with the sought row number...*/ + + node = bsearch (GUINT_TO_POINTER (row_to_find), + model->files->data, + model->n_nodes_valid, + model->node_size, + compare_indices); + if (node == NULL) + return FALSE; + + /* ... Second, back up until we find the first visible node with that row number */ + + id = node_index (model, node); + while (!get_node (model, id)->visible) + id--; + + g_assert (get_node (model, id)->row == row_to_find); + } + else { - parent = *iter; - if (!gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[i])) - return FALSE; + /* Slow path - the nodes need to be validated up to the sought one */ + + node_validate_rows (model, G_MAXUINT, n); /* note that this is really "n", not row_to_find - see node_validate_rows() */ + id = model->n_nodes_valid - 1; + if (model->n_nodes_valid == 0 || get_node (model, id)->row != row_to_find) + return FALSE; } + ITER_INIT_FROM_INDEX (model, iter, id); return TRUE; } +static gboolean +gtk_file_system_model_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path) +{ + g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE); + + if (gtk_tree_path_get_depth (path) > 1) + return FALSE; + + return gtk_file_system_model_iter_nth_child (tree_model, + iter, + NULL, + gtk_tree_path_get_indices (path)[0]); +} + static GtkTreePath * gtk_file_system_model_get_path (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - FileModelNode *node = iter->user_data; - - GtkTreePath *result = gtk_tree_path_new (); - - while (node) - { - FileModelNode *parent = node->parent; - FileModelNode *children; - int n = 0; - - if (parent) - children = parent->children; - else - children = model->roots; - - while (children != node) - { - if (children->is_visible) - n++; - children = children->next; - } - gtk_tree_path_prepend_index (result, n); - - node = parent; - } + g_return_val_if_fail (ITER_IS_VALID (model, iter), NULL); - return result; + return tree_path_new_from_node (model, ITER_INDEX (iter)); } static void @@ -359,51 +606,42 @@ gtk_file_system_model_get_value (GtkTreeModel *tree_model, GValue *value) { GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - FileModelNode *node = iter->user_data; - GFileInfo *info; + const GValue *original; - switch (column) - { - case GTK_FILE_SYSTEM_MODEL_INFO: - if (model->has_editable && node == model->roots) - info = NULL; - else - info = file_model_node_get_info (model, node); - - g_value_set_object (value, info); - break; - case GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME: - { - g_value_init (value, G_TYPE_STRING); - - if (model->has_editable && node == model->roots) - g_value_set_static_string (value, ""); - else - { - GFileInfo *info = file_model_node_get_info (model, node); + g_return_if_fail ((guint) column < model->n_columns); + g_return_if_fail (ITER_IS_VALID (model, iter)); - g_value_set_string (value, g_file_info_get_display_name (info)); - } - } - break; - default: - g_assert_not_reached (); + original = _gtk_file_system_model_get_value (model, iter, column); + if (original) + { + g_value_init (value, G_VALUE_TYPE (original)); + g_value_copy (original, value); } + else + g_value_init (value, model->column_types[column]); } static gboolean gtk_file_system_model_iter_next (GtkTreeModel *tree_model, GtkTreeIter *iter) { - FileModelNode *node = iter->user_data; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); + guint i; - node = node->next; - while (node && !node->is_visible) - node = node->next; - - iter->user_data = node; + g_return_val_if_fail (ITER_IS_VALID (model, iter), FALSE); + + for (i = ITER_INDEX (iter) + 1; i < model->files->len; i++) + { + FileModelNode *node = get_node (model, i); - return node != NULL; + if (node->visible) + { + ITER_INIT_FROM_INDEX (model, iter, i); + return TRUE; + } + } + + return FALSE; } static gboolean @@ -411,41 +649,14 @@ gtk_file_system_model_iter_children (GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent) { - GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - FileModelNode *children; - - if (parent) - { - FileModelNode *parent_node = parent->user_data; - children = file_model_node_get_children (model, parent_node); - } - else - { - children = model->roots; - } - - while (children && !children->is_visible) - children = children->next; - - iter->user_data = children; - - return children != NULL; + return FALSE; } static gboolean gtk_file_system_model_iter_has_child (GtkTreeModel *tree_model, GtkTreeIter *iter) { - FileModelNode *node = iter->user_data; - GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - - if (node->depth == model->max_depth) - return FALSE; - else - { - GFileInfo *info = file_model_node_get_info (model, node); - return (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY); - } + return FALSE; } static gint @@ -453,110 +664,305 @@ gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model, GtkTreeIter *iter) { GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - FileModelNode *children; - gint n = 0; if (iter) + return 0; + + return node_get_tree_row (model, model->files->len - 1) + 1; +} + +static gboolean +gtk_file_system_model_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child) +{ + return FALSE; +} + +static void +gtk_file_system_model_ref_node (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + /* nothing to do */ +} + +static void +gtk_file_system_model_unref_node (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + /* nothing to do */ +} + +static void +gtk_file_system_model_iface_init (GtkTreeModelIface *iface) +{ + iface->get_flags = gtk_file_system_model_get_flags; + iface->get_n_columns = gtk_file_system_model_get_n_columns; + iface->get_column_type = gtk_file_system_model_get_column_type; + iface->get_iter = gtk_file_system_model_get_iter; + iface->get_path = gtk_file_system_model_get_path; + iface->get_value = gtk_file_system_model_get_value; + iface->iter_next = gtk_file_system_model_iter_next; + iface->iter_children = gtk_file_system_model_iter_children; + iface->iter_has_child = gtk_file_system_model_iter_has_child; + iface->iter_n_children = gtk_file_system_model_iter_n_children; + iface->iter_nth_child = gtk_file_system_model_iter_nth_child; + iface->iter_parent = gtk_file_system_model_iter_parent; + iface->ref_node = gtk_file_system_model_ref_node; + iface->unref_node = gtk_file_system_model_unref_node; +} + +/*** GtkTreeSortable ***/ + +typedef struct _SortData SortData; +struct _SortData { + GtkFileSystemModel * model; + GtkTreeIterCompareFunc func; + gpointer data; + int order; /* -1 to invert sort order or 1 to keep it */ +}; + +/* returns FALSE if no sort necessary */ +static gboolean +sort_data_init (SortData *data, GtkFileSystemModel *model) +{ + GtkTreeDataSortHeader *header; + + if (model->files->len <= 2) + return FALSE; + + switch (model->sort_column_id) { - FileModelNode *node = iter->user_data; - children = file_model_node_get_children (model, node); + case GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: + if (!model->default_sort_func) + return FALSE; + data->func = model->default_sort_func; + data->data = model->default_sort_data; + break; + case GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: + return FALSE; + default: + header = _gtk_tree_data_list_get_header (model->sort_list, model->sort_column_id); + if (header == NULL) + return FALSE; + data->func = header->func; + data->data = header->data; + break; } - else + + data->order = model->sort_order == GTK_SORT_DESCENDING ? -1 : 1; + data->model = model; + return TRUE; +} + +static int +compare_array_element (gconstpointer a, gconstpointer b, gpointer user_data) +{ + SortData *data = user_data; + GtkTreeIter itera, iterb; + + ITER_INIT_FROM_INDEX (data->model, &itera, node_index (data->model, a)); + ITER_INIT_FROM_INDEX (data->model, &iterb, node_index (data->model, b)); + return data->func (GTK_TREE_MODEL (data->model), &itera, &iterb, data->data) * data->order; +} + +static void +gtk_file_system_model_sort (GtkFileSystemModel *model) +{ + SortData data; + + if (model->frozen) { - children = model->roots; + model->sort_on_thaw = TRUE; + return; } - while (children) + if (sort_data_init (&data, model)) { - if (children->is_visible) - n++; - children = children->next; + GtkTreePath *path; + guint i; + guint r, n_visible_rows; + + node_validate_rows (model, G_MAXUINT, G_MAXUINT); + n_visible_rows = node_get_tree_row (model, model->files->len - 1) + 1; + model->n_nodes_valid = 0; + g_hash_table_remove_all (model->file_lookup); + g_qsort_with_data (get_node (model, 1), /* start at index 1; don't sort the editable row */ + model->files->len - 1, + model->node_size, + compare_array_element, + &data); + g_assert (model->n_nodes_valid == 0); + g_assert (g_hash_table_size (model->file_lookup) == 0); + if (n_visible_rows) + { + int *new_order = g_new (int, n_visible_rows); + + r = 0; + for (i = 0; i < model->files->len; i++) + { + FileModelNode *node = get_node (model, i); + if (!node->visible) + { + node->row = r; + continue; + } + + new_order[r] = node->row - 1; + r++; + node->row = r; + } + g_assert (r == n_visible_rows); + path = gtk_tree_path_new (); + gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model), + path, + NULL, + new_order); + gtk_tree_path_free (path); + g_free (new_order); + } } - return n; + model->sort_on_thaw = FALSE; +} + +static void +gtk_file_system_model_sort_node (GtkFileSystemModel *model, guint node) +{ + /* FIXME: improve */ + gtk_file_system_model_sort (model); } static gboolean -gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreeIter *parent, - gint n) +gtk_file_system_model_get_sort_column_id (GtkTreeSortable *sortable, + gint *sort_column_id, + GtkSortType *order) { - GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model); - FileModelNode *children; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable); - if (parent) - { - FileModelNode *parent_node = parent->user_data; - children = file_model_node_get_children (model, parent_node); - } - else - { - children = model->roots; - } + if (sort_column_id) + *sort_column_id = model->sort_column_id; + if (order) + *order = model->sort_order; + + if (model->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID || + model->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) + return FALSE; + + return TRUE; +} - while (children && !children->is_visible) - children = children->next; +static void +gtk_file_system_model_set_sort_column_id (GtkTreeSortable *sortable, + gint sort_column_id, + GtkSortType order) +{ + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable); + + if ((model->sort_column_id == sort_column_id) && + (model->sort_order == order)) + return; - while (n && children) + if (sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID) { - n--; - children = children->next; - while (children && !children->is_visible) - children = children->next; + if (sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) + { + GtkTreeDataSortHeader *header = NULL; + + header = _gtk_tree_data_list_get_header (model->sort_list, + sort_column_id); + + /* We want to make sure that we have a function */ + g_return_if_fail (header != NULL); + g_return_if_fail (header->func != NULL); + } + else + { + g_return_if_fail (model->default_sort_func != NULL); + } } - iter->user_data = children; - return children != NULL; + model->sort_column_id = sort_column_id; + model->sort_order = order; + + gtk_tree_sortable_sort_column_changed (sortable); + + gtk_file_system_model_sort (model); } -static gboolean -gtk_file_system_model_iter_parent (GtkTreeModel *tree_model, - GtkTreeIter *iter, - GtkTreeIter *child) +static void +gtk_file_system_model_set_sort_func (GtkTreeSortable *sortable, + gint sort_column_id, + GtkTreeIterCompareFunc func, + gpointer data, + GDestroyNotify destroy) { - FileModelNode *node = child->user_data; - - node = node->parent; - iter->user_data = node; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable); + + model->sort_list = _gtk_tree_data_list_set_header (model->sort_list, + sort_column_id, + func, data, destroy); - return node != NULL; + if (model->sort_column_id == sort_column_id) + gtk_file_system_model_sort (model); } static void -gtk_file_system_model_ref_node (GtkTreeModel *tree_model, - GtkTreeIter *iter) +gtk_file_system_model_set_default_sort_func (GtkTreeSortable *sortable, + GtkTreeIterCompareFunc func, + gpointer data, + GDestroyNotify destroy) +{ + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable); + + if (model->default_sort_destroy) + { + GDestroyNotify d = model->default_sort_destroy; + + model->default_sort_destroy = NULL; + d (model->default_sort_data); + } + + model->default_sort_func = func; + model->default_sort_data = data; + model->default_sort_destroy = destroy; + + if (model->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID) + gtk_file_system_model_sort (model); +} + +static gboolean +gtk_file_system_model_has_default_sort_func (GtkTreeSortable *sortable) { - file_model_node_ref (iter->user_data); + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable); + + return (model->default_sort_func != NULL); } static void -gtk_file_system_model_unref_node (GtkTreeModel *tree_model, - GtkTreeIter *iter) +gtk_file_system_model_sortable_init (GtkTreeSortableIface *iface) { - file_model_node_unref (GTK_FILE_SYSTEM_MODEL (tree_model), - iter->user_data); + iface->get_sort_column_id = gtk_file_system_model_get_sort_column_id; + iface->set_sort_column_id = gtk_file_system_model_set_sort_column_id; + iface->set_sort_func = gtk_file_system_model_set_sort_func; + iface->set_default_sort_func = gtk_file_system_model_set_default_sort_func; + iface->has_default_sort_func = gtk_file_system_model_has_default_sort_func; } +/*** GtkTreeDragSource ***/ + static gboolean drag_source_row_draggable (GtkTreeDragSource *drag_source, GtkTreePath *path) { - GtkFileSystemModel *model; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (drag_source); GtkTreeIter iter; - FileModelNode *node; - - model = GTK_FILE_SYSTEM_MODEL (drag_source); if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path)) return FALSE; - if (!model->has_editable) - return TRUE; - - node = iter.user_data; - return (node != model->roots); + return ITER_INDEX (&iter) != 0; } static gboolean @@ -564,239 +970,531 @@ drag_source_drag_data_get (GtkTreeDragSource *drag_source, GtkTreePath *path, GtkSelectionData *selection_data) { - GtkFileSystemModel *model; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (drag_source); + FileModelNode *node; GtkTreeIter iter; - GFile *file; char *uris[2]; - model = GTK_FILE_SYSTEM_MODEL (drag_source); - if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path)) return FALSE; - file = _gtk_file_system_model_get_file (model, &iter); - g_assert (file != NULL); + node = get_node (model, ITER_INDEX (&iter)); + if (node->file == NULL) + return FALSE; - uris[0] = g_file_get_uri (file); + uris[0] = g_file_get_uri (node->file); uris[1] = NULL; - gtk_selection_data_set_uris (selection_data, uris); - g_free (uris[0]); return TRUE; } -/* Callback used when the root folder finished loading */ static void -root_folder_finished_loading_cb (GFile *folder, - GtkFileSystemModel *model) +drag_source_iface_init (GtkTreeDragSourceIface *iface) { - g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0); + iface->row_draggable = drag_source_row_draggable; + iface->drag_data_get = drag_source_drag_data_get; + iface->drag_data_delete = NULL; } -static void -got_root_folder_cb (GCancellable *cancellable, - GtkFolder *folder, - const GError *error, - gpointer data) -{ - gboolean cancelled = g_cancellable_is_cancelled (cancellable); - GtkFileSystemModel *model = data; - GSList *tmp_list; - - tmp_list = g_slist_find (model->pending_cancellables, cancellable); - if (!tmp_list) - goto out; - - model->pending_cancellables = g_slist_delete_link (model->pending_cancellables, - tmp_list); +/*** GtkFileSystemModel ***/ - if (cancelled || !folder) - goto out; +/* Signal IDs */ +enum { + FINISHED_LOADING, + LAST_SIGNAL +}; - model->root_folder = g_object_ref (folder); +static guint file_system_model_signals[LAST_SIGNAL] = { 0 }; - g_signal_connect_object (model->root_folder, "finished-loading", - G_CALLBACK (root_folder_finished_loading_cb), model, 0); - g_signal_connect_object (model->root_folder, "deleted", - G_CALLBACK (root_deleted_callback), model, 0); - g_signal_connect_object (model->root_folder, "files-added", - G_CALLBACK (root_files_added_callback), model, 0); - g_signal_connect_object (model->root_folder, "files-changed", - G_CALLBACK (root_files_changed_callback), model, 0); - g_signal_connect_object (model->root_folder, "files-removed", - G_CALLBACK (root_files_removed_callback), model, 0); + -out: - g_object_unref (model); - g_object_unref (cancellable); -} +G_DEFINE_TYPE_WITH_CODE (GtkFileSystemModel, _gtk_file_system_model, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_MODEL, + gtk_file_system_model_iface_init) + G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_SORTABLE, + gtk_file_system_model_sortable_init) + G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE, + drag_source_iface_init)) -/** - * _gtk_file_system_model_new: - * @file_system: an object implementing #GtkFileSystem - * @root_file: the root file path to show. - * @max_depth: the maximum depth from the children of @root_file - * or the roots of the file system to display in - * the file selector). A depth of 0 displays - * only the immediate children of @root_file, - * or the roots of the filesystem. -1 for no - * maximum depth. - * @error: location to store error, or %NULL. - * - * Creates a new #GtkFileSystemModel object. The #GtkFileSystemModel - * object wraps a #GtkFileSystem interface as a #GtkTreeModel. - * Using the @root_file and @max_depth parameters, the tree model - * can be restricted to a subportion of the entire file system. - * - * Return value: the newly created #GtkFileSystemModel object, or NULL if there - * was an error. - **/ -GtkFileSystemModel * -_gtk_file_system_model_new (GtkFileSystem *file_system, - GFile *root_file, - gint max_depth, - const gchar *attributes, - GError **error) +static void +gtk_file_system_model_dispose (GObject *object) { - GtkFileSystemModel *model; - GCancellable *cancellable; + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object); - g_return_val_if_fail (GTK_IS_FILE_SYSTEM (file_system), NULL); - g_return_val_if_fail (G_IS_FILE (root_file), NULL); - g_return_val_if_fail (error == NULL || *error == NULL, NULL); + if (model->dir_thaw_source) + { + g_source_remove (model->dir_thaw_source); + model->dir_thaw_source = 0; + } - /* Then, actually create the model and the root nodes */ + g_cancellable_cancel (model->cancellable); + if (model->dir_monitor) + g_file_monitor_cancel (model->dir_monitor); - model = g_object_new (GTK_TYPE_FILE_SYSTEM_MODEL, NULL); - model->file_system = g_object_ref (file_system); - if (max_depth < 0) - model->max_depth = G_MAXUSHORT; - else - model->max_depth = MIN (max_depth, G_MAXUSHORT); + G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object); +} - model->attributes = g_strdup (attributes); - model->root_folder = NULL; - model->root_file = g_object_ref (root_file); - model->roots = NULL; +static void +gtk_file_system_model_finalize (GObject *object) +{ + GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object); + guint i; - cancellable = _gtk_file_system_get_folder (file_system, root_file, - attributes, - got_root_folder_cb, - g_object_ref (model)); - if (!cancellable) + for (i = 0; i < model->files->len; i++) { - /* In this case got_root_folder_cb() will never be called, so we - * need to unref model twice. - */ - g_object_unref (model); - g_object_unref (model); - - g_set_error_literal (error, - GTK_FILE_CHOOSER_ERROR, - GTK_FILE_CHOOSER_ERROR_NONEXISTENT, - _("Could not obtain root folder")); - - return NULL; + int v; + + FileModelNode *node = get_node (model, i); + if (node->file) + g_object_unref (node->file); + if (node->info) + g_object_unref (node->info); + + for (v = 0; v < model->n_columns; v++) + if (G_VALUE_TYPE (&node->values[v]) != G_TYPE_INVALID) + g_value_unset (&node->values[v]); } + g_array_free (model->files, TRUE); + + g_object_unref (model->cancellable); + g_free (model->attributes); + if (model->dir) + g_object_unref (model->dir); + if (model->dir_monitor) + g_object_unref (model->dir_monitor); + g_hash_table_destroy (model->file_lookup); + if (model->filter) + g_object_unref (model->filter); - model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable); + g_slice_free1 (sizeof (GType) * model->n_columns, model->column_types); - return model; + _gtk_tree_data_list_header_free (model->sort_list); + if (model->default_sort_destroy) + model->default_sort_destroy (model->default_sort_data); + + G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object); } static void -model_refilter_recurse (GtkFileSystemModel *model, - FileModelNode *parent, - GtkTreePath *path) +_gtk_file_system_model_class_init (GtkFileSystemModelClass *class) { - GtkTreeModel *tree_model = GTK_TREE_MODEL (model); - int i = 0; - FileModelNode *nodes; - gboolean has_children = FALSE; + GObjectClass *gobject_class = G_OBJECT_CLASS (class); - if (parent && !parent->loaded) - return; + gobject_class->finalize = gtk_file_system_model_finalize; + gobject_class->dispose = gtk_file_system_model_dispose; - if (parent) - nodes = parent->children; - else - nodes = model->roots; + file_system_model_signals[FINISHED_LOADING] = + g_signal_new (I_("finished-loading"), + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkFileSystemModelClass, finished_loading), + NULL, NULL, + _gtk_marshal_VOID__POINTER, + G_TYPE_NONE, 1, G_TYPE_POINTER); +} - while (nodes) - { - FileModelNode *next = nodes->next; - gboolean is_visible; - - gtk_tree_path_append_index (path, i); +static void +_gtk_file_system_model_init (GtkFileSystemModel *model) +{ + model->show_files = TRUE; + model->show_folders = TRUE; + model->show_hidden = FALSE; + model->filter_folders = FALSE; - is_visible = file_model_node_is_visible (model, nodes); - - if (!is_visible && nodes->is_visible) - { - file_model_node_clear (model, nodes); - gtk_tree_model_row_deleted (tree_model, path); + model->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID; - nodes->is_visible = FALSE; - } - else if (is_visible && !nodes->is_visible) - { - GtkTreeIter iter; + model->file_lookup = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal); + model->cancellable = g_cancellable_new (); +} - iter.user_data = nodes; - nodes->is_visible = TRUE; - gtk_tree_model_row_inserted (tree_model, path, &iter); - } - else - model_refilter_recurse (model, nodes, path); +/*** API ***/ - if (is_visible) - { - has_children = TRUE; - i++; - } - - gtk_tree_path_up (path); - - nodes = next; - } +static void +gtk_file_system_model_closed_enumerator (GObject *object, GAsyncResult *res, gpointer data) +{ + g_file_enumerator_close_finish (G_FILE_ENUMERATOR (object), res, NULL); +} - if (parent && !has_children) - { - /* Fixme - need to insert dummy node here */ - } +static gboolean +thaw_func (gpointer data) +{ + GtkFileSystemModel *model = data; + + thaw_updates (model); + model->dir_thaw_source = 0; + + return FALSE; } static void -model_refilter_all (GtkFileSystemModel *model) +gtk_file_system_model_got_files (GObject *object, GAsyncResult *res, gpointer data) { - GtkTreePath *path; + GFileEnumerator *enumerator = G_FILE_ENUMERATOR (object); + GtkFileSystemModel *model = data; + GList *walk, *files; + GError *error = NULL; - path = gtk_tree_path_new (); - model_refilter_recurse (model, NULL, path); - gtk_tree_path_free (path); -} + gdk_threads_enter (); -/** - * _gtk_file_system_model_set_show_hidden: - * @model: a #GtkFileSystemModel - * @show_hidden: whether hidden files should be displayed - * - * Sets whether hidden files should be included in the #GtkTreeModel + files = g_file_enumerator_next_files_finish (enumerator, res, &error); + + if (files) + { + if (model->dir_thaw_source == 0) + { + freeze_updates (model); + model->dir_thaw_source = gdk_threads_add_timeout_full (IO_PRIORITY + 1, + 50, + thaw_func, + model, + NULL); + } + + for (walk = files; walk; walk = walk->next) + { + const char *name; + GFileInfo *info; + GFile *file; + + info = walk->data; + name = g_file_info_get_name (info); + if (name == NULL) + { + /* Shouldn't happen, but the APIs allow it */ + g_object_unref (info); + continue; + } + file = g_file_get_child (model->dir, name); + add_file (model, file, info); + g_object_unref (file); + g_object_unref (info); + } + g_list_free (files); + + g_file_enumerator_next_files_async (enumerator, + g_file_is_native (model->dir) ? 50 * FILES_PER_QUERY : FILES_PER_QUERY, + IO_PRIORITY, + model->cancellable, + gtk_file_system_model_got_files, + model); + } + else + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + { + g_file_enumerator_close_async (enumerator, + IO_PRIORITY, + model->cancellable, + gtk_file_system_model_closed_enumerator, + NULL); + if (model->dir_thaw_source != 0) + { + g_source_remove (model->dir_thaw_source); + model->dir_thaw_source = 0; + thaw_updates (model); + } + + g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, error); + } + + if (error) + g_error_free (error); + } + + gdk_threads_leave (); +} + +static void +gtk_file_system_model_query_done (GObject * object, + GAsyncResult *res, + gpointer data) +{ + GtkFileSystemModel *model = data; /* only a valid pointer if not cancelled */ + GFile *file = G_FILE (object); + GFileInfo *info; + guint id; + + info = g_file_query_info_finish (file, res, NULL); + if (info == NULL) + return; + + gdk_threads_enter (); + + _gtk_file_system_model_update_file (model, file, info); + + id = node_get_for_file (model, file); + gtk_file_system_model_sort_node (model, id); + + gdk_threads_leave (); +} + +static void +gtk_file_system_model_monitor_change (GFileMonitor * monitor, + GFile * file, + GFile * other_file, + GFileMonitorEvent type, + GtkFileSystemModel *model) +{ + switch (type) + { + case G_FILE_MONITOR_EVENT_CREATED: + case G_FILE_MONITOR_EVENT_CHANGED: + case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED: + /* We can treat all of these the same way */ + g_file_query_info_async (file, + model->attributes, + G_FILE_QUERY_INFO_NONE, + IO_PRIORITY, + model->cancellable, + gtk_file_system_model_query_done, + model); + break; + case G_FILE_MONITOR_EVENT_DELETED: + gdk_threads_enter (); + remove_file (model, file); + gdk_threads_leave (); + break; + case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT: + /* FIXME: use freeze/thaw with this somehow? */ + case G_FILE_MONITOR_EVENT_PRE_UNMOUNT: + case G_FILE_MONITOR_EVENT_UNMOUNTED: + default: + /* ignore these */ + break; + } +} + +static void +gtk_file_system_model_got_enumerator (GObject *dir, GAsyncResult *res, gpointer data) +{ + GtkFileSystemModel *model = data; + GFileEnumerator *enumerator; + GError *error = NULL; + + gdk_threads_enter (); + + enumerator = g_file_enumerate_children_finish (G_FILE (dir), res, &error); + if (enumerator == NULL) + { + if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + { + g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, error); + g_error_free (error); + } + } + else + { + g_file_enumerator_next_files_async (enumerator, + g_file_is_native (model->dir) ? 50 * FILES_PER_QUERY : FILES_PER_QUERY, + IO_PRIORITY, + model->cancellable, + gtk_file_system_model_got_files, + model); + g_object_unref (enumerator); + model->dir_monitor = g_file_monitor_directory (model->dir, + G_FILE_MONITOR_NONE, + model->cancellable, + NULL); /* we don't mind if directory monitoring isn't supported, so the GError is NULL here */ + if (model->dir_monitor) + g_signal_connect (model->dir_monitor, + "changed", + G_CALLBACK (gtk_file_system_model_monitor_change), + model); + } + + gdk_threads_leave (); +} + +static void +gtk_file_system_model_set_n_columns (GtkFileSystemModel *model, + gint n_columns, + va_list args) +{ + guint i; + + g_assert (model->files == NULL); + g_assert (n_columns > 0); + + model->n_columns = n_columns; + model->column_types = g_slice_alloc (sizeof (GType) * n_columns); + + model->node_size = sizeof (FileModelNode) + sizeof (GValue) * (n_columns - 1); /* minus 1 because FileModelNode.values[] has a default size of 1 */ + + for (i = 0; i < (guint) n_columns; i++) + { + GType type = va_arg (args, GType); + if (! _gtk_tree_data_list_check_type (type)) + { + g_error ("%s: type %s cannot be a column type for GtkFileSystemModel\n", G_STRLOC, g_type_name (type)); + return; /* not reached */ + } + + model->column_types[i] = type; + } + + model->sort_list = _gtk_tree_data_list_header_new (n_columns, model->column_types); + + model->files = g_array_sized_new (FALSE, FALSE, model->node_size, FILES_PER_QUERY); + /* add editable node at start */ + g_array_set_size (model->files, 1); + memset (get_node (model, 0), 0, model->node_size); +} + +static void +gtk_file_system_model_set_directory (GtkFileSystemModel *model, + GFile * dir, + const gchar * attributes) +{ + g_assert (G_IS_FILE (dir)); + + model->dir = g_object_ref (dir); + model->attributes = g_strdup (attributes); + + g_file_enumerate_children_async (model->dir, + attributes, + G_FILE_QUERY_INFO_NONE, + IO_PRIORITY, + model->cancellable, + gtk_file_system_model_got_enumerator, + model); + +} + +static GtkFileSystemModel * +_gtk_file_system_model_new_valist (GtkFileSystemModelGetValue get_func, + gpointer get_data, + guint n_columns, + va_list args) +{ + GtkFileSystemModel *model; + + model = g_object_new (GTK_TYPE_FILE_SYSTEM_MODEL, NULL); + model->get_func = get_func; + model->get_data = get_data; + + gtk_file_system_model_set_n_columns (model, n_columns, args); + + return model; +} + +/** + * _gtk_file_system_model_new: + * @get_func: function to call for getting a value + * @get_data: user data argument passed to @get_func + * @n_columns: number of columns + * @...: @n_columns #GType types for the columns + * + * Creates a new #GtkFileSystemModel object. You need to add files + * to the list using _gtk_file_system_model_add_and_query_file() + * or _gtk_file_system_model_update_file(). + * + * Return value: the newly created #GtkFileSystemModel + **/ +GtkFileSystemModel * +_gtk_file_system_model_new (GtkFileSystemModelGetValue get_func, + gpointer get_data, + guint n_columns, + ...) +{ + GtkFileSystemModel *model; + va_list args; + + g_return_val_if_fail (get_func != NULL, NULL); + g_return_val_if_fail (n_columns > 0, NULL); + + va_start (args, n_columns); + model = _gtk_file_system_model_new_valist (get_func, get_data, n_columns, args); + va_end (args); + + return model; +} + +/** + * _gtk_file_system_model_new_for_directory: + * @directory: the directory to show. + * @attributes: (allow-none): attributes to immediately load or %NULL for all + * @get_func: function that the model should call to query data about a file + * @get_data: user data to pass to the @get_func + * @n_columns: number of columns + * @...: @n_columns #GType types for the columns + * + * Creates a new #GtkFileSystemModel object. The #GtkFileSystemModel + * object wraps the given @directory as a #GtkTreeModel. + * The model will query the given directory with the given @attributes + * and add all files inside the directory automatically. If supported, + * it will also monitor the drectory and update the model's + * contents to reflect changes, if the @directory supports monitoring. + * + * Return value: the newly created #GtkFileSystemModel + **/ +GtkFileSystemModel * +_gtk_file_system_model_new_for_directory (GFile * dir, + const gchar * attributes, + GtkFileSystemModelGetValue get_func, + gpointer get_data, + guint n_columns, + ...) +{ + GtkFileSystemModel *model; + va_list args; + + g_return_val_if_fail (G_IS_FILE (dir), NULL); + g_return_val_if_fail (get_func != NULL, NULL); + g_return_val_if_fail (n_columns > 0, NULL); + + va_start (args, n_columns); + model = _gtk_file_system_model_new_valist (get_func, get_data, n_columns, args); + va_end (args); + + gtk_file_system_model_set_directory (model, dir, attributes); + + return model; +} + +static void +gtk_file_system_model_refilter_all (GtkFileSystemModel *model) +{ + guint i; + + if (model->frozen) + { + model->filter_on_thaw = TRUE; + return; + } + + freeze_updates (model); + + /* start at index 1, don't change the editable */ + for (i = 1; i < model->files->len; i++) + node_compute_visibility_and_filters (model, i); + + model->filter_on_thaw = FALSE; + thaw_updates (model); +} + +/** + * _gtk_file_system_model_set_show_hidden: + * @model: a #GtkFileSystemModel + * @show_hidden: whether hidden files should be displayed + * + * Sets whether hidden files should be included in the #GtkTreeModel * for display. **/ void _gtk_file_system_model_set_show_hidden (GtkFileSystemModel *model, gboolean show_hidden) { + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + show_hidden = show_hidden != FALSE; if (show_hidden != model->show_hidden) { model->show_hidden = show_hidden; - model_refilter_all (model); + gtk_file_system_model_refilter_all (model); } } @@ -812,12 +1510,14 @@ void _gtk_file_system_model_set_show_folders (GtkFileSystemModel *model, gboolean show_folders) { + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + show_folders = show_folders != FALSE; if (show_folders != model->show_folders) { model->show_folders = show_folders; - model_refilter_all (model); + gtk_file_system_model_refilter_all (model); } } @@ -834,29 +1534,124 @@ void _gtk_file_system_model_set_show_files (GtkFileSystemModel *model, gboolean show_files) { + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + show_files = show_files != FALSE; if (show_files != model->show_files) { model->show_files = show_files; - model_refilter_all (model); + gtk_file_system_model_refilter_all (model); + } +} + +/** + * _gtk_file_system_model_set_filter_folders: + * @model: a #GtkFileSystemModel + * @filter_folders: whether the filter applies to folders + * + * Sets whether the filter set by _gtk_file_system_model_set_filter() + * applies to folders. By default, it does not and folders are always + * visible. + **/ +void +_gtk_file_system_model_set_filter_folders (GtkFileSystemModel *model, + gboolean filter_folders) +{ + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + + filter_folders = filter_folders != FALSE; + + if (filter_folders != model->filter_folders) + { + model->filter_folders = filter_folders; + gtk_file_system_model_refilter_all (model); } } +/** + * _gtk_file_system_model_get_cancellable: + * @model: the model + * + * Gets the cancellable used by the @model. This is the cancellable used + * internally by the @model that will be cancelled when @model is + * disposed. So you can use it for operations that should be cancelled + * when the model goes away. + * + * Returns: The cancellable used by @model + **/ +GCancellable * +_gtk_file_system_model_get_cancellable (GtkFileSystemModel *model) +{ + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL); + + return model->cancellable; +} + +/** + * _gtk_file_system_model_iter_is_visible: + * @model: the model + * @iter: a valid iterator + * + * Checks if the iterator is visible. A visible iterator references + * a row that is currently exposed using the #GtkTreeModel API. If + * the iterator is invisible, it references a file that is not shown + * for some reason, such as being filtered out by the current filter or + * being a hidden file. + * + * Returns: %TRUE if the iterator is visible + **/ +gboolean +_gtk_file_system_model_iter_is_visible (GtkFileSystemModel *model, + GtkTreeIter *iter) +{ + FileModelNode *node; + + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), FALSE); + g_return_val_if_fail (iter != NULL, FALSE); + + node = get_node (model, ITER_INDEX (iter)); + return node->visible; +} + +/** + * _gtk_file_system_model_iter_is_filtered_out: + * @model: the model + * @iter: a valid iterator + * + * Checks if the iterator is filtered out. This is only useful for rows + * that refer to folders, as those are always visible regardless + * of what the current filter says. This function lets you see + * the results of the filter. + * + * Returns: %TRUE if the iterator passed the current filter; %FALSE if the + * filter would not have let the row pass. + **/ +gboolean +_gtk_file_system_model_iter_is_filtered_out (GtkFileSystemModel *model, + GtkTreeIter *iter) +{ + FileModelNode *node; + + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), FALSE); + g_return_val_if_fail (iter != NULL, FALSE); + + node = get_node (model, ITER_INDEX (iter)); + return node->filtered_out; +} + /** * _gtk_file_system_model_get_info: * @model: a #GtkFileSystemModel * @iter: a #GtkTreeIter pointing to a row of @model * * Gets the #GFileInfo structure for a particular row - * of @model. The information included in this structure - * is determined by the @types parameter to - * _gtk_file_system_model_new(). + * of @model. * * Return value: a #GFileInfo structure. This structure * is owned by @model and must not be modified or freed. - * If you want to save the information for later use, - * you must make a copy, since the structure may be + * If you want to keep the information for later use, + * you must take a reference, since the structure may be * freed on later changes to the file system. If you have * called _gtk_file_system_model_add_editable() and the @iter * corresponds to the row that this function returned, the @@ -868,11 +1663,12 @@ _gtk_file_system_model_get_info (GtkFileSystemModel *model, { FileModelNode *node; - node = iter->user_data; - if (model->has_editable && node == model->roots) - return NULL; - else - return file_model_node_get_info (model, node); + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL); + g_return_val_if_fail (iter != NULL, NULL); + + node = get_node (model, ITER_INDEX (iter)); + g_assert (node->info == NULL || G_IS_FILE_INFO (node->info)); + return node->info; } /** @@ -880,7 +1676,7 @@ _gtk_file_system_model_get_info (GtkFileSystemModel *model, * @model: a #GtkFileSystemModel * @iter: a #GtkTreeIter pointing to a row of @model * - * Gets the path for a particular row in @model. + * Gets the file for a particular row in @model. * * Return value: the file. This object is owned by @model and * or freed. If you want to save the path for later use, @@ -891,309 +1687,306 @@ GFile * _gtk_file_system_model_get_file (GtkFileSystemModel *model, GtkTreeIter *iter) { - FileModelNode *node = iter->user_data; + FileModelNode *node; - if (model->has_editable && node == model->roots) - return NULL; + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL); - if (node->is_dummy) - return node->parent->file; - else - return node->file; + node = get_node (model, ITER_INDEX (iter)); + return node->file; } -static void -unref_node_and_parents (GtkFileSystemModel *model, - FileModelNode *node) +/** + * _gtk_file_system_model_get_value: + * @model: a #GtkFileSystemModel + * @iter: a #GtkTreeIter pointing to a row of @model + * @column: the column to get the value for + * + * Gets the value associated with the given row @iter and @column. + * If no value is available yet and the default value should be used, + * %NULL is returned. + * This is a performance optimization for the calls + * gtk_tree_model_get() or gtk_tree_model_get_value(), which copy + * the value and spend a considerable amount of time in iterator + * lookups. Both of which are slow. + * + * Returns: a pointer to the actual value as stored in @model or %NULL + * if no value available yet. + **/ +const GValue * +_gtk_file_system_model_get_value (GtkFileSystemModel *model, + GtkTreeIter * iter, + int column) { - file_model_node_unref (model, node); - if (node->parent) - file_model_node_unref (model, node->parent); + FileModelNode *node; + + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL); + g_return_val_if_fail (column >= 0 && (guint) column < model->n_columns, NULL); + + node = get_node (model, ITER_INDEX (iter)); + + if (!G_VALUE_TYPE (&node->values[column])) + { + g_value_init (&node->values[column], model->column_types[column]); + if (!model->get_func (model, + node->file, + node->info, + column, + &node->values[column], + model->get_data)) + { + g_value_unset (&node->values[column]); + return NULL; + } + } + + return &node->values[column]; } -static FileModelNode * -find_child_node (GtkFileSystemModel *model, - FileModelNode *parent_node, - GFile *file) +static guint +node_get_for_file (GtkFileSystemModel *model, + GFile * file) { - FileModelNode *children; - - if (parent_node) - children = file_model_node_get_children (model, parent_node); - else - children = model->roots; + guint i; - while (children) + i = GPOINTER_TO_UINT (g_hash_table_lookup (model->file_lookup, file)); + if (i != 0) + return i; + + /* Node 0 is the editable row and has no associated file or entry in the table, so we start counting from 1. + * + * The invariant here is that the files in model->files[n] for n < g_hash_table_size (model->file_lookup) + * are already added to the hash table. The table can get cleared when we re-sort; this loop merely rebuilds + * our (file -> index) mapping on demand. + * + * If we exit the loop, the next pending batch of mappings will be resolved when this function gets called again + * with another file that is not yet in the mapping. + */ + for (i = g_hash_table_size (model->file_lookup) + 1; i < model->files->len; i++) { - if (children->is_visible && - children->file && - g_file_equal (children->file, file)) - return children; + FileModelNode *node = get_node (model, i); - children = children->next; + g_hash_table_insert (model->file_lookup, node->file, GUINT_TO_POINTER (i)); + if (g_file_equal (node->file, file)) + return i; } - return NULL; + return 0; } /** - * _gtk_file_system_model_set_filter: - * @mode: a #GtkFileSystemModel - * @filter: function to be called for each file - * @user_data: data to pass to @filter - * - * Sets a callback called for each file/directory to see whether - * it should be included in model. If this function was made - * public, we'd want to include a GDestroyNotify as well. + * _gtk_file_system_model_get_iter_for_file: + * @model: the model + * @iter: the iterator to be initialized + * @file: the file to look up + * + * Initializes @iter to point to the row used for @file, if @file is part + * of the model. Note that upon successful return, @iter may point to an + * invisible row in the @model. Use + * _gtk_file_system_model_iter_is_visible() to make sure it is visible to + * the tree view. + * + * Returns: %TRUE if file is part of the model and @iter was initialized **/ -void -_gtk_file_system_model_set_filter (GtkFileSystemModel *model, - GtkFileSystemModelFilter filter, - gpointer user_data) +gboolean +_gtk_file_system_model_get_iter_for_file (GtkFileSystemModel *model, + GtkTreeIter *iter, + GFile * file) { - g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); - - model->filter_func = filter; - model->filter_data = user_data; + guint i; - model_refilter_all (model); -} + g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), FALSE); + g_return_val_if_fail (iter != NULL, FALSE); + g_return_val_if_fail (G_IS_FILE (file), FALSE); + i = node_get_for_file (model, file); -struct RefPathData -{ - GtkFileSystemModel *model; - FileModelNode *node; - FileModelNode *parent_node; - GSList *files; - GSList *cleanups; - GtkFileSystemModelPathFunc func; - gpointer user_data; -}; + if (i == 0) + return FALSE; + + ITER_INIT_FROM_INDEX (model, iter, i); + return TRUE; +} -/* FIXME: maybe we have to wait on finished-loading? */ +/* When an element is added or removed to the model->files array, we need to + * update the model->file_lookup mappings of (node, index), as the indexes + * change. This function adds the specified increment to the index in that pair + * if the index is equal or after the specified id. We use this to slide the + * mappings up or down when a node is added or removed, respectively. + */ static void -ref_path_cb (GCancellable *cancellable, - GtkFolder *folder, - const GError *error, - gpointer data) +adjust_file_lookup (GtkFileSystemModel *model, guint id, int increment) { - struct RefPathData *info = data; - gboolean cancelled = g_cancellable_is_cancelled (cancellable); - - if (!g_slist_find (info->model->pending_cancellables, cancellable)) - goto out; + GHashTableIter iter; + gpointer key; + gpointer value; - info->model->pending_cancellables = g_slist_remove (info->model->pending_cancellables, cancellable); - - /* Note that !folder means that the child node was already - * found, without using get_folder. - */ - if (cancelled || error) - goto out; + g_hash_table_iter_init (&iter, model->file_lookup); - if (folder) - info->cleanups = g_slist_prepend (info->cleanups, folder); - else if (g_slist_length (info->files) == 1 - && g_file_equal (info->node->file, info->files->data)) + while (g_hash_table_iter_next (&iter, &key, &value)) { - /* Done, now call the function */ - if (info->node) - { - GtkTreeIter iter; - GtkTreePath *path; + guint index = GPOINTER_TO_UINT (value); - iter.user_data = info->node; - path = gtk_tree_model_get_path (GTK_TREE_MODEL (info->model), &iter); + if (index >= id) + { + index += increment; + g_hash_table_iter_replace (&iter, GUINT_TO_POINTER (index)); + } + } +} - (* info->func) (info->model, path, &iter, info->user_data); +/** + * add_file: + * @model: the model + * @file: the file to add + * @info: the information to associate with the file + * + * Adds the given @file with its associated @info to the @model. + * If the model is frozen, the file will only show up after it is thawn. + **/ +static void +add_file (GtkFileSystemModel *model, + GFile *file, + GFileInfo *info) +{ + FileModelNode *node; + + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (G_IS_FILE (file)); + g_return_if_fail (G_IS_FILE_INFO (info)); - gtk_tree_path_free (path); - } + node = g_slice_alloc0 (model->node_size); + node->file = g_object_ref (file); + if (info) + node->info = g_object_ref (info); + node->frozen_add = model->frozen ? TRUE : FALSE; - goto out; - } + g_array_append_vals (model->files, node, 1); + g_slice_free1 (model->node_size, node); - info->node = find_child_node (info->model, info->parent_node, info->files->data); - if (info->node) - file_model_node_ref (info->node); - else - { - goto out; - } + if (!model->frozen) + node_compute_visibility_and_filters (model, model->files->len -1); - g_object_unref (info->files); - info->files = g_slist_remove (info->files, info->files->data); + gtk_file_system_model_sort_node (model, model->files->len -1); +} - if (g_slist_length (info->files) < 1) - { - /* Done, now call the function */ - if (info->node) - { - GtkTreeIter iter; - GtkTreePath *path; +/** + * remove_file: + * @model: the model + * @file: file to remove from the model. The file must have been + * added to the model previously + * + * Removes the given file from the model. If the file is not part of + * @model, this function does nothing. + **/ +static void +remove_file (GtkFileSystemModel *model, + GFile *file) +{ + FileModelNode *node; + guint id; + guint row; - iter.user_data = info->node; - path = gtk_tree_model_get_path (GTK_TREE_MODEL (info->model), &iter); + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (G_IS_FILE (file)); - (* info->func) (info->model, path, &iter, info->user_data); + id = node_get_for_file (model, file); + if (id == 0) + return; - gtk_tree_path_free (path); - } + node = get_node (model, id); + row = node_get_tree_row (model, id); - goto out; - } - else - { - info->parent_node = info->node; + node_invalidate_index (model, id); - if (info->parent_node->loaded) - { - info->node = find_child_node (info->model, info->parent_node, info->files->data); - ref_path_cb (NULL, NULL, NULL, info); - } - else - { - GCancellable *cancellable; - - cancellable = _gtk_file_system_get_folder (info->model->file_system, - info->files->data, - info->model->attributes, - ref_path_cb, data); - info->model->pending_cancellables = - g_slist_append (info->model->pending_cancellables, cancellable); - } + g_hash_table_remove (model->file_lookup, file); + g_object_unref (node->file); + adjust_file_lookup (model, id, -1); - return; - } + if (node->info) + g_object_unref (node->info); + + g_array_remove_index (model->files, id); -out: - if (info->node) - unref_node_and_parents (info->model, info->node); - g_object_unref (info->files); - g_slist_foreach (info->cleanups, (GFunc)g_object_unref, NULL); - g_slist_free (info->cleanups); - g_object_unref (info->model); - g_free (info); + /* We don't need to resort, as removing a row doesn't change the sorting order of the other rows */ - g_object_unref (cancellable); + emit_row_deleted_for_row (model, row); } /** - * _gtk_file_system_model_path_do: - * @model: a #GtkFileSystemModel - * @path: a path pointing to a file in the filesystem - * for @model. - * @func: Function to call with the path and iter corresponding - * to @path. - * @user_data: data to pass to @func - * - * Locates @path within @model, referencing - * (gtk_tree_model_ref_node()) all parent nodes, - * calls @func passing in the path and iter for @path, - * then unrefs all the parent nodes. - * - * The reason for doing this operation as a callback - * is so that if the operation performed with the - * path and iter results in referencing the node - * and/or parent nodes, we don't load all the information - * about the nodes. + * _gtk_file_system_model_update_file: + * @model: the model + * @file: the file + * @info: the new file info * - * This function is particularly useful for expanding - * a #GtkTreeView to a particular point in the file system. - */ + * Tells the file system model that the file changed and that the + * new @info should be used for it now. If the file is not part of + * @model, it will get added automatically. + **/ void -_gtk_file_system_model_path_do (GtkFileSystemModel *model, - GFile *file, - GtkFileSystemModelPathFunc func, - gpointer user_data) +_gtk_file_system_model_update_file (GtkFileSystemModel *model, + GFile *file, + GFileInfo *info) { - GFile *parent_file; - GSList *files = NULL; FileModelNode *node; - struct RefPathData *info; - - if (g_file_equal (file, model->root_file)) - return; - - parent_file = g_file_get_parent (file); + guint i, id; + GFileInfo *old_info; - if (!parent_file) - return; + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (G_IS_FILE (file)); + g_return_if_fail (G_IS_FILE_INFO (info)); - files = g_slist_prepend (files, g_object_ref (file)); - while (!g_file_equal (parent_file, model->root_file)) + id = node_get_for_file (model, file); + if (id == 0) { - files = g_slist_prepend (files, parent_file); - parent_file = g_file_get_parent (parent_file); - if (!parent_file) - { - g_slist_foreach (files, (GFunc) g_object_unref, NULL); - g_slist_free (files); - return; - } + add_file (model, file, info); + id = node_get_for_file (model, file); } - if (g_slist_length (files) < 1) - return; + node = get_node (model, id); + + old_info = node->info; + node->info = g_object_ref (info); + if (old_info) + g_object_unref (old_info); - /* Now we have all paths, except the root path */ - node = find_child_node (model, NULL, files->data); - if (!node) + for (i = 0; i < model->n_columns; i++) { - g_slist_foreach (files, (GFunc) g_object_unref, NULL); - g_slist_free (files); - return; + if (G_VALUE_TYPE (&node->values[i])) + g_value_unset (&node->values[i]); } - file_model_node_ref (node); + if (node->visible) + emit_row_changed_for_node (model, id); +} - g_object_unref (files->data); - files = g_slist_remove (files, files->data); +/** + * _gtk_file_system_model_set_filter: + * @mode: a #GtkFileSystemModel + * @filter: (allow-none): %NULL or filter to use + * + * Sets a filter to be used for deciding if a row should be visible or not. + * Whether this filter applies to directories can be toggled with + * _gtk_file_system_model_set_filter_folders(). + **/ +void +_gtk_file_system_model_set_filter (GtkFileSystemModel *model, + GtkFileFilter * filter) +{ + GtkFileFilter *old_filter; - if (g_slist_length (files) < 1) - { - /* Done, now call the function */ - if (node) - { - GtkTreeIter iter; - GtkTreePath *path; + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (filter == NULL || GTK_IS_FILE_FILTER (filter)); + + if (filter) + g_object_ref (filter); - iter.user_data = node; - path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); + old_filter = model->filter; + model->filter = filter; - (* func) (model, path, &iter, user_data); + if (old_filter) + g_object_unref (old_filter); - gtk_tree_path_free (path); - unref_node_and_parents (model, node); - } - } - else - { - info = g_new0 (struct RefPathData, 1); - info->files = files; - info->model = g_object_ref (model); - info->func = func; - info->user_data = user_data; - info->node = node; - - if (info->node->loaded) - { - info->parent_node = info->node; - info->node = find_child_node (model, info->parent_node, info->files->data); - ref_path_cb (NULL, NULL, NULL, info); - } - else - { - GCancellable *cancellable; - - cancellable = _gtk_file_system_get_folder (model->file_system, - files->data, - model->attributes, - ref_path_cb, info); - model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable); - } - } + gtk_file_system_model_refilter_all (model); } /** @@ -1209,26 +2002,11 @@ _gtk_file_system_model_path_do (GtkFileSystemModel *model, void _gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *iter) { - FileModelNode *node; - GtkTreePath *path; - - g_return_if_fail (!model->has_editable); - - model->has_editable = TRUE; - - node = file_model_node_new (model, NULL); - node->is_visible = TRUE; - - node->next = model->roots; - model->roots = node; - - path = gtk_tree_path_new (); - gtk_tree_path_append_index (path, 0); - iter->user_data = node; - - gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, iter); + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (!get_node (model, 0)->visible); - gtk_tree_path_free (path); + node_set_visible_and_filtered_out (model, 0, TRUE, FALSE); + ITER_INIT_FROM_INDEX (model, iter, 0); } /** @@ -1242,734 +2020,146 @@ _gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *ite void _gtk_file_system_model_remove_editable (GtkFileSystemModel *model) { - GtkTreePath *path; - FileModelNode *node; - - g_return_if_fail (model->has_editable); - - model->has_editable = FALSE; - - node = model->roots; - model->roots = model->roots->next; - file_model_node_free (node); - - path = gtk_tree_path_new (); - gtk_tree_path_append_index (path, 0); - - gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); - - gtk_tree_path_free (path); -} - -static FileModelNode * -file_model_node_new (GtkFileSystemModel *model, - GFile *file) -{ - FileModelNode *node = g_new0 (FileModelNode, 1); - - node->model = model; - node->file = file ? g_object_ref (file) : NULL; - - return node; -} - -static void -file_model_node_free (FileModelNode *node) -{ - file_model_node_clear (node->model, node); - - if (node->file) - g_object_unref (node->file); - - if (node->info) - g_object_unref (node->info); - - g_free (node); -} - -static GFileInfo * -file_model_node_get_info (GtkFileSystemModel *model, - FileModelNode *node) -{ - if (!node->info) - { - if (node->is_dummy) - { - node->info = g_file_info_new (); - g_file_info_set_display_name (node->info, _("(Empty)")); - } - else if (node->parent || model->root_folder) - { - node->info = _gtk_folder_get_info ((node->parent != NULL) ? node->parent->folder : model->root_folder, - node->file); - } - else - g_assert_not_reached (); - } - - return node->info; -} - -static gboolean -file_model_node_is_visible (GtkFileSystemModel *model, - FileModelNode *node) -{ - if (model->show_folders != model->show_files || - !model->show_hidden || - model->filter_func) - { - GFileInfo *info = file_model_node_get_info (model, node); - gboolean is_folder; - - if (!info) - { - /* File probably disappeared underneath us or resides in a - directory where we have only partial access rights. */ - return FALSE; - } - - is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY); - - if (model->show_folders != model->show_files && - model->show_folders != is_folder) - return FALSE; - - if (!model->show_hidden && g_file_info_get_is_hidden (info)) - return FALSE; - - if (model->filter_func && - !model->filter_func (model, node->file, info, model->filter_data)) - return FALSE; - } - - return TRUE; -} - -static void -file_model_node_clear (GtkFileSystemModel *model, - FileModelNode *node) -{ - FileModelNode *children; - - file_model_node_idle_clear_cancel (node); - - children = node->children; - node->children = NULL; - node->loaded = FALSE; - - while (children) - { - FileModelNode *next = children->next; - - file_model_node_free (children); - - children = next; - } - - if (node->folder) - { - /* Unreffing node->folder may cause roots_changed, - * so we need to be careful about ordering. - */ - GtkFolder *folder = node->folder; - node->folder = NULL; - - g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (deleted_callback), node); - g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_added_callback), node); - g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_changed_callback), node); - g_signal_handlers_disconnect_by_func (folder, G_CALLBACK (files_removed_callback), node); - - g_object_unref (folder); - } -} - -static void -file_model_node_ref (FileModelNode *node) -{ - node->ref_count++; - if (node->ref_count == 1 && node->parent) - node->parent->n_referenced_children++; -} - -static gboolean -idle_clear_callback (GtkFileSystemModel *model) -{ - while (model->idle_clears) - { - FileModelNode *node = model->idle_clears->data; - model->idle_clears = g_slist_delete_link (model->idle_clears, model->idle_clears); - - node->idle_clear = FALSE; - file_model_node_clear (node->model, node); - } - - return FALSE; -} - -static void -file_model_node_idle_clear (FileModelNode *node) -{ - if (!node->idle_clear) - { - GtkFileSystemModel *model = node->model; - - node->idle_clear = TRUE; - if (!model->idle_clears) - { - model->idle_clear_source = g_idle_source_new (); - g_source_set_priority (model->idle_clear_source, G_PRIORITY_HIGH); - g_source_set_closure (model->idle_clear_source, - g_cclosure_new_object (G_CALLBACK (idle_clear_callback), - G_OBJECT (model))); - g_source_attach (model->idle_clear_source, NULL); - } - - model->idle_clears = g_slist_prepend (model->idle_clears, node); - node->idle_clear = TRUE; - } -} - -static void -file_model_node_idle_clear_cancel (FileModelNode *node) -{ - if (node->idle_clear) - { - GtkFileSystemModel *model = node->model; + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (get_node (model, 0)->visible); - model->idle_clears = g_slist_remove (model->idle_clears, node); - if (!model->idle_clears) - { - g_source_destroy (model->idle_clear_source); - model->idle_clear_source = NULL; - } - - node->idle_clear = FALSE; - } + node_set_visible_and_filtered_out (model, 0, FALSE, FALSE); } +/** + * freeze_updates: + * @model: a #GtkFileSystemModel + * + * Freezes most updates on the model, so that performing multiple operations on + * the files in the model do not cause any events. Use thaw_updates() to resume + * proper operations. It is fine to call this function multiple times as long as + * freeze and thaw calls are balanced. + **/ static void -file_model_node_unref (GtkFileSystemModel *model, - FileModelNode *node) +freeze_updates (GtkFileSystemModel *model) { - node->ref_count--; - if (node->ref_count == 0) - { - file_model_node_clear (model, node); - if (node->parent) - file_model_node_child_unref (node->parent); - } -} + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); -static void -file_model_node_child_unref (FileModelNode *parent) -{ - parent->n_referenced_children--; - if (parent->n_referenced_children == 0) - file_model_node_idle_clear (parent); + model->frozen++; } -struct GetChildrenData -{ - GtkFileSystemModel *model; - FileModelNode *node; -}; - +/** + * thaw_updates: + * @model: a #GtkFileSystemModel + * + * Undoes the effect of a previous call to freeze_updates() + **/ static void -get_children_get_folder_cb (GCancellable *cancellable, - GtkFolder *folder, - const GError *error, - gpointer callback_data) +thaw_updates (GtkFileSystemModel *model) { - gboolean cancelled = g_cancellable_is_cancelled (cancellable); - struct GetChildrenData *data = callback_data; - FileModelNode *child_node; - GSList *tmp_list; - - tmp_list = g_slist_find (data->model->pending_cancellables, cancellable); + gboolean stuff_added; - if (!tmp_list) - goto out; - - data->model->pending_cancellables = g_slist_delete_link (data->model->pending_cancellables, tmp_list); - - if (cancelled || !folder) - { - /* error, no folder, remove dummy child */ - if (data->node->parent && data->node->parent->has_dummy) - { - data->node->parent->children = NULL; - data->node->parent->has_dummy = FALSE; - } - - file_model_node_free (data->node); - - goto out; - } - - data->node->folder = folder; - data->node->load_pending = FALSE; - - g_signal_connect (data->node->folder, "deleted", - G_CALLBACK (deleted_callback), data->node); - g_signal_connect (data->node->folder, "files-added", - G_CALLBACK (files_added_callback), data->node); - g_signal_connect (data->node->folder, "files-changed", - G_CALLBACK (files_changed_callback), data->node); - g_signal_connect (data->node->folder, "files-removed", - G_CALLBACK (files_removed_callback), data->node); - - data->node->loaded = TRUE; - - /* We claimed this folder had children, so we - * have to add a dummy child, possibly to remove later. - */ - child_node = file_model_node_new (data->model, NULL); - child_node->is_visible = TRUE; - child_node->parent = data->node; - child_node->is_dummy = TRUE; - - data->node->children = child_node; - data->node->has_dummy = TRUE; - - g_object_set_data (G_OBJECT (data->node->folder), I_("model-node"), data->node); - -out: - g_object_unref (data->model); - g_free (data); + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (model->frozen > 0); - g_object_unref (cancellable); -} + model->frozen--; + if (model->frozen > 0) + return; -static FileModelNode * -file_model_node_get_children (GtkFileSystemModel *model, - FileModelNode *node) -{ - if (node->ref_count == 0) - return NULL; + stuff_added = get_node (model, model->files->len - 1)->frozen_add; - if (!node->loaded && !node->load_pending) + if (model->filter_on_thaw) + gtk_file_system_model_refilter_all (model); + if (model->sort_on_thaw) + gtk_file_system_model_sort (model); + if (stuff_added) { - GFileInfo *info = file_model_node_get_info (model, node); - gboolean has_children = FALSE; - gboolean is_folder = (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY); - - file_model_node_idle_clear_cancel (node); + guint i; - if (node->depth < model->max_depth && is_folder) + for (i = 0; i < model->files->len; i++) { - struct GetChildrenData *data; - GCancellable *cancellable; - - data = g_new (struct GetChildrenData, 1); - data->model = g_object_ref (model); - data->node = node; - - cancellable = - _gtk_file_system_get_folder (model->file_system, - node->file, - model->attributes, - get_children_get_folder_cb, - data); + FileModelNode *node = get_node (model, i); - model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable); - node->load_pending = TRUE; - - if (!has_children) - { - /* The hard case ... we claimed this folder had children, but actually - * it didn't. We have to add a dummy child, possibly to remove later. - */ - FileModelNode *child_node = file_model_node_new (model, NULL); - child_node->is_visible = TRUE; - child_node->parent = node; - child_node->is_dummy = TRUE; - - node->children = child_node; - node->has_dummy = TRUE; - } - } - } - - return node->children; -} - -static gint -file_compare_func (GFile *file1, - GFile *file2) -{ - gchar *uri1, *uri2; - gint result; - - uri1 = g_file_get_uri (file1); - uri2 = g_file_get_uri (file2); - - result = g_strcmp0 (uri1, uri2); - - g_free (uri1); - g_free (uri2); - - return result; -} - -static GSList * -sort_file_list (GSList *list) -{ - GSList *copy; - - copy = g_slist_copy (list); - return g_slist_sort (copy, (GCompareFunc) file_compare_func); -} - -static void -do_files_added (GtkFileSystemModel *model, - FileModelNode *parent_node, - GSList *files) -{ - GtkTreeModel *tree_model = GTK_TREE_MODEL (model); - FileModelNode *children; - FileModelNode *prev = NULL; - GtkTreeIter iter; - GtkTreePath *path; - GSList *sorted_files, *tmp_list; - - sorted_files = sort_file_list (files); - - if (parent_node) - { - iter.user_data = parent_node; - path = gtk_tree_model_get_path (tree_model, &iter); - children = parent_node->children; - } - else - { - path = gtk_tree_path_new (); - children = model->roots; - } - - gtk_tree_path_down (path); - - if (parent_node && parent_node->has_dummy) - { - prev = children; - children = children->next; - gtk_tree_path_next (path); - } - - for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next) - { - GFile *file = tmp_list->data; - - while (children && - (!children->file || !g_file_equal (children->file, file))) - { - prev = children; - if (children->is_visible) - gtk_tree_path_next (path); - - children = children->next; - } - - if (children && - children->file && g_file_equal (children->file, file)) - { - /* Shouldn't happen */ - } - else - { - FileModelNode *new; - - new = file_model_node_new (model, file); - - if (children) - new->next = children; - if (prev) - prev->next = new; - else if (parent_node) - parent_node->children = new; - else - model->roots = new; - - prev = new; - - if (parent_node) - { - new->parent = parent_node; - new->depth = parent_node->depth + 1; - } - - new->is_visible = file_model_node_is_visible (model, new); - - if (new->is_visible) - { - iter.user_data = new; - gtk_tree_path_free (path); - path = gtk_tree_model_get_path (tree_model, &iter); - gtk_tree_model_row_inserted (tree_model, path, &iter); - - if (gtk_file_system_model_iter_has_child (tree_model, &iter)) - gtk_tree_model_row_has_child_toggled (tree_model, path, &iter); - - if (parent_node && parent_node->has_dummy) - { - FileModelNode *dummy = parent_node->children; - GtkTreePath *dummy_path; - - parent_node->children = parent_node->children->next; - parent_node->has_dummy = FALSE; - - dummy_path = gtk_tree_path_copy (path); - gtk_tree_path_up (dummy_path); - gtk_tree_path_down (dummy_path); - - gtk_tree_model_row_deleted (tree_model, dummy_path); - gtk_tree_path_free (dummy_path); - - if (dummy->ref_count) - file_model_node_child_unref (parent_node); - file_model_node_free (dummy); - } - - gtk_tree_path_next (path); - } - } - } - - gtk_tree_path_free (path); - g_slist_free (sorted_files); -} - -static void -do_files_changed (GtkFileSystemModel *model, - FileModelNode *parent_node, - GSList *files) -{ - GtkTreeModel *tree_model = GTK_TREE_MODEL (model); - FileModelNode *children; - GtkTreeIter iter; - GtkTreePath *path; - GSList *sorted_files; - GSList *tmp_list; - - sorted_files = sort_file_list (files); - - if (parent_node) - { - iter.user_data = parent_node; - path = gtk_tree_model_get_path (tree_model, &iter); - children = parent_node->children; - } - else - { - path = gtk_tree_path_new (); - children = model->roots; - } - - gtk_tree_path_down (path); - - if (parent_node && parent_node->has_dummy) - { - children = children->next; - gtk_tree_path_next (path); - } - - for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next) - { - GFile *file = tmp_list->data; - - while (children && - (!children->file || !g_file_equal (children->file, file))) - { - if (children->is_visible) - gtk_tree_path_next (path); - - children = children->next; - } - - if (children && - children->file && g_file_equal (children->file, file)) - { - gtk_tree_model_row_changed (tree_model, path, &iter); - } - else - { - /* Shouldn't happen */ - } + if (!node->frozen_add) + continue; + node->frozen_add = FALSE; + node_compute_visibility_and_filters (model, i); + } } - - gtk_tree_path_free (path); - g_slist_free (sorted_files); } -static void -do_files_removed (GtkFileSystemModel *model, - FileModelNode *parent_node, - GSList *files) +/** + * _gtk_file_system_model_clear_cache: + * @model: a #GtkFileSystemModel + * @column: the column to clear or -1 for all columns + * + * Clears the cached values in the model for the given @column. Use + * this function whenever your get_value function would return different + * values for a column. + * The file chooser uses this for example when the icon theme changes to + * invalidate the cached pixbufs. + **/ +void +_gtk_file_system_model_clear_cache (GtkFileSystemModel *model, + int column) { - GtkTreeModel *tree_model = GTK_TREE_MODEL (model); - FileModelNode *children; - FileModelNode *prev = NULL; - GtkTreeIter iter; - GtkTreePath *path; - GSList *sorted_files; - GSList *tmp_list; - FileModelNode *tmp_child; - gint n_visible; + guint i; + int start, end; + gboolean changed; - sorted_files = sort_file_list (files); + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (column >= -1 && (guint) column < model->n_columns); - if (parent_node) + if (column > -1) { - iter.user_data = parent_node; - path = gtk_tree_model_get_path (tree_model, &iter); - children = parent_node->children; + start = column; + end = column + 1; } else { - path = gtk_tree_path_new (); - children = model->roots; - } - - /* Count the number of currently visible children, so that - * can catch when we need to insert a dummy node. - */ - n_visible = 0; - for (tmp_child = children; tmp_child; tmp_child = tmp_child->next) - { - if (tmp_child->is_visible) - n_visible++; - } - - gtk_tree_path_down (path); - - if (parent_node && parent_node->has_dummy) - { - prev = children; - children = children->next; - gtk_tree_path_next (path); + start = 0; + end = model->n_columns; } - for (tmp_list = sorted_files; tmp_list; tmp_list = tmp_list->next) + for (i = 0; i < model->files->len; i++) { - GFile *file = tmp_list->data; - - while (children && - (!children->file || !g_file_equal (children->file, file))) - { - prev = children; - if (children->is_visible) - gtk_tree_path_next (path); - - children = children->next; - } - - if (children && - children->file && g_file_equal (children->file, file)) - { - FileModelNode *next = children->next; - - if (children->is_visible) - n_visible--; - - if (parent_node && n_visible == 0) - { - FileModelNode *dummy = file_model_node_new (model, NULL); - dummy->is_visible = TRUE; - dummy->parent = parent_node; - dummy->is_dummy = TRUE; - - parent_node->children = dummy; - parent_node->has_dummy = TRUE; - - iter.user_data = dummy; - gtk_tree_model_row_inserted (tree_model, path, &iter); - gtk_tree_path_next (path); + FileModelNode *node = get_node (model, i); + changed = FALSE; + for (column = start; column < end; column++) + { + if (!G_VALUE_TYPE (&node->values[column])) + continue; + + g_value_unset (&node->values[column]); + changed = TRUE; + } - prev = dummy; - } - - if (prev) - prev->next = next; - else if (parent_node) - parent_node->children = next; - else - model->roots = next; - - if (parent_node && children->ref_count) - file_model_node_child_unref (parent_node); - - if (children->is_visible) - gtk_tree_model_row_deleted (tree_model, path); - - file_model_node_free (children); - - children = next; - } - else - { - /* Shouldn't happen */ - } + if (changed && node->visible) + emit_row_changed_for_node (model, i); } - gtk_tree_path_free (path); - g_slist_free (sorted_files); -} - -static void -deleted_callback (GFile *folder, - FileModelNode *node) -{ -} - -static void -files_added_callback (GFile *folder, - GSList *files, - FileModelNode *node) -{ - do_files_added (node->model, node, files); -} - -static void -files_changed_callback (GFile *folder, - GSList *files, - FileModelNode *node) -{ - do_files_changed (node->model, node, files); -} - -static void -files_removed_callback (GFile *folder, - GSList *files, - FileModelNode *node) -{ - do_files_removed (node->model, node, files); -} - -static void -root_deleted_callback (GFile *folder, - GtkFileSystemModel *model) -{ -} - -static void -root_files_added_callback (GFile *folder, - GSList *files, - GtkFileSystemModel *model) -{ - do_files_added (model, NULL, files); -} - -static void -root_files_changed_callback (GFile *folder, - GSList *files, - GtkFileSystemModel *model) -{ - do_files_changed (model, NULL, files); + /* FIXME: resort? */ } -static void -root_files_removed_callback (GFile *folder, - GSList *files, - GtkFileSystemModel *model) +/** + * _gtk_file_system_model_add_and_query_file: + * @model: a #GtkFileSystemModel + * @file: the file to add + * @attributes: attributes to query before adding the file + * + * This is a conenience function that calls g_file_query_info_async() on + * the given file, and when successful, adds it to the model. + * Upon failure, the @file is discarded. + **/ +void +_gtk_file_system_model_add_and_query_file (GtkFileSystemModel *model, + GFile * file, + const char * attributes) { - do_files_removed (model, NULL, files); + g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model)); + g_return_if_fail (G_IS_FILE (file)); + g_return_if_fail (attributes != NULL); + + g_file_query_info_async (file, + attributes, + G_FILE_QUERY_INFO_NONE, + IO_PRIORITY, + model->cancellable, + gtk_file_system_model_query_done, + model); }