forked from AuroraMiddleware/gtk
18b56b9970
The new model is mostly API-compatible with the old model (minimal changes were required), but is a lot faster and has a lot of very desirable features. - 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 - columns are managed by the creator of the model, so any number of nodes can be added as needed. This also makes the API more similar to GtkListStore. - Values are filled on demand using a function given when creating the model. - The function can decide to let the model cache returned values or decide to be called again the next time the value is queried. - implements GtkTreeSortable - _gtk_file_system_model_get_value() was added to significantly speed up value access, which is necessary when sorting large models.
1663 lines
48 KiB
C
1663 lines
48 KiB
C
/* GTK - The GIMP Toolkit
|
||
* gtkfilesystemmodel.c: GtkTreeModel wrapping a GtkFileSystem
|
||
* Copyright (C) 2003, Red Hat, Inc.
|
||
*
|
||
* This library is free software; you can redistribute it and/or
|
||
* modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation; either
|
||
* version 2 of the License, or (at your option) any later version.
|
||
*
|
||
* This library is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||
* 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.
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#include "gtkfilesystemmodel.h"
|
||
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
|
||
#include "gtkintl.h"
|
||
#include "gtkmarshalers.h"
|
||
#include "gtktreedatalist.h"
|
||
#include "gtktreednd.h"
|
||
#include "gtktreemodel.h"
|
||
#include "gtkalias.h"
|
||
|
||
/*** DEFINES ***/
|
||
|
||
/* priority used for all async callbacks in the main loop
|
||
* This should be higher than redraw priorities so multiple callbacks
|
||
* firing can be handled without intermediate redraws */
|
||
#define IO_PRIORITY G_PRIORITY_DEFAULT
|
||
|
||
/* random number that everyone else seems to use, too */
|
||
#define FILES_PER_QUERY 100
|
||
|
||
typedef struct _FileModelNode FileModelNode;
|
||
typedef struct _GtkFileSystemModelClass GtkFileSystemModelClass;
|
||
|
||
struct _FileModelNode
|
||
{
|
||
GFile * file; /* file represented by this node or NULL for editable */
|
||
GFileInfo * info; /* info for this file or NULL if unknown */
|
||
|
||
guint index; /* if valid, index in path - aka visible nodes before this one */
|
||
|
||
guint visible :1; /* if the file is currently visible */
|
||
guint frozen_add :1; /* true if the model was frozen and the entry has not been added yet */
|
||
|
||
GValue values[1]; /* actually n_columns values */
|
||
};
|
||
|
||
struct _GtkFileSystemModel
|
||
{
|
||
GObject parent_instance;
|
||
|
||
GFile * dir; /* directory that's displayed */
|
||
guint dir_thaw_source;/* GSource id for unfreezing the model */
|
||
char * attributes; /* attributes the file info must contain */
|
||
GFileMonitor * dir_monitor; /* directory that is monitored */
|
||
|
||
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 */
|
||
|
||
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 */
|
||
|
||
int sort_column_id; /* current sorting column */
|
||
GtkSortType sort_order; /* current sorting order */
|
||
GList * sort_list; /* list of sorting functions */
|
||
GtkTreeIterCompareFunc default_sort_func; /* default sort function */
|
||
gpointer default_sort_data; /* data to pass to default sort func */
|
||
GDestroyNotify default_sort_destroy; /* function to call to destroy default_sort_data */
|
||
|
||
guint frozen; /* number of times we're frozen */
|
||
|
||
gboolean filter_on_thaw :1;/* set when filtering needs to happen upon thawing */
|
||
gboolean sort_on_thaw :1;/* set when sorting needs to happen upon thawing */
|
||
|
||
guint show_hidden :1; /* whether to show hidden files */
|
||
guint show_folders :1;/* whether to show folders */
|
||
guint show_files :1; /* whether to show files */
|
||
};
|
||
|
||
#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))
|
||
|
||
struct _GtkFileSystemModelClass
|
||
{
|
||
GObjectClass parent_class;
|
||
|
||
/* Signals */
|
||
|
||
void (*finished_loading) (GtkFileSystemModel *model, GError *error);
|
||
};
|
||
|
||
/* iter setup:
|
||
* @user_data: the model
|
||
* @user_data2: GUINT_TO_POINTER of array index of current entry
|
||
*
|
||
* All other fields are unused. Note that the array index does not corrspond
|
||
* 1:1 with the path index as entries might not be visible.
|
||
*/
|
||
#define ITER_INDEX(iter) GPOINTER_TO_UINT((iter)->user_data2)
|
||
#define ITER_IS_VALID(model, iter) ((model) == (iter)->user_data)
|
||
#define ITER_INIT_FROM_INDEX(model, _iter, _index) G_STMT_START {\
|
||
g_assert (_index < (model)->files->len); \
|
||
(_iter)->user_data = (model); \
|
||
(_iter)->user_data2 = GUINT_TO_POINTER (_index); \
|
||
}G_STMT_END
|
||
|
||
/*** FileModelNode ***/
|
||
|
||
#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))
|
||
|
||
static void
|
||
node_validate_indexes (GtkFileSystemModel *model, guint min_index, guint min_visible)
|
||
{
|
||
guint validate, current;
|
||
|
||
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;
|
||
else
|
||
current = 0;
|
||
while (validate <= min_index && current <= min_visible)
|
||
{
|
||
FileModelNode *node = get_node (model, validate);
|
||
if (node->visible)
|
||
current++;
|
||
node->index = current;
|
||
validate++;
|
||
}
|
||
model->n_indexes_valid = validate;
|
||
}
|
||
|
||
static guint
|
||
node_get_index (GtkFileSystemModel *model, guint id)
|
||
{
|
||
if (model->n_indexes_valid <= id)
|
||
node_validate_indexes (model, id, G_MAXUINT);
|
||
|
||
return get_node (model, id)->index - 1;
|
||
}
|
||
|
||
static void
|
||
node_invalidate_index (GtkFileSystemModel *model, guint id)
|
||
{
|
||
model->n_indexes_valid = MIN (model->n_indexes_valid, id);
|
||
}
|
||
|
||
static GtkTreePath *
|
||
gtk_tree_path_new_from_node (GtkFileSystemModel *model, guint id)
|
||
{
|
||
guint i = node_get_index (model, id);
|
||
|
||
g_assert (i < model->files->len);
|
||
|
||
return gtk_tree_path_new_from_indices (i, -1);
|
||
}
|
||
|
||
static void
|
||
node_set_visible (GtkFileSystemModel *model, guint id, gboolean visible)
|
||
{
|
||
FileModelNode *node = get_node (model, id);
|
||
GtkTreePath *path;
|
||
GtkTreeIter iter;
|
||
|
||
if (node->visible == visible ||
|
||
node->frozen_add)
|
||
return;
|
||
|
||
if (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);
|
||
}
|
||
else
|
||
{
|
||
path = gtk_tree_path_new_from_node (model, id);
|
||
node->visible = FALSE;
|
||
node_invalidate_index (model, id);
|
||
gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path);
|
||
gtk_tree_path_free (path);
|
||
}
|
||
}
|
||
|
||
static gboolean
|
||
node_should_be_visible (GtkFileSystemModel *model, guint id)
|
||
{
|
||
FileModelNode *node = get_node (model, id);
|
||
gboolean is_folder;
|
||
|
||
if (node->info == NULL)
|
||
return FALSE;
|
||
|
||
if (!model->show_hidden &&
|
||
(g_file_info_get_is_hidden (node->info) || g_file_info_get_is_backup (node->info)))
|
||
return FALSE;
|
||
|
||
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 (model->filter_func &&
|
||
!model->filter_func (model, node->file, node->info, model->filter_data))
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/*** GtkTreeModel ***/
|
||
|
||
static GtkTreeModelFlags
|
||
gtk_file_system_model_get_flags (GtkTreeModel *tree_model)
|
||
{
|
||
/* GTK_TREE_MODEL_ITERS_PERSIST doesn't work with arrays :( */
|
||
return GTK_TREE_MODEL_LIST_ONLY;
|
||
}
|
||
|
||
static gint
|
||
gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
|
||
|
||
return model->n_columns;
|
||
}
|
||
|
||
static GType
|
||
gtk_file_system_model_get_column_type (GtkTreeModel *tree_model,
|
||
gint i)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
|
||
|
||
g_return_val_if_fail (i >= 0 && (guint) i < model->n_columns, G_TYPE_NONE);
|
||
|
||
return model->column_types[i];
|
||
}
|
||
|
||
static int
|
||
compare_indices (gconstpointer key, gconstpointer _node)
|
||
{
|
||
const FileModelNode *node = _node;
|
||
|
||
return GPOINTER_TO_UINT (key) - node->index;
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter,
|
||
GtkTreeIter *parent,
|
||
gint n)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
|
||
char *node;
|
||
guint id, find;
|
||
|
||
g_return_val_if_fail (n >= 0, FALSE);
|
||
|
||
if (parent != NULL)
|
||
return FALSE;
|
||
|
||
find = n + 1;
|
||
|
||
if (model->n_indexes_valid > 0 &&
|
||
get_node (model, model->n_indexes_valid - 1)->index >= find)
|
||
{
|
||
/* fast path */
|
||
node = bsearch (GUINT_TO_POINTER (find),
|
||
model->files->data,
|
||
model->n_indexes_valid,
|
||
NODE_SIZE (model),
|
||
compare_indices);
|
||
if (node == NULL)
|
||
return FALSE;
|
||
|
||
id = node_index (model, node);
|
||
while (!get_node (model, id)->visible)
|
||
id--;
|
||
}
|
||
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)
|
||
return FALSE;
|
||
}
|
||
|
||
ITER_INIT_FROM_INDEX (model, iter, id);
|
||
return TRUE;
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_get_iter (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter,
|
||
GtkTreePath *path)
|
||
{
|
||
g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
|
||
|
||
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);
|
||
|
||
g_return_val_if_fail (ITER_IS_VALID (model, iter), NULL);
|
||
|
||
return gtk_tree_path_new_from_node (model, ITER_INDEX (iter));
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_get_value (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter,
|
||
gint column,
|
||
GValue *value)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
|
||
const GValue *original;
|
||
|
||
g_return_if_fail ((guint) column < model->n_columns);
|
||
g_return_if_fail (ITER_IS_VALID (model, iter));
|
||
|
||
original = _gtk_file_system_model_get_value (model, iter, column);
|
||
if (original)
|
||
{
|
||
g_value_init (value, G_VALUE_TYPE (original));
|
||
g_value_copy (original, value);
|
||
}
|
||
else
|
||
g_value_init (value, model->column_types[column]);
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_iter_next (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
|
||
guint i;
|
||
|
||
g_return_val_if_fail (ITER_IS_VALID (model, iter), FALSE);
|
||
|
||
for (i = ITER_INDEX (iter) + 1; i < model->files->len; i++)
|
||
{
|
||
FileModelNode *node = get_node (model, i);
|
||
|
||
if (node->visible)
|
||
{
|
||
ITER_INIT_FROM_INDEX (model, iter, i);
|
||
return TRUE;
|
||
}
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_iter_children (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter,
|
||
GtkTreeIter *parent)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_iter_has_child (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
static gint
|
||
gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
|
||
|
||
if (iter)
|
||
return 0;
|
||
|
||
return node_get_index (model, model->files->len - 1) + 1;
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_iter_parent (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter,
|
||
GtkTreeIter *child)
|
||
{
|
||
return FALSE;
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_ref_node (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
/* FIXME: implement */
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_unref_node (GtkTreeModel *tree_model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
/* 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;
|
||
}
|
||
|
||
/*** GtkTreeSortable ***/
|
||
|
||
typedef struct _SortData SortData;
|
||
struct _SortData {
|
||
GtkFileSystemModel * model;
|
||
GtkTreeIterCompareFunc func;
|
||
gpointer data;
|
||
int order; /* -1 to invert sort order or 1 to keep it */
|
||
};
|
||
|
||
/* returns FALSE if no sort necessary */
|
||
static gboolean
|
||
sort_data_init (SortData *data, GtkFileSystemModel *model)
|
||
{
|
||
GtkTreeDataSortHeader *header;
|
||
|
||
if (model->files->len <= 2)
|
||
return FALSE;
|
||
|
||
switch (model->sort_column_id)
|
||
{
|
||
case GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID:
|
||
if (!model->default_sort_func)
|
||
return FALSE;
|
||
data->func = model->default_sort_func;
|
||
data->data = model->default_sort_data;
|
||
break;
|
||
case GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID:
|
||
return FALSE;
|
||
default:
|
||
header = _gtk_tree_data_list_get_header (model->sort_list, model->sort_column_id);
|
||
if (header == NULL)
|
||
return FALSE;
|
||
data->func = header->func;
|
||
data->data = header->data;
|
||
break;
|
||
}
|
||
|
||
data->order = model->sort_order == GTK_SORT_DESCENDING ? -1 : 1;
|
||
data->model = model;
|
||
return TRUE;
|
||
}
|
||
|
||
static int
|
||
compare_array_element (gconstpointer a, gconstpointer b, gpointer user_data)
|
||
{
|
||
SortData *data = user_data;
|
||
GtkTreeIter itera, iterb;
|
||
|
||
ITER_INIT_FROM_INDEX (data->model, &itera, node_index (data->model, a));
|
||
ITER_INIT_FROM_INDEX (data->model, &iterb, node_index (data->model, b));
|
||
return data->func (GTK_TREE_MODEL (data->model), &itera, &iterb, data->data) * data->order;
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_sort (GtkFileSystemModel *model)
|
||
{
|
||
SortData data;
|
||
|
||
if (model->frozen)
|
||
{
|
||
model->sort_on_thaw = TRUE;
|
||
return;
|
||
}
|
||
|
||
if (sort_data_init (&data, model))
|
||
{
|
||
GtkTreePath *path;
|
||
guint i, j, n_elements;
|
||
|
||
node_validate_indexes (model, G_MAXUINT, G_MAXUINT);
|
||
n_elements = node_get_index (model, model->files->len - 1) + 1;
|
||
model->n_indexes_valid = 0;
|
||
g_hash_table_remove_all (model->file_lookup);
|
||
g_qsort_with_data (get_node (model, 1),
|
||
model->files->len - 1,
|
||
NODE_SIZE (model),
|
||
compare_array_element,
|
||
&data);
|
||
g_assert (model->n_indexes_valid == 0);
|
||
g_assert (g_hash_table_size (model->file_lookup) == 0);
|
||
if (n_elements)
|
||
{
|
||
int *new_order = g_new (int, n_elements);
|
||
|
||
j = 0;
|
||
for (i = 0; i < model->files->len; i++)
|
||
{
|
||
FileModelNode *node = get_node (model, i);
|
||
if (!node->visible)
|
||
{
|
||
node->index = j;
|
||
continue;
|
||
}
|
||
|
||
new_order[j] = node->index;
|
||
j++;
|
||
node->index = j;
|
||
}
|
||
g_assert (j == n_elements);
|
||
path = gtk_tree_path_new ();
|
||
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (model),
|
||
path,
|
||
NULL,
|
||
new_order);
|
||
gtk_tree_path_free (path);
|
||
g_free (new_order);
|
||
}
|
||
}
|
||
|
||
model->sort_on_thaw = FALSE;
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_sort_node (GtkFileSystemModel *model, guint node)
|
||
{
|
||
/* FIXME: improve */
|
||
gtk_file_system_model_sort (model);
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_get_sort_column_id (GtkTreeSortable *sortable,
|
||
gint *sort_column_id,
|
||
GtkSortType *order)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
|
||
|
||
if (sort_column_id)
|
||
*sort_column_id = model->sort_column_id;
|
||
if (order)
|
||
*order = model->sort_order;
|
||
|
||
if (model->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID ||
|
||
model->sort_column_id == GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_set_sort_column_id (GtkTreeSortable *sortable,
|
||
gint sort_column_id,
|
||
GtkSortType order)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
|
||
|
||
if ((model->sort_column_id == sort_column_id) &&
|
||
(model->sort_order == order))
|
||
return;
|
||
|
||
if (sort_column_id != GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)
|
||
{
|
||
if (sort_column_id != GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)
|
||
{
|
||
GtkTreeDataSortHeader *header = NULL;
|
||
|
||
header = _gtk_tree_data_list_get_header (model->sort_list,
|
||
sort_column_id);
|
||
|
||
/* We want to make sure that we have a function */
|
||
g_return_if_fail (header != NULL);
|
||
g_return_if_fail (header->func != NULL);
|
||
}
|
||
else
|
||
{
|
||
g_return_if_fail (model->default_sort_func != NULL);
|
||
}
|
||
}
|
||
|
||
|
||
model->sort_column_id = sort_column_id;
|
||
model->sort_order = order;
|
||
|
||
gtk_tree_sortable_sort_column_changed (sortable);
|
||
|
||
gtk_file_system_model_sort (model);
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_set_sort_func (GtkTreeSortable *sortable,
|
||
gint sort_column_id,
|
||
GtkTreeIterCompareFunc func,
|
||
gpointer data,
|
||
GDestroyNotify destroy)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
|
||
|
||
model->sort_list = _gtk_tree_data_list_set_header (model->sort_list,
|
||
sort_column_id,
|
||
func, data, destroy);
|
||
|
||
if (model->sort_column_id == sort_column_id)
|
||
gtk_file_system_model_sort (model);
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_set_default_sort_func (GtkTreeSortable *sortable,
|
||
GtkTreeIterCompareFunc func,
|
||
gpointer data,
|
||
GDestroyNotify destroy)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
|
||
|
||
if (model->default_sort_destroy)
|
||
{
|
||
GDestroyNotify d = model->default_sort_destroy;
|
||
|
||
model->default_sort_destroy = NULL;
|
||
d (model->default_sort_data);
|
||
}
|
||
|
||
model->default_sort_func = func;
|
||
model->default_sort_data = data;
|
||
model->default_sort_destroy = destroy;
|
||
|
||
if (model->sort_column_id == GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)
|
||
gtk_file_system_model_sort (model);
|
||
}
|
||
|
||
static gboolean
|
||
gtk_file_system_model_has_default_sort_func (GtkTreeSortable *sortable)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
|
||
|
||
return (model->default_sort_func != NULL);
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_sortable_init (GtkTreeSortableIface *iface)
|
||
{
|
||
iface->get_sort_column_id = gtk_file_system_model_get_sort_column_id;
|
||
iface->set_sort_column_id = gtk_file_system_model_set_sort_column_id;
|
||
iface->set_sort_func = gtk_file_system_model_set_sort_func;
|
||
iface->set_default_sort_func = gtk_file_system_model_set_default_sort_func;
|
||
iface->has_default_sort_func = gtk_file_system_model_has_default_sort_func;
|
||
}
|
||
|
||
/*** GtkTreeDragSource ***/
|
||
|
||
static gboolean
|
||
drag_source_row_draggable (GtkTreeDragSource *drag_source,
|
||
GtkTreePath *path)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (drag_source);
|
||
GtkTreeIter iter;
|
||
|
||
if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
|
||
return FALSE;
|
||
|
||
return ITER_INDEX (&iter) != 0;
|
||
}
|
||
|
||
static gboolean
|
||
drag_source_drag_data_get (GtkTreeDragSource *drag_source,
|
||
GtkTreePath *path,
|
||
GtkSelectionData *selection_data)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (drag_source);
|
||
FileModelNode *node;
|
||
GtkTreeIter iter;
|
||
char *uris[2];
|
||
|
||
if (!gtk_file_system_model_get_iter (GTK_TREE_MODEL (model), &iter, path))
|
||
return FALSE;
|
||
|
||
node = get_node (model, ITER_INDEX (&iter));
|
||
if (node->file == NULL)
|
||
return FALSE;
|
||
|
||
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;
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
/*** 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_SORTABLE,
|
||
gtk_file_system_model_sortable_init)
|
||
G_IMPLEMENT_INTERFACE (GTK_TYPE_TREE_DRAG_SOURCE,
|
||
drag_source_iface_init))
|
||
|
||
static void
|
||
gtk_file_system_model_dispose (GObject *object)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
|
||
|
||
g_cancellable_cancel (model->cancellable);
|
||
if (model->dir_monitor)
|
||
g_file_monitor_cancel (model->dir_monitor);
|
||
|
||
G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->dispose (object);
|
||
}
|
||
|
||
|
||
static void
|
||
gtk_file_system_model_finalize (GObject *object)
|
||
{
|
||
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (object);
|
||
guint i;
|
||
|
||
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);
|
||
|
||
g_object_unref (model->cancellable);
|
||
g_free (model->attributes);
|
||
if (model->dir)
|
||
g_object_unref (model->dir);
|
||
if (model->dir_monitor)
|
||
g_object_unref (model->dir_monitor);
|
||
g_hash_table_destroy (model->file_lookup);
|
||
|
||
_gtk_tree_data_list_header_free (model->sort_list);
|
||
if (model->default_sort_destroy)
|
||
model->default_sort_destroy (model->default_sort_data);
|
||
|
||
G_OBJECT_CLASS (_gtk_file_system_model_parent_class)->finalize (object);
|
||
}
|
||
|
||
static void
|
||
_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__POINTER,
|
||
G_TYPE_NONE, 1, G_TYPE_POINTER);
|
||
}
|
||
|
||
static void
|
||
_gtk_file_system_model_init (GtkFileSystemModel *model)
|
||
{
|
||
model->show_files = TRUE;
|
||
model->show_folders = TRUE;
|
||
model->show_hidden = FALSE;
|
||
|
||
model->sort_column_id = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
|
||
|
||
model->file_lookup = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal);
|
||
model->cancellable = g_cancellable_new ();
|
||
}
|
||
|
||
/*** API ***/
|
||
|
||
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 gboolean
|
||
thaw_func (gpointer data)
|
||
{
|
||
GtkFileSystemModel *model = data;
|
||
|
||
_gtk_file_system_model_thaw_updates (model);
|
||
model->dir_thaw_source = 0;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_got_files (GObject *object, GAsyncResult *res, gpointer data)
|
||
{
|
||
GFileEnumerator *enumerator = G_FILE_ENUMERATOR (object);
|
||
GtkFileSystemModel *model = data;
|
||
GList *walk, *files;
|
||
GError *error = NULL;
|
||
|
||
gdk_threads_enter ();
|
||
|
||
files = g_file_enumerator_next_files_finish (enumerator, res, &error);
|
||
|
||
if (files)
|
||
{
|
||
if (model->dir_thaw_source == 0)
|
||
{
|
||
_gtk_file_system_model_freeze_updates (model);
|
||
model->dir_thaw_source = gdk_threads_add_timeout_full (IO_PRIORITY + 1,
|
||
50,
|
||
thaw_func,
|
||
model,
|
||
NULL);
|
||
}
|
||
|
||
for (walk = files; walk; walk = walk->next)
|
||
{
|
||
const char *name;
|
||
GFileInfo *info;
|
||
GFile *file;
|
||
|
||
info = walk->data;
|
||
name = g_file_info_get_name (info);
|
||
if (name == NULL)
|
||
{
|
||
/* Shouldn't happen, but the APIs allow it */
|
||
g_object_unref (info);
|
||
continue;
|
||
}
|
||
file = g_file_get_child (model->dir, name);
|
||
_gtk_file_system_model_add_file (model, file, info);
|
||
g_object_unref (file);
|
||
g_object_unref (info);
|
||
}
|
||
g_list_free (files);
|
||
}
|
||
|
||
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);
|
||
|
||
if (model->dir_thaw_source != 0)
|
||
{
|
||
g_source_remove (model->dir_thaw_source);
|
||
model->dir_thaw_source = 0;
|
||
_gtk_file_system_model_thaw_updates (model);
|
||
}
|
||
|
||
g_object_unref (model);
|
||
}
|
||
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 ();
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_query_done (GObject * object,
|
||
GAsyncResult *res,
|
||
gpointer data)
|
||
{
|
||
GtkFileSystemModel *model = data; /* only a valid pointer if not cancelled */
|
||
GFile *file = G_FILE (object);
|
||
GFileInfo *info;
|
||
|
||
info = g_file_query_info_finish (file, res, NULL);
|
||
if (info == NULL)
|
||
return;
|
||
|
||
_gtk_file_system_model_update_file (model, file, info, TRUE);
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_monitor_change (GFileMonitor * monitor,
|
||
GFile * file,
|
||
GFile * other_file,
|
||
GFileMonitorEvent type,
|
||
GtkFileSystemModel *model)
|
||
{
|
||
switch (type)
|
||
{
|
||
case G_FILE_MONITOR_EVENT_CREATED:
|
||
case G_FILE_MONITOR_EVENT_CHANGED:
|
||
case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
|
||
/* We can treat all of these the same way */
|
||
g_file_query_info_async (file,
|
||
model->attributes,
|
||
0,
|
||
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);
|
||
break;
|
||
case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
|
||
/* FIXME: use freeze/thaw with this somehow? */
|
||
case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
|
||
case G_FILE_MONITOR_EVENT_UNMOUNTED:
|
||
default:
|
||
/* ignore these */
|
||
break;
|
||
}
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_got_enumerator (GObject *dir, GAsyncResult *res, gpointer data)
|
||
{
|
||
GtkFileSystemModel *model = data;
|
||
GFileEnumerator *enumerator;
|
||
GError *error = NULL;
|
||
|
||
gdk_threads_enter ();
|
||
|
||
enumerator = g_file_enumerate_children_finish (G_FILE (dir), res, &error);
|
||
if (enumerator == NULL)
|
||
{
|
||
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,
|
||
g_file_is_native (model->dir) ? 50 * FILES_PER_QUERY : FILES_PER_QUERY,
|
||
IO_PRIORITY,
|
||
model->cancellable,
|
||
gtk_file_system_model_got_files,
|
||
model);
|
||
g_object_unref (enumerator);
|
||
model->dir_monitor = g_file_monitor_directory (model->dir,
|
||
0,
|
||
model->cancellable,
|
||
NULL);
|
||
if (model->dir_monitor)
|
||
g_signal_connect (model->dir_monitor,
|
||
"changed",
|
||
G_CALLBACK (gtk_file_system_model_monitor_change),
|
||
model);
|
||
}
|
||
|
||
gdk_threads_leave ();
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_set_n_columns (GtkFileSystemModel *model,
|
||
gint n_columns,
|
||
va_list args)
|
||
{
|
||
guint i;
|
||
|
||
g_assert (model->files == NULL);
|
||
|
||
model->n_columns = n_columns;
|
||
model->column_types = g_slice_alloc0 (sizeof (GType) * n_columns);
|
||
|
||
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;
|
||
}
|
||
|
||
model->column_types[i] = type;
|
||
}
|
||
|
||
model->sort_list = _gtk_tree_data_list_header_new (n_columns, model->column_types);
|
||
|
||
model->files = g_array_new (FALSE, FALSE, NODE_SIZE (model));
|
||
/* add editable node at start */
|
||
g_array_set_size (model->files, 1);
|
||
memset (get_node (model, 0), 0, NODE_SIZE (model));
|
||
}
|
||
|
||
static void
|
||
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));
|
||
|
||
model->dir = g_object_ref (dir);
|
||
model->attributes = g_strdup (attributes);
|
||
|
||
g_object_ref (model);
|
||
g_file_enumerate_children_async (model->dir,
|
||
attributes,
|
||
0,
|
||
IO_PRIORITY,
|
||
model->cancellable,
|
||
gtk_file_system_model_got_enumerator,
|
||
model);
|
||
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_new:
|
||
* @directory: the directory to show.
|
||
* @attributes: attributes to immediately load or %NULL for all
|
||
* @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.
|
||
*
|
||
* 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,
|
||
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;
|
||
|
||
va_start (args, n_columns);
|
||
gtk_file_system_model_set_n_columns (model, n_columns, args);
|
||
va_end (args);
|
||
|
||
gtk_file_system_model_set_directory (model, dir, attributes);
|
||
|
||
return model;
|
||
}
|
||
|
||
static void
|
||
gtk_file_system_model_refilter_all (GtkFileSystemModel *model)
|
||
{
|
||
guint i;
|
||
|
||
if (model->frozen)
|
||
{
|
||
model->filter_on_thaw = TRUE;
|
||
return;
|
||
}
|
||
|
||
_gtk_file_system_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));
|
||
}
|
||
|
||
model->filter_on_thaw = FALSE;
|
||
_gtk_file_system_model_thaw_updates (model);
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_set_show_hidden:
|
||
* @model: a #GtkFileSystemModel
|
||
* @show_hidden: whether hidden files should be displayed
|
||
*
|
||
* Sets whether hidden files should be included in the #GtkTreeModel
|
||
* for display.
|
||
**/
|
||
void
|
||
_gtk_file_system_model_set_show_hidden (GtkFileSystemModel *model,
|
||
gboolean show_hidden)
|
||
{
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
|
||
show_hidden = show_hidden != FALSE;
|
||
|
||
if (show_hidden != model->show_hidden)
|
||
{
|
||
model->show_hidden = show_hidden;
|
||
gtk_file_system_model_refilter_all (model);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_set_show_folders:
|
||
* @model: a #GtkFileSystemModel
|
||
* @show_folders: whether folders should be displayed
|
||
*
|
||
* Sets whether folders should be included in the #GtkTreeModel for
|
||
* display.
|
||
**/
|
||
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;
|
||
gtk_file_system_model_refilter_all (model);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_set_show_files:
|
||
* @model: a #GtkFileSystemModel
|
||
* @show_files: whether files (as opposed to folders) should
|
||
* be displayed.
|
||
*
|
||
* Sets whether files (as opposed to folders) should be included
|
||
* in the #GtkTreeModel for display.
|
||
**/
|
||
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;
|
||
gtk_file_system_model_refilter_all (model);
|
||
}
|
||
}
|
||
|
||
GCancellable *
|
||
_gtk_file_system_model_get_cancellable (GtkFileSystemModel *model)
|
||
{
|
||
g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
|
||
|
||
return model->cancellable;
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_get_info:
|
||
* @model: a #GtkFileSystemModel
|
||
* @iter: a #GtkTreeIter pointing to a row of @model
|
||
*
|
||
* Gets the #GFileInfo structure for a particular row
|
||
* of @model.
|
||
*
|
||
* Return value: a #GFileInfo structure. This structure
|
||
* is owned by @model and must not be modified or freed.
|
||
* If you want to keep the information for later use,
|
||
* you must take a reference, since the structure may be
|
||
* freed on later changes to the file system. If you have
|
||
* called _gtk_file_system_model_add_editable() and the @iter
|
||
* corresponds to the row that this function returned, the
|
||
* return value will be NULL.
|
||
**/
|
||
GFileInfo *
|
||
_gtk_file_system_model_get_info (GtkFileSystemModel *model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
FileModelNode *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;
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_get_file:
|
||
* @model: a #GtkFileSystemModel
|
||
* @iter: a #GtkTreeIter pointing to a row of @model
|
||
*
|
||
* Gets the file for a particular row in @model.
|
||
*
|
||
* Return value: the file. This object is owned by @model and
|
||
* or freed. If you want to save the path for later use,
|
||
* you must take a ref, since the object may be freed
|
||
* on later changes to the file system.
|
||
**/
|
||
GFile *
|
||
_gtk_file_system_model_get_file (GtkFileSystemModel *model,
|
||
GtkTreeIter *iter)
|
||
{
|
||
FileModelNode *node;
|
||
|
||
g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
|
||
|
||
node = get_node (model, ITER_INDEX (iter));
|
||
return node->file;
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_get_value:
|
||
* @model: a #GtkFileSystemModel
|
||
* @iter: a #GtkTreeIter pointing to a row of @model
|
||
* @column: the column to get the value for
|
||
*
|
||
* Gets the value associated with the given row @iter and @column.
|
||
* If no value is available yet and the default value should be used,
|
||
* %NULL is returned.
|
||
* This is a performance optimization for the calls
|
||
* gtk_tree_model_get() or gtk_tree_model_get_value(), which copy
|
||
* the value and spend a considerable amount of time in iterator
|
||
* lookups. Both of which are slow.
|
||
*
|
||
* Returns: a pointer to the actual value as stored in @model or %NULL
|
||
* if no value available yet.
|
||
**/
|
||
const GValue *
|
||
_gtk_file_system_model_get_value (GtkFileSystemModel *model,
|
||
GtkTreeIter * iter,
|
||
int column)
|
||
{
|
||
FileModelNode *node;
|
||
|
||
g_return_val_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model), NULL);
|
||
g_return_val_if_fail (column >= 0 && (guint) column < model->n_columns, NULL);
|
||
|
||
node = get_node (model, ITER_INDEX (iter));
|
||
|
||
if (!G_VALUE_TYPE (&node->values[column]))
|
||
{
|
||
g_value_init (&node->values[column], model->column_types[column]);
|
||
if (!model->get_func (model,
|
||
node->file,
|
||
node->info,
|
||
column,
|
||
&node->values[column],
|
||
model->get_data))
|
||
{
|
||
g_value_unset (&node->values[column]);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
return &node->values[column];
|
||
}
|
||
|
||
static guint
|
||
node_get_for_file (GtkFileSystemModel *model,
|
||
GFile * file)
|
||
{
|
||
guint i;
|
||
|
||
i = GPOINTER_TO_UINT (g_hash_table_lookup (model->file_lookup, file));
|
||
if (i != 0)
|
||
return i;
|
||
|
||
/* node 0 is the editable row and has no associated file or entry in the table */
|
||
for (i = g_hash_table_size (model->file_lookup) + 1; i < model->files->len; i++)
|
||
{
|
||
FileModelNode *node = get_node (model, i);
|
||
|
||
g_hash_table_insert (model->file_lookup, node->file, GUINT_TO_POINTER (i));
|
||
if (g_file_equal (node->file, file))
|
||
return i;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
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);
|
||
|
||
i = node_get_for_file (model, file);
|
||
|
||
if (i == 0)
|
||
return FALSE;
|
||
|
||
ITER_INIT_FROM_INDEX (model, iter, i);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_add_file:
|
||
* @model: the model
|
||
* @file: the file to add
|
||
* @info: the information to associate with the file
|
||
*
|
||
* Adds the given @file with its associated @info to the @model.
|
||
* If the model is frozen, the file will only show up after it is thawn.
|
||
**/
|
||
void
|
||
_gtk_file_system_model_add_file (GtkFileSystemModel *model,
|
||
GFile *file,
|
||
GFileInfo *info)
|
||
{
|
||
FileModelNode *node;
|
||
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
g_return_if_fail (G_IS_FILE (file));
|
||
g_return_if_fail (G_IS_FILE_INFO (info));
|
||
|
||
node = g_slice_alloc0 (NODE_SIZE (model));
|
||
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);
|
||
|
||
if (!model->frozen)
|
||
node_set_visible (model, model->files->len -1,
|
||
node_should_be_visible (model, model->files->len - 1));
|
||
gtk_file_system_model_sort_node (model, model->files->len -1);
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_remove_file:
|
||
* @model: the model
|
||
* @file: file to remove from the model. The file must have been
|
||
* added to the model previously
|
||
*
|
||
* Removes the given file from the model. If the file is not part of
|
||
* @model, this function does nothing.
|
||
**/
|
||
void
|
||
_gtk_file_system_model_remove_file (GtkFileSystemModel *model,
|
||
GFile *file)
|
||
{
|
||
FileModelNode *node;
|
||
guint id;
|
||
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
g_return_if_fail (G_IS_FILE (file));
|
||
|
||
id = node_get_for_file (model, file);
|
||
if (id == 0)
|
||
return;
|
||
|
||
node = get_node (model, id);
|
||
node_set_visible (model, id, FALSE);
|
||
g_object_unref (node->file);
|
||
if (node->info)
|
||
g_object_unref (node->info);
|
||
g_array_remove_index (model->files, id);
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_update_file:
|
||
* @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
|
||
* @model, it will get added automatically.
|
||
**/
|
||
void
|
||
_gtk_file_system_model_update_file (GtkFileSystemModel *model,
|
||
GFile *file,
|
||
GFileInfo *info,
|
||
gboolean requires_resort)
|
||
{
|
||
FileModelNode *node;
|
||
guint i, id;
|
||
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
g_return_if_fail (G_IS_FILE (file));
|
||
g_return_if_fail (G_IS_FILE_INFO (info));
|
||
|
||
id = node_get_for_file (model, file);
|
||
if (id == 0)
|
||
_gtk_file_system_model_add_file (model, file, info);
|
||
|
||
node = get_node (model, id);
|
||
if (node->info)
|
||
g_object_unref (node->info);
|
||
node->info = g_object_ref (info);
|
||
for (i = 0; i < model->n_columns; i++)
|
||
{
|
||
if (G_VALUE_TYPE (&node->values[i]))
|
||
g_value_unset (&node->values[i]);
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
/**
|
||
* _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);
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_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.
|
||
**/
|
||
void
|
||
_gtk_file_system_model_freeze_updates (GtkFileSystemModel *model)
|
||
{
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
|
||
model->frozen++;
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_thaw_updates:
|
||
* @model: a #GtkFileSystemModel
|
||
*
|
||
* Undoes the effect of a previous call to
|
||
* _gtk_file_system_model_freeze_updates()
|
||
**/
|
||
void
|
||
_gtk_file_system_model_thaw_updates (GtkFileSystemModel *model)
|
||
{
|
||
gboolean stuff_added;
|
||
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
g_return_if_fail (model->frozen > 0);
|
||
|
||
model->frozen--;
|
||
if (model->frozen > 0)
|
||
return;
|
||
|
||
stuff_added = get_node (model, model->files->len - 1)->frozen_add;
|
||
|
||
if (model->filter_on_thaw)
|
||
gtk_file_system_model_refilter_all (model);
|
||
if (model->sort_on_thaw)
|
||
gtk_file_system_model_sort (model);
|
||
if (stuff_added)
|
||
{
|
||
guint i;
|
||
|
||
for (i = 0; i < model->files->len; i++)
|
||
{
|
||
FileModelNode *node = get_node (model, i);
|
||
|
||
if (!node->frozen_add)
|
||
continue;
|
||
node->frozen_add = FALSE;
|
||
node_set_visible (model, i, node_should_be_visible (model, i));
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* _gtk_file_system_model_clear_cached_values:
|
||
* @model: a #GtkFileSystemModel
|
||
* @column: the column to clear or -1 for all columns
|
||
*
|
||
* Clears the cached values in the model for the given @column. Use
|
||
* this function whenever your get_value function would return different
|
||
* values for a column.
|
||
* The file chooser uses this for example when the icon theme changes to
|
||
* invalidate the cached pixbufs.
|
||
**/
|
||
void
|
||
_gtk_file_system_model_clear_cache (GtkFileSystemModel *model,
|
||
int column)
|
||
{
|
||
guint i;
|
||
int start, end;
|
||
gboolean changed;
|
||
|
||
g_return_if_fail (GTK_IS_FILE_SYSTEM_MODEL (model));
|
||
g_return_if_fail (column >= -1 && (guint) column < model->n_columns);
|
||
|
||
if (column)
|
||
{
|
||
start = column;
|
||
end = column + 1;
|
||
}
|
||
else
|
||
{
|
||
start = 0;
|
||
end = model->n_columns;
|
||
}
|
||
|
||
for (i = 0; i < model->files->len; i++)
|
||
{
|
||
FileModelNode *node = get_node (model, i);
|
||
changed = FALSE;
|
||
for (column = start; column < end; column++)
|
||
{
|
||
if (!G_VALUE_TYPE (&node->values[column]))
|
||
continue;
|
||
|
||
g_value_unset (&node->values[column]);
|
||
changed = TRUE;
|
||
}
|
||
|
||
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);
|
||
}
|
||
}
|
||
|
||
/* FIXME: resort? */
|
||
}
|
||
|