/* Asserts that all files in @included are also in @including */
static void
scan_directory (GFile *directory,
FileScannedCallback scanned_callback,
gpointer callback_data)
{
GQueue *files;
GQueue *file_infos;
GFileEnumerator *enumerator;
files = g_queue_new ();
file_infos = g_queue_new ();
g_queue_push_tail (files, g_object_ref (directory));
g_queue_push_tail (file_infos,
g_file_query_info (directory,
G_FILE_ATTRIBUTE_STANDARD_NAME","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL));
while (!g_queue_is_empty (files)) {
g_autoptr (GFile) file;
g_autoptr (GFileInfo) file_info;
file = g_queue_pop_tail (files);
file_info = g_queue_pop_tail (file_infos);
if (scanned_callback) {
scanned_callback (file, file_info, callback_data);
}
if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY) {
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL);
if (enumerator) {
GFile *child;
GFileInfo *child_info;
child_info = g_file_enumerator_next_file (enumerator, NULL, NULL);
while (child_info != NULL) {
child = g_file_get_child (file, g_file_info_get_name (child_info));
g_queue_push_tail (files, child);
g_queue_push_tail (file_infos, child_info);
child_info = g_file_enumerator_next_file (enumerator, NULL, NULL);
}
g_object_unref (enumerator);
}
}
}
g_queue_free_full (files, g_object_unref);
g_queue_free_full (file_infos, g_object_unref);
}
/**
* Iterates over an enumerator obtained from a directory.
* @param main_struct : main structure of the program
* @param directory is the directory we are iterating over
* @param file_enum is the enumerator obtained when opening a directory
* to carve it.
*/
static void iterate_over_enum(main_struct_t *main_struct, gchar *directory, GFileEnumerator *file_enum)
{
GError *error = NULL;
GFileInfo *fileinfo = NULL;
file_event_t *file_event = NULL;
if (main_struct != NULL && file_enum != NULL)
{
fileinfo = g_file_enumerator_next_file(file_enum, NULL, &error);
while (error == NULL && fileinfo != NULL)
{
/* file_event is used and freed in the thread
* save_one_file_threaded where the queue save_queue
* is used
*/
file_event = new_file_event_t(directory, fileinfo);
g_async_queue_push(main_struct->save_queue, file_event);
fileinfo = free_object(fileinfo);
fileinfo = g_file_enumerator_next_file(file_enum, NULL, &error);
}
}
}
static GArray *
_get_ref_frame_cache (GstValidateSsim * self, const gchar * ref_file)
{
GFile *ref_dir_file = NULL;
GFileInfo *info;
GFileEnumerator *fenum;
GArray *frames = NULL;
gchar *ref_dir = NULL;
ref_dir = g_path_get_dirname (ref_file);
frames = g_hash_table_lookup (self->priv->ref_frames_cache, ref_file);
if (frames)
goto done;
ref_dir_file = g_file_new_for_path (ref_dir);
if (!(fenum = g_file_enumerate_children (ref_dir_file,
"standard::*", G_FILE_QUERY_INFO_NONE, NULL, NULL))) {
GST_INFO ("%s is not a folder", ref_dir);
goto done;
}
for (info = g_file_enumerator_next_file (fenum, NULL, NULL);
info; info = g_file_enumerator_next_file (fenum, NULL, NULL)) {
Frame iframe;
const gchar *display_name = g_file_info_get_display_name (info);
if (!_filename_get_timestamp (self, display_name, &iframe.ts)) {
g_object_unref (info);
continue;
}
iframe.path = g_build_path (G_DIR_SEPARATOR_S,
ref_dir, g_file_info_get_name (info), NULL);
g_object_unref (info);
if (!frames) {
frames = g_array_new (TRUE, TRUE, sizeof (Frame));
g_array_set_clear_func (frames, (GDestroyNotify) _free_frame);
}
g_array_append_val (frames, iframe);
}
if (frames) {
g_array_sort (frames, (GCompareFunc) _sort_frames);
g_hash_table_insert (self->priv->ref_frames_cache, g_strdup (ref_dir),
frames);
}
done:
g_clear_object (&ref_dir_file);
g_free (ref_dir);
return frames;
}
static GList *
ephy_web_application_get_application_list_internal (gboolean only_legacy)
{
GFileEnumerator *children = NULL;
GFileInfo *info;
GList *applications = NULL;
g_autofree char *parent_directory_path = NULL;
g_autoptr(GFile) parent_directory = NULL;
if (only_legacy)
parent_directory_path = g_build_filename (g_get_user_config_dir (), "epiphany", NULL);
else
parent_directory_path = g_strdup (g_get_user_data_dir ());
parent_directory = g_file_new_for_path (parent_directory_path);
children = g_file_enumerate_children (parent_directory,
"standard::name",
0, NULL, NULL);
if (!children)
return NULL;
info = g_file_enumerator_next_file (children, NULL, NULL);
while (info) {
const char *name;
name = g_file_info_get_name (info);
if ((only_legacy && g_str_has_prefix (name, "app-")) ||
(!only_legacy && g_str_has_prefix (name, EPHY_WEB_APP_PROGRAM_NAME_PREFIX))) {
EphyWebApplication *app;
char *profile_dir;
profile_dir = g_build_filename (parent_directory_path, name, NULL);
app = ephy_web_application_for_profile_directory (profile_dir);
if (app) {
if (!only_legacy) {
g_autofree char *app_file = g_build_filename (profile_dir, ".app", NULL);
if (g_file_test (app_file, G_FILE_TEST_EXISTS))
applications = g_list_prepend (applications, app);
else
g_object_unref (app);
} else
applications = g_list_prepend (applications, app);
}
g_free (profile_dir);
}
g_object_unref (info);
info = g_file_enumerator_next_file (children, NULL, NULL);
}
g_object_unref (children);
return g_list_reverse (applications);
}
int recurseDirs(const char *path, ThreadManager *threadman) {
GValue message = {0,};
g_value_init(&message,G_TYPE_STRING);
g_value_set_string(&message,"busy");
g_object_set_property(G_OBJECT(threadman),"status", &message);
g_value_unset(&message);
if(path==NULL) {
return 1;
}
sleep(1);
GFile *dir = g_file_new_for_path(path);
GFileEnumerator *fileEnumerator;
GError *errorHandler=NULL;
fileEnumerator = g_file_enumerate_children(dir,"standard::*",G_FILE_QUERY_INFO_NONE,NULL,&errorHandler);
if(errorHandler!=NULL) {
fprintf(stderr,"ERROR: %s\n",errorHandler->message);
g_error_free(errorHandler);
return 1;
}
if(fileEnumerator!=NULL) {
GFileInfo *finfo = g_file_enumerator_next_file(fileEnumerator,NULL,NULL);
while(finfo!=NULL) {
if(!g_file_info_get_is_hidden(finfo)) {
const gchar *name;
char *fullPath;
name = g_file_info_get_name(finfo);
fullPath = strdup(path);
fullPath = realloc(fullPath,strlen(path)+3+strlen(name));
strcat(fullPath,"/");
strcat(fullPath,name);
if(g_file_info_get_file_type(finfo)==G_FILE_TYPE_DIRECTORY) {
int res = recurseDirs(fullPath,threadman);
if(res!=0) {
fprintf(stderr,"Error with %s\n",fullPath);
}
} else {
const gchar *type = g_file_info_get_attribute_string(finfo,G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
if(strcmp(type,"audio/mpeg")==0) {
addToIndex(name,fullPath,type);
}
}
free(fullPath);
}
finfo = g_file_enumerator_next_file(fileEnumerator,NULL,NULL);
}
g_object_unref(fileEnumerator);
}
return 0;
}
GPtrArray *
symbol_db_util_get_source_files_by_mime (const gchar* dir, const GHashTable *mimes)
{
GPtrArray* files = g_ptr_array_new();
GFile *file;
GFileEnumerator *enumerator;
GFileInfo* info;
GError *error = NULL;
gchar *buildable_dir;
g_return_val_if_fail (dir != NULL, NULL);
g_return_val_if_fail (mimes != NULL, NULL);
if ((file = g_file_new_for_commandline_arg (dir)) == NULL)
return NULL;
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
NULL, &error);
if (!enumerator)
{
g_warning ("Could not enumerate: %s %s\n",
g_file_get_path (file),
error->message);
g_error_free (error);
g_object_unref (file);
return files;
}
buildable_dir = g_file_get_path (file);
for (info = g_file_enumerator_next_file (enumerator, NULL, NULL); info != NULL;
info = g_file_enumerator_next_file (enumerator, NULL, NULL))
{
const gchar *mime_type = g_file_info_get_content_type (info);
if (!mime_type)
continue;
if (g_hash_table_lookup ((GHashTable*)mimes, mime_type) != NULL)
{
g_ptr_array_add (files, g_build_filename (buildable_dir, g_file_info_get_name (info), NULL));
}
}
g_free (buildable_dir);
g_object_unref (enumerator);
g_object_unref (file);
return files;
}
/**
* gwy_module_load_directory:
* @path: Name of directory to be scanned for modules and module libraries.
* Subdirectories are <emphasis>not</emphasis> scanned.
* @errorlist: (allow-none):
* Location to store possible errors.
* Errors from %GWY_MODULE_ERROR or %G_IO_ERROR domain can occur.
*
* Loads modules and module libraries from a directory.
*
* This function only loads the modules or libraries and queues them for
* registration. You need to call also gwy_module_register_types() some time
* in the future to finish the registration.
*
* Returns: The number of shared libraries that were found and loaded as either
* modules of module libraries.
**/
guint
gwy_module_load_directory(const gchar *path,
GwyErrorList **errorlist)
{
static const gchar attrs[] = (G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP ","
G_FILE_ATTRIBUTE_STANDARD_NAME);
g_return_val_if_fail(path, 0);
GFile *file = g_file_new_for_path(path);
GError *error = NULL;
GFileEnumerator *enumerator = g_file_enumerate_children(file, attrs, 0,
NULL, &error);
if (!enumerator) {
gwy_error_list_propagate(errorlist, error);
g_object_unref(file);
return 0;
}
guint count = 0;
for (GFileInfo *fileinfo = g_file_enumerator_next_file(enumerator, NULL,
&error);
fileinfo;
(void)g_object_unref(fileinfo),
(fileinfo = g_file_enumerator_next_file(enumerator, NULL, &error))) {
if (g_file_info_get_is_hidden(fileinfo)
|| g_file_info_get_is_backup(fileinfo))
continue;
GFileType filetype = g_file_info_get_file_type(fileinfo);
if (filetype != G_FILE_TYPE_REGULAR
&& filetype != G_FILE_TYPE_SYMBOLIC_LINK)
continue;
const gchar *name = g_file_info_get_name(fileinfo);
if (!g_str_has_suffix(name, "." G_MODULE_SUFFIX))
continue;
gchar *fullname = g_build_filename(path, name, NULL);
if (queue_one_module_or_library(fullname, errorlist))
count++;
g_free(fullname);
}
if (error)
gwy_error_list_propagate(errorlist, error);
g_object_unref(enumerator);
g_object_unref(file);
return count;
}
/**
* as_utils_delete_dir_recursive:
* @dirname: Directory to remove
*
* Remove directory and all its children (like rm -r does).
*
* Returns: %TRUE if operation was successful
*/
gboolean
as_utils_delete_dir_recursive (const gchar* dirname)
{
GError *error = NULL;
gboolean ret = FALSE;
GFile *dir;
GFileEnumerator *enr;
GFileInfo *info;
g_return_val_if_fail (dirname != NULL, FALSE);
if (!g_file_test (dirname, G_FILE_TEST_IS_DIR))
return TRUE;
dir = g_file_new_for_path (dirname);
enr = g_file_enumerate_children (dir, "standard::name", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &error);
if (error != NULL)
goto out;
if (enr == NULL)
goto out;
info = g_file_enumerator_next_file (enr, NULL, &error);
if (error != NULL)
goto out;
while (info != NULL) {
gchar *path;
path = g_build_filename (dirname, g_file_info_get_name (info), NULL);
if (g_file_test (path, G_FILE_TEST_IS_DIR)) {
as_utils_delete_dir_recursive (path);
} else {
g_remove (path);
}
g_object_unref (info);
info = g_file_enumerator_next_file (enr, NULL, &error);
if (error != NULL)
goto out;
}
if (g_file_test (dirname, G_FILE_TEST_EXISTS)) {
g_rmdir (dirname);
}
ret = TRUE;
out:
g_object_unref (dir);
if (enr != NULL)
g_object_unref (enr);
if (error != NULL) {
g_critical ("Could not remove directory: %s", error->message);
g_error_free (error);
}
return ret;
}
/**
* Create list of infos about objects in opened directory
* Return: NS_OK when list obtained, otherwise error code according
* to failed operation.
*/
nsresult
nsGIOInputStream::DoOpenDirectory()
{
GError *error = nullptr;
GFileEnumerator *f_enum = g_file_enumerate_children(mHandle,
"standard::*,time::*",
G_FILE_QUERY_INFO_NONE,
nullptr,
&error);
if (!f_enum) {
nsresult rv = MapGIOResult(error);
g_warning("Cannot read from directory: %s", error->message);
g_error_free(error);
return rv;
}
// fill list of file infos
GFileInfo *info = g_file_enumerator_next_file(f_enum, nullptr, &error);
while (info) {
mDirList = g_list_append(mDirList, info);
info = g_file_enumerator_next_file(f_enum, nullptr, &error);
}
g_object_unref(f_enum);
if (error) {
g_warning("Error reading directory content: %s", error->message);
nsresult rv = MapGIOResult(error);
g_error_free(error);
return rv;
}
mDirOpen = true;
// Sort list of file infos by using FileInfoComparator function
mDirList = g_list_sort(mDirList, FileInfoComparator);
mDirListPtr = mDirList;
// Write base URL (make sure it ends with a '/')
mDirBuf.AppendLiteral("300: ");
mDirBuf.Append(mSpec);
if (mSpec.get()[mSpec.Length() - 1] != '/')
mDirBuf.Append('/');
mDirBuf.Append('\n');
// Write column names
mDirBuf.AppendLiteral("200: filename content-length last-modified file-type\n");
// Write charset (assume UTF-8)
// XXX is this correct?
mDirBuf.AppendLiteral("301: UTF-8\n");
SetContentTypeOfChannel(APPLICATION_HTTP_INDEX_FORMAT);
return NS_OK;
}
gboolean
libre_impuesto_file_delete_dir_recursively (GFile *directory, GError **error)
{
GFileEnumerator *children = NULL;
GFileInfo *info;
gboolean ret = TRUE;
children = g_file_enumerate_children (directory,
"standard::name,standard::type",
0, NULL, error);
if (error)
goto out;
info = g_file_enumerator_next_file (children, NULL, error);
while (info || error) {
GFile *child;
const char *name;
GFileType type;
if (error)
goto out;
name = g_file_info_get_name (info);
child = g_file_get_child (directory, name);
type = g_file_info_get_file_type (info);
if (type == G_FILE_TYPE_DIRECTORY)
ret = libre_impuesto_file_delete_dir_recursively (child, error);
else if (type == G_FILE_TYPE_REGULAR)
ret = g_file_delete (child, NULL, error);
g_object_unref (info);
if (!ret)
goto out;
info = g_file_enumerator_next_file (children, NULL, error);
}
ret = TRUE;
g_file_delete (directory, NULL, error);
out:
if (children)
g_object_unref (children);
return ret;
}
static gboolean
append_dir(GtkTreeStore* store, GtkTreeIter* parent_iter,
GFile* dir, const char* encoding)
{
GtkTreeIter iter;
GFileInfo* info;
GFileEnumerator* e;
gboolean success_all = TRUE;
e = g_file_enumerate_children(dir,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (e == NULL)
return success_all;
info = g_file_enumerator_next_file(e, NULL, NULL);
while (info != NULL) {
const char* name = g_file_info_get_name(info);
char* display_name = get_display_name(name);
char* new_name = get_new_name(name, encoding);
GFileType ftype;
file_list_model_append(store, &iter, parent_iter,
NULL, name, display_name, new_name);
if (new_name == NULL)
success_all = FALSE;
ftype = g_file_info_get_file_type(info);
if (ftype == G_FILE_TYPE_DIRECTORY) {
gboolean res;
GFile* child = g_file_get_child(dir, name);
res = append_dir(store, &iter, child, encoding);
g_object_unref(child);
if (!res)
success_all = FALSE;
}
g_object_unref(info);
g_free(display_name);
g_free(new_name);
info = g_file_enumerator_next_file(e, NULL, NULL);
}
g_object_unref(e);
return success_all;
}
static void
rb_psp_source_create_playlists (RBGenericPlayerSource *source)
{
GMount *mount;
GFile *music_dir;
g_object_get (source, "mount", &mount, NULL);
music_dir = find_music_dir (mount);
g_object_unref (mount);
if (music_dir != NULL) {
GFileEnumerator *e;
GFileInfo *info;
e = g_file_enumerate_children (music_dir, G_FILE_ATTRIBUTE_STANDARD_NAME","G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (e != NULL) {
while ((info = g_file_enumerator_next_file (e, NULL, NULL)) != NULL) {
GFile *file;
const char *name;
if (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY) {
g_object_unref (info);
continue;
}
name = g_file_info_get_name (info);
file = g_file_resolve_relative_path (music_dir, name);
visit_playlist_dirs (RB_PSP_SOURCE (source), file);
g_object_unref (file);
g_object_unref (info);
}
g_object_unref (e);
}
g_object_unref (music_dir);
}
}
static GList *
get_description_files (GFile *dir)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GFile *desc_file;
GList *files;
const gchar *name;
enumerator = g_file_enumerate_children (dir,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if (!enumerator) {
return NULL;
}
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL) {
name = g_file_info_get_name (info);
if (g_str_has_suffix (name, ".description")) {
desc_file = g_file_enumerator_get_child (enumerator, info);
files = g_list_insert_sorted (files, desc_file, compare_files);
}
g_object_unref (info);
}
g_object_unref (enumerator);
return files;
}
static gboolean
xplayer_pl_parser_load_directory (GFile *file, GList **list, gboolean *unhandled)
{
GFileEnumerator *e;
GFileInfo *info;
GError *err = NULL;
*list = NULL;
*unhandled = FALSE;
e = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
NULL, &err);
if (e == NULL) {
if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED) != FALSE)
*unhandled = TRUE;
g_error_free (err);
return FALSE;
}
while ((info = g_file_enumerator_next_file (e, NULL, NULL)) != NULL)
*list = g_list_prepend (*list, info);
g_file_enumerator_close (e, NULL, NULL);
g_object_unref (e);
return TRUE;
}
int
main (int argc, char **argv)
{
GFile *dir;
GFileEnumerator *fenum;
GFileInfo *info;
GError *error = NULL;
g_type_init();
dir = g_file_new_for_uri ("file:///home/gabriel/Fotos/Festa%20D%C3%A9ia");
fenum = g_file_enumerate_children (dir,
"*",
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
if (error)
g_printerr ("FUDEU: %s\n", error->message);
while ((info = g_file_enumerator_next_file(fenum, NULL, NULL))){
g_print ("LISTANDO: %s\n", g_file_info_get_name (info));
g_object_unref (info);
}
return 0;
}
static void
_delete_trash_file (GFile *file,
gboolean del_file,
gboolean del_children)
{
GFileInfo *info;
GFile *child;
GFileEnumerator *enumerator;
if (del_children)
{
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL);
if (enumerator)
{
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL)
{
child = g_file_get_child (file, g_file_info_get_name (info));
_delete_trash_file (child, TRUE,
g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY);
g_object_unref (child);
g_object_unref (info);
}
g_file_enumerator_close (enumerator, NULL, NULL);
g_object_unref (enumerator);
}
}
if (del_file)
{
g_file_delete (file, NULL, NULL);
}
}
QStringList Dir::m_entry_list()
{
QStringList entries;
if(m_info->isDir())
{
GError *err = NULL;
GFileEnumerator *enumerator = g_file_enumerate_children(m_file, "*", G_FILE_QUERY_INFO_NONE, NULL, &err);
if(!enumerator)
{
g_object_unref(enumerator);
return entries;
}
for(GFileInfo *info = g_file_enumerator_next_file(enumerator, NULL, &err); !(info == 0); info = g_file_enumerator_next_file(enumerator , NULL, &err))
{
entries.append(QString(g_file_get_uri(m_file)) + "/" + QString(g_file_info_get_name(info)));
g_object_unref(info);
}
g_file_enumerator_close(enumerator, NULL, &err);
g_object_unref(enumerator);
}
return entries;
}
static void
directory_foreach (GFile *file,
gchar *suffix,
GFunc func,
gpointer user_data)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GFile *child;
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (!enumerator) {
return;
}
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL) {
if (!suffix || g_str_has_suffix (g_file_info_get_name (info), suffix)) {
child = g_file_enumerator_get_child (enumerator, info);
(func) (child, user_data);
g_object_unref (child);
}
g_object_unref (info);
}
g_object_unref (enumerator);
}
static SoupBuffer *
webkit_soup_directory_input_stream_read_next_file (WebKitSoupDirectoryInputStream *stream,
GCancellable *cancellable,
GError **error)
{
GFileInfo *info;
SoupBuffer *buffer;
GError *err = NULL;
do {
info = g_file_enumerator_next_file (stream->enumerator, cancellable, &err);
if (info == NULL) {
if (err) {
g_propagate_error (error, err);
return NULL;
} else if (!stream->done) {
stream->done = TRUE;
return soup_buffer_new (SOUP_MEMORY_STATIC,
EXIT_STRING,
sizeof (EXIT_STRING));
} else {
return NULL;
}
}
buffer = webkit_soup_directory_input_stream_parse_info (stream, info);
} while (buffer == NULL);
return buffer;
}
/*Recursively delete the file.*/
void
codeslayer_utils_file_delete (GFile *file,
GError **error)
{
GFileEnumerator *enumerator;
enumerator = g_file_enumerate_children (file, "standard::*",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL);
if (enumerator != NULL)
{
GFileInfo *file_info;
while ((file_info = g_file_enumerator_next_file (enumerator, NULL, NULL)) != NULL)
{
GFile *child;
const char *file_name = g_file_info_get_name (file_info);
child = g_file_get_child (file, file_name);
if (g_file_info_get_file_type (file_info) == G_FILE_TYPE_DIRECTORY)
codeslayer_utils_file_delete (child, error);
g_file_delete (child, NULL, error);
g_object_unref(child);
g_object_unref (file_info);
}
g_object_unref (enumerator);
}
g_file_delete (file, NULL, error);
}
static gboolean
read_all_children (char *filename,
const char *attributes,
GList **list_out)
{
GFileEnumerator *enumerator;
GList *list;
GFile *file;
GFileInfo *info;
file = g_file_new_for_path (filename);
enumerator = g_file_enumerate_children (file, attributes, 0, NULL, NULL);
if (enumerator == NULL) {
return FALSE;
}
list = NULL;
do {
info = g_file_enumerator_next_file (enumerator, NULL, NULL);
if (info) {
list = g_list_prepend (list, info);
}
} while (info != NULL);
g_object_unref (enumerator);
g_object_unref (file);
*list_out = g_list_reverse (list);
return TRUE;
}
static gboolean
xmms_gvfs_browse (xmms_xform_t *xform, const gchar *url, xmms_error_t *error)
{
GError *err = NULL;
GFile *file;
GFileInfo *info;
GFileEnumerator *enumerator;
/* Same hack as in _init */
if (!g_ascii_strncasecmp (url, "file://", 7)) {
file = g_file_new_for_path (url+7);
} else {
file = g_file_new_for_uri (url);
}
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_SIZE,
G_FILE_QUERY_INFO_NONE,
NULL,
&err);
g_object_unref (file);
if (!enumerator) {
xmms_error_set (error, XMMS_ERROR_GENERIC, err->message);
return FALSE;
}
while ((info = g_file_enumerator_next_file (enumerator, NULL, NULL))) {
guint32 child_type, flags = 0;
guint64 child_size;
const gchar *child_name;
child_name = g_file_info_get_attribute_byte_string (info,
G_FILE_ATTRIBUTE_STANDARD_NAME);
child_type = g_file_info_get_attribute_uint32 (info,
G_FILE_ATTRIBUTE_STANDARD_TYPE);
child_size = g_file_info_get_attribute_uint64 (info,
G_FILE_ATTRIBUTE_STANDARD_SIZE);
if (child_type & G_FILE_TYPE_DIRECTORY) {
flags |= XMMS_XFORM_BROWSE_FLAG_DIR;
}
xmms_xform_browse_add_entry (xform, child_name, flags);
if (~child_type & G_FILE_TYPE_DIRECTORY) {
xmms_xform_browse_add_entry_property_int (xform,
XMMS_MEDIALIB_ENTRY_PROPERTY_SIZE,
child_size);
}
g_object_unref (info);
}
g_file_enumerator_close (enumerator, NULL, NULL);
return TRUE;
}
static void
updater_find_sub_directories (updater_t *updater, GFile *file)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GError *err = NULL;
g_return_if_fail (updater);
g_return_if_fail (file);
enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE, NULL, &err);
g_clear_error (&err);
while ((info = g_file_enumerator_next_file (enumerator, NULL, &err)) != NULL) {
const gchar *name;
GFile *child;
name = g_file_info_get_name (info);
child = g_file_get_child (file, name);
g_object_unref (info);
updater_add_watcher (updater, child);
g_object_unref (child);
}
g_object_unref (enumerator);
}
static int
run_all_tests (int argc, char **argv)
{
GFile *dir, *file;
GFileInfo *info;
GFileEnumerator *children;
GList *list = NULL;
dir = g_file_new_for_path ("uri");
children = g_file_enumerate_children (dir,
G_FILE_ATTRIBUTE_STANDARD_NAME,
0, NULL, NULL);
while ((info = g_file_enumerator_next_file (children, NULL, NULL))) {
const gchar *name = g_file_info_get_attribute_byte_string (info,
G_FILE_ATTRIBUTE_STANDARD_NAME);
if (!g_str_has_suffix (name, ".test"))
continue;
list = g_list_insert_sorted (list, (gchar *) name, (GCompareFunc) strcmp);
}
while (list) {
gchar *test_id = g_strconcat ("/", list->data, NULL);
file = g_file_get_child (dir, list->data);
g_test_add_data_func (test_id, file, run_test);
g_free (test_id);
list = g_list_delete_link (list, list);
}
return g_test_run ();
}
void
test_utils_add_test_for_all_files (const gchar *prefix,
GFile *base,
GFile *file,
GTestDataFunc test_func,
AddTestFunc add_test_func)
{
GFileEnumerator *enumerator;
GFileInfo *info;
GList *l, *files;
GError *error = NULL;
if (g_file_query_file_type (file, 0, NULL) != G_FILE_TYPE_DIRECTORY)
{
gchar *test_path;
gchar *relative_path;
if (base)
relative_path = g_file_get_relative_path (base, file);
else
relative_path = g_file_get_path (file);
test_path = g_strconcat (prefix, "/", relative_path, NULL);
g_test_add_data_func_full (test_path, g_object_ref (file), test_func, g_object_unref);
return;
}
enumerator = g_file_enumerate_children (file, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
g_assert_no_error (error);
files = NULL;
while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
{
GFile *next_file = g_file_get_child (file, g_file_info_get_name (info));
if (add_test_func == NULL || add_test_func (next_file))
{
files = g_list_prepend (files, g_object_ref (next_file));
}
g_object_unref (next_file);
g_object_unref (info);
}
g_assert_no_error (error);
g_object_unref (enumerator);
files = g_list_sort (files, compare_files);
for (l = files; l; l = l->next)
{
test_utils_add_test_for_all_files (prefix, base, l->data, test_func, add_test_func);
}
g_list_free_full (files, g_object_unref);
}
bool recursive_delete_path( GFile * file )
{
bool result = false;
GFileInfo * info = g_file_query_info( file, "standard::*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL );
if ( info )
{
if ( g_file_info_get_file_type( info ) == G_FILE_TYPE_DIRECTORY )
{
GFileEnumerator * enumerator = g_file_enumerate_children( file, "standard::*", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, NULL );
if ( enumerator )
{
while ( true )
{
GError * error = NULL;
GFileInfo * child_info = g_file_enumerator_next_file( enumerator, NULL, &error );
if ( ! child_info )
{
g_clear_error( &error );
break;
}
GFile * child = g_file_resolve_relative_path( file, g_file_info_get_name( child_info ) );
bool child_deleted = recursive_delete_path( child );
g_object_unref( G_OBJECT( child_info ) );
g_object_unref( G_OBJECT( child ) );
if ( ! child_deleted )
{
break;
}
}
g_object_unref( G_OBJECT( enumerator ) );
}
}
g_object_unref( G_OBJECT( info ) );
gchar * s = g_file_get_path( file );
g_debug( "DELETING '%s'", s );
g_free( s );
// Will delete the file or directory
result = g_file_delete( file, NULL, NULL );
}
return result;
}
/* Search the documentation pages for the string 'text', building the index
if necessary */
void
i7_search_window_search_documentation(I7SearchWindow *self)
{
GError *err;
if(doc_index == NULL) { /* documentation index hasn't been built yet */
GFile *doc_file = i7_app_get_data_file_va(i7_app_get(), "Documentation", NULL);
GFileEnumerator *docdir;
if((docdir = g_file_enumerate_children(doc_file, "standard::*", G_FILE_QUERY_INFO_NONE, NULL, &err)) == NULL) {
IO_ERROR_DIALOG(GTK_WINDOW(self), doc_file, err, _("opening documentation directory"));
g_object_unref(doc_file);
return;
}
start_spinner(self);
GFileInfo *info;
while((info = g_file_enumerator_next_file(docdir, NULL, &err)) != NULL) {
const char *basename = g_file_info_get_name(info);
const char *displayname = g_file_info_get_display_name(info);
if(!g_str_has_suffix(basename, ".html") ||
(!g_str_has_prefix(basename, "doc") && !g_str_has_prefix(basename, "Rdoc")))
continue;
char *label = g_strdup_printf(_("Please be patient, indexing %s..."), displayname);
gtk_label_set_text(GTK_LABEL(self->search_text), label);
g_free(label);
while(gtk_events_pending())
gtk_main_iteration();
GFile *file = g_file_get_child(doc_file, basename);
GSList *doctexts = html_to_ascii(file, g_str_has_prefix(basename, "R"));
g_object_unref(file);
if(doctexts != NULL) {
GSList *iter;
/* Append the entries to the documentation index and search them
right now while we're at it */
for(iter = doctexts; iter != NULL; iter = g_slist_next(iter)) {
doc_index = g_list_prepend(doc_index, iter->data);
search_documentation(iter->data, self);
}
g_slist_free(doctexts);
}
}
g_object_unref(doc_file);
stop_spinner(self);
update_label(self);
} else {
start_spinner(self);
g_list_foreach(doc_index, (GFunc)search_documentation, self);
stop_spinner(self);
}
return;
}
static GFile *
find_dir_no_case (GFile *root, gboolean look_for_psp)
{
GFileEnumerator *e;
GFileInfo *info;
GFile *ret;
GFile *music_dir;
ret = music_dir = NULL;
e = g_file_enumerate_children (root, G_FILE_ATTRIBUTE_STANDARD_NAME","G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (e == NULL)
return ret;
while ((info = g_file_enumerator_next_file (e, NULL, NULL)) != NULL) {
const char *name;
name = g_file_info_get_name (info);
if (g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY) {
g_object_unref (info);
continue;
}
if (g_ascii_strcasecmp (name, "MUSIC") == 0) {
music_dir = g_file_resolve_relative_path (root, name);
g_object_unref (info);
if (look_for_psp)
continue;
else
break;
}
if (look_for_psp) {
if (g_ascii_strcasecmp (name, "PSP") == 0) {
GFile *psp_dir;
psp_dir = g_file_resolve_relative_path (root, name);
ret = find_dir_no_case (psp_dir, FALSE);
g_object_unref (psp_dir);
if (ret != NULL) {
g_object_unref (info);
if (music_dir != NULL)
g_object_unref (music_dir);
music_dir = NULL;
break;
}
}
}
g_object_unref (info);
}
g_object_unref (e);
if (ret == NULL)
ret = music_dir;
return ret;
}
void locke_appmanager_scan_for_deploys(LockeAppManager *lam, GFile *deployDir) {
if (g_file_query_file_type(deployDir, G_FILE_QUERY_INFO_NONE, NULL)
!= G_FILE_TYPE_DIRECTORY) {
g_log(LSVR_DOMAIN, G_LOG_LEVEL_WARNING,
"Hey, autodeploy dir '%s' does not exist!! Create it to be able to make deploys. ",
g_file_get_path(deployDir));
return;
}
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, "Scanning folder '%s' for application deployments",
g_file_get_path(deployDir));
/* Get file enumerator */
GError *err = NULL;
GFileEnumerator *files = g_file_enumerate_children(deployDir, "*",
G_FILE_QUERY_INFO_NONE, NULL, &err);
if (err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR, "Unable to get file list for directory '%s': %s",
g_file_get_path(deployDir), err->message);
g_error_free(err);
goto scan_for_deploys_finally;
}
/* process each file individually */
GFileInfo *fileInfo = NULL;
do {
fileInfo = g_file_enumerator_next_file(files, NULL, &err);
if (err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR, "Unable to get file for directory '%s': %s",
g_file_get_path(deployDir), err->message);
g_error_free(err);
goto scan_for_deploys_finally;
}
/* stop condition */
if (fileInfo == NULL)
break;
/* finally, process the file */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_INFO, " =========> Processing file '%s'",
g_file_info_get_display_name(fileInfo));
locke_appmanager_add_application(lam, g_file_get_path(deployDir),
g_file_info_get_name(fileInfo));
} while (TRUE);
/* Close open things */
g_file_enumerator_close(files, NULL, &err);
if (err != NULL) {
/* Report error to user, and free error */
g_log(LSVR_DOMAIN, G_LOG_LEVEL_ERROR,
"Error closing file enumerator for directory '%s': %s",
g_file_get_path(deployDir), err->message);
g_error_free(err);
goto scan_for_deploys_finally;
}
/* Free allocated memory */
scan_for_deploys_finally: g_object_unref(files);
}
static gboolean
nautilus_disc_burn_is_empty (GtkWindow *toplevel)
{
GFileEnumerator *enumerator;
GFileInfo *info = NULL;
GError *error = NULL;
GFile *file;
file = g_file_new_for_uri (BURN_URI);
enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME,
G_FILE_QUERY_INFO_NONE,
NULL,
&error);
if (!enumerator) {
gchar *string;
DEBUG_PRINT ("Could not open burn uri %s: %s\n",
uri,
error->message);
if (!toplevel) {
g_error_free (error);
return TRUE;
}
string = g_strdup_printf ("%s.", _("An internal error occurred"));
brasero_utils_message_dialog (GTK_WIDGET (toplevel),
string,
error ? error->message:NULL,
GTK_MESSAGE_ERROR);
g_free (string);
g_object_unref (file);
g_error_free (error);
return TRUE;
}
info = g_file_enumerator_next_file (enumerator, NULL, NULL);
g_object_unref (enumerator);
g_object_unref (file);
if (!info) {
if (!toplevel)
return TRUE;
brasero_utils_message_dialog (GTK_WIDGET (toplevel),
_("Please add files."),
_("There are no files to write to disc"),
GTK_MESSAGE_ERROR);
return TRUE;
}
g_object_unref (info);
return FALSE;
}
