X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkfilesystemmodel.c;h=132902b31788851b2fecc1b75ac822a8f26b2085;hb=1865b9a1116d166c9abc5c75f5d01270574007c5;hp=ef3df19ece2b2451b0c71d2d85a75f0cd28acc7b;hpb=18b56b997089595df4c602d8d045a291d69a7ff8;p=~andy%2Fgtk
diff --git a/gtk/gtkfilesystemmodel.c b/gtk/gtkfilesystemmodel.c
index ef3df19ec..132902b31 100644
--- a/gtk/gtkfilesystemmodel.c
+++ b/gtk/gtkfilesystemmodel.c
@@ -13,9 +13,7 @@
* 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 "config.h"
@@ -25,12 +23,99 @@
#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 ***/
@@ -50,9 +135,12 @@ struct _FileModelNode
GFile * file; /* file represented by this node or NULL for editable */
GFileInfo * info; /* info for this file or NULL if unknown */
- guint index; /* if valid, index in path - aka visible nodes before this one */
+ 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 */
@@ -64,21 +152,26 @@ struct _GtkFileSystemModel
GFile * dir; /* directory that's displayed */
guint dir_thaw_source;/* GSource id for unfreezing the model */
- char * attributes; /* attributes the file info must contain */
- GFileMonitor * dir_monitor; /* directory that is monitored */
+ 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 */
- guint n_indexes_valid;/* count of valid indexes */
- GHashTable * file_lookup; /* file => array index table */
+ 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 */
- GtkFileSystemModelFilter filter_func; /* filter to use for deciding which nodes are visible */
- gpointer filter_data; /* data to pass to filter_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 */
@@ -95,6 +188,7 @@ struct _GtkFileSystemModel
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))
@@ -110,6 +204,18 @@ struct _GtkFileSystemModelClass
void (*finished_loading) (GtkFileSystemModel *model, GError *error);
};
+static void freeze_updates (GtkFileSystemModel *model);
+static void thaw_updates (GtkFileSystemModel *model);
+
+static guint node_get_for_file (GtkFileSystemModel *model,
+ GFile *file);
+
+static void add_file (GtkFileSystemModel *model,
+ GFile *file,
+ GFileInfo *info);
+static void remove_file (GtkFileSystemModel *model,
+ GFile *file);
+
/* iter setup:
* @user_data: the model
* @user_data2: GUINT_TO_POINTER of array index of current entry
@@ -127,66 +233,121 @@ struct _GtkFileSystemModelClass
/*** FileModelNode ***/
-#define NODE_SIZE(_model) (sizeof (FileModelNode) + sizeof (GValue) * (MAX ((_model)->n_columns, 1) - 1))
-#define get_node(_model, _index) ((FileModelNode *) (((guint8 *) (_model)->files->data) + (_index) * NODE_SIZE (_model)))
-#define node_index(_model, _node) (((guint8 *) (_node) - (guint8 *) (_model)->files->data) / NODE_SIZE (_model))
+/* 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
-node_validate_indexes (GtkFileSystemModel *model, guint min_index, guint min_visible)
+node_validate_rows (GtkFileSystemModel *model, guint up_to_index, guint up_to_row)
{
- guint validate, current;
+ guint i, row;
if (model->files->len == 0)
return;
- min_index = MIN (min_index, model->files->len - 1);
- validate = model->n_indexes_valid;
- if (validate)
- current = get_node (model, validate - 1)->index;
+
+ 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
- current = 0;
- while (validate <= min_index && current <= min_visible)
+ row = 0;
+
+ while (i <= up_to_index && row <= up_to_row)
{
- FileModelNode *node = get_node (model, validate);
+ FileModelNode *node = get_node (model, i);
if (node->visible)
- current++;
- node->index = current;
- validate++;
+ row++;
+ node->row = row;
+ i++;
}
- model->n_indexes_valid = validate;
+ model->n_nodes_valid = i;
}
static guint
-node_get_index (GtkFileSystemModel *model, guint id)
+node_get_tree_row (GtkFileSystemModel *model, guint index)
{
- if (model->n_indexes_valid <= id)
- node_validate_indexes (model, id, G_MAXUINT);
+ if (model->n_nodes_valid <= index)
+ node_validate_rows (model, index, G_MAXUINT);
- return get_node (model, id)->index - 1;
+ return get_node (model, index)->row - 1;
}
static void
node_invalidate_index (GtkFileSystemModel *model, guint id)
{
- model->n_indexes_valid = MIN (model->n_indexes_valid, id);
+ model->n_nodes_valid = MIN (model->n_nodes_valid, id);
}
static GtkTreePath *
-gtk_tree_path_new_from_node (GtkFileSystemModel *model, guint id)
+tree_path_new_from_node (GtkFileSystemModel *model, guint id)
{
- guint i = node_get_index (model, id);
+ guint r = node_get_tree_row (model, id);
- g_assert (i < model->files->len);
+ g_assert (r < model->files->len);
- return gtk_tree_path_new_from_indices (i, -1);
+ return gtk_tree_path_new_from_indices (r, -1);
}
static void
-node_set_visible (GtkFileSystemModel *model, guint id, gboolean visible)
+emit_row_inserted_for_node (GtkFileSystemModel *model, guint id)
{
- FileModelNode *node = get_node (model, id);
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
+emit_row_changed_for_node (GtkFileSystemModel *model, guint id)
+{
+ 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
+emit_row_deleted_for_row (GtkFileSystemModel *model, guint row)
+{
+ GtkTreePath *path;
+
+ path = gtk_tree_path_new_from_indices (row, -1);
+ gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+ gtk_tree_path_free (path);
+}
+
+static void
+node_set_visible_and_filtered_out (GtkFileSystemModel *model, guint id, gboolean visible, gboolean filtered_out)
+{
+ FileModelNode *node = get_node (model, id);
+
+ /* Filteredness */
+
+ if (node->filtered_out != filtered_out)
+ {
+ node->filtered_out = filtered_out;
+ if (node->visible && visible)
+ emit_row_changed_for_node (model, id);
+ }
+
+ /* Visibility */
+
if (node->visible == visible ||
node->frozen_add)
return;
@@ -195,26 +356,92 @@ node_set_visible (GtkFileSystemModel *model, guint id, gboolean visible)
{
node->visible = TRUE;
node_invalidate_index (model, id);
- path = gtk_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);
+ emit_row_inserted_for_node (model, id);
}
else
{
- path = gtk_tree_path_new_from_node (model, id);
+ guint row;
+
+ row = node_get_tree_row (model, id);
+ g_assert (row < model->files->len);
+
node->visible = FALSE;
node_invalidate_index (model, id);
- gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
- gtk_tree_path_free (path);
+ 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;
+
+ 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)
+node_should_be_visible (GtkFileSystemModel *model, guint id, gboolean filtered_out)
{
FileModelNode *node = get_node (model, id);
- gboolean is_folder;
+ gboolean result;
if (node->info == NULL)
return FALSE;
@@ -223,19 +450,35 @@ node_should_be_visible (GtkFileSystemModel *model, guint id)
(g_file_info_get_is_hidden (node->info) || g_file_info_get_is_backup (node->info)))
return FALSE;
- is_folder = _gtk_file_info_consider_as_directory (node->info);
-
- /* wtf? */
- if (model->show_folders != model->show_files &&
- model->show_folders != is_folder)
- return FALSE;
+ if (_gtk_file_info_consider_as_directory (node->info))
+ {
+ if (!model->show_folders)
+ return FALSE;
+ if (!model->filter_folders)
+ return TRUE;
+ }
+ else
+ {
+ if (!model->show_files)
+ return FALSE;
+ }
- if (model->filter_func &&
- !model->filter_func (model, node->file, node->info, model->filter_data))
- return FALSE;
+ result = !filtered_out;
- return TRUE;
+ return result;
+}
+
+static void
+node_compute_visibility_and_filters (GtkFileSystemModel *model, guint id)
+{
+ 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 ***/
@@ -271,7 +514,7 @@ compare_indices (gconstpointer key, gconstpointer _node)
{
const FileModelNode *node = _node;
- return GPOINTER_TO_UINT (key) - node->index;
+ return GPOINTER_TO_UINT (key) - node->row;
}
static gboolean
@@ -282,36 +525,46 @@ gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model,
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
char *node;
- guint id, find;
+ guint id;
+ guint row_to_find;
g_return_val_if_fail (n >= 0, FALSE);
if (parent != NULL)
return FALSE;
- find = n + 1;
+ 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_indexes_valid > 0 &&
- get_node (model, model->n_indexes_valid - 1)->index >= find)
+ if (model->n_nodes_valid > 0 &&
+ get_node (model, model->n_nodes_valid - 1)->row >= row_to_find)
{
- /* fast path */
- node = bsearch (GUINT_TO_POINTER (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_indexes_valid,
- NODE_SIZE (model),
+ 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
{
- node_validate_indexes (model, G_MAXUINT, n);
- id = model->n_indexes_valid - 1;
- if (model->n_indexes_valid == 0 || get_node (model, id)->index != find)
+ /* 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;
}
@@ -326,6 +579,9 @@ gtk_file_system_model_get_iter (GtkTreeModel *tree_model,
{
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,
@@ -340,7 +596,7 @@ gtk_file_system_model_get_path (GtkTreeModel *tree_model,
g_return_val_if_fail (ITER_IS_VALID (model, iter), NULL);
- return gtk_tree_path_new_from_node (model, ITER_INDEX (iter));
+ return tree_path_new_from_node (model, ITER_INDEX (iter));
}
static void
@@ -412,7 +668,7 @@ gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model,
if (iter)
return 0;
- return node_get_index (model, model->files->len - 1) + 1;
+ return node_get_tree_row (model, model->files->len - 1) + 1;
}
static gboolean
@@ -427,14 +683,14 @@ static void
gtk_file_system_model_ref_node (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
- /* FIXME: implement */
+ /* nothing to do */
}
static void
gtk_file_system_model_unref_node (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
- /* FIXME: implement */
+ /* nothing to do */
}
static void
@@ -524,38 +780,39 @@ gtk_file_system_model_sort (GtkFileSystemModel *model)
if (sort_data_init (&data, model))
{
GtkTreePath *path;
- guint i, j, n_elements;
+ guint i;
+ guint r, n_visible_rows;
- node_validate_indexes (model, G_MAXUINT, G_MAXUINT);
- n_elements = node_get_index (model, model->files->len - 1) + 1;
- model->n_indexes_valid = 0;
+ 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),
+ g_qsort_with_data (get_node (model, 1), /* start at index 1; don't sort the editable row */
model->files->len - 1,
- NODE_SIZE (model),
+ model->node_size,
compare_array_element,
&data);
- g_assert (model->n_indexes_valid == 0);
+ g_assert (model->n_nodes_valid == 0);
g_assert (g_hash_table_size (model->file_lookup) == 0);
- if (n_elements)
+ if (n_visible_rows)
{
- int *new_order = g_new (int, n_elements);
+ int *new_order = g_new (int, n_visible_rows);
- j = 0;
+ r = 0;
for (i = 0; i < model->files->len; i++)
{
FileModelNode *node = get_node (model, i);
if (!node->visible)
{
- node->index = j;
+ node->row = r;
continue;
}
- new_order[j] = node->index;
- j++;
- node->index = j;
+ new_order[r] = node->row - 1;
+ r++;
+ node->row = r;
}
- g_assert (j == n_elements);
+ g_assert (r == n_visible_rows);
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
path,
@@ -766,6 +1023,12 @@ gtk_file_system_model_dispose (GObject *object)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
+ if (model->dir_thaw_source)
+ {
+ g_source_remove (model->dir_thaw_source);
+ model->dir_thaw_source = 0;
+ }
+
g_cancellable_cancel (model->cancellable);
if (model->dir_monitor)
g_file_monitor_cancel (model->dir_monitor);
@@ -782,11 +1045,17 @@ gtk_file_system_model_finalize (GObject *object)
for (i = 0; i < model->files->len; i++)
{
+ 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);
@@ -797,6 +1066,10 @@ gtk_file_system_model_finalize (GObject *object)
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);
+
+ g_slice_free1 (sizeof (GType) * model->n_columns, model->column_types);
_gtk_tree_data_list_header_free (model->sort_list);
if (model->default_sort_destroy)
@@ -829,6 +1102,7 @@ _gtk_file_system_model_init (GtkFileSystemModel *model)
model->show_files = TRUE;
model->show_folders = TRUE;
model->show_hidden = FALSE;
+ model->filter_folders = FALSE;
model->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
@@ -849,7 +1123,7 @@ thaw_func (gpointer data)
{
GtkFileSystemModel *model = data;
- _gtk_file_system_model_thaw_updates (model);
+ thaw_updates (model);
model->dir_thaw_source = 0;
return FALSE;
@@ -871,7 +1145,7 @@ gtk_file_system_model_got_files (GObject *object, GAsyncResult *res, gpointer da
{
if (model->dir_thaw_source == 0)
{
- _gtk_file_system_model_freeze_updates (model);
+ freeze_updates (model);
model->dir_thaw_source = gdk_threads_add_timeout_full (IO_PRIORITY + 1,
50,
thaw_func,
@@ -894,41 +1168,41 @@ gtk_file_system_model_got_files (GObject *object, GAsyncResult *res, gpointer da
continue;
}
file = g_file_get_child (model->dir, name);
- _gtk_file_system_model_add_file (model, file, info);
+ add_file (model, file, info);
g_object_unref (file);
g_object_unref (info);
}
g_list_free (files);
- }
- if (files == NULL)
+ 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
{
- g_file_enumerator_close_async (enumerator,
- IO_PRIORITY,
- model->cancellable,
- gtk_file_system_model_closed_enumerator,
- NULL);
- if (error)
- g_error_free (error);
- else
- g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, NULL);
-
- if (model->dir_thaw_source != 0)
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
- g_source_remove (model->dir_thaw_source);
- model->dir_thaw_source = 0;
- _gtk_file_system_model_thaw_updates (model);
+ 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);
}
- g_object_unref (model);
+ if (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);
gdk_threads_leave ();
}
@@ -941,12 +1215,20 @@ gtk_file_system_model_query_done (GObject * object,
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;
- _gtk_file_system_model_update_file (model, file, info, TRUE);
+ 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
@@ -964,14 +1246,16 @@ gtk_file_system_model_monitor_change (GFileMonitor * monitor,
/* We can treat all of these the same way */
g_file_query_info_async (file,
model->attributes,
- 0,
+ G_FILE_QUERY_INFO_NONE,
IO_PRIORITY,
model->cancellable,
gtk_file_system_model_query_done,
model);
break;
case G_FILE_MONITOR_EVENT_DELETED:
- _gtk_file_system_model_remove_file (model, file);
+ 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? */
@@ -995,9 +1279,11 @@ gtk_file_system_model_got_enumerator (GObject *dir, GAsyncResult *res, gpointer
enumerator = g_file_enumerate_children_finish (G_FILE (dir), res, &error);
if (enumerator == NULL)
{
- g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, error);
- g_object_unref (model);
- g_error_free (error);
+ 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
{
@@ -1009,9 +1295,9 @@ gtk_file_system_model_got_enumerator (GObject *dir, GAsyncResult *res, gpointer
model);
g_object_unref (enumerator);
model->dir_monitor = g_file_monitor_directory (model->dir,
- 0,
+ G_FILE_MONITOR_NONE,
model->cancellable,
- NULL);
+ 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",
@@ -1030,17 +1316,20 @@ gtk_file_system_model_set_n_columns (GtkFileSystemModel *model,
guint i;
g_assert (model->files == NULL);
+ g_assert (n_columns > 0);
model->n_columns = n_columns;
- model->column_types = g_slice_alloc0 (sizeof (GType) * 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_warning ("%s: Invalid type %s\n", G_STRLOC, g_type_name (type));
- continue;
+ 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;
@@ -1048,10 +1337,10 @@ gtk_file_system_model_set_n_columns (GtkFileSystemModel *model,
model->sort_list = _gtk_tree_data_list_header_new (n_columns, model->column_types);
- model->files = g_array_new (FALSE, FALSE, NODE_SIZE (model));
+ 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, NODE_SIZE (model));
+ memset (get_node (model, 0), 0, model->node_size);
}
static void
@@ -1059,16 +1348,14 @@ gtk_file_system_model_set_directory (GtkFileSystemModel *model,
GFile * dir,
const gchar * attributes)
{
- g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
- g_return_if_fail (dir == NULL || G_IS_FILE (dir));
+ g_assert (G_IS_FILE (dir));
model->dir = g_object_ref (dir);
model->attributes = g_strdup (attributes);
- g_object_ref (model);
g_file_enumerate_children_async (model->dir,
attributes,
- 0,
+ G_FILE_QUERY_INFO_NONE,
IO_PRIORITY,
model->cancellable,
gtk_file_system_model_got_enumerator,
@@ -1076,39 +1363,90 @@ gtk_file_system_model_set_directory (GtkFileSystemModel *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: attributes to immediately load or %NULL for all
- * @error: location to store error, or %NULL.
+ * @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 @attributes immediately and only add
- * files with those attributes present.
+ * 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 object, or NULL if there
- * was an error.
+ * Return value: the newly created #GtkFileSystemModel
**/
GtkFileSystemModel *
-_gtk_file_system_model_new (GFile * dir,
- const gchar * attributes,
- GtkFileSystemModelGetValue get_func,
- gpointer get_data,
- guint n_columns,
- ...)
+_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);
-
- model = g_object_new (GTK_TYPE_FILE_SYSTEM_MODEL, NULL);
- model->get_func = get_func;
- model->get_data = get_data;
+ g_return_val_if_fail (get_func != NULL, NULL);
+ g_return_val_if_fail (n_columns > 0, NULL);
va_start (args, n_columns);
- gtk_file_system_model_set_n_columns (model, n_columns, args);
+ 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);
@@ -1127,16 +1465,14 @@ gtk_file_system_model_refilter_all (GtkFileSystemModel *model)
return;
}
- _gtk_file_system_model_freeze_updates (model);
+ freeze_updates (model);
/* start at index 1, don't change the editable */
for (i = 1; i < model->files->len; i++)
- {
- node_set_visible (model, i, node_should_be_visible (model, i));
- }
+ node_compute_visibility_and_filters (model, i);
model->filter_on_thaw = FALSE;
- _gtk_file_system_model_thaw_updates (model);
+ thaw_updates (model);
}
/**
@@ -1209,6 +1545,41 @@ _gtk_file_system_model_set_show_files (GtkFileSystemModel *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)
{
@@ -1217,6 +1588,58 @@ _gtk_file_system_model_get_cancellable (GtkFileSystemModel *model)
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
@@ -1241,6 +1664,7 @@ _gtk_file_system_model_get_info (GtkFileSystemModel *model,
FileModelNode *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));
@@ -1328,7 +1752,15 @@ node_get_for_file (GtkFileSystemModel *model,
if (i != 0)
return i;
- /* node 0 is the editable row and has no associated file or entry in the table */
+ /* 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++)
{
FileModelNode *node = get_node (model, i);
@@ -1341,6 +1773,20 @@ node_get_for_file (GtkFileSystemModel *model,
return 0;
}
+/**
+ * _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
+ **/
gboolean
_gtk_file_system_model_get_iter_for_file (GtkFileSystemModel *model,
GtkTreeIter *iter,
@@ -1361,8 +1807,35 @@ _gtk_file_system_model_get_iter_for_file (GtkFileSystemModel *model,
return TRUE;
}
+/* 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
+adjust_file_lookup (GtkFileSystemModel *model, guint id, int increment)
+{
+ GHashTableIter iter;
+ gpointer key;
+ gpointer value;
+
+ g_hash_table_iter_init (&iter, model->file_lookup);
+
+ while (g_hash_table_iter_next (&iter, &key, &value))
+ {
+ guint index = GPOINTER_TO_UINT (value);
+
+ if (index >= id)
+ {
+ index += increment;
+ g_hash_table_iter_replace (&iter, GUINT_TO_POINTER (index));
+ }
+ }
+}
+
/**
- * _gtk_file_system_model_add_file:
+ * add_file:
* @model: the model
* @file: the file to add
* @info: the information to associate with the file
@@ -1370,10 +1843,10 @@ _gtk_file_system_model_get_iter_for_file (GtkFileSystemModel *model,
* 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.
**/
-void
-_gtk_file_system_model_add_file (GtkFileSystemModel *model,
- GFile *file,
- GFileInfo *info)
+static void
+add_file (GtkFileSystemModel *model,
+ GFile *file,
+ GFileInfo *info)
{
FileModelNode *node;
@@ -1381,23 +1854,23 @@ _gtk_file_system_model_add_file (GtkFileSystemModel *model,
g_return_if_fail (G_IS_FILE (file));
g_return_if_fail (G_IS_FILE_INFO (info));
- node = g_slice_alloc0 (NODE_SIZE (model));
+ 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;
g_array_append_vals (model->files, node, 1);
- g_slice_free1 (NODE_SIZE (model), node);
+ g_slice_free1 (model->node_size, node);
if (!model->frozen)
- node_set_visible (model, model->files->len -1,
- node_should_be_visible (model, model->files->len - 1));
+ node_compute_visibility_and_filters (model, model->files->len -1);
+
gtk_file_system_model_sort_node (model, model->files->len -1);
}
/**
- * _gtk_file_system_model_remove_file:
+ * remove_file:
* @model: the model
* @file: file to remove from the model. The file must have been
* added to the model previously
@@ -1405,12 +1878,13 @@ _gtk_file_system_model_add_file (GtkFileSystemModel *model,
* Removes the given file from the model. If the file is not part of
* @model, this function does nothing.
**/
-void
-_gtk_file_system_model_remove_file (GtkFileSystemModel *model,
- GFile *file)
+static void
+remove_file (GtkFileSystemModel *model,
+ GFile *file)
{
FileModelNode *node;
guint id;
+ guint row;
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
g_return_if_fail (G_IS_FILE (file));
@@ -1420,11 +1894,22 @@ _gtk_file_system_model_remove_file (GtkFileSystemModel *model,
return;
node = get_node (model, id);
- node_set_visible (model, id, FALSE);
+ row = node_get_tree_row (model, id);
+
+ node_invalidate_index (model, id);
+
+ g_hash_table_remove (model->file_lookup, file);
g_object_unref (node->file);
+ adjust_file_lookup (model, id, -1);
+
if (node->info)
g_object_unref (node->info);
+
g_array_remove_index (model->files, id);
+
+ /* We don't need to resort, as removing a row doesn't change the sorting order of the other rows */
+
+ emit_row_deleted_for_row (model, row);
}
/**
@@ -1432,7 +1917,6 @@ _gtk_file_system_model_remove_file (GtkFileSystemModel *model,
* @model: the model
* @file: the file
* @info: the new file info
- * @requires_resort: FIXME: get rid of this argument
*
* 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
@@ -1441,11 +1925,11 @@ _gtk_file_system_model_remove_file (GtkFileSystemModel *model,
void
_gtk_file_system_model_update_file (GtkFileSystemModel *model,
GFile *file,
- GFileInfo *info,
- gboolean requires_resort)
+ GFileInfo *info)
{
FileModelNode *node;
guint i, id;
+ GFileInfo *old_info;
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
g_return_if_fail (G_IS_FILE (file));
@@ -1453,12 +1937,18 @@ _gtk_file_system_model_update_file (GtkFileSystemModel *model,
id = node_get_for_file (model, file);
if (id == 0)
- _gtk_file_system_model_add_file (model, file, info);
+ {
+ add_file (model, file, info);
+ id = node_get_for_file (model, file);
+ }
node = get_node (model, id);
- if (node->info)
- g_object_unref (node->info);
+
+ old_info = node->info;
node->info = g_object_ref (info);
+ if (old_info)
+ g_object_unref (old_info);
+
for (i = 0; i < model->n_columns; i++)
{
if (G_VALUE_TYPE (&node->values[i]))
@@ -1466,39 +1956,35 @@ _gtk_file_system_model_update_file (GtkFileSystemModel *model,
}
if (node->visible)
- {
- GtkTreePath *path;
- GtkTreeIter iter;
-
- path = gtk_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);
- }
-
- if (requires_resort)
- gtk_file_system_model_sort_node (model, id);
+ emit_row_changed_for_node (model, id);
}
/**
* _gtk_file_system_model_set_filter:
* @mode: a #GtkFileSystemModel
- * @filter: function to be called for each file
- * @user_data: data to pass to @filter
+ * @filter: (allow-none): %NULL or filter to use
*
- * 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.
+ * 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,
- GtkFileSystemModelFilter filter,
- gpointer user_data)
+ GtkFileFilter * filter)
{
+ GtkFileFilter *old_filter;
+
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
+ g_return_if_fail (filter == NULL || GTK_IS_FILE_FILTER (filter));
- model->filter_func = filter;
- model->filter_data = user_data;
+ if (filter)
+ g_object_ref (filter);
+
+ old_filter = model->filter;
+ model->filter = filter;
+
+ if (old_filter)
+ g_object_unref (old_filter);
gtk_file_system_model_refilter_all (model);
}
@@ -1519,7 +2005,7 @@ _gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *ite
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
g_return_if_fail (!get_node (model, 0)->visible);
- node_set_visible (model, 0, TRUE);
+ node_set_visible_and_filtered_out (model, 0, TRUE, FALSE);
ITER_INIT_FROM_INDEX (model, iter, 0);
}
@@ -1537,21 +2023,20 @@ _gtk_file_system_model_remove_editable (GtkFileSystemModel *model)
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
g_return_if_fail (get_node (model, 0)->visible);
- node_set_visible (model, 0, FALSE);
+ node_set_visible_and_filtered_out (model, 0, FALSE, FALSE);
}
/**
- * _gtk_file_system_model_freeze_updates:
+ * 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 _gtk_file_system_model_thaw_updates() to resume proper
- * operations. It is fine to call this function multiple times as
- * long as freeze and thaw calls are balanced.
+ * 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.
**/
-void
-_gtk_file_system_model_freeze_updates (GtkFileSystemModel *model)
+static void
+freeze_updates (GtkFileSystemModel *model)
{
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
@@ -1559,14 +2044,13 @@ _gtk_file_system_model_freeze_updates (GtkFileSystemModel *model)
}
/**
- * _gtk_file_system_model_thaw_updates:
+ * thaw_updates:
* @model: a #GtkFileSystemModel
*
- * Undoes the effect of a previous call to
- * _gtk_file_system_model_freeze_updates()
+ * Undoes the effect of a previous call to freeze_updates()
**/
-void
-_gtk_file_system_model_thaw_updates (GtkFileSystemModel *model)
+static void
+thaw_updates (GtkFileSystemModel *model)
{
gboolean stuff_added;
@@ -1594,13 +2078,13 @@ _gtk_file_system_model_thaw_updates (GtkFileSystemModel *model)
if (!node->frozen_add)
continue;
node->frozen_add = FALSE;
- node_set_visible (model, i, node_should_be_visible (model, i));
+ node_compute_visibility_and_filters (model, i);
}
}
}
/**
- * _gtk_file_system_model_clear_cached_values:
+ * _gtk_file_system_model_clear_cache:
* @model: a #GtkFileSystemModel
* @column: the column to clear or -1 for all columns
*
@@ -1621,7 +2105,7 @@ _gtk_file_system_model_clear_cache (GtkFileSystemModel *model,
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
g_return_if_fail (column >= -1 && (guint) column < model->n_columns);
- if (column)
+ if (column > -1)
{
start = column;
end = column + 1;
@@ -1646,17 +2130,36 @@ _gtk_file_system_model_clear_cache (GtkFileSystemModel *model,
}
if (changed && node->visible)
- {
- GtkTreePath *path;
- GtkTreeIter iter;
-
- path = gtk_tree_path_new_from_node (model, i);
- ITER_INIT_FROM_INDEX (model, &iter, i);
- gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter);
- gtk_tree_path_free (path);
- }
+ emit_row_changed_for_node (model, i);
}
/* FIXME: resort? */
}
+/**
+ * _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)
+{
+ 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);
+}