static VALUE
fileenumerator_close_async(int argc, VALUE *argv, VALUE self)
{
VALUE rbio_priority, rbcancellable, block;
int io_priority;
GCancellable *cancellable;
rb_scan_args(argc, argv, "02&", &rbio_priority, &rbcancellable, &block);
io_priority = RVAL2IOPRIORITYDEFAULT(rbio_priority);
cancellable = RVAL2GCANCELLABLE(rbcancellable);
SAVE_BLOCK(block);
g_file_enumerator_close_async(_SELF(self),
io_priority,
cancellable,
rbgio_async_ready_callback,
(gpointer)block);
return self;
}
static void
got_more_files (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
LoadBasenamesData *data = user_data;
GList *infos, *l;
GFileInfo *info;
const char *name;
gboolean append_slash;
char *t;
char *basename;
if (data->completer == NULL)
{
/* Was cancelled */
load_basenames_data_free (data);
return;
}
infos = g_file_enumerator_next_files_finish (data->enumerator, res, NULL);
for (l = infos; l != NULL; l = l->next)
{
info = l->data;
if (data->dirs_only &&
g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY)
{
g_object_unref (info);
continue;
}
append_slash = g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY;
name = g_file_info_get_name (info);
if (name == NULL)
{
g_object_unref (info);
continue;
}
if (data->should_escape)
basename = g_uri_escape_string (name,
G_URI_RESERVED_CHARS_ALLOWED_IN_PATH,
TRUE);
else
/* If not should_escape, must be a local filename, convert to utf8 */
basename = g_filename_to_utf8 (name, -1, NULL, NULL, NULL);
if (basename)
{
if (append_slash)
{
t = basename;
basename = g_strconcat (basename, "/", NULL);
g_free (t);
}
data->basenames = g_list_prepend (data->basenames, basename);
}
g_object_unref (info);
}
g_list_free (infos);
if (infos)
{
/* Not last, get more files */
g_file_enumerator_next_files_async (data->enumerator,
100,
0,
data->cancellable,
got_more_files, data);
}
else
{
data->completer->basename_loader = NULL;
if (data->completer->basenames_dir)
g_object_unref (data->completer->basenames_dir);
g_list_foreach (data->completer->basenames, (GFunc)g_free, NULL);
g_list_free (data->completer->basenames);
data->completer->basenames_dir = g_object_ref (data->dir);
data->completer->basenames = data->basenames;
data->completer->basenames_are_escaped = data->should_escape;
data->basenames = NULL;
g_file_enumerator_close_async (data->enumerator, 0, NULL, NULL, NULL);
g_signal_emit (data->completer, signals[GOT_COMPLETION_DATA], 0);
load_basenames_data_free (data);
}
}
static void
more_files_callback (GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
InsensitiveFileSearchData *data = (InsensitiveFileSearchData *) (user_data);
GList *files, *l;
gchar *filename = NULL, *component, *case_folded_name,
*name_collation_key;
gboolean end_of_files, is_utf8;
files = g_file_enumerator_next_files_finish (data->enumerator,
res, NULL);
end_of_files = files == NULL;
component = data->split_path[data->index];
g_return_if_fail (component != NULL);
is_utf8 = (g_utf8_validate (component, -1, NULL));
if (is_utf8)
{
case_folded_name = g_utf8_casefold (component, -1);
name_collation_key = g_utf8_collate_key (case_folded_name, -1);
g_free (case_folded_name);
}
else
{
name_collation_key = g_ascii_strdown (component, -1);
}
for (l = files; l != NULL; l = l->next)
{
GFileInfo *info;
const gchar *this_name;
gchar *key;
info = l->data;
this_name = g_file_info_get_name (info);
if (is_utf8 && g_utf8_validate (this_name, -1, NULL))
{
gchar *case_folded;
case_folded = g_utf8_casefold (this_name, -1);
key = g_utf8_collate_key (case_folded, -1);
g_free (case_folded);
}
else
{
key = g_ascii_strdown (this_name, -1);
}
if (strcmp (key, name_collation_key) == 0)
filename = g_strdup (this_name);
g_free (key);
if (filename)
break;
}
g_list_free_full (files, g_object_unref);
g_free (name_collation_key);
if (filename)
{
GFile *next_file;
g_file_enumerator_close_async (data->enumerator,
G_PRIORITY_DEFAULT,
data->cancellable,
NULL, NULL);
g_object_unref (data->enumerator);
data->enumerator = NULL;
/* Set the current file and continue searching */
next_file = g_file_get_child (data->current_file, filename);
g_free (filename);
g_object_unref (data->current_file);
data->current_file = next_file;
data->index++;
/* Skip any empty components due to multiple slashes */
while (data->split_path[data->index] != NULL &&
*data->split_path[data->index] == 0)
data->index++;
if (data->split_path[data->index] == NULL)
{
/* Search is complete, file was found */
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
g_simple_async_result_set_op_res_gpointer (simple, g_object_ref (data->current_file), g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
return;
}
/* Continue searching down the tree */
g_file_enumerate_children_async (data->current_file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
0, G_PRIORITY_DEFAULT,
data->cancellable,
enumerated_children_callback,
data);
return;
}
if (end_of_files)
{
/* Could not find the given file, abort the search */
GSimpleAsyncResult *simple;
GFile *file;
g_object_unref (data->enumerator);
data->enumerator = NULL;
simple = g_simple_async_result_new (G_OBJECT (data->root),
data->callback,
data->user_data,
_g_find_file_insensitive_async);
file = g_file_get_child (data->root, data->original_path);
g_simple_async_result_set_op_res_gpointer (simple, file, g_object_unref);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
clear_find_file_insensitive_state (data);
return;
}
/* Continue enumerating */
g_file_enumerator_next_files_async (data->enumerator,
INSENSITIVE_SEARCH_ITEMS_PER_CALLBACK,
G_PRIORITY_DEFAULT,
data->cancellable,
more_files_callback,
data);
}
