[gtk+/filesystemmodel: 3/28] optimize GtkFileSystemModel: step 1
- From: Benjamin Otte <otte src gnome org>
- To: svn-commits-list gnome org
- Subject: [gtk+/filesystemmodel: 3/28] optimize GtkFileSystemModel: step 1
- Date: Tue, 23 Jun 2009 16:17:06 -0400 (EDT)
commit d460aa7d5a02a48d3981032ad6ca1da148ed1537
Author: Benjamin Otte <otte gnome org>
Date: Wed Jun 17 17:36:31 2009 +0200
optimize GtkFileSystemModel: step 1
This is the first iteration of improving GtkFileSystemModel. The way I
imagine it working is implemented. Changes:
- the model does no longer support a tree, just a list of files in a
given directory
- the storage has been moved to a GArray as opposed to a tree
- no more dependency on GtkFileSystem
- the API supports 2-step loading, so that slow content sniffing can
happen later
Missing features include:
- implementing GtkSortable
- 2-step-loading
- monitoring not implemented
gtk/gtkfilechooserdefault.c | 82 +--
gtk/gtkfilesystemmodel.c | 1360 ++++++++++++++++++++++---------------------
gtk/gtkfilesystemmodel.h | 21 +-
3 files changed, 727 insertions(+), 736 deletions(-)
---
diff --git a/gtk/gtkfilechooserdefault.c b/gtk/gtkfilechooserdefault.c
index 34dc8b3..6ee285d 100644
--- a/gtk/gtkfilechooserdefault.c
+++ b/gtk/gtkfilechooserdefault.c
@@ -376,11 +376,6 @@ static void list_row_activated (GtkTreeView *tree_view,
GtkTreeViewColumn *column,
GtkFileChooserDefault *impl);
-static void select_func (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data);
-
static void path_bar_clicked (GtkPathBar *path_bar,
GFile *file,
GFile *child,
@@ -6615,11 +6610,17 @@ show_and_select_files_finished_loading (GtkFolder *folder,
for (l = data->files; l; l = l->next)
{
- GFile *file;
+ GtkTreeSelection *selection;
+ GtkTreeIter iter, sorted_iter;
- file = l->data;
- _gtk_file_system_model_path_do (data->impl->browse_files_model, file,
- select_func, data->impl);
+ if (!_gtk_file_system_model_get_iter_for_file (data->impl->browse_files_model,
+ &iter,
+ l->data))
+ continue;
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->impl->browse_files_tree_view));
+
+ gtk_tree_model_sort_convert_child_iter_to_iter (data->impl->sort_model, &sorted_iter, &iter);
+ gtk_tree_selection_select_iter (selection, &sorted_iter);
}
browse_files_center_selected_row (data->impl);
@@ -6734,6 +6735,7 @@ pending_select_files_process (GtkFileChooserDefault *impl)
/* Callback used when the file system model finishes loading */
static void
browse_files_model_finished_loading_cb (GtkFileSystemModel *model,
+ GError * error,
GtkFileChooserDefault *impl)
{
profile_start ("start", NULL);
@@ -6803,17 +6805,10 @@ set_list_model (GtkFileChooserDefault *impl,
set_busy_cursor (impl, TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (impl->browse_files_tree_view), NULL);
- impl->browse_files_model = _gtk_file_system_model_new (impl->file_system,
- impl->current_folder, 0,
- "standard,time,thumbnail::*",
- error);
- if (!impl->browse_files_model)
- {
- set_busy_cursor (impl, FALSE);
- profile_end ("end", NULL);
- return FALSE;
- }
-
+ impl->browse_files_model = _gtk_file_system_model_new (impl->current_folder,
+ "standard::name,standard::type,standard::display-name,"
+ "standard::is-hidden,standard::is-backup",
+ "standard,time,thumbnail");
load_setup_timer (impl); /* This changes the state to LOAD_PRELOAD */
g_signal_connect (impl->browse_files_model, "finished-loading",
@@ -7319,22 +7314,6 @@ gtk_file_chooser_default_set_current_name (GtkFileChooser *chooser,
_gtk_file_chooser_entry_set_file_part (GTK_FILE_CHOOSER_ENTRY (impl->location_entry), name);
}
-static void
-select_func (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeSelection *selection;
- GtkTreeIter sorted_iter;
-
- selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (impl->browse_files_tree_view));
-
- gtk_tree_model_sort_convert_child_iter_to_iter (impl->sort_model, &sorted_iter, iter);
- gtk_tree_selection_select_iter (selection, &sorted_iter);
-}
-
static gboolean
gtk_file_chooser_default_select_file (GtkFileChooser *chooser,
GFile *file,
@@ -7391,33 +7370,26 @@ gtk_file_chooser_default_select_file (GtkFileChooser *chooser,
}
static void
-unselect_func (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data)
-{
- GtkFileChooserDefault *impl = user_data;
- GtkTreeView *tree_view = GTK_TREE_VIEW (impl->browse_files_tree_view);
- GtkTreePath *sorted_path;
-
- sorted_path = gtk_tree_model_sort_convert_child_path_to_path (impl->sort_model,
- path);
- gtk_tree_selection_unselect_path (gtk_tree_view_get_selection (tree_view),
- sorted_path);
- gtk_tree_path_free (sorted_path);
-}
-
-static void
gtk_file_chooser_default_unselect_file (GtkFileChooser *chooser,
GFile *file)
{
GtkFileChooserDefault *impl = GTK_FILE_CHOOSER_DEFAULT (chooser);
+ GtkTreeView *tree_view = GTK_TREE_VIEW (impl->browse_files_tree_view);
+ GtkTreeIter iter, sorted_iter;
if (!impl->browse_files_model)
return;
- _gtk_file_system_model_path_do (impl->browse_files_model, file,
- unselect_func, impl);
+ if (!_gtk_file_system_model_get_iter_for_file (impl->browse_files_model,
+ &iter,
+ file))
+ return;
+
+ gtk_tree_model_sort_convert_child_iter_to_iter (impl->sort_model,
+ &sorted_iter,
+ &iter);
+ gtk_tree_selection_unselect_iter (gtk_tree_view_get_selection (tree_view),
+ &sorted_iter);
}
static gboolean
diff --git a/gtk/gtkfilesystemmodel.c b/gtk/gtkfilesystemmodel.c
index 8ab5fed..c947dc1 100644
--- a/gtk/gtkfilesystemmodel.c
+++ b/gtk/gtkfilesystemmodel.c
@@ -19,73 +19,60 @@
*/
#include "config.h"
-#include <string.h>
-#include "gtkfilechooserprivate.h"
#include "gtkfilesystemmodel.h"
-#include "gtkfilesystem.h"
+
+#include <stdlib.h>
+#include <string.h>
+
#include "gtkintl.h"
#include "gtkmarshalers.h"
#include "gtktreednd.h"
#include "gtktreemodel.h"
#include "gtkalias.h"
-typedef struct _GtkFileSystemModelClass GtkFileSystemModelClass;
-typedef struct _FileModelNode FileModelNode;
+/*** DEFINES ***/
-struct _GtkFileSystemModel
-{
- GObject parent_instance;
-
- GtkFileSystem *file_system;
- gchar *attributes;
- FileModelNode *roots;
- GtkFolder *root_folder;
- GFile *root_file;
+/* 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
- GtkFileSystemModelFilter filter_func;
- gpointer filter_data;
+/* random number that everyone else seems to use, too */
+#define FILES_PER_QUERY 100
- GSList *idle_clears;
- GSource *idle_clear_source;
+typedef struct _FileModelNode FileModelNode;
+typedef struct _GtkFileSystemModelClass GtkFileSystemModelClass;
- gushort max_depth;
+struct _FileModelNode
+{
+ GFile * file; /* file represented by this node or NULL for editable */
+ GFileInfo * info; /* info for this file or NULL if unknown */
- GSList *pending_cancellables;
+ guint index; /* index in path - aka visible nodes before this one */
- guint show_hidden : 1;
- guint show_folders : 1;
- guint show_files : 1;
- guint folders_only : 1;
- guint has_editable : 1;
+ guint visible :1; /* if the file is currently visible */
};
-struct _FileModelNode
+struct _GtkFileSystemModel
{
- GFile *file;
- FileModelNode *next;
+ GObject parent_instance;
- GFileInfo *info;
- GtkFolder *folder;
+ GFile * dir; /* directory that's displayed */
+ char * attributes; /* attributes the file info must contain */
+ char * full_attributes;/* attributes the file info should contain */
- FileModelNode *children;
- FileModelNode *parent;
- GtkFileSystemModel *model;
+ GCancellable * cancellable; /* cancellable in use for all operations - cancelled on dispose */
+ GArray * files; /* array of FileModelNode containing all our files */
- guint ref_count;
- guint n_referenced_children;
+ GtkFileSystemModelFilter filter_func; /* filter to use for deciding which nodes are visible */
+ gpointer filter_data; /* data to pass to filter_func */
- gushort depth;
-
- guint has_dummy : 1;
- guint is_dummy : 1;
- guint is_visible : 1;
- guint loaded : 1;
- guint idle_clear : 1;
- guint load_pending : 1;
+ 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 */
};
-
#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))
@@ -96,230 +83,104 @@ struct _GtkFileSystemModelClass
/* Signals */
- void (*finished_loading) (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);
-
-/* Signal IDs */
-enum {
- FINISHED_LOADING,
- LAST_SIGNAL
+ void (*finished_loading) (GtkFileSystemModel *model, GError *error);
};
-static guint file_system_model_signals[LAST_SIGNAL] = { 0 };
-
-
-
-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))
-
-static void
-_gtk_file_system_model_class_init (GtkFileSystemModelClass *class)
-{
- GObjectClass *gobject_class = G_OBJECT_CLASS (class);
-
- gobject_class->finalize = gtk_file_system_model_finalize;
- gobject_class->dispose = gtk_file_system_model_dispose;
-
- 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);
-}
+/* 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
-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;
-}
+/*** FileModelNode ***/
-static void
-_gtk_file_system_model_init (GtkFileSystemModel *model)
-{
- model->show_files = TRUE;
- model->show_folders = TRUE;
- model->show_hidden = FALSE;
-}
+#define get_node(_model, _index) (&g_array_index ((_model)->files, FileModelNode, (_index)))
+#define gtk_tree_path_new_from_node(_model, _index) gtk_tree_path_new_from_indices (get_node ((_model), (_index))->index, -1)
static void
-gtk_file_system_model_finalize (GObject *object)
+node_set_visible (GtkFileSystemModel *model, guint id, gboolean visible)
{
- GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
- FileModelNode *children, *next;
-
- if (model->root_folder)
- g_object_unref (model->root_folder);
-
- if (model->root_file)
- g_object_unref (model->root_file);
+ FileModelNode *node = get_node (model, id);
+ GtkTreePath *path;
+ GtkTreeIter iter;
+ guint i;
- if (model->file_system)
- g_object_unref (model->file_system);
+ if (node->visible == visible)
+ return;
- children = model->roots;
- while (children)
+ node->visible = visible;
+ if (visible)
{
- next = children->next;
- file_model_node_free (children);
- children = next;
+ for (i = id; i < model->files->len; i++)
+ get_node (model, i)->index++;
+ 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);
+ }
+ else
+ {
+ path = gtk_tree_path_new_from_node (model, id);
+ for (i = id; i < model->files->len; i++)
+ get_node (model, i)->index--;
+ gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
+ gtk_tree_path_free (path);
}
- g_free (model->attributes);
-
- G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object);
+ id = -1;
+ for (i = 0; i < model->files->len; i++)
+ {
+ node = get_node (model, i);
+ if (node->visible)
+ id++;
+ g_assert (node->index == id);
+ }
}
-
-static void
-gtk_file_system_model_dispose (GObject *object)
+static gboolean
+node_should_be_visible (GtkFileSystemModel *model, guint id)
{
- GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
+ FileModelNode *node = get_node (model, id);
+ gboolean is_folder;
- if (model->pending_cancellables)
- {
- GSList *l;
+ if (node->info == NULL)
+ 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->show_hidden &&
+ (g_file_info_get_is_hidden (node->info) || g_file_info_get_is_backup (node->info)))
+ return FALSE;
- G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object);
-}
+ 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;
-static void
-drag_source_iface_init (GtkTreeDragSourceIface *iface)
-{
- iface->row_draggable = drag_source_row_draggable;
- iface->drag_data_get = drag_source_drag_data_get;
- iface->drag_data_delete = NULL;
+
+ if (model->filter_func &&
+ !model->filter_func (model, node->file, node->info, model->filter_data))
+ return FALSE;
+
+ return TRUE;
}
-/*
- * ******************** 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
@@ -330,80 +191,80 @@ gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model)
static GType
gtk_file_system_model_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ gint i)
{
- switch (index)
+ switch (i)
{
case GTK_FILE_SYSTEM_MODEL_INFO:
return G_TYPE_FILE_INFO;
case GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME:
return G_TYPE_STRING;
- default:
+ default:
g_assert_not_reached ();
return G_TYPE_NONE;
}
}
+static int
+compare_indices (gconstpointer key, gconstpointer _node)
+{
+ const FileModelNode *node = _node;
+
+ return GPOINTER_TO_UINT (key) - node->index;
+}
+
static gboolean
-gtk_file_system_model_get_iter (GtkTreeModel *tree_model,
- GtkTreeIter *iter,
- GtkTreePath *path)
+gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model,
+ GtkTreeIter *iter,
+ GtkTreeIter *parent,
+ gint n)
{
- GtkTreeIter parent;
- gint *indices;
- gint depth, i;
+ GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
+ FileModelNode *node, *first;
- indices = gtk_tree_path_get_indices (path);
- depth = gtk_tree_path_get_depth (path);
+ g_return_val_if_fail (n >= 0, FALSE);
- g_return_val_if_fail (depth > 0, FALSE);
+ if (parent != NULL || (guint) n > get_node (model, model->files->len - 1)->index)
+ return FALSE;
- if (!gtk_tree_model_iter_nth_child (tree_model, iter, NULL, indices[0]))
+ node = bsearch (GUINT_TO_POINTER ((guint) n),
+ model->files->data,
+ model->files->len,
+ sizeof (FileModelNode),
+ compare_indices);
+ if (node == NULL)
return FALSE;
- for (i = 1; i < depth; i++)
- {
- parent = *iter;
- if (!gtk_tree_model_iter_nth_child (tree_model, iter, &parent, indices[i]))
- return FALSE;
- }
+ first = get_node (model, 0);
+ while (node >= first && !node->visible)
+ node--;
+ ITER_INIT_FROM_INDEX (model, iter, (guint) (node - get_node (model, 0)));
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);
+
+ 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);
+ g_return_val_if_fail (ITER_IS_VALID (model, iter), NULL);
- node = parent;
- }
-
- return result;
+ return gtk_tree_path_new_from_node (model, ITER_INDEX (iter));
}
static void
@@ -413,31 +274,27 @@ 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;
+ FileModelNode *node;
+
+ g_return_if_fail (ITER_IS_VALID (model, iter));
+
+ node = get_node (model, ITER_INDEX (iter));
+ g_assert (node->visible);
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);
+ g_value_init (value, G_TYPE_FILE_INFO);
+ g_value_set_object (value, node->info);
break;
case GTK_FILE_SYSTEM_MODEL_DISPLAY_NAME:
{
g_value_init (value, G_TYPE_STRING);
- if (model->has_editable && node == model->roots)
+ if (node->info == NULL)
g_value_set_static_string (value, "");
else
- {
- GFileInfo *info = file_model_node_get_info (model, node);
-
- g_value_set_string (value, g_file_info_get_display_name (info));
- }
+ g_value_set_string (value, g_file_info_get_display_name (node->info));
}
break;
default:
@@ -449,15 +306,23 @@ 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);
- return node != NULL;
+ for (i = ITER_INDEX (iter) + 1; i < model->files->len; i++)
+ {
+ FileModelNode *node = get_node (model, i);
+
+ if (node->visible)
+ {
+ ITER_INIT_FROM_INDEX (model, iter, i);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
}
static gboolean
@@ -465,41 +330,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 _gtk_file_info_consider_as_directory (info);
- }
+ return FALSE;
}
static gint
@@ -507,62 +345,11 @@ 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)
- {
- FileModelNode *node = iter->user_data;
- children = file_model_node_get_children (model, node);
- }
- else
- {
- children = model->roots;
- }
-
- while (children)
- {
- if (children->is_visible)
- n++;
- children = children->next;
- }
+ return 0;
- return n;
-}
-
-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);
- 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;
-
- while (n && children)
- {
- n--;
- children = children->next;
- while (children && !children->is_visible)
- children = children->next;
- }
-
- iter->user_data = children;
-
- return children != NULL;
+ return get_node (model, model->files->len - 1)->index + 1;
}
static gboolean
@@ -570,47 +357,55 @@ gtk_file_system_model_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child)
{
- FileModelNode *node = child->user_data;
-
- node = node->parent;
- iter->user_data = node;
-
- return node != NULL;
+ return FALSE;
}
static void
gtk_file_system_model_ref_node (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
- file_model_node_ref (iter->user_data);
+ /* FIXME: implement */
}
static void
gtk_file_system_model_unref_node (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
- file_model_node_unref (GTK_FILE_SYSTEM_MODEL (tree_model),
- iter->user_data);
+ /* FIXME: implement */
}
+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;
+}
+
+/*** 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
@@ -618,219 +413,292 @@ 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;
}
+/*** GtkFileSystemModel ***/
+
+/* Signal IDs */
+enum {
+ FINISHED_LOADING,
+ LAST_SIGNAL
+};
+
+static guint file_system_model_signals[LAST_SIGNAL] = { 0 };
+
+
+
+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))
+
static void
-got_root_folder_cb (GCancellable *cancellable,
- GtkFolder *folder,
- const GError *error,
- gpointer data)
+gtk_file_system_model_dispose (GObject *object)
{
- gboolean cancelled = g_cancellable_is_cancelled (cancellable);
- GtkFileSystemModel *model = data;
- GSList *tmp_list;
+ GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
- tmp_list = g_slist_find (model->pending_cancellables, cancellable);
- if (!tmp_list)
- goto out;
+ g_cancellable_cancel (model->cancellable);
- model->pending_cancellables = g_slist_delete_link (model->pending_cancellables,
- tmp_list);
+ G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object);
+}
- if (cancelled || !folder)
- goto out;
- model->root_folder = g_object_ref (folder);
+static void
+gtk_file_system_model_finalize (GObject *object)
+{
+ GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
+ guint i;
- 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);
+ for (i = 0; i < model->files->len; i++)
+ {
+ FileModelNode *node = get_node (model, i);
+ if (node->file)
+ g_object_unref (node->file);
+ if (node->info)
+ g_object_unref (node->info);
+ }
+ g_array_free (model->files, TRUE);
-out:
- g_object_unref (model);
- g_object_unref (cancellable);
+ g_object_unref (model->cancellable);
+ g_free (model->attributes);
+ g_object_unref (model->dir);
+
+ G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object);
}
-/**
- * _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_class_init (GtkFileSystemModelClass *class)
{
- GtkFileSystemModel *model;
- GCancellable *cancellable;
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
- 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);
+ gobject_class->finalize = gtk_file_system_model_finalize;
+ gobject_class->dispose = gtk_file_system_model_dispose;
- /* Then, actually create the model and the root nodes */
+ 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);
+}
- 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);
+/* NB: takes ownership of file and info */
+static void
+gtk_file_system_model_add_node (GtkFileSystemModel *model,
+ FileModelNode * node)
+{
+ g_assert (!node->visible); /* must be made visible later */
+ g_assert (model->files->len > 0);
- model->attributes = g_strdup (attributes);
- model->root_folder = NULL;
- model->root_file = g_object_ref (root_file);
+ node->index = get_node (model, model->files->len - 1)->index;
- model->roots = NULL;
+ g_array_append_vals (model->files, node, 1);
+}
- cancellable = _gtk_file_system_get_folder (file_system, root_file,
- attributes,
- got_root_folder_cb,
- g_object_ref (model));
- if (!cancellable)
- {
- /* 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);
+static void
+_gtk_file_system_model_init (GtkFileSystemModel *model)
+{
+ FileModelNode node = { NULL, NULL, -1, FALSE };
- g_set_error_literal (error,
- GTK_FILE_CHOOSER_ERROR,
- GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
- _("Could not obtain root folder"));
+ model->files = g_array_new (FALSE, FALSE, sizeof (FileModelNode));
+ g_array_append_val (model->files, node);
- return NULL;
- }
+ model->show_files = TRUE;
+ model->show_folders = TRUE;
+ model->show_hidden = FALSE;
+
+ model->cancellable = g_cancellable_new ();
+}
- model->pending_cancellables = g_slist_append (model->pending_cancellables, cancellable);
+/*** API ***/
- return model;
+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);
}
static void
-model_refilter_recurse (GtkFileSystemModel *model,
- FileModelNode *parent,
- GtkTreePath *path)
+gtk_file_system_model_got_files (GObject *object, GAsyncResult *res, gpointer data)
{
- GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
- int i = 0;
- FileModelNode *nodes;
- gboolean has_children = FALSE;
+ GFileEnumerator *enumerator = G_FILE_ENUMERATOR (object);
+ GtkFileSystemModel *model = data;
+ GList *walk, *files;
+ GError *error = NULL;
- if (parent && !parent->loaded)
- return;
+ gdk_threads_enter ();
- if (parent)
- nodes = parent->children;
- else
- nodes = model->roots;
+ files = g_file_enumerator_next_files_finish (enumerator, res, &error);
- while (nodes)
+ for (walk = files; walk; walk = walk->next)
{
- FileModelNode *next = nodes->next;
- gboolean is_visible;
+ FileModelNode node;
+ const char *name;
- gtk_tree_path_append_index (path, i);
+ node.info = walk->data;
+ name = g_file_info_get_name (node.info);
+ if (name == NULL)
+ {
+ /* Shouldn't happen, but the APIs allow it */
+ g_object_unref (node.info);
+ continue;
+ }
+ node.file = g_file_get_child (model->dir, name);
+ /* set as invisible, because node_should_be_visible() requires it being added already */
+ node.visible = FALSE;
+ gtk_file_system_model_add_node (model, &node);
+ node_set_visible (model, model->files->len - 1,
+ node_should_be_visible (model, model->files->len - 1));
+ }
+ g_list_free (files);
- 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);
+ if (files == NULL)
+ {
+ 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);
+ g_object_unref (model);
+ }
+ else
+ g_file_enumerator_next_files_async (enumerator,
+ FILES_PER_QUERY,
+ IO_PRIORITY,
+ model->cancellable,
+ gtk_file_system_model_got_files,
+ model);
- nodes->is_visible = FALSE;
- }
- else if (is_visible && !nodes->is_visible)
- {
- GtkTreeIter iter;
+ gdk_threads_leave ();
+}
- iter.user_data = nodes;
- nodes->is_visible = TRUE;
- gtk_tree_model_row_inserted (tree_model, path, &iter);
- }
- else
- model_refilter_recurse (model, nodes, path);
+static void
+gtk_file_system_model_got_enumerator (GObject *dir, GAsyncResult *res, gpointer data)
+{
+ GtkFileSystemModel *model = data;
+ GFileEnumerator *enumerator;
+ GError *error = NULL;
- if (is_visible)
- {
- has_children = TRUE;
- i++;
- }
-
- gtk_tree_path_up (path);
-
- nodes = next;
- }
+ gdk_threads_enter ();
- if (parent && !has_children)
+ enumerator = g_file_enumerate_children_finish (G_FILE (dir), res, &error);
+ if (enumerator == NULL)
{
- /* Fixme - need to insert dummy node here */
+ g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0, error);
+ g_object_unref (model);
+ g_error_free (error);
+ }
+ else
+ {
+ g_file_enumerator_next_files_async (enumerator,
+ FILES_PER_QUERY,
+ IO_PRIORITY,
+ model->cancellable,
+ gtk_file_system_model_got_files,
+ model);
+ g_object_unref (enumerator);
}
+
+ gdk_threads_leave ();
+}
+
+/**
+ * _gtk_file_system_model_new:
+ * @directory: the directory to show.
+ * @attributes: attributes to immediately load or %NULL for all
+ * @full_attributes: %NULL or a superset of @attributes
+ * @error: location to store error, or %NULL.
+ *
+ * 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. After all files have been added,
+ * @full_attributes will be queried on-demand and the file infos will be
+ * updated. The GtkTreeModel::row-changed signal will be emitted when this
+ * happens. It is suggested that you only query attributes that are
+ * immediately necessary for using this model and add all other attributes
+ * to @full_attributes to avoid slow load times. Worst offenders are
+ * content type and thumbnails.
+ * If @full_attributes is non-%NULL, the model will also initially not
+ * follow symlinks to improve load times.
+ *
+ * Return value: the newly created #GtkFileSystemModel object, or NULL if there
+ * was an error.
+ **/
+GtkFileSystemModel *
+_gtk_file_system_model_new (GFile * dir,
+ const gchar *attributes,
+ const gchar *full_attributes)
+{
+ GtkFileSystemModel *model;
+
+ g_return_val_if_fail (G_IS_FILE (dir), NULL);
+
+ model = g_object_new (GTK_TYPE_FILE_SYSTEM_MODEL, NULL);
+ model->dir = g_object_ref (dir);
+ model->attributes = g_strdup (attributes);
+ model->full_attributes = g_strdup (full_attributes);
+
+ g_object_ref (model);
+ g_file_enumerate_children_async (dir,
+#if 1
+ full_attributes ? full_attributes : attributes,
+ 0,
+#else
+ attributes,
+ full_attributes ? G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS : 0,
+#endif
+ IO_PRIORITY,
+ model->cancellable,
+ gtk_file_system_model_got_enumerator,
+ model);
+
+ return model;
}
static void
-model_refilter_all (GtkFileSystemModel *model)
+gtk_file_system_model_refilter_all (GtkFileSystemModel *model)
{
- GtkTreePath *path;
+ guint i;
- path = gtk_tree_path_new ();
- model_refilter_recurse (model, NULL, path);
- gtk_tree_path_free (path);
+ /* don't change the editable */
+ for (i = 1; i < model->files->len; i++)
+ {
+ node_set_visible (model, i, node_should_be_visible (model, i));
+ }
}
/**
@@ -845,12 +713,14 @@ 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);
}
}
@@ -866,12 +736,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);
}
}
@@ -888,12 +760,14 @@ 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);
}
}
@@ -904,8 +778,9 @@ _gtk_file_system_model_set_show_files (GtkFileSystemModel *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().
+ * is determined by the attributes and full_attributes
+ * parameter to _gtk_file_system_model_new(). Note that the
+ * full_attributes might not be filled in yet.
*
* Return value: a #GFileInfo structure. This structure
* is owned by @model and must not be modified or freed.
@@ -922,11 +797,11 @@ _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);
+
+ node = get_node (model, ITER_INDEX (iter));
+ g_assert (node->info == NULL || G_IS_FILE_INFO (node->info));
+ return node->info;
}
/**
@@ -945,15 +820,255 @@ 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);
+
+ node = get_node (model, ITER_INDEX (iter));
+ return node->file;
+}
+
+gboolean
+_gtk_file_system_model_get_iter_for_file (GtkFileSystemModel *model,
+ GtkTreeIter *iter,
+ GFile * file)
+{
+ guint i;
+
+ 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);
+
+ /* node 0 is the editable row and has no associated file */
+ for (i = 1; i < model->files->len; i++)
+ {
+ FileModelNode *node = get_node (model, i);
+
+ if (!node->visible)
+ continue;
+
+ if (g_file_equal (node->file, file))
+ {
+ ITER_INIT_FROM_INDEX (model, iter, i);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * _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.
+ **/
+void
+_gtk_file_system_model_set_filter (GtkFileSystemModel *model,
+ GtkFileSystemModelFilter filter,
+ gpointer user_data)
+{
+ g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
+
+ model->filter_func = filter;
+ model->filter_data = user_data;
+
+ gtk_file_system_model_refilter_all (model);
+}
+
+/**
+ * _gtk_file_system_model_add_editable:
+ * @model: a #GtkFileSystemModel
+ * @iter: Location to return the iter corresponding to the editable row
+ *
+ * Adds an "empty" row at the beginning of the model. This does not refer to
+ * any file, but is a temporary placeholder for a file name that the user will
+ * type when a corresponding cell is made editable. When your code is done
+ * using this temporary row, call _gtk_file_system_model_remove_editable().
+ **/
+void
+_gtk_file_system_model_add_editable (GtkFileSystemModel *model, GtkTreeIter *iter)
+{
+ 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);
+ ITER_INIT_FROM_INDEX (model, iter, 0);
+}
+
+/**
+ * _gtk_file_system_model_remove_editable:
+ * @model: a #GtkFileSystemModel
+ *
+ * Removes the "empty" row at the beginning of the model that was
+ * created with _gtk_file_system_model_add_editable(). You should call
+ * this function when your code is finished editing this temporary row.
+ **/
+void
+_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);
+}
+
+
+#if 0
+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);
+
+/* Callback used when the root folder finished loading */
+static void
+root_folder_finished_loading_cb (GFile *folder,
+ GtkFileSystemModel *model)
+{
+ g_signal_emit (model, file_system_model_signals[FINISHED_LOADING], 0);
+}
+
+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;
- if (node->is_dummy)
- return node->parent->file;
+ model->pending_cancellables = g_slist_delete_link (model->pending_cancellables,
+ tmp_list);
+
+ if (cancelled || !folder)
+ goto out;
+
+ model->root_folder = g_object_ref (folder);
+
+ 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);
+}
+
+static void
+model_refilter_recurse (GtkFileSystemModel *model,
+ FileModelNode *parent,
+ GtkTreePath *path)
+{
+ GtkTreeModel *tree_model = GTK_TREE_MODEL (model);
+ int i = 0;
+ FileModelNode *nodes;
+ gboolean has_children = FALSE;
+
+ if (parent && !parent->loaded)
+ return;
+
+ if (parent)
+ nodes = parent->children;
else
- return node->file;
+ nodes = model->roots;
+
+ while (nodes)
+ {
+ FileModelNode *next = nodes->next;
+ gboolean is_visible;
+
+ gtk_tree_path_append_index (path, i);
+
+ 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);
+
+ nodes->is_visible = FALSE;
+ }
+ else if (is_visible && !nodes->is_visible)
+ {
+ GtkTreeIter iter;
+
+ iter.user_data = nodes;
+ nodes->is_visible = TRUE;
+ gtk_tree_model_row_inserted (tree_model, path, &iter);
+ }
+ else
+ model_refilter_recurse (model, nodes, path);
+
+ if (is_visible)
+ {
+ has_children = TRUE;
+ i++;
+ }
+
+ gtk_tree_path_up (path);
+
+ nodes = next;
+ }
+
+ if (parent && !has_children)
+ {
+ /* Fixme - need to insert dummy node here */
+ }
}
static void
@@ -990,29 +1105,6 @@ find_child_node (GtkFileSystemModel *model,
return NULL;
}
-/**
- * _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.
- **/
-void
-_gtk_file_system_model_set_filter (GtkFileSystemModel *model,
- GtkFileSystemModelFilter filter,
- gpointer user_data)
-{
- g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
-
- model->filter_func = filter;
- model->filter_data = user_data;
-
- model_refilter_all (model);
-}
-
struct RefPathData
{
@@ -1252,71 +1344,6 @@ _gtk_file_system_model_path_do (GtkFileSystemModel *model,
}
}
-/**
- * _gtk_file_system_model_add_editable:
- * @model: a #GtkFileSystemModel
- * @iter: Location to return the iter corresponding to the editable row
- *
- * Adds an "empty" row at the beginning of the model. This does not refer to
- * any file, but is a temporary placeholder for a file name that the user will
- * type when a corresponding cell is made editable. When your code is done
- * using this temporary row, call _gtk_file_system_model_remove_editable().
- **/
-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);
-
- gtk_tree_path_free (path);
-}
-
-/**
- * _gtk_file_system_model_remove_editable:
- * @model: a #GtkFileSystemModel
- *
- * Removes the "empty" row at the beginning of the model that was
- * created with _gtk_file_system_model_add_editable(). You should call
- * this function when your code is finished editing this temporary row.
- **/
-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)
@@ -2030,3 +2057,4 @@ root_files_removed_callback (GFile *folder,
{
do_files_removed (model, NULL, files);
}
+#endif
diff --git a/gtk/gtkfilesystemmodel.h b/gtk/gtkfilesystemmodel.h
index 750fa33..f9e608d 100644
--- a/gtk/gtkfilesystemmodel.h
+++ b/gtk/gtkfilesystemmodel.h
@@ -40,13 +40,14 @@ typedef enum {
GTK_FILE_SYSTEM_MODEL_N_COLUMNS
} GtkFileSystemModelColumns;
-GtkFileSystemModel *_gtk_file_system_model_new (GtkFileSystem *file_system,
- GFile *root_file,
- gint max_depth,
- const gchar *attributes,
- GError **error);
+GtkFileSystemModel *_gtk_file_system_model_new (GFile * dir,
+ const gchar * attributes,
+ const gchar * full_attributes);
GFileInfo * _gtk_file_system_model_get_info (GtkFileSystemModel *model,
GtkTreeIter *iter);
+gboolean _gtk_file_system_model_get_iter_for_file(GtkFileSystemModel *model,
+ GtkTreeIter *iter,
+ GFile * file);
GFile * _gtk_file_system_model_get_file (GtkFileSystemModel *model,
GtkTreeIter *iter);
void _gtk_file_system_model_set_show_hidden (GtkFileSystemModel *model,
@@ -65,16 +66,6 @@ void _gtk_file_system_model_set_filter (GtkFileSystemModel *model,
GtkFileSystemModelFilter filter,
gpointer user_data);
-typedef void (*GtkFileSystemModelPathFunc) (GtkFileSystemModel *model,
- GtkTreePath *path,
- GtkTreeIter *iter,
- gpointer user_data);
-
-void _gtk_file_system_model_path_do (GtkFileSystemModel *model,
- GFile *file,
- GtkFileSystemModelPathFunc func,
- gpointer user_data);
-
void _gtk_file_system_model_add_editable (GtkFileSystemModel *model,
GtkTreeIter *iter);
void _gtk_file_system_model_remove_editable (GtkFileSystemModel *model);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
